@a3s-lab/office 0.33.0 → 0.35.0

package/dist/0~spreadsheet-editor.js

@@ -5315,6 +5315,70 @@ function spreadsheetCellFillRangeIsSafe(range) {
 function sameSpreadsheetCellRange(left, right) {
     return left.row[0] === right.row[0] && left.row[1] === right.row[1] && left.column[0] === right.column[0] && left.column[1] === right.column[1];
 }
+function canEditSpreadsheetSelection(context) {
+    return Boolean(context.editable && context.workbook && context.targetSheetId);
+}
+function spreadsheetLiveCommandRange(context) {
+    const selection = spreadsheetLiveCommandSelection(context);
+    return spreadsheetSingleRange(selection ?? context.fallbackRange);
+}
+function spreadsheetLiveCommandSelection(context) {
+    return spreadsheetLiveCommandSelections(context)?.at(-1);
+}
+function spreadsheetLiveCommandSelections(context) {
+    const shadow = context.selectionRef?.current;
+    if (shadow?.sheetId === context.targetSheetId) return [
+        shadow.selection
+    ];
+    return context.workbook?.getSelection();
+}
+function acceptSpreadsheetSelectionChange(selectionRef, sheetId, selection) {
+    const nextSelection = finiteSpreadsheetSelection(selection);
+    const requested = selectionRef.requested;
+    if (requested && (requested.sheetId !== sheetId || !sameSpreadsheetSelectionValue(requested.selection, nextSelection))) return null;
+    const next = {
+        sheetId,
+        selection: nextSelection
+    };
+    selectionRef.current = next;
+    return next;
+}
+function rememberSpreadsheetCommandSelection(context, selection) {
+    if (!context.selectionRef || !context.targetSheetId) return;
+    const next = {
+        ...selection,
+        row: [
+            ...selection.row
+        ],
+        column: [
+            ...selection.column
+        ]
+    };
+    context.selectionRef.current = {
+        sheetId: context.targetSheetId,
+        selection: next
+    };
+    context.selectionRef.requested = {
+        sheetId: context.targetSheetId,
+        selection: {
+            ...next,
+            row: [
+                ...next.row
+            ],
+            column: [
+                ...next.column
+            ]
+        }
+    };
+}
+function releaseSpreadsheetSelectionRequest(selectionRef) {
+    selectionRef.requested = null;
+}
+function sameSpreadsheetSelectionValue(left, right) {
+    const normalizedLeft = finiteSpreadsheetSelection(left);
+    const normalizedRight = finiteSpreadsheetSelection(right);
+    return normalizedLeft.row[0] === normalizedRight.row[0] && normalizedLeft.row[1] === normalizedRight.row[1] && normalizedLeft.column[0] === normalizedRight.column[0] && normalizedLeft.column[1] === normalizedRight.column[1] && normalizedLeft.row_focus === normalizedRight.row_focus && normalizedLeft.column_focus === normalizedRight.column_focus;
+}
 function createSpreadsheetCellFillExtension() {
     return createOfficeEditorExtension({
         name: 'spreadsheetCellFill',
@@ -5365,9 +5429,11 @@ function materializeSpreadsheetCellFillRows(sheet, plan) {
 }
 function spreadsheetSelectedCellFillPlan(context, direction) {
     if (!context.editable || !context.workbook || !context.targetSheetId || context.targetSheetId !== context.activeSheetId) return null;
-    const selections = context.workbook.getSelection();
+    const selections = spreadsheetLiveCommandSelections(context);
     if (selections?.length !== 1) return null;
-    const plan = planSpreadsheetCellFill(selections[0], direction);
+    const selection = selections[0];
+    if (!selection) return null;
+    const plan = planSpreadsheetCellFill(selection, direction);
     if (!plan) return null;
     const sheet = context.content.sheets.find((candidate)=>candidate.id === context.targetSheetId);
     return canApplySpreadsheetCellFill(sheet, plan) ? plan : null;
@@ -6323,13 +6389,6 @@ function applySelectedCellStyle(context, preset) {
 function liveSpreadsheetCellStyleRange(context) {
     return spreadsheetSingleRange(context.workbook?.getSelection()?.at(-1) ?? context.fallbackRange);
 }
-function canEditSpreadsheetSelection(context) {
-    return Boolean(context.editable && context.workbook && context.targetSheetId);
-}
-function spreadsheetLiveCommandRange(context) {
-    const selection = context.workbook?.getSelection()?.at(-1);
-    return spreadsheetSingleRange(selection ?? context.fallbackRange);
-}
 const MAX_SPREADSHEET_ROWS = 1048576;
 const spreadsheetPasteContentOptions = [
     {
@@ -8493,7 +8552,7 @@ function updateSpreadsheetSelection(context, storage, update) {
     if (!context.workbook || !context.targetSheetId) return false;
     const sheet = context.content.sheets.find((candidate)=>candidate.id === context.targetSheetId);
     if (!sheet) return false;
-    const liveSelection = context.workbook.getSelection()?.at(-1) ?? context.fallbackRange;
+    const liveSelection = spreadsheetLiveCommandSelection(context) ?? context.fallbackRange;
     const rememberedFocus = storage.focus;
     const selection = rememberedFocus && spreadsheetSelectionContainsFocus(liveSelection, rememberedFocus) ? {
         ...liveSelection,
@@ -8507,6 +8566,7 @@ function updateSpreadsheetSelection(context, storage, update) {
         ], {
             id: context.targetSheetId
         });
+        rememberSpreadsheetCommandSelection(context, next);
         storage.focus = {
             row: next.row_focus ?? next.row[1] ?? next.row[0] ?? 0,
             column: next.column_focus ?? next.column[1] ?? next.column[0] ?? 0
@@ -10010,6 +10070,16 @@ function pasteCells(context, values) {
         ], {
             id: context.targetSheetId
         });
+        rememberSpreadsheetCommandSelection(context, {
+            row: [
+                ...range.row
+            ],
+            column: [
+                ...range.column
+            ],
+            row_focus: range.row[0],
+            column_focus: range.column[0]
+        });
     } catch  {}
     syncSpreadsheetFormulaBar(context, data[0][0]);
     return true;
@@ -25395,6 +25465,60 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
     const editorFocusOrigin = useOfficeEditorFocusOrigin();
     const workbookRef = useRef(null);
     const projectedWorkbookSheetsRef = useRef([]);
+    useLayoutEffect(()=>{
+        const container = spreadsheetCanvasRef.current;
+        if (!container || preview) return;
+        let pendingEditor = null;
+        let pointerEnteredEditor = false;
+        const moveEditorCaretToEnd = (editor)=>{
+            if (document.activeElement !== editor || !editor.isConnected || !editor.textContent) return false;
+            const selection = document.getSelection();
+            if (!selection) return false;
+            const range = document.createRange();
+            range.selectNodeContents(editor);
+            range.collapse(false);
+            selection.removeAllRanges();
+            selection.addRange(range);
+            return true;
+        };
+        const handlePointerDown = (event)=>{
+            pointerEnteredEditor = event.target instanceof Element && Boolean(event.target.closest('.luckysheet-cell-input'));
+        };
+        const handleFocusIn = (event)=>{
+            const target = event.target;
+            const editor = target instanceof Element ? target.closest('.luckysheet-cell-input') : null;
+            if (!editor || pointerEnteredEditor) {
+                pendingEditor = null;
+                pointerEnteredEditor = false;
+                return;
+            }
+            pendingEditor = editor;
+            queueMicrotask(()=>{
+                if (pendingEditor === editor && moveEditorCaretToEnd(editor)) pendingEditor = null;
+            });
+        };
+        const observer = new MutationObserver(()=>{
+            const editor = pendingEditor;
+            if (!editor || document.activeElement !== editor) return;
+            if (!editor.textContent) return;
+            moveEditorCaretToEnd(editor);
+            pendingEditor = null;
+        });
+        container.addEventListener('pointerdown', handlePointerDown, true);
+        container.addEventListener('focusin', handleFocusIn, true);
+        observer.observe(container, {
+            characterData: true,
+            childList: true,
+            subtree: true
+        });
+        return ()=>{
+            container.removeEventListener('pointerdown', handlePointerDown, true);
+            container.removeEventListener('focusin', handleFocusIn, true);
+            observer.disconnect();
+        };
+    }, [
+        preview
+    ]);
     const spreadsheetZoomRef = useRef(100);
     const [workbookInstance, setWorkbookInstance] = useState(null);
     const bindWorkbookInstance = useCallback((instance)=>{
@@ -25413,6 +25537,10 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
     const [panel, setPanel] = useState(null);
     const panelTriggerRef = useRef(null);
     const [selectionState, setSelectionState] = useState(null);
+    const selectionStateRef = useRef({
+        current: null,
+        requested: null
+    });
     const formatPainterSelectionHandlerRef = useRef((_sheetId, _selection)=>void 0);
     const [contextMenu, setContextMenu] = useState(null);
     const [formatCellsDialog, setFormatCellsDialog] = useState(null);
@@ -25588,15 +25716,16 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
                 collaborationView?.activateSheet(id);
                 if (previewRef.current) setPreviewActiveSheetId(id);
                 else setNavigationActiveSheetId(id);
+                selectionStateRef.current.current = null;
+                releaseSpreadsheetSelectionRequest(selectionStateRef.current);
                 setSelectionState(null);
             },
             afterSelectionChange: (sheetId, selection)=>{
-                collaborationView?.select(sheetId, selection);
-                setSelectionState({
-                    sheetId,
-                    selection
-                });
-                formatPainterSelectionHandlerRef.current(sheetId, selection);
+                const next = acceptSpreadsheetSelectionChange(selectionStateRef.current, sheetId, selection);
+                if (!next) return;
+                collaborationView?.select(sheetId, next.selection);
+                setSelectionState(next);
+                formatPainterSelectionHandlerRef.current(sheetId, next.selection);
             },
             beforeUpdateCell: (row, column)=>{
                 const sheet = contentRef.current.sheets.find((candidate)=>candidate.id === activeSheetIdRef.current);
@@ -25876,6 +26005,8 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
         if (!sheet) return false;
         activeSheetIdRef.current = sheetId;
         if (collaborationView && !collaborationView.activateSheet(sheetId)) return false;
+        selectionStateRef.current.current = null;
+        releaseSpreadsheetSelectionRequest(selectionStateRef.current);
         setSelectionState(null);
         if (previewRef.current) setPreviewActiveSheetId(sheetId);
         try {
@@ -25910,7 +26041,7 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
                 targetRow: activeCell.row,
                 targetColumn: activeCell.column
             });
-            setSelectionState({
+            const nextSelection = {
                 sheetId,
                 selection: {
                     row: [
@@ -25922,7 +26053,21 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
                     row_focus: activeCell.row,
                     column_focus: activeCell.column
                 }
-            });
+            };
+            selectionStateRef.current.current = nextSelection;
+            selectionStateRef.current.requested = {
+                sheetId,
+                selection: {
+                    ...nextSelection.selection,
+                    row: [
+                        ...nextSelection.selection.row
+                    ],
+                    column: [
+                        ...nextSelection.selection.column
+                    ]
+                }
+            };
+            setSelectionState(nextSelection);
         } catch  {
             return false;
         }
@@ -26043,6 +26188,7 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
             toggle: (attribute)=>richTextSelectionRef.current?.toggle(contentRef.current, acceptSpreadsheetCommandChange, attribute) ?? false
         },
         selection: selectionState,
+        selectionRef: selectionStateRef.current,
         table: spreadsheetTable.commandPort,
         targetSheetGridSize,
         targetSheetId: toolbarSheetId,
@@ -26150,6 +26296,7 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
         if ('Escape' === event.key && isSpreadsheetCellEditingTarget(event.target)) requestAnimationFrame(()=>focusSpreadsheetGrid(spreadsheetCanvasRef.current));
     };
     const handleSpreadsheetKeyDownCapture = (event)=>{
+        releaseSpreadsheetSelectionRequest(selectionStateRef.current);
         if ('Alt' === event.key && !event.repeat && event.target instanceof Element && event.target.closest('.fortune-sheet-overlay') && reserveAutoFilterAltKey()) {
             event.preventDefault();
             event.stopPropagation();
@@ -26158,6 +26305,7 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
         handleSpreadsheetEditingEscape(event);
     };
     const handleSpreadsheetPointerDownCapture = (event)=>{
+        releaseSpreadsheetSelectionRequest(selectionStateRef.current);
         const controller = richTextSelectionRef.current;
         if (!controller) return;
         if (!isSpreadsheetRichTextFormatPointerTarget(event.target)) return void controller.clear();

package/dist/0~work-pptx-export.js

@@ -3,7 +3,7 @@ import { normalizeRadarStyle, presentationChartShowsLegend, presentationChartAxe
 import { directChildren, xmlNamespacePrefix, parseXml, firstDescendant, directChild, descendants, childPath, attribute } from "./4121.js";
 import { workSpreadsheetChartAxisShowsMajorGridlinesByDefault, workSpreadsheetChartAxisDefaultLabelPosition, workSpreadsheetChartAxisIsCategoryAxis, workSpreadsheetChartAxisIsValueAxis } from "./8715.js";
 import { presentationGroupPath, withPresentationDesign } from "./0~1403.js";
-import { patchPptxChartLayoutAndSeriesStyles, patchPptxTransitions, patchPptxComments, patchPptxChartDataLabels, patchPptxChartSeriesAnalysis } from "./0~7614.js";
+import { patchPptxChartLayoutAndSeriesStyles, patchPptxTransitions, patchPptxComments, patchPptxChartDataLabels, patchPptxChartSeriesAnalysis, patchPptxAnimations } from "./0~7828.js";
 const DRAWING_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';
 async function patchPptxChartAxes(buffer, slides) {
     const charts = slides.flatMap((slide)=>slide.elements.flatMap((element)=>'chart' === element.type && element.chart ? [
@@ -270,27 +270,40 @@ const PRESENTATIONML_NAMESPACE = 'http://schemas.openxmlformats.org/presentation
 const DRAWINGML_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';
 const GROUPABLE_PART = /^ppt\/(?:slides|slideLayouts|slideMasters)\/[^/]+\.xml$/;
 class PptxGroupExportRegistry {
+    animatedElementKeys = new Set();
     bindings = new Map();
+    bindingsByElement = new Map();
     roleCounts = new Map();
     markerSequence = 0;
     get size() {
         return this.bindings.size;
     }
+    registerAnimatedElements(scope, elementIds) {
+        for (const elementId of elementIds)this.animatedElementKeys.add(exportElementKey(scope, elementId));
+    }
     objectName(scope, element, role) {
         const groupPath = presentationGroupPath(element);
-        if (!groupPath.length) return;
+        const elementKey = exportElementKey(scope, element.id);
+        if (!groupPath.length && !this.animatedElementKeys.has(elementKey)) return;
+        const existing = this.bindingsByElement.get(elementKey);
+        if (existing) return existing.marker;
         const roleCount = (this.roleCounts.get(role) ?? 0) + 1;
         this.roleCounts.set(role, roleCount);
         this.markerSequence += 1;
         const marker = `${EXPORT_MARKER_PREFIX}${this.markerSequence}`;
-        this.bindings.set(marker, {
+        const binding = {
             displayName: `${pptxRoleName(role)} ${roleCount}`,
             groupPath,
             groupScope: scope,
             marker
-        });
+        };
+        this.bindings.set(marker, binding);
+        this.bindingsByElement.set(elementKey, binding);
         return marker;
     }
+    markerForElement(scope, elementId) {
+        return this.bindingsByElement.get(exportElementKey(scope, elementId))?.marker;
+    }
     binding(marker) {
         return this.bindings.get(marker);
     }
@@ -315,7 +328,7 @@ async function patchPptxNativeGroups(buffer, registry) {
     }
     for (const binding of registry.values()){
         const count = found.get(binding.marker) ?? 0;
-        if (1 !== count) throw new Error(`PPTX group export expected one generated object for ${binding.displayName}, but found ${count}.`);
+        if (1 !== count) throw new Error(`PPTX export expected one generated object for ${binding.displayName}, but found ${count}.`);
     }
     return archive.generateAsync({
         type: 'arraybuffer',
@@ -323,6 +336,7 @@ async function patchPptxNativeGroups(buffer, registry) {
     });
 }
 function patchPptxShapeTree(shapeTree, registry, found) {
+    normalizePptxNonVisualIds(shapeTree);
     const sceneNodes = directChildren(shapeTree).filter(isPptxSceneNode).map((node, order)=>{
         const properties = firstDescendant(node, 'cNvPr');
         const objectName = properties ? attribute(properties, 'name') : null;
@@ -342,9 +356,9 @@ function patchPptxShapeTree(shapeTree, registry, found) {
     });
     if (!sceneNodes.some((item)=>item.binding)) return false;
     const roots = new Map();
-    const rootNodes = sceneNodes.filter((item)=>!item.binding);
+    const rootNodes = sceneNodes.filter((item)=>!item.binding?.groupPath.length);
     for (const item of sceneNodes){
-        if (!item.binding) continue;
+        if (!item.binding?.groupPath.length) continue;
         let siblings = roots;
         let bucket;
         for (const groupId of item.binding.groupPath){
@@ -378,7 +392,6 @@ function patchPptxShapeTree(shapeTree, registry, found) {
     ].sort((left, right)=>left.order - right.order);
     const extensionList = directChild(shapeTree, 'extLst') ?? null;
     for (const item of renderedRoots)shapeTree.insertBefore(item.node, extensionList);
-    normalizePptxNonVisualIds(shapeTree);
     return true;
 }
 function renderPptxGroup(bucket, document, nextId, nextGroupNumber) {
@@ -492,6 +505,9 @@ function normalizePptxNonVisualIds(shapeTree) {
 function groupBucketKey(scope, groupId) {
     return `${scope}\u0000${groupId}`;
 }
+function exportElementKey(scope, elementId) {
+    return `${scope}\u0000${elementId}`;
+}
 function isPptxSceneNode(node) {
     return [
         'contentPart',
@@ -735,7 +751,9 @@ function createPptxExportState(artifact, PptxGenJS) {
         if (!source.useLayoutBackground) slide.background = {
             color: source.background.replace('#', '')
         };
-        for (const element of source.elements)addPresentationElement(slide, element, presentation, slideWidth, slideHeight, groups, `slide:${source.id}`, element.placeholder ? binding?.placeholderNames.get(element.placeholder.key) : void 0);
+        const groupScope = `slide:${source.id}`;
+        groups.registerAnimatedElements(groupScope, source.animations?.map((animation)=>animation.elementId) ?? []);
+        for (const element of source.elements)addPresentationElement(slide, element, presentation, slideWidth, slideHeight, groups, groupScope, element.placeholder ? binding?.placeholderNames.get(element.placeholder.key) : void 0);
         if (source.notes?.trim()) slide.addNotes(source.notes);
     }
     return {
@@ -758,7 +776,8 @@ async function createPptxBlob(artifact, PptxGenJS) {
     const withChartSeriesAnalysis = await patchPptxChartSeriesAnalysis(withChartAxes, slides);
     const withTransitions = await patchPptxTransitions(withChartSeriesAnalysis, slides);
     const withComments = await patchPptxComments(withTransitions, slides, 'presentation' === artifact.content.type ? artifact.content.width ?? 13.333 : 13.333, 'presentation' === artifact.content.type ? artifact.content.height ?? 7.5 : 7.5);
-    const patched = await patchPptxNativeGroups(withComments, groups);
+    const withAnimations = await patchPptxAnimations(withComments, slides, groups);
+    const patched = await patchPptxNativeGroups(withAnimations, groups);
     return new Blob([
         patched
     ], {
@@ -886,8 +905,13 @@ function addPresentationElement(slide, element, presentation, slideWidth, slideH
         });
         return;
     }
-    if ('shape' === element.type) addShape(slide, element, presentation, x, y, width, height, resolvedPlaceholder, groups.objectName(groupScope, element, 'shape'));
-    if (element.text) addText(slide, element, x, y, width, height, resolvedPlaceholder, groups.objectName(groupScope, element, 'text'));
+    if ('shape' === element.type) {
+        const objectName = groups.objectName(groupScope, element, 'shape');
+        if (element.text || element.textRuns?.length) addText(slide, element, x, y, width, height, resolvedPlaceholder, objectName, pptxShapeType(presentation, element));
+        else addShape(slide, element, presentation, x, y, width, height, resolvedPlaceholder, objectName);
+        return;
+    }
+    if ('text' === element.type) addText(slide, element, x, y, width, height, resolvedPlaceholder, groups.objectName(groupScope, element, 'text'));
 }
 function pptxChartData(chart) {
     if (presentationChartUsesNumericXAxis(chart.type)) return [
@@ -926,7 +950,7 @@ function pptxLegendPosition(position) {
     return 'r';
 }
 function addShape(slide, element, presentation, x, y, width, height, placeholder, objectName) {
-    const shapeType = 'ellipse' === element.shapeType ? presentation.ShapeType.ellipse : 'triangle' === element.shapeType ? presentation.ShapeType.triangle : 'diamond' === element.shapeType ? presentation.ShapeType.diamond : 'roundRect' === element.shapeType ? presentation.ShapeType.roundRect : presentation.ShapeType.rect;
+    const shapeType = pptxShapeType(presentation, element);
     const fillColor = element.fill.replace('#', '');
     const borderColor = (element.borderColor ?? element.fill).replace('#', '');
     const options = {
@@ -954,7 +978,7 @@ function addShape(slide, element, presentation, x, y, width, height, placeholder
     };
     slide.addShape(shapeType, options);
 }
-function addText(slide, element, x, y, width, height, placeholder, objectName) {
+function addText(slide, element, x, y, width, height, placeholder, objectName, shape) {
     const text = element.textRuns?.length ? element.textRuns.map((run)=>({
             text: run.text,
             options: {
@@ -989,9 +1013,14 @@ function addText(slide, element, x, y, width, height, placeholder, objectName) {
         valign: element.verticalAlign ?? 'middle',
         margin: 'transparent' === element.fill ? 0 : 10,
         breakLine: false,
+        shape,
         fill: 'transparent' === element.fill ? void 0 : {
             color: element.fill.replace('#', '')
         },
+        line: element.borderWidth && element.borderColor ? {
+            color: element.borderColor.replace('#', ''),
+            width: element.borderWidth
+        } : void 0,
         hyperlink: element.href ? {
             url: element.href
         } : void 0,
@@ -1001,6 +1030,13 @@ function addText(slide, element, x, y, width, height, placeholder, objectName) {
         } : {}
     });
 }
+function pptxShapeType(presentation, element) {
+    if ('ellipse' === element.shapeType) return presentation.ShapeType.ellipse;
+    if ('triangle' === element.shapeType) return presentation.ShapeType.triangle;
+    if ('diamond' === element.shapeType) return presentation.ShapeType.diamond;
+    if ('roundRect' === element.shapeType) return presentation.ShapeType.roundRect;
+    return presentation.ShapeType.rect;
+}
 async function presentationArrayBuffer(output) {
     if (output instanceof ArrayBuffer) return output;
     if (output instanceof Blob) return output.arrayBuffer();

package/dist/0~work-pptx-import.js

@@ -1,6 +1,6 @@
 import { contentTypeForPart, directChildren, bytesToDataUrl, OoxmlPackage, firstDescendant, descendants, directChild, childPath, attribute, createOfficeId as createWorkId } from "./4121.js";
 import { normalizeRadarStyle, normalizePresentationChartLegendPosition, presentationChartUsesNumericXAxis, normalizePresentationBubbleScale, normalizePresentationBubbleSizeRepresents, withPresentationChartLayout, normalizeDoughnutHoleSize, normalizePresentationScatterStyle } from "./0~work-presentation-charts.js";
-import { loadPptxCommentAuthors, readPptxSlideComments, readPptxChartLayoutAndSeriesStyles, readPptxTransition, readPptxChartSeriesAnalysis, readPptxChartDataLabels } from "./0~7614.js";
+import { loadPptxCommentAuthors, readPptxSlideComments, readPptxChartLayoutAndSeriesStyles, readPptxAnimations, readPptxTransition, readPptxChartSeriesAnalysis, readPptxChartDataLabels } from "./0~7828.js";
 import { parseXlsxChartAxes } from "./4166.js";
 import { scaledPresentationVisuals } from "./0~work-presentation-visual-scale.js";
 async function loadPptxTheme(archive, presentationRelationships) {
@@ -547,6 +547,7 @@ async function parseSlide(archive, slidePart, slideNumber, slideWidthEmu, slideH
         theme,
         issues,
         imageBudget,
+        elementIdByPptxShapeId: new Map(),
         location: `幻灯片 ${slideNumber}`
     };
     const design = await ensurePptxDesignDefinitions(archive, inheritance.layout, inheritance.master, context, designs);
@@ -554,6 +555,7 @@ async function parseSlide(archive, slidePart, slideNumber, slideWidthEmu, slideH
     const shapeTree = firstDescendant(document1, 'spTree');
     for (const child of shapeTree ? directChildren(shapeTree) : [])elements.push(...await parseSlideNode(child, context));
     const resolvedElements = inheritPptxPlaceholderStyles(elements, design.master, design.layout);
+    const animationResult = readPptxAnimations(document1, context.elementIdByPptxShapeId);
     const transition = readPptxTransition(document1);
     const commentResult = await readPptxSlideComments(archive, relationships, commentAuthors, slideNumber, slideWidthEmu, slideHeightEmu);
     if (commentResult.comments.length) addIssue(context, 'pptx.comments', 'Comments', `${commentResult.comments.length} traditional slide comment(s), authors, dates, and positions are preserved and editable.`, 'info');
@@ -564,7 +566,8 @@ async function parseSlide(archive, slidePart, slideNumber, slideWidthEmu, slideH
         addIssue(context, 'pptx.transition', 'Slide transitions', transition.transition ? 'Basic slide transitions and advance timing are preserved, editable, and replayed in presentation preview.' : 'This slide transition is not editable and remains in the original PPTX only.', transition.transition ? 'info' : 'warning');
         for (const diagnostic of transition.diagnostics)addIssue(context, diagnostic.code, 'Slide transitions', diagnostic.message);
     }
-    if (firstDescendant(document1, 'timing')) addIssue(context, 'pptx.animation', 'Animations', 'Object animations are not replayed and will be omitted on export.');
+    if (animationResult.animations.length) addIssue(context, 'pptx.animation', 'Animations', `${animationResult.animations.length} supported object entrance animation(s) are preserved, editable, replayed, and exported.`, 'info');
+    for (const diagnostic of animationResult.diagnostics)addIssue(context, diagnostic.code, 'Animations', diagnostic.message);
     for (const relationship of relationships.values())if (relationship.type.includes('/audio') || relationship.type.includes('/video') || relationship.type.includes('/media')) addIssue(context, 'pptx.media', 'Embedded media', 'Audio and video remain in the original file but are not playable yet.');
     else if (relationship.type.endsWith('/oleObject') || relationship.type.endsWith('/package')) addIssue(context, 'pptx.ole', 'Embedded objects', 'Embedded Office or OLE objects remain in the original file only.');
     const slideBackground = readPptxBackground(document1, theme);
@@ -578,7 +581,8 @@ async function parseSlide(archive, slidePart, slideNumber, slideWidthEmu, slideH
         elements: resolvedElements,
         notes: await readSpeakerNotes(archive, relationships, context),
         comments: commentResult.comments.length ? commentResult.comments : void 0,
-        transition: transition.transition
+        transition: transition.transition,
+        animations: animationResult.animations.length ? animationResult.animations : void 0
     };
 }
 async function loadPptxPresentationDesigns(archive, relationships, slideWidthEmu, slideHeightEmu, theme, issues, imageBudget, registry) {
@@ -592,6 +596,7 @@ async function loadPptxPresentationDesigns(archive, relationships, slideWidthEmu
         theme,
         issues,
         imageBudget,
+        elementIdByPptxShapeId: new Map(),
         location: '母版与布局'
     };
     for (const relationship of relationships.values()){
@@ -659,6 +664,7 @@ function ensureFallbackPptxMaster(registry) {
 async function parsePptxDesignElements(part, context) {
     const partContext = {
         ...context,
+        elementIdByPptxShapeId: new Map(),
         relationships: part.relationships,
         placeholders: new Map()
     };
@@ -712,24 +718,30 @@ function inheritPptxPlaceholderStyle(element, definition) {
     };
 }
 async function parseSlideNode(node, context, transform) {
-    if ('sp' === node.localName) return [
+    let elements;
+    if ('sp' === node.localName) elements = [
         withImportedGroupTransform(parseShape(node, context, transform), transform)
     ];
-    if ('pic' === node.localName) return [
+    else if ('pic' === node.localName) elements = [
         withImportedGroupTransform(await parsePicture(node, context, transform), transform)
     ];
-    if ('graphicFrame' === node.localName) return [
+    else if ('graphicFrame' === node.localName) elements = [
         withImportedGroupTransform(await parseGraphicFrame(node, context, transform), transform)
     ];
-    if ('cxnSp' === node.localName) return [
+    else if ('cxnSp' === node.localName) elements = [
         withImportedGroupTransform(parseConnector(node, context, transform), transform)
     ];
-    if ('grpSp' === node.localName) return parseGroup(node, context, transform);
+    else {
+        if ('grpSp' === node.localName) return parseGroup(node, context, transform);
+        elements = [];
+    }
     if ([
         'contentPart',
         'oleObj'
     ].includes(node.localName)) addIssue(context, 'pptx.content-part', 'Embedded content', 'An embedded slide object remains available in the original PPTX only.');
-    return [];
+    const pptxShapeId = attribute(firstDescendant(node, 'cNvPr') ?? node, 'id');
+    if (pptxShapeId && 1 === elements.length) context.elementIdByPptxShapeId.set(pptxShapeId, elements[0].id);
+    return elements;
 }
 function parseShape(node, context, transform) {
     const box = elementBox(node, context, transform);