@a3s-lab/office 0.2.2 → 0.4.0

package/dist/4560.js

@@ -0,0 +1,674 @@
+import { initializeWorkOfficeCollaborationMetadata, assertWorkOfficeCollaborationEditable, OfficeCollaborationError as WorkOfficeCollaborationError, readOfficeCollaborationMetadata as readWorkOfficeCollaborationMetadata, registerWorkOfficeCollaborationInitializer, markWorkOfficeCollaborationInitialized, assertWorkOfficeCollaborationOrigin } from "./9787.js";
+import { workOfficeCollaborationJsonEqual, isWorkOfficeCollaborationRecord, cloneWorkOfficeCollaborationJson } from "./4650.js";
+import * as __rspack_external_yjs from "yjs";
+function validateWorkOfficePresentationContent(content) {
+    if (!content || 'presentation' !== content.type) invalidWorkOfficePresentationInput('a Presentation content value');
+    const result = {
+        type: 'presentation',
+        slides: validateRecords(content.slides, 'slide', validateSlide)
+    };
+    if (void 0 !== content.width) result.width = requiredFiniteNumber(content.width, 'presentation width');
+    if (void 0 !== content.height) result.height = requiredFiniteNumber(content.height, 'presentation height');
+    if (void 0 !== content.masters) result.masters = validateRecords(content.masters, 'presentation master', validateMaster);
+    if (void 0 !== content.layouts) result.layouts = validateRecords(content.layouts, 'presentation layout', validateLayout);
+    assertPresentationReferences(result);
+    return result;
+}
+function validateSharedWorkOfficePresentationContent(content) {
+    try {
+        return validateWorkOfficePresentationContent(content);
+    } catch (error) {
+        if (error instanceof WorkOfficeCollaborationError) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The shared Presentation collaboration content is invalid: ${error.message}`);
+        throw error;
+    }
+}
+function invalidWorkOfficePresentationShared(label) {
+    throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The shared Presentation collaboration ${label} is invalid.`);
+}
+function validateRecords(value, label, validate) {
+    if (!Array.isArray(value)) invalidWorkOfficePresentationInput(`an array of ${label}s`);
+    const ids = new Set();
+    return value.map((item)=>{
+        const validated = validate(item);
+        if (ids.has(validated.id)) invalidWorkOfficePresentationInput(`a unique ${label} ID; '${validated.id}' is repeated`);
+        ids.add(validated.id);
+        return validated;
+    });
+}
+function validateSlide(value) {
+    const record = requiredInputRecord(value, 'slide');
+    const slide = validateJsonRecord(record, 'slide');
+    slide.id = requiredIdentifier(record.id, 'slide');
+    slide.name = requiredString(record.name, 'slide name');
+    slide.background = requiredString(record.background, 'slide background');
+    slide.elements = validateRecords(record.elements, `element in slide '${slide.id}'`, validateElement);
+    if (void 0 !== record.layoutId) slide.layoutId = requiredIdentifier(record.layoutId, 'slide layout');
+    if (void 0 !== record.comments) slide.comments = validateRecords(record.comments, `comment in slide '${slide.id}'`, validateComment);
+    return slide;
+}
+function validateMaster(value) {
+    const record = requiredInputRecord(value, 'presentation master');
+    const master = validateJsonRecord(record, 'presentation master');
+    master.id = requiredIdentifier(record.id, 'presentation master');
+    master.name = requiredString(record.name, 'presentation master name');
+    master.background = requiredString(record.background, 'presentation master background');
+    master.elements = validateRecords(record.elements, `element in presentation master '${master.id}'`, validateElement);
+    return master;
+}
+function validateLayout(value) {
+    const record = requiredInputRecord(value, 'presentation layout');
+    const layout = validateJsonRecord(record, 'presentation layout');
+    layout.id = requiredIdentifier(record.id, 'presentation layout');
+    layout.name = requiredString(record.name, 'presentation layout name');
+    layout.masterId = requiredIdentifier(record.masterId, 'presentation layout master');
+    layout.elements = validateRecords(record.elements, `element in presentation layout '${layout.id}'`, validateElement);
+    return layout;
+}
+function validateElement(value) {
+    const record = requiredInputRecord(value, 'presentation element');
+    const element = validateJsonRecord(record, 'presentation element');
+    element.id = requiredIdentifier(record.id, 'presentation element');
+    element.type = requiredString(record.type, 'presentation element type');
+    if ('text' !== element.type && 'shape' !== element.type && 'image' !== element.type && 'table' !== element.type && 'chart' !== element.type && 'line' !== element.type) invalidWorkOfficePresentationInput('a supported presentation element type');
+    for (const key of [
+        'x',
+        'y',
+        'width',
+        'height',
+        'fontSize'
+    ])element[key] = requiredFiniteNumber(record[key], `presentation element ${key}`);
+    element.text = requiredString(record.text, 'presentation element text');
+    element.color = requiredString(record.color, 'presentation element color');
+    element.fill = requiredString(record.fill, 'presentation element fill');
+    if ('boolean' != typeof record.bold) invalidWorkOfficePresentationInput('a boolean presentation element bold value');
+    element.bold = record.bold;
+    if ('left' !== record.align && 'center' !== record.align && 'right' !== record.align) invalidWorkOfficePresentationInput('a supported presentation text alignment');
+    element.align = record.align;
+    return element;
+}
+function validateComment(value) {
+    const record = requiredInputRecord(value, 'slide comment');
+    const comment = validateJsonRecord(record, 'slide comment');
+    comment.id = requiredIdentifier(record.id, 'slide comment');
+    comment.author = requiredString(record.author, 'slide comment author');
+    comment.date = requiredString(record.date, 'slide comment date');
+    comment.text = requiredString(record.text, 'slide comment text');
+    comment.x = requiredFiniteNumber(record.x, 'slide comment x');
+    comment.y = requiredFiniteNumber(record.y, 'slide comment y');
+    if (void 0 !== record.initials) comment.initials = requiredString(record.initials, 'slide comment initials');
+    return comment;
+}
+function validateJsonRecord(value, label) {
+    try {
+        return cloneWorkOfficeCollaborationJson(value);
+    } catch (error) {
+        throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `Presentation collaboration requires a JSON-compatible ${label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function assertPresentationReferences(content) {
+    const masterIds = new Set((content.masters ?? []).map(({ id })=>id));
+    for (const layout of content.layouts ?? [])if (!masterIds.has(layout.masterId)) invalidWorkOfficePresentationInput(`presentation layout '${layout.id}' to reference an existing master`);
+    const layoutIds = new Set((content.layouts ?? []).map(({ id })=>id));
+    for (const slide of content.slides)if (void 0 !== slide.layoutId && !layoutIds.has(slide.layoutId)) invalidWorkOfficePresentationInput(`slide '${slide.id}' to reference an existing presentation layout`);
+}
+function requiredInputRecord(value, label) {
+    if (!isWorkOfficeCollaborationRecord(value)) invalidWorkOfficePresentationInput(`a valid ${label} record`);
+    return value;
+}
+function requiredIdentifier(value, label) {
+    const result = requiredString(value, `${label} ID`);
+    if (!result || result !== result.trim() || result.length > 256) invalidWorkOfficePresentationInput(`a ${label} ID containing 1 to 256 characters`);
+    return result;
+}
+function requiredString(value, label) {
+    if ('string' != typeof value) invalidWorkOfficePresentationInput(`a string ${label}`);
+    return value;
+}
+function requiredFiniteNumber(value, label) {
+    if ('number' != typeof value || !Number.isFinite(value)) invalidWorkOfficePresentationInput(`a finite number for ${label}`);
+    return value;
+}
+function invalidWorkOfficePresentationInput(expected) {
+    throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `Presentation collaboration requires ${expected}.`);
+}
+const PRESENTATION_RECORD_ELEMENTS = 'elements';
+const PRESENTATION_RECORD_ELEMENT_ORDER = 'elementOrder';
+const PRESENTATION_RECORD_COMMENTS = 'comments';
+const PRESENTATION_RECORD_COMMENT_ORDER = 'commentOrder';
+const PRESENTATION_RECORD_COMMENTS_PRESENT = 'commentsPresent';
+function nestedPresentationMap(parent, key, label) {
+    const existing = parent.get(key);
+    if (existing instanceof __rspack_external_yjs.Map) return existing;
+    if (void 0 !== existing) invalidWorkOfficePresentationShared(label);
+    const value = new __rspack_external_yjs.Map();
+    parent.set(key, value);
+    return value;
+}
+function nestedPresentationArray(parent, key, label) {
+    const existing = parent.get(key);
+    if (existing instanceof __rspack_external_yjs.Array) return existing;
+    if (void 0 !== existing) invalidWorkOfficePresentationShared(label);
+    const value = new __rspack_external_yjs.Array();
+    parent.set(key, value);
+    return value;
+}
+function requiredPresentationMap(parent, key, label) {
+    const value = parent.get(key);
+    if (!(value instanceof __rspack_external_yjs.Map)) invalidWorkOfficePresentationShared(label);
+    return value;
+}
+function requiredPresentationArray(parent, key, label) {
+    const value = parent.get(key);
+    if (!(value instanceof __rspack_external_yjs.Array)) invalidWorkOfficePresentationShared(label);
+    return value;
+}
+function validatedPresentationOrder(order, records, label) {
+    const seen = new Set();
+    const values = [];
+    for (const value of order.toArray()){
+        if ('string' != typeof value || !value.trim()) invalidWorkOfficePresentationShared(`${label} order`);
+        if (!seen.has(value)) {
+            seen.add(value);
+            values.push(value);
+        }
+    }
+    if (seen.size !== records.size || Array.from(records.keys()).some((id)=>!seen.has(id))) invalidWorkOfficePresentationShared(`${label} order and record set`);
+    return values;
+}
+function readPresentationCollection(records, order, label) {
+    return validatedPresentationOrder(order, records, label).map((id)=>{
+        const record = requiredPresentationMap(records, id, label);
+        assertCommentRootsMatchRecordKind(record, label);
+        const value = {};
+        for (const [key, item] of record.entries()){
+            if (key === PRESENTATION_RECORD_COMMENTS_PRESENT) {
+                if ('slide' !== label || true !== item) invalidWorkOfficePresentationShared(`${label} comment presence`);
+                continue;
+            }
+            if (!isNestedPresentationField(key)) {
+                if (item instanceof __rspack_external_yjs.AbstractType) invalidWorkOfficePresentationShared(`${label} field '${key}'`);
+                value[key] = cloneWorkOfficeCollaborationJson(item);
+            }
+        }
+        if (value.id !== id) invalidWorkOfficePresentationShared(`${label} identity`);
+        value.elements = readIdRecords(requiredPresentationMap(record, PRESENTATION_RECORD_ELEMENTS, `${label} elements`), requiredPresentationArray(record, PRESENTATION_RECORD_ELEMENT_ORDER, `${label} element order`), `${label} element`);
+        if ('slide' === label) readSlideComments(record, value);
+        return value;
+    });
+}
+function patchPresentationElements(records, order, previous, next, parentLabel) {
+    patchPresentationIdRecords(records, order, previous, next, `${parentLabel} element`);
+}
+function patchPresentationIdRecords(records, order, previous, next, label) {
+    const previousById = new Map(previous.map((value)=>[
+            value.id,
+            value
+        ]));
+    const nextById = new Map(next.map((value)=>[
+            value.id,
+            value
+        ]));
+    for (const value of previous)if (!nextById.has(value.id)) records.delete(value.id);
+    for (const value of next){
+        const before = previousById.get(value.id);
+        if (before && workOfficeCollaborationJsonEqual(before, value)) continue;
+        let record = records.get(value.id);
+        if (void 0 === record) {
+            record = new __rspack_external_yjs.Map();
+            records.set(value.id, record);
+        }
+        if (!(record instanceof __rspack_external_yjs.Map)) invalidWorkOfficePresentationShared(label);
+        patchPresentationJsonMap(record, before ?? {}, value);
+    }
+    patchPresentationOrder(order, previous.map((value)=>value.id), next.map((value)=>value.id));
+}
+function patchPresentationOrder(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)) {
+        const changedIds = next.filter((id)=>previousIds.has(id));
+        for (const id of changedIds)removeAll(order, id);
+        for (const id of next)if (!order.toArray().includes(id)) insertRelative(order, next, id);
+    }
+}
+function assertCommentRootsMatchRecordKind(record, label) {
+    if ('slide' !== label && (record.has(PRESENTATION_RECORD_COMMENTS) || record.has(PRESENTATION_RECORD_COMMENT_ORDER) || record.has(PRESENTATION_RECORD_COMMENTS_PRESENT))) invalidWorkOfficePresentationShared(`${label} comments`);
+}
+function isNestedPresentationField(key) {
+    return key === PRESENTATION_RECORD_ELEMENTS || key === PRESENTATION_RECORD_ELEMENT_ORDER || key === PRESENTATION_RECORD_COMMENTS || key === PRESENTATION_RECORD_COMMENT_ORDER;
+}
+function readSlideComments(record, value) {
+    const commentRecords = requiredPresentationMap(record, PRESENTATION_RECORD_COMMENTS, 'slide comments');
+    const commentOrder = requiredPresentationArray(record, PRESENTATION_RECORD_COMMENT_ORDER, 'slide comment order');
+    if (commentRecords.size > 0 || commentOrder.length > 0) value.comments = readIdRecords(commentRecords, commentOrder, 'slide comment');
+    else if (true === record.get(PRESENTATION_RECORD_COMMENTS_PRESENT)) value.comments = [];
+}
+function readIdRecords(records, order, label) {
+    return validatedPresentationOrder(order, records, label).map((id)=>readJsonMap(requiredPresentationMap(records, id, label), id, label));
+}
+function readJsonMap(record, expectedId, label) {
+    const value = {};
+    for (const [key, item] of record.entries()){
+        if (item instanceof __rspack_external_yjs.AbstractType) invalidWorkOfficePresentationShared(`${label} field '${key}'`);
+        value[key] = cloneWorkOfficeCollaborationJson(item);
+    }
+    if (value.id !== expectedId) invalidWorkOfficePresentationShared(`${label} identity`);
+    return value;
+}
+function patchPresentationJsonMap(target, previous, next) {
+    const keys = new Set([
+        ...Object.keys(previous),
+        ...Object.keys(next)
+    ]);
+    for (const key of keys)if (!workOfficeCollaborationJsonEqual(previous[key], next[key])) if (void 0 === next[key]) target.delete(key);
+    else target.set(key, cloneWorkOfficeCollaborationJson(next[key]));
+}
+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 PRESENTATION_OPTIONS_ROOT = 'presentation.options';
+const PRESENTATION_SLIDES_ROOT = 'presentation.slides';
+const PRESENTATION_SLIDE_ORDER_ROOT = 'presentation.slide-order';
+const PRESENTATION_MASTERS_ROOT = 'presentation.masters';
+const PRESENTATION_MASTER_ORDER_ROOT = 'presentation.master-order';
+const PRESENTATION_LAYOUTS_ROOT = 'presentation.layouts';
+const PRESENTATION_LAYOUT_ORDER_ROOT = 'presentation.layout-order';
+function workOfficePresentationRoots(document, rootName) {
+    return {
+        options: document.getMap(rootName(PRESENTATION_OPTIONS_ROOT)),
+        slides: document.getMap(rootName(PRESENTATION_SLIDES_ROOT)),
+        slideOrder: document.getArray(rootName(PRESENTATION_SLIDE_ORDER_ROOT)),
+        masters: document.getMap(rootName(PRESENTATION_MASTERS_ROOT)),
+        masterOrder: document.getArray(rootName(PRESENTATION_MASTER_ORDER_ROOT)),
+        layouts: document.getMap(rootName(PRESENTATION_LAYOUTS_ROOT)),
+        layoutOrder: document.getArray(rootName(PRESENTATION_LAYOUT_ORDER_ROOT))
+    };
+}
+function initializeWorkOfficePresentationRoots(roots, content) {
+    patchOptionalJson(roots.options, 'width', void 0, content.width);
+    patchOptionalJson(roots.options, 'height', void 0, content.height);
+    patchCollection({
+        label: 'slide',
+        order: roots.slideOrder,
+        previous: [],
+        records: roots.slides,
+        next: content.slides
+    });
+    patchCollection({
+        label: 'presentation master',
+        order: roots.masterOrder,
+        previous: [],
+        records: roots.masters,
+        next: content.masters ?? []
+    });
+    patchCollection({
+        label: 'presentation layout',
+        order: roots.layoutOrder,
+        previous: [],
+        records: roots.layouts,
+        next: content.layouts ?? []
+    });
+}
+function readWorkOfficePresentationRoots(roots) {
+    const width = optionalSharedNumber(roots.options.get('width'), 'presentation width');
+    const height = optionalSharedNumber(roots.options.get('height'), 'presentation height');
+    const result = {
+        type: 'presentation',
+        slides: readPresentationCollection(roots.slides, roots.slideOrder, 'slide')
+    };
+    if (void 0 !== width) result.width = width;
+    if (void 0 !== height) result.height = height;
+    const masters = readPresentationCollection(roots.masters, roots.masterOrder, 'presentation master');
+    const layouts = readPresentationCollection(roots.layouts, roots.layoutOrder, 'presentation layout');
+    if (masters.length > 0) result.masters = masters;
+    if (layouts.length > 0) result.layouts = layouts;
+    return validateSharedWorkOfficePresentationContent(result);
+}
+function patchWorkOfficePresentationRoots(roots, previous, next) {
+    const shared = readWorkOfficePresentationRoots(roots);
+    assertChangedRecordsStillExist(previous, next, shared);
+    patchOptionalJson(roots.options, 'width', previous.width, next.width);
+    patchOptionalJson(roots.options, 'height', previous.height, next.height);
+    patchCollection({
+        label: 'slide',
+        order: roots.slideOrder,
+        previous: previous.slides,
+        records: roots.slides,
+        next: next.slides
+    });
+    patchCollection({
+        label: 'presentation master',
+        order: roots.masterOrder,
+        previous: previous.masters ?? [],
+        records: roots.masters,
+        next: next.masters ?? []
+    });
+    patchCollection({
+        label: 'presentation layout',
+        order: roots.layoutOrder,
+        previous: previous.layouts ?? [],
+        records: roots.layouts,
+        next: next.layouts ?? []
+    });
+}
+function assertChangedRecordsStillExist(previous, next, shared) {
+    assertChangedCollectionExists(previous.slides, next.slides, shared.slides, 'slide');
+    assertChangedCollectionExists(previous.masters ?? [], next.masters ?? [], shared.masters ?? [], 'presentation master');
+    assertChangedCollectionExists(previous.layouts ?? [], next.layouts ?? [], shared.layouts ?? [], 'presentation layout');
+}
+function assertChangedCollectionExists(previous, next, shared, label) {
+    const previousById = new Map(previous.map((value)=>[
+            value.id,
+            value
+        ]));
+    const sharedById = new Map(shared.map((value)=>[
+            value.id,
+            value
+        ]));
+    for (const value of next){
+        const before = previousById.get(value.id);
+        const current = sharedById.get(value.id);
+        if (before && !workOfficeCollaborationJsonEqual(before, value) && !current) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The ${label} '${value.id}' was removed before this change could be applied. Refresh the shared snapshot before retrying.`);
+        if (before && current) {
+            assertChangedChildRecordsExist(before.elements, value.elements, current.elements, `element in ${label} '${value.id}'`);
+            if ('slide' === label) assertChangedChildRecordsExist(before.comments ?? [], value.comments ?? [], current.comments ?? [], `comment in slide '${value.id}'`);
+        }
+    }
+}
+function assertChangedChildRecordsExist(previous, next, shared, label) {
+    const previousById = new Map(previous.map((value)=>[
+            value.id,
+            value
+        ]));
+    const sharedIds = new Set(shared.map((value)=>value.id));
+    for (const value of next){
+        const before = previousById.get(value.id);
+        if (before && !workOfficeCollaborationJsonEqual(before, value) && !sharedIds.has(value.id)) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The ${label} '${value.id}' was removed before this change could be applied. Refresh the shared snapshot before retrying.`);
+    }
+}
+function assertWorkOfficePresentationRootsEmpty(roots) {
+    if (roots.options.size > 0 || roots.slides.size > 0 || roots.slideOrder.length > 0 || roots.masters.size > 0 || roots.masterOrder.length > 0 || roots.layouts.size > 0 || roots.layoutOrder.length > 0) throw new WorkOfficeCollaborationError('office.collaboration.bootstrap_ambiguous', 'The Presentation collaboration roots contain data without initialized metadata.');
+}
+function workOfficePresentationUndoScope(roots) {
+    return [
+        roots.options,
+        roots.slides,
+        roots.slideOrder,
+        roots.masters,
+        roots.masterOrder,
+        roots.layouts,
+        roots.layoutOrder
+    ];
+}
+function patchCollection({ label, order, previous, records, next }) {
+    const previousById = new Map(previous.map((value)=>[
+            value.id,
+            value
+        ]));
+    const nextById = new Map(next.map((value)=>[
+            value.id,
+            value
+        ]));
+    for (const value of previous)if (!nextById.has(value.id)) {
+        records.delete(value.id);
+        office_presentation_collaboration_model_removeAll(order, value.id);
+    }
+    for (const value of next){
+        const before = previousById.get(value.id);
+        if (before && workOfficeCollaborationJsonEqual(before, value)) continue;
+        let record = records.get(value.id);
+        if (void 0 === record) {
+            record = new __rspack_external_yjs.Map();
+            records.set(value.id, record);
+        }
+        if (!(record instanceof __rspack_external_yjs.Map)) invalidWorkOfficePresentationShared(label);
+        patchRecord(record, before, value, label);
+    }
+    patchPresentationOrder(order, previous.map((value)=>value.id), next.map((value)=>value.id));
+}
+function patchRecord(record, previous, next, label) {
+    const elements = nestedPresentationMap(record, PRESENTATION_RECORD_ELEMENTS, `${label} elements`);
+    const elementOrder = nestedPresentationArray(record, PRESENTATION_RECORD_ELEMENT_ORDER, `${label} element order`);
+    const nextRecord = next;
+    const previousRecord = previous;
+    const keys = new Set([
+        ...Object.keys(previousRecord ?? {}),
+        ...Object.keys(nextRecord)
+    ]);
+    keys.delete('elements');
+    keys.delete('comments');
+    for (const key of keys)if (!(previous && workOfficeCollaborationJsonEqual(previousRecord?.[key], nextRecord[key]))) if (void 0 === nextRecord[key]) record.delete(key);
+    else record.set(key, cloneWorkOfficeCollaborationJson(nextRecord[key]));
+    const comments = 'slide' === label ? nestedPresentationMap(record, PRESENTATION_RECORD_COMMENTS, 'slide comments') : void 0;
+    const commentOrder = 'slide' === label ? nestedPresentationArray(record, PRESENTATION_RECORD_COMMENT_ORDER, 'slide comment order') : void 0;
+    patchPresentationElements(elements, elementOrder, previous?.elements ?? [], next.elements, label);
+    if (comments && commentOrder) {
+        const previousComments = previousRecord?.comments;
+        const nextComments = nextRecord.comments;
+        if (void 0 !== previousComments || void 0 !== nextComments) {
+            if (void 0 !== nextComments) record.set(PRESENTATION_RECORD_COMMENTS_PRESENT, true);
+            else record.delete(PRESENTATION_RECORD_COMMENTS_PRESENT);
+            patchPresentationIdRecords(comments, commentOrder, previousComments ?? [], nextComments ?? [], 'slide comment');
+        }
+    }
+}
+function optionalSharedNumber(value, label) {
+    if (void 0 === value) return;
+    if ('number' != typeof value || !Number.isFinite(value)) invalidWorkOfficePresentationShared(label);
+    return value;
+}
+function office_presentation_collaboration_model_removeAll(order, id) {
+    for(let index = order.length - 1; index >= 0; index -= 1)if (order.get(index) === id) order.delete(index, 1);
+}
+function patchOptionalJson(target, key, previous, next) {
+    if (workOfficeCollaborationJsonEqual(previous, next)) return;
+    if (void 0 === next) target.delete(key);
+    else target.set(key, cloneWorkOfficeCollaborationJson(next));
+}
+function initializeWorkOfficePresentationCollaboration(session, content) {
+    assertPresentationSession(session);
+    assertWorkOfficeCollaborationEditable(session);
+    const prepared = validateWorkOfficePresentationContent(content);
+    const existing = readWorkOfficeCollaborationMetadata(session);
+    if (existing?.initialized) return {
+        initialized: false,
+        content: readWorkOfficePresentationCollaboration(session)
+    };
+    const roots = presentationRoots(session);
+    assertWorkOfficePresentationRootsEmpty(roots);
+    const origin = session.createOrigin('bootstrap');
+    session.transact(()=>{
+        const metadata = initializeWorkOfficeCollaborationMetadata(session);
+        if (metadata.initialized) return;
+        registerWorkOfficeCollaborationInitializer(session);
+        initializeWorkOfficePresentationRoots(roots, prepared);
+        markWorkOfficeCollaborationInitialized(session);
+    }, origin);
+    return {
+        initialized: true,
+        content: readWorkOfficePresentationCollaboration(session)
+    };
+}
+function readWorkOfficePresentationCollaboration(session) {
+    assertInitializedPresentationSession(session);
+    return readWorkOfficePresentationRoots(presentationRoots(session));
+}
+function replaceWorkOfficePresentationCollaboration(session, previous, next, origin = session.localOrigin) {
+    assertInitializedPresentationSession(session);
+    assertWorkOfficeCollaborationEditable(session);
+    const before = validateWorkOfficePresentationContent(previous);
+    const after = validateWorkOfficePresentationContent(next);
+    if (workOfficeCollaborationJsonEqual(before, after)) return false;
+    session.transact(()=>{
+        patchWorkOfficePresentationRoots(presentationRoots(session), before, after);
+    }, origin);
+    return true;
+}
+function createWorkOfficePresentationCollaborationBinding(session, options = {}) {
+    assertInitializedPresentationSession(session);
+    return new WorkOfficePresentationCollaborationBindingImpl(session, options);
+}
+class WorkOfficePresentationCollaborationBindingImpl {
+    origin;
+    #session;
+    #undoManager;
+    #roots;
+    #undoScope;
+    #listeners = new Set();
+    #errorListeners = new Set();
+    #historyListeners = new Set();
+    #destroyed = false;
+    #pendingChange = false;
+    #pendingLocal = true;
+    #pendingOrigin;
+    constructor(session, options){
+        this.#session = session;
+        this.#roots = presentationRoots(session);
+        this.origin = options.origin ?? session.createOrigin(session.localOrigin.kind);
+        assertWorkOfficeCollaborationOrigin(this.origin);
+        this.#undoScope = workOfficePresentationUndoScope(this.#roots);
+        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);
+    }
+    content() {
+        this.ensureActive();
+        return readWorkOfficePresentationRoots(this.#roots);
+    }
+    replace(previous, next) {
+        this.ensureActive();
+        return replaceWorkOfficePresentationCollaboration(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.destroy();
+        this.#listeners.clear();
+        this.#errorListeners.clear();
+        this.#historyListeners.clear();
+    }
+    #onTransaction = (transaction)=>{
+        const changedParents = new Set(transaction.changedParentTypes.keys());
+        if (this.#destroyed || !this.#undoScope.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 Presentation collaboration binding has been destroyed.');
+    }
+}
+function presentationRoots(session) {
+    return workOfficePresentationRoots(session.document, session.rootName.bind(session));
+}
+function assertPresentationSession(session) {
+    if ('presentation' === session.kind) return;
+    throw new WorkOfficeCollaborationError('office.collaboration.kind_mismatch', `A Presentation collaboration binding cannot use a '${session.kind}' session.`);
+}
+function assertInitializedPresentationSession(session) {
+    assertPresentationSession(session);
+    const metadata = readWorkOfficeCollaborationMetadata(session);
+    if (metadata?.initialized) return;
+    throw new WorkOfficeCollaborationError('office.collaboration.not_initialized', 'The Presentation collaboration session has not been initialized.');
+}
+export { createWorkOfficePresentationCollaborationBinding as createOfficePresentationCollaborationBinding, initializeWorkOfficePresentationCollaboration as initializeOfficePresentationCollaboration, readWorkOfficePresentationCollaboration as readOfficePresentationCollaboration, replaceWorkOfficePresentationCollaboration as replaceOfficePresentationCollaboration };