@a3s-lab/office 0.38.1 → 0.40.0

package/dist/4560.js

@@ -1,6 +1,117 @@
+import { createOfficeId as createWorkId } from "./4121.js";
 import { initializeWorkOfficeCollaborationMetadata, assertWorkOfficeCollaborationEditable, OfficeCollaborationError as WorkOfficeCollaborationError, readOfficeCollaborationMetadata as readWorkOfficeCollaborationMetadata, registerWorkOfficeCollaborationInitializer, markWorkOfficeCollaborationInitialized, assertWorkOfficeCollaborationOrigin } from "./9787.js";
 import { workOfficeCollaborationJsonEqual, canonicalWorkOfficeCollaborationJson, isWorkOfficeCollaborationRecord, cloneWorkOfficeCollaborationJson } from "./4650.js";
 import * as __rspack_external_yjs from "yjs";
+function createWorkSlideAnimation(elementId, effect, previous) {
+    return normalizeWorkSlideAnimation({
+        id: previous?.id ?? createWorkId('slide-animation'),
+        elementId,
+        effect,
+        trigger: previous?.trigger ?? 'on-click',
+        durationMs: previous?.durationMs ?? 500,
+        delayMs: previous?.delayMs ?? 0,
+        direction: isFlyAnimationEffect(effect) ? previous?.direction ?? 'left' : void 0
+    });
+}
+function normalizeWorkSlideAnimation(animation) {
+    return {
+        ...animation,
+        durationMs: boundedInteger(animation.durationMs, 100, 60000),
+        delayMs: boundedInteger(animation.delayMs, 0, 60000),
+        direction: isFlyAnimationEffect(animation.effect) ? normalizeWorkSlideAnimationDirection(animation.direction) : void 0
+    };
+}
+function workSlideAnimationClass(effect) {
+    return 'disappear' === effect || 'fade-out' === effect || 'fly-out' === effect || 'zoom-out' === effect ? 'exit' : 'entrance';
+}
+function workSlideAnimationEffectMatchesClass(effect, animationClass) {
+    return workSlideAnimationClass(effect) === animationClass;
+}
+function workSlideAnimationForElement(slide, elementId, animationClass) {
+    if (!elementId) return;
+    return slide.animations?.find((animation)=>animation.elementId === elementId && workSlideAnimationClass(animation.effect) === animationClass);
+}
+function workSlideAnimationIndex(slide, animationId) {
+    if (!animationId) return -1;
+    return slide.animations?.findIndex((animation)=>animation.id === animationId) ?? -1;
+}
+function workSlideAnimationCues(animations) {
+    const cues = [];
+    let current;
+    for (const raw of animations ?? []){
+        const animation = normalizeWorkSlideAnimation(raw);
+        if (!current || 'on-click' === animation.trigger) {
+            current = {
+                automatic: 'on-click' !== animation.trigger,
+                items: [],
+                totalDurationMs: 0
+            };
+            cues.push(current);
+        }
+        const previous = current.items.at(-1);
+        const baseStart = 'after-previous' === animation.trigger ? previous?.endOffsetMs ?? 0 : 'with-previous' === animation.trigger ? previous?.startOffsetMs ?? 0 : 0;
+        const startOffsetMs = baseStart + animation.delayMs;
+        const endOffsetMs = startOffsetMs + animation.durationMs;
+        current.items.push({
+            animation,
+            startOffsetMs,
+            endOffsetMs
+        });
+        current.totalDurationMs = Math.max(current.totalDurationMs, endOffsetMs);
+    }
+    return cues;
+}
+function initialWorkSlideAnimationCueIndex(cues) {
+    return cues[0]?.automatic ? 0 : -1;
+}
+function workSlideAnimationSequenceIssue(animations) {
+    const classTargets = new Set();
+    for (const animation of animations ?? []){
+        const key = `${animation.elementId}\u0000${workSlideAnimationClass(animation.effect)}`;
+        if (classTargets.has(key)) return 'duplicate-class';
+        classTargets.add(key);
+    }
+    for (const cue of workSlideAnimationCues(animations)){
+        const rangesByTarget = new Map();
+        for (const item of cue.items){
+            const ranges = rangesByTarget.get(item.animation.elementId) ?? [];
+            if (ranges.some((range)=>item.startOffsetMs < range.endOffsetMs && item.endOffsetMs > range.startOffsetMs)) return 'overlapping-target';
+            ranges.push(item);
+            rangesByTarget.set(item.animation.elementId, ranges);
+        }
+    }
+}
+function removeWorkSlideAnimationsForElements(slide, elementIds) {
+    const animations = slide.animations?.filter((animation)=>!elementIds.has(animation.elementId));
+    if (animations?.length === slide.animations?.length) return slide;
+    return {
+        ...slide,
+        animations: animations?.length ? animations : void 0
+    };
+}
+function remapWorkSlideAnimations(animations, elementIds) {
+    const remapped = (animations ?? []).flatMap((animation)=>{
+        const elementId = elementIds.get(animation.elementId);
+        return elementId ? [
+            {
+                ...animation,
+                id: createWorkId('slide-animation'),
+                elementId
+            }
+        ] : [];
+    });
+    return remapped.length ? remapped : void 0;
+}
+function normalizeWorkSlideAnimationDirection(direction) {
+    return 'right' === direction || 'up' === direction || 'down' === direction ? direction : 'left';
+}
+function isFlyAnimationEffect(effect) {
+    return 'fly-in' === effect || 'fly-out' === effect;
+}
+function boundedInteger(value, minimum, maximum) {
+    const finite = Number.isFinite(value) ? Math.round(value) : minimum;
+    return Math.min(maximum, Math.max(minimum, finite));
+}
 function validateWorkOfficePresentationContent(content) {
     if (!content || 'presentation' !== content.type) invalidWorkOfficePresentationInput('a Presentation content value');
     const result = {
@@ -50,30 +161,34 @@ function validateSlide(value) {
 function validateSlideAnimations(value, slide) {
     if (!Array.isArray(value) || value.length > 256) invalidWorkOfficePresentationInput("an array of at most 256 slide animations");
     const animationIds = new Set();
-    const targetIds = new Set();
+    const classTargetIds = new Set();
     const elementIds = new Set(slide.elements.map((element)=>element.id));
-    return value.map((item)=>{
+    const animations = value.map((item)=>{
         const record = requiredInputRecord(item, 'slide animation');
         const animation = validateJsonRecord(record, 'slide animation');
         animation.id = requiredIdentifier(record.id, 'slide animation');
         animation.elementId = requiredIdentifier(record.elementId, 'slide animation element');
         if (animationIds.has(animation.id)) invalidWorkOfficePresentationInput(`a unique slide animation ID; '${animation.id}' is repeated`);
         if (!elementIds.has(animation.elementId)) invalidWorkOfficePresentationInput(`slide animation '${animation.id}' to reference an existing element`);
-        if (targetIds.has(animation.elementId)) invalidWorkOfficePresentationInput(`at most one entrance animation for element '${animation.elementId}'`);
-        if ('appear' !== record.effect && 'fade' !== record.effect && 'fly-in' !== record.effect && 'zoom' !== record.effect) invalidWorkOfficePresentationInput('a supported slide entrance animation effect');
+        if ('appear' !== record.effect && 'fade' !== record.effect && 'fly-in' !== record.effect && 'zoom' !== record.effect && 'disappear' !== record.effect && 'fade-out' !== record.effect && 'fly-out' !== record.effect && 'zoom-out' !== record.effect) invalidWorkOfficePresentationInput('a supported slide entrance or exit animation effect');
         animation.effect = record.effect;
+        const animationClass = workSlideAnimationClass(animation.effect);
+        const classTargetId = `${animation.elementId}\u0000${animationClass}`;
+        if (classTargetIds.has(classTargetId)) invalidWorkOfficePresentationInput(`at most one ${animationClass} animation for element '${animation.elementId}'`);
         if ('on-click' !== record.trigger && 'with-previous' !== record.trigger && 'after-previous' !== record.trigger) invalidWorkOfficePresentationInput('a supported slide animation trigger');
         animation.trigger = record.trigger;
         animation.durationMs = requiredIntegerInRange(record.durationMs, 100, 60000, 'slide animation duration');
         animation.delayMs = requiredIntegerInRange(record.delayMs, 0, 60000, 'slide animation delay');
-        if ('fly-in' === animation.effect) {
-            if ('left' !== record.direction && 'right' !== record.direction && 'up' !== record.direction && 'down' !== record.direction) invalidWorkOfficePresentationInput('a direction for each fly-in animation');
+        if ('fly-in' === animation.effect || 'fly-out' === animation.effect) {
+            if ('left' !== record.direction && 'right' !== record.direction && 'up' !== record.direction && 'down' !== record.direction) invalidWorkOfficePresentationInput('a direction for each fly-in or fly-out animation');
             animation.direction = record.direction;
-        } else if (void 0 !== record.direction) invalidWorkOfficePresentationInput('slide animation directions only on fly-in effects');
+        } else if (void 0 !== record.direction) invalidWorkOfficePresentationInput('slide animation directions only on fly-in or fly-out effects');
         animationIds.add(animation.id);
-        targetIds.add(animation.elementId);
+        classTargetIds.add(classTargetId);
         return animation;
     });
+    if ('overlapping-target' === workSlideAnimationSequenceIssue(animations)) invalidWorkOfficePresentationInput('animations for one element to avoid overlapping inside one playback cue');
+    return animations;
 }
 function validateMaster(value) {
     const record = requiredInputRecord(value, 'presentation master');
@@ -857,4 +972,4 @@ function assertInitializedPresentationSession(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 };
+export { createWorkOfficePresentationCollaborationBinding as createOfficePresentationCollaborationBinding, createWorkSlideAnimation, initialWorkSlideAnimationCueIndex, initializeWorkOfficePresentationCollaboration as initializeOfficePresentationCollaboration, normalizeWorkSlideAnimation, readWorkOfficePresentationCollaboration as readOfficePresentationCollaboration, remapWorkSlideAnimations, removeWorkSlideAnimationsForElements, replaceWorkOfficePresentationCollaboration as replaceOfficePresentationCollaboration, workSlideAnimationClass, workSlideAnimationCues, workSlideAnimationEffectMatchesClass, workSlideAnimationForElement, workSlideAnimationIndex, workSlideAnimationSequenceIssue };

package/dist/internal/features/work/editors/presentation-animation-panel.d.ts

@@ -1,11 +1,13 @@
-import type { WorkSlideAnimation, WorkSlideAnimationEffect } from '../work-types';
-export declare function PresentationAnimationPanel({ animation, canMove, canPreview, editable, onMove, onPreview, onSetEffect, onUpdate, }: {
-    animation: WorkSlideAnimation | undefined;
-    canMove: (direction: -1 | 1) => boolean;
+import type { WorkSlideAnimation, WorkSlideAnimationClass, WorkSlideAnimationEffect } from '../work-types';
+export declare function PresentationAnimationPanel({ animations, canMove, canPreview, canUpdate, editable, elementId, onMove, onPreview, onSetEffect, onUpdate, }: {
+    animations: Record<WorkSlideAnimationClass, WorkSlideAnimation | undefined>;
+    canMove: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => boolean;
     canPreview: boolean;
+    canUpdate: (animationClass: WorkSlideAnimationClass, patch: Partial<WorkSlideAnimation>) => boolean;
     editable: boolean;
-    onMove: (direction: -1 | 1) => void;
+    elementId: string | undefined;
+    onMove: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => void;
     onPreview: () => void;
-    onSetEffect: (effect: WorkSlideAnimationEffect | undefined) => void;
-    onUpdate: (patch: Partial<WorkSlideAnimation>) => void;
+    onSetEffect: (animationClass: WorkSlideAnimationClass, effect: WorkSlideAnimationEffect | undefined) => void;
+    onUpdate: (animationClass: WorkSlideAnimationClass, patch: Partial<WorkSlideAnimation>) => void;
 }): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-command-types.d.ts

@@ -1,5 +1,5 @@
 import type { OfficeKernelPresentationAlignment } from '../../../kernel/office-kernel-protocol';
-import type { WorkPresentationContent, WorkSlideAnimation, WorkSlideAnimationEffect, WorkSlideElement, WorkSlideTransition, WorkSlideTextRun } from '../work-types';
+import type { WorkPresentationContent, WorkSlideAnimation, WorkSlideAnimationClass, WorkSlideAnimationEffect, WorkSlideElement, WorkSlideTransition, WorkSlideTextRun } from '../work-types';
 import type { OfficeEditorCanCommands } from './office-editor-extension';
 import type { PresentationDesignMode } from './presentation-editor-types';
 import type { PresentationDistribution } from './presentation-selection';
@@ -37,7 +37,7 @@ export interface PresentationEditorCommands {
     groupElements: () => boolean;
     instantiatePlaceholder: (definition: WorkSlideElement) => PresentationCommandResult;
     locatePresentationComment: (slideId: string, commentId: string) => PresentationCommandResult;
-    moveEntranceAnimation: (direction: -1 | 1) => PresentationCommandResult;
+    moveAnimation: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => PresentationCommandResult;
     nudgeSelection: (key: string, distance: number) => boolean;
     openComment: (commentId: string) => PresentationCommandResult;
     pasteSelection: () => boolean;
@@ -52,7 +52,7 @@ export interface PresentationEditorCommands {
     selectSlide: (slideId: string, returnToSlideMode?: boolean) => PresentationCommandResult;
     setPresentationContent: (content: WorkPresentationContent) => PresentationCommandResult;
     setBackground: (color: string) => PresentationCommandResult;
-    setEntranceAnimation: (effect: WorkSlideAnimationEffect | undefined) => PresentationCommandResult;
+    setAnimation: (animationClass: WorkSlideAnimationClass, effect: WorkSlideAnimationEffect | undefined) => PresentationCommandResult;
     setPresentationLayoutBackground: (color: string | undefined) => PresentationCommandResult;
     setPresentationMasterBackground: (color: string) => PresentationCommandResult;
     setTransition: (transition: WorkSlideTransition | undefined) => PresentationCommandResult;
@@ -69,7 +69,7 @@ export interface PresentationEditorCommands {
     updateElement: (patch: Partial<WorkSlideElement>, options?: {
         restoreTextFocus?: boolean;
     }) => PresentationCommandResult;
-    updateEntranceAnimation: (patch: Partial<WorkSlideAnimation>) => PresentationCommandResult;
+    updateAnimation: (animationClass: WorkSlideAnimationClass, patch: Partial<WorkSlideAnimation>) => PresentationCommandResult;
     updateNotes: (notes: string) => PresentationCommandResult;
     updatePresentationComment: (slideId: string, commentId: string, text: string) => PresentationCommandResult;
     updateTextElement: (elementId: string, value: {
@@ -112,14 +112,14 @@ export interface PresentationSlideCommandPort {
     updateNotes: (notes: string) => PresentationCommandResult;
 }
 export interface PresentationAnimationCommandPort {
-    canMoveEntranceAnimation: (direction: -1 | 1) => boolean;
+    canMoveAnimation: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => boolean;
     canPreviewAnimations: boolean;
-    canSetEntranceAnimation: boolean;
-    canUpdateEntranceAnimation: boolean;
-    moveEntranceAnimation: (direction: -1 | 1) => PresentationCommandResult;
+    canSetAnimation: boolean;
+    canUpdateAnimation: (animationClass: WorkSlideAnimationClass, patch: Partial<WorkSlideAnimation>) => boolean;
+    moveAnimation: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => PresentationCommandResult;
     previewAnimations: () => PresentationCommandResult;
-    setEntranceAnimation: (effect: WorkSlideAnimationEffect | undefined) => PresentationCommandResult;
-    updateEntranceAnimation: (patch: Partial<WorkSlideAnimation>) => PresentationCommandResult;
+    setAnimation: (animationClass: WorkSlideAnimationClass, effect: WorkSlideAnimationEffect | undefined) => PresentationCommandResult;
+    updateAnimation: (animationClass: WorkSlideAnimationClass, patch: Partial<WorkSlideAnimation>) => PresentationCommandResult;
 }
 export interface PresentationInsertCommandPort {
     enabled: boolean;

package/dist/internal/features/work/editors/presentation-slide-canvas.d.ts

@@ -1,5 +1,6 @@
 import { type WorkPresentationDesignContent } from '../work-presentation-layouts';
-import type { WorkPresentationContent, WorkSlide, WorkSlideAnimation, WorkSlideElement } from '../work-types';
+import { type WorkSlideAnimationCueItem } from '../work-presentation-animation';
+import type { WorkPresentationContent, WorkSlide, WorkSlideElement } from '../work-types';
 export declare function SlideCanvas({ content, designContent, slide, interactive, aspectRatio, animationCueIndex, showPlaceholders, }: {
     content?: WorkPresentationContent;
     designContent?: WorkPresentationDesignContent;
@@ -21,9 +22,10 @@ export declare function EditableSlideTable({ element, onChange, }: {
 }): import("react").JSX.Element | null;
 export declare function slideElementStyle(element: WorkSlideElement): React.CSSProperties;
 interface SlideElementAnimationPlayback {
-    animation: WorkSlideAnimation;
-    startOffsetMs: number;
-    state: 'finished' | 'pending' | 'playing';
+    animations: WorkSlideAnimationCueItem[];
+    finallyVisible: boolean;
+    initiallyVisible: boolean;
+    state: 'hidden' | 'playing' | 'visible';
 }
 export declare function slideTextStyle(element: WorkSlideElement): React.CSSProperties;
 export declare function SlideElementTextPreview({ element, showPlaceholder, }: {

package/dist/internal/features/work/editors/use-presentation-animation-commands.d.ts

@@ -1,11 +1,11 @@
-import type { WorkPresentationContent, WorkSlide, WorkSlideAnimation, WorkSlideAnimationEffect } from '../work-types';
+import type { WorkPresentationContent, WorkSlide, WorkSlideAnimation, WorkSlideAnimationClass, WorkSlideAnimationEffect } from '../work-types';
 export interface PresentationAnimationCommands {
-    canMoveEntranceAnimation: (direction: -1 | 1) => boolean;
-    canSetEntranceAnimation: boolean;
-    canUpdateEntranceAnimation: boolean;
-    moveEntranceAnimation: (direction: -1 | 1) => boolean;
-    setEntranceAnimation: (effect: WorkSlideAnimationEffect | undefined) => boolean;
-    updateEntranceAnimation: (patch: Partial<WorkSlideAnimation>) => boolean;
+    canMoveAnimation: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => boolean;
+    canSetAnimation: boolean;
+    canUpdateAnimation: (animationClass: WorkSlideAnimationClass, patch: Partial<WorkSlideAnimation>) => boolean;
+    moveAnimation: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => boolean;
+    setAnimation: (animationClass: WorkSlideAnimationClass, effect: WorkSlideAnimationEffect | undefined) => boolean;
+    updateAnimation: (animationClass: WorkSlideAnimationClass, patch: Partial<WorkSlideAnimation>) => boolean;
 }
 export declare function usePresentationAnimationCommands({ content, onChange, selectedElementId, selectedSlide, }: {
     content: WorkPresentationContent;

package/dist/internal/features/work/work-document-format-change-tracking.d.ts

@@ -3,7 +3,7 @@ import type { EditorState, PluginKey, Transaction } from '@tiptap/pm/state';
 import type { WorkDocumentChangeIdentity } from './work-document-changes';
 interface DocumentFormattingChangeTrackingOptions {
     isTracking: () => boolean;
-    createChange: (kind: 'formatting' | 'paragraph-formatting') => WorkDocumentChangeIdentity;
+    createChange: (kind: 'formatting' | 'paragraph-formatting' | 'numbering') => WorkDocumentChangeIdentity;
 }
 export declare function trackDocumentFormattingTransaction(transaction: Transaction, state: EditorState, type: ProseMirrorMark['type'], options: DocumentFormattingChangeTrackingOptions, pluginKey: PluginKey): void;
 export {};

package/dist/internal/features/work/work-document-numbering-change-tracking.d.ts

@@ -0,0 +1,7 @@
+import type { EditorState, Transaction } from '@tiptap/pm/state';
+import type { WorkDocumentChangeIdentity } from './work-document-changes';
+interface DocumentNumberingChangeTrackingOptions {
+    createChange: () => WorkDocumentChangeIdentity;
+}
+export declare function trackDocumentNumberingChangeTransaction(transaction: Transaction, state: EditorState, options: DocumentNumberingChangeTrackingOptions): boolean;
+export {};

package/dist/internal/features/work/work-document-numbering-changes.d.ts

@@ -0,0 +1,29 @@
+export type DocumentNumberingChangeType = 'a' | 'A' | 'i' | 'I' | null;
+export interface DocumentNumberingChangeSnapshot {
+    start: number;
+    type: DocumentNumberingChangeType;
+    officeNumberingId: string | null;
+    officeAbstractNumberingId: string | null;
+    officeNumberingLevel: string | null;
+    officeNumberingFormat: string | null;
+    officeNumberingText: string | null;
+    officeNumberingSuffix: string | null;
+    officeNumberingAlignment: string | null;
+    officeNumberingIndentLeft: string | null;
+    officeNumberingIndentRight: string | null;
+    officeNumberingIndentStart: string | null;
+    officeNumberingIndentEnd: string | null;
+    officeNumberingIndentHanging: string | null;
+    officeNumberingIndentFirstLine: string | null;
+    officeNumberingRestartAfterLevel: string | null;
+    level: number;
+    originalFormat: number;
+    originalSuffix: string;
+}
+export declare const DOCUMENT_NUMBERING_CHANGE_ATTRIBUTES: readonly ["numberingChangeKind", "numberingChangeId", "numberingChangeActorId", "numberingChangeAuthor", "numberingChangeDate", "numberingChangeBefore"];
+export declare function serializeDocumentNumberingChange(attributes: Record<string, unknown>): string;
+export declare function parseDocumentNumberingChange(value: unknown): DocumentNumberingChangeSnapshot | null;
+export declare function restoredDocumentNumberingAttributes(attributes: Record<string, unknown>, serialized: unknown): Record<string, unknown> | null;
+export declare function clearDocumentNumberingChangeAttributes(attributes: Record<string, unknown>): Record<string, unknown>;
+export declare function numberingFormatFromType(type: DocumentNumberingChangeType): number;
+export declare function numberingTypeFromFormat(format: number): DocumentNumberingChangeType | undefined;

package/dist/internal/features/work/work-docx-import.d.ts

@@ -5,22 +5,23 @@ import { type ImportedDocxCitationMarkers } from './work-docx-citation-import';
 import { type ImportedDocxCommentMarkers } from './work-docx-comment-import';
 import { type ImportedDocxEquationMarkers } from './work-docx-equation-import';
 import { type ImportedDocxFieldMarkers } from './work-docx-field-import';
-import { type ImportedDocxIndexMarkers } from './work-docx-index-import';
-import { type ImportedDocxTableOfContentsMarkers } from './work-docx-table-of-contents-import';
 import { type ImportedDocxImageLayoutMarkers } from './work-docx-image-layout-import';
+import { type ImportedDocxIndexMarkers } from './work-docx-index-import';
 import { type ImportedDocxListMarkers } from './work-docx-list-import';
+import { type ImportedDocxNumberingChangeMarkers } from './work-docx-numbering-change-import';
 import { type ImportedDocxParagraphAlignmentMarkers } from './work-docx-paragraph-alignment-import';
+import { type ImportedDocxParagraphBorderMarkers } from './work-docx-paragraph-borders-import';
 import { type ImportedDocxParagraphDirectionMarkers } from './work-docx-paragraph-direction-import';
-import { type ImportedDocxParagraphIdentityMarkers } from './work-docx-paragraph-identity-import';
 import { type ImportedDocxParagraphFormattingChangeMarkers } from './work-docx-paragraph-format-change-import';
+import { type ImportedDocxParagraphIdentityMarkers } from './work-docx-paragraph-identity-import';
 import { type ImportedDocxParagraphIndentMarkers } from './work-docx-paragraph-indent-import';
 import { type ImportedDocxParagraphPaginationMarkers } from './work-docx-paragraph-pagination-import';
-import { type ImportedDocxParagraphBorderMarkers } from './work-docx-paragraph-borders-import';
 import { type ImportedDocxParagraphShadingMarkers } from './work-docx-paragraph-shading-import';
 import { type ImportedDocxParagraphSpacingMarkers } from './work-docx-paragraph-spacing-import';
 import { type ImportedDocxRunFormattingMarkers } from './work-docx-run-formatting-import';
 import { type ImportedDocxParagraphTabStopMarkers } from './work-docx-tab-stop-import';
 import { type ImportedDocxTableCellMarkers } from './work-docx-table-cell-import';
+import { type ImportedDocxTableOfContentsMarkers } from './work-docx-table-of-contents-import';
 import { type ImportedDocxTableRowMarkers } from './work-docx-table-row-import';
 import { type ImportedDocxTableSizingMarkers } from './work-docx-table-sizing-import';
 import { OoxmlPackage } from './work-ooxml-package';
@@ -43,6 +44,7 @@ export interface PreparedDocxImport {
     equationMarkers: ImportedDocxEquationMarkers;
     citationMarkers: ImportedDocxCitationMarkers;
     listMarkers: ImportedDocxListMarkers;
+    numberingChangeMarkers: ImportedDocxNumberingChangeMarkers;
     imageLayoutMarkers: ImportedDocxImageLayoutMarkers;
     paragraphIdentityMarkers: ImportedDocxParagraphIdentityMarkers;
     paragraphFormattingChangeMarkers: ImportedDocxParagraphFormattingChangeMarkers;
@@ -62,6 +64,6 @@ export interface PreparedDocxImport {
     trackChanges: boolean;
 }
 export declare function prepareDocxImport(buffer: ArrayBuffer, sourcePackage?: OoxmlPackage): Promise<PreparedDocxImport>;
-export declare function applyDocxSectionsToHtml(html: string, sections: PreparedDocxImport['sections'], captionMarkers?: ImportedDocxCaptionMarkers, bookmarkMarkers?: ImportedDocxBookmarkMarkers, changeMarkers?: ImportedDocxChangeMarkers, commentMarkers?: ImportedDocxCommentMarkers, fieldMarkers?: ImportedDocxFieldMarkers, tableOfContentsMarkers?: ImportedDocxTableOfContentsMarkers, indexMarkers?: ImportedDocxIndexMarkers, equationMarkers?: ImportedDocxEquationMarkers, citationMarkers?: ImportedDocxCitationMarkers, listMarkers?: ImportedDocxListMarkers, imageLayoutMarkers?: ImportedDocxImageLayoutMarkers, paragraphIdentityMarkers?: ImportedDocxParagraphIdentityMarkers, paragraphFormattingChangeMarkers?: ImportedDocxParagraphFormattingChangeMarkers, paragraphAlignmentMarkers?: ImportedDocxParagraphAlignmentMarkers, runFormattingMarkers?: ImportedDocxRunFormattingMarkers, paragraphDirectionMarkers?: ImportedDocxParagraphDirectionMarkers, paragraphIndentMarkers?: ImportedDocxParagraphIndentMarkers, paragraphSpacingMarkers?: ImportedDocxParagraphSpacingMarkers, paragraphBorderMarkers?: ImportedDocxParagraphBorderMarkers, paragraphShadingMarkers?: ImportedDocxParagraphShadingMarkers, paragraphPaginationMarkers?: ImportedDocxParagraphPaginationMarkers, bibliography?: WorkDocumentContent['bibliography'], tabStopMarkers?: ImportedDocxParagraphTabStopMarkers, tableCellMarkers?: ImportedDocxTableCellMarkers, tableRowMarkers?: ImportedDocxTableRowMarkers, tableSizingMarkers?: ImportedDocxTableSizingMarkers): string;
+export declare function applyDocxSectionsToHtml(html: string, sections: PreparedDocxImport['sections'], captionMarkers?: ImportedDocxCaptionMarkers, bookmarkMarkers?: ImportedDocxBookmarkMarkers, changeMarkers?: ImportedDocxChangeMarkers, commentMarkers?: ImportedDocxCommentMarkers, fieldMarkers?: ImportedDocxFieldMarkers, tableOfContentsMarkers?: ImportedDocxTableOfContentsMarkers, indexMarkers?: ImportedDocxIndexMarkers, equationMarkers?: ImportedDocxEquationMarkers, citationMarkers?: ImportedDocxCitationMarkers, listMarkers?: ImportedDocxListMarkers, numberingChangeMarkers?: ImportedDocxNumberingChangeMarkers, imageLayoutMarkers?: ImportedDocxImageLayoutMarkers, paragraphIdentityMarkers?: ImportedDocxParagraphIdentityMarkers, paragraphFormattingChangeMarkers?: ImportedDocxParagraphFormattingChangeMarkers, paragraphAlignmentMarkers?: ImportedDocxParagraphAlignmentMarkers, runFormattingMarkers?: ImportedDocxRunFormattingMarkers, paragraphDirectionMarkers?: ImportedDocxParagraphDirectionMarkers, paragraphIndentMarkers?: ImportedDocxParagraphIndentMarkers, paragraphSpacingMarkers?: ImportedDocxParagraphSpacingMarkers, paragraphBorderMarkers?: ImportedDocxParagraphBorderMarkers, paragraphShadingMarkers?: ImportedDocxParagraphShadingMarkers, paragraphPaginationMarkers?: ImportedDocxParagraphPaginationMarkers, bibliography?: WorkDocumentContent['bibliography'], tabStopMarkers?: ImportedDocxParagraphTabStopMarkers, tableCellMarkers?: ImportedDocxTableCellMarkers, tableRowMarkers?: ImportedDocxTableRowMarkers, tableSizingMarkers?: ImportedDocxTableSizingMarkers): string;
 export declare function readDocxLayout(buffer: ArrayBuffer): Promise<ImportedDocumentLayout>;
 export {};

package/dist/internal/features/work/work-docx-list-export.d.ts

@@ -12,6 +12,7 @@ export interface DocxListExportContext {
     numberingSourceIdentities: Array<DocxSourceNumberingIdentity | null>;
     paragraphBorderPatches?: DocxParagraphBorderPatchCollector;
     themePatches?: DocxThemePatchCollector;
+    numberingChangeMarker?: (list: HTMLElement, itemIndex: number) => string | null;
 }
 type InlineRuns = (element: HTMLElement) => Promise<ParagraphChild[]>;
 export declare function listToDocxParagraphs(list: HTMLElement, docx: typeof import('docx'), context: DocxListExportContext, inlineRuns: InlineRuns, depth?: number): Promise<Array<InstanceType<typeof docx.Paragraph>>>;

package/dist/internal/features/work/work-docx-numbering-change-export.d.ts

@@ -0,0 +1,13 @@
+interface DocxNumberingChangePatch {
+    marker: string;
+    id: number;
+    author: string;
+    date: string;
+    original: string;
+}
+export declare class DocxNumberingChangePatchCollector {
+    readonly patches: DocxNumberingChangePatch[];
+    register(list: HTMLElement, itemIndex: number, id: number): string | null;
+}
+export declare function patchDocxNumberingChanges(buffer: ArrayBuffer, patches: readonly DocxNumberingChangePatch[]): Promise<ArrayBuffer>;
+export {};

package/dist/internal/features/work/work-docx-numbering-change-import.d.ts

@@ -0,0 +1,17 @@
+export interface ImportedDocxNumberingChangeGroup {
+    markers: string[];
+    id: string;
+    author: string;
+    date: string;
+    start: number;
+    level: number;
+    format: number;
+    suffix: string;
+}
+export interface ImportedDocxNumberingChangeMarkers {
+    groups: ImportedDocxNumberingChangeGroup[];
+}
+export declare function markDocxNumberingChanges(document: Document): ImportedDocxNumberingChangeMarkers;
+export declare function applyImportedDocxNumberingChangeMarkers(document: Document, markers: ImportedDocxNumberingChangeMarkers): void;
+export declare function hasImportedDocxNumberingChangeMarkers(markers: ImportedDocxNumberingChangeMarkers): boolean;
+export declare function isSupportedDocxNumberingChange(change: Element): boolean;

package/dist/internal/features/work/work-presentation-animation.d.ts

@@ -1,4 +1,4 @@
-import type { WorkSlide, WorkSlideAnimation, WorkSlideAnimationEffect } from './work-types';
+import type { WorkSlide, WorkSlideAnimation, WorkSlideAnimationClass, WorkSlideAnimationEffect } from './work-types';
 export { WORK_SLIDE_ANIMATION_LIMIT, WORK_SLIDE_ANIMATION_MAX_DELAY_MS, WORK_SLIDE_ANIMATION_MAX_DURATION_MS, WORK_SLIDE_ANIMATION_MIN_DURATION_MS, } from './work-presentation-animation-constraints';
 export interface WorkSlideAnimationCueItem {
     animation: WorkSlideAnimation;
@@ -10,11 +10,15 @@ export interface WorkSlideAnimationCue {
     items: WorkSlideAnimationCueItem[];
     totalDurationMs: number;
 }
+export type WorkSlideAnimationSequenceIssue = 'duplicate-class' | 'overlapping-target';
 export declare function createWorkSlideAnimation(elementId: string, effect: WorkSlideAnimationEffect, previous?: WorkSlideAnimation): WorkSlideAnimation;
 export declare function normalizeWorkSlideAnimation(animation: WorkSlideAnimation): WorkSlideAnimation;
-export declare function workSlideAnimationForElement(slide: WorkSlide, elementId: string | undefined): WorkSlideAnimation | undefined;
+export declare function workSlideAnimationClass(effect: WorkSlideAnimationEffect): WorkSlideAnimationClass;
+export declare function workSlideAnimationEffectMatchesClass(effect: WorkSlideAnimationEffect, animationClass: WorkSlideAnimationClass): boolean;
+export declare function workSlideAnimationForElement(slide: WorkSlide, elementId: string | undefined, animationClass: WorkSlideAnimationClass): WorkSlideAnimation | undefined;
 export declare function workSlideAnimationIndex(slide: WorkSlide, animationId: string | undefined): number;
 export declare function workSlideAnimationCues(animations: readonly WorkSlideAnimation[] | undefined): WorkSlideAnimationCue[];
 export declare function initialWorkSlideAnimationCueIndex(cues: readonly WorkSlideAnimationCue[]): number;
+export declare function workSlideAnimationSequenceIssue(animations: readonly WorkSlideAnimation[] | undefined): WorkSlideAnimationSequenceIssue | undefined;
 export declare function removeWorkSlideAnimationsForElements(slide: WorkSlide, elementIds: ReadonlySet<string>): WorkSlide;
 export declare function remapWorkSlideAnimations(animations: readonly WorkSlideAnimation[] | undefined, elementIds: ReadonlyMap<string, string>): WorkSlideAnimation[] | undefined;

package/dist/internal/features/work/work-presentation-clipboard.d.ts

@@ -1,10 +1,6 @@
 import type { WorkSlide, WorkSlideAnimation, WorkSlideElement } from './work-types';
 export declare const PRESENTATION_OBJECT_OFFSET_STEP = 5;
 export type WorkPresentationClipboardPayload = {
-    kind: 'element';
-    element: WorkSlideElement;
-    animation?: WorkSlideAnimation;
-} | {
     kind: 'elements';
     elements: WorkSlideElement[];
     animations?: WorkSlideAnimation[];
@@ -20,7 +16,6 @@ export interface WorkPresentationElementPaste {
     animations?: WorkSlideAnimation[];
     elements: WorkSlideElement[];
 }
-export declare function copyPresentationElement(element: WorkSlideElement, animation?: WorkSlideAnimation): void;
 export declare function copyPresentationElements(elements: readonly WorkSlideElement[], animations?: readonly WorkSlideAnimation[]): void;
 export declare function copyPresentationSlide(slide: WorkSlide): void;
 export declare function takePresentationClipboard(): WorkPresentationClipboardRead | null;

package/dist/internal/features/work/work-types.d.ts

@@ -106,7 +106,7 @@ export interface WorkDocumentContent {
     comments?: WorkDocumentComment[];
     bibliography?: WorkDocumentBibliography;
 }
-export type WorkDocumentChangeKind = 'insertion' | 'deletion' | 'formatting' | 'paragraph-formatting';
+export type WorkDocumentChangeKind = 'insertion' | 'deletion' | 'formatting' | 'paragraph-formatting' | 'numbering';
 export type WorkDocumentChangeDecisionAction = 'accept' | 'reject';
 /**
  * Immutable audit record created when an editor accepts or rejects one
@@ -589,12 +589,16 @@ export interface WorkSlideTransition {
     advanceOnClick: boolean;
     advanceAfterMs?: number;
 }
-export type WorkSlideAnimationEffect = 'appear' | 'fade' | 'fly-in' | 'zoom';
+export type WorkSlideAnimationClass = 'entrance' | 'exit';
+export type WorkSlideEntranceAnimationEffect = 'appear' | 'fade' | 'fly-in' | 'zoom';
+export type WorkSlideExitAnimationEffect = 'disappear' | 'fade-out' | 'fly-out' | 'zoom-out';
+export type WorkSlideAnimationEffect = WorkSlideEntranceAnimationEffect | WorkSlideExitAnimationEffect;
 export type WorkSlideAnimationTrigger = 'on-click' | 'with-previous' | 'after-previous';
 export type WorkSlideAnimationDirection = 'left' | 'right' | 'up' | 'down';
 /**
- * One bounded entrance animation applied to one slide-owned element.
- * Array order on `WorkSlide.animations` is the canonical playback order.
+ * One bounded entrance or exit animation applied to one slide-owned element.
+ * An element may own at most one animation from each class. Array order on
+ * `WorkSlide.animations` is the canonical playback order.
  */
 export interface WorkSlideAnimation {
     id: string;