@a3s-lab/office 0.33.0 → 0.34.0

package/README.md

@@ -56,12 +56,13 @@ workflows, and a separate Rust automation plane.
 
 ## Latest on `main`
 
-The `0.33.0` release plus the current `main` branch expose these capabilities
+The `0.34.0` release plus the current `main` branch expose these capabilities
 as normal user-facing Playground templates, with matching implementation
 detail in the documentation:
 
 | Editor | Latest capability | Public entry |
 | --- | --- | --- |
+| Presentation | Author, reorder, preview, collaborate on, and play ordered appear, fade, fly-in, and zoom entrance animations with on-click, with-previous, and after-previous triggers; the bounded subset round-trips through native PPTX timing trees | Playground **Latest capabilities → 入场动画** · [Presentation reference](docs/latest/en/components/presentation.mdx#entrance-animations) |
 | Writer | Compare the current document with an imported DOCX, HTML, or TXT version and generate deterministic insertion, deletion, character-formatting, and paragraph-formatting revisions; combine a reviewed copy only after exact baseline verification | Playground **Latest capabilities → 文档比较** · [Document reference](docs/latest/en/components/document.mdx#document-compare-and-combine) |
 | Writer | Insert, customize, navigate, and explicitly refresh a typed Table of Contents with heading and native outline levels 1–9, hyperlinks, page numbers, alignment, four leader styles, and native DOCX `TOC` round trips | Playground **Latest capabilities → 可更新目录** · [Document reference](docs/latest/en/components/document.mdx#native-table-of-contents) |
 | Writer | Mark primary and secondary index terms, cross-references, and bold/italic page numbers; insert, navigate, customize, and refresh a bounded native index with editable DOCX `XE` and `INDEX` round trips | Playground **Latest capabilities → 原生索引** · [Document reference](docs/latest/en/components/document.mdx#native-document-index) |
@@ -70,7 +71,7 @@ detail in the documentation:
 | Spreadsheet | Complete common Data Validation input, blank/dropdown, and Stop/Warning/Information error settings with native XLSX round trips | Playground **Latest capabilities → 数据验证** · [Spreadsheet reference](docs/latest/en/components/spreadsheet.mdx#data-validation) |
 | PDF | Insert, delete, rotate, reorder, extract, merge, and split pages through a dedicated Web Worker, with Blob-level Undo/Redo and independent binary reopen verification | Playground **Latest capabilities → 组织 PDF 页面** · [PDF reference](docs/latest/en/components/pdf.mdx#page-organization) |
 
-All seven entries are reachable from the first Playground viewport. The six
+All eight entries are reachable from the first Playground viewport. The seven
 content templates also remain under **新建**; **组织 PDF 页面** opens the normal
 PDF file workflow because page organization must operate on host-provided source
 bytes. The highlighted strip keeps each capability discoverable without a deep
@@ -163,7 +164,7 @@ baseline rather than one specific release.
 | Text, shapes, tables, charts, and images | **Partial** — typed editable objects with native import/export paths | Broader shapes, connectors, effects, SmartArt, and embedded chart editing |
 | Masters and layouts | **Partial** — import/export inheritance with editable common paths | Full visual master, layout, and placeholder authoring |
 | Transitions and timings | **Partial** — fade, push, wipe, split, cut, and click/automatic advance | Broader transition catalog and timing controls |
-| Animations and media | **Gap** — no production animation timeline, trigger model, audio, video, or recording path | Object animation, motion paths, media editing, and recording |
+| Animations and media | **Partial** — the Work scene model authors, validates, copies, collaborates on, previews, and plays ordered appear/fade/fly-in/zoom entrance cues with click/with-previous/after-previous triggers and bounded timing; this supported entrance subset round-trips through native PPTX timing trees | Exit/emphasis effects, motion paths, audio, video, recording, and broader PPTX preservation |
 | Slideshow and presenter workflows | **Supported** — current/beginning start, keyboard playback, notes, timer, and responsive presenter view | Rehearsal, recording, ink/laser, and richer multi-display controls |
 | Review and collaboration | **Partial** — comments, shared presence, remote object locations, and host transport | Threads, assignments, mentions, and integrated cloud review |
 | PPTX, print, PDF, and video | **Partial** — PPTX round trip plus slide/notes/handout PDF models; no video export | Broader print controls, vector fidelity, media preservation, and video export |
@@ -1622,6 +1623,7 @@ without hard-coded return URLs.
 
 - [Live Playground](https://a3s-lab.github.io/Office/)
 - [Documentation center](https://a3s-lab.github.io/Office/docs/)
+- [A3S Office 0.34.0 documentation](https://a3s-lab.github.io/Office/docs/0.34.0/)
 - [A3S Office 0.33.0 documentation](https://a3s-lab.github.io/Office/docs/0.33.0/)
 - [A3S Office 0.32.0 documentation](https://a3s-lab.github.io/Office/docs/0.32.0/)
 - [A3S Office 0.31.0 documentation](https://a3s-lab.github.io/Office/docs/0.31.0/)

package/dist/0~5809.js

@@ -0,0 +1,123 @@
+import { createOfficeId as createWorkId } from "./4121.js";
+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: 'fly-in' === effect ? previous?.direction ?? 'left' : void 0
+    });
+}
+function normalizeWorkSlideAnimation(animation) {
+    return {
+        ...animation,
+        durationMs: boundedInteger(animation.durationMs, 100, 60000),
+        delayMs: boundedInteger(animation.delayMs, 0, 60000),
+        direction: 'fly-in' === animation.effect ? normalizeWorkSlideAnimationDirection(animation.direction) : void 0
+    };
+}
+function workSlideAnimationForElement(slide, elementId) {
+    if (!elementId) return;
+    return slide.animations?.find((animation)=>animation.elementId === elementId);
+}
+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 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 boundedInteger(value, minimum, maximum) {
+    const finite = Number.isFinite(value) ? Math.round(value) : minimum;
+    return Math.min(maximum, Math.max(minimum, finite));
+}
+const CARDINAL_DIRECTIONS = new Set([
+    'left',
+    'right',
+    'up',
+    'down'
+]);
+const SPLIT_DIRECTIONS = new Set([
+    'in',
+    'out'
+]);
+function createWorkSlideTransition(type, previous) {
+    const common = {
+        type,
+        speed: previous?.speed ?? 'medium',
+        advanceOnClick: previous?.advanceOnClick ?? true,
+        advanceAfterMs: previous?.advanceAfterMs
+    };
+    if ('push' === type || 'wipe' === type) return {
+        ...common,
+        direction: previous?.direction && CARDINAL_DIRECTIONS.has(previous.direction) ? previous.direction : 'left'
+    };
+    if ('split' === type) return {
+        ...common,
+        direction: previous?.direction && SPLIT_DIRECTIONS.has(previous.direction) ? previous.direction : 'out',
+        orientation: previous?.orientation ?? 'horizontal'
+    };
+    return common;
+}
+function slideTransitionDurationMilliseconds(transition) {
+    if (transition?.speed === 'fast') return 500;
+    if (transition?.speed === 'slow') return 2000;
+    return 1000;
+}
+function workSlideTransitionsEqual(left, right) {
+    if (!left || !right) return left === right;
+    return left.type === right.type && left.speed === right.speed && left.direction === right.direction && left.orientation === right.orientation && left.advanceOnClick === right.advanceOnClick && left.advanceAfterMs === right.advanceAfterMs;
+}
+export { createWorkSlideAnimation, createWorkSlideTransition, initialWorkSlideAnimationCueIndex, normalizeWorkSlideAnimation, remapWorkSlideAnimations, removeWorkSlideAnimationsForElements, slideTransitionDurationMilliseconds, workSlideAnimationCues, workSlideAnimationForElement, workSlideAnimationIndex, workSlideTransitionsEqual };

package/dist/{0~7614.js → 0~7828.js}

@@ -1,9 +1,9 @@
 import jszip from "jszip";
-import { descendants, directChildren, directChild, xmlNamespacePrefix, attribute, firstDescendant, parseXml } from "./4121.js";
+import { directChildren, xmlNamespacePrefix, parseXml, firstDescendant, descendants, directChild, attribute, createOfficeId as createWorkId } from "./4121.js";
 import { normalizePresentationChartDataLabelPosition, normalizePresentationChartDataLabels, normalizePresentationChartSeriesStyle } from "./0~work-presentation-charts.js";
 import { parseXlsxChartSeriesStyle, xlsxChartSeriesMarkerXml, parseXlsxTrendline, isSupportedXlsxChartLegend, isSupportedXlsxChartPlotLayout, isSupportedXlsxChartSeriesFormatting, parseXlsxChartPlotLayout, parseXlsxChartLegend, xlsxChartSeriesShapePropertiesXml, parseXlsxErrorBars } from "./4166.js";
 import { workSpreadsheetChartSupportsErrorBars, workSpreadsheetChartSupportsGrouping, normalizeWorkSpreadsheetChartSmoothLines, workSpreadsheetChartSupportsSeriesAnalysis, normalizeWorkSpreadsheetChartSeriesStyle, normalizeWorkSpreadsheetErrorBars, normalizeWorkSpreadsheetChartOverlap, workSpreadsheetChartUsesNumericXAxis, workSpreadsheetChartSupportsBarSpacing, normalizeWorkSpreadsheetChartLegendOverlay, normalizeWorkSpreadsheetChartGapWidth, normalizeWorkSpreadsheetChartGrouping, workSpreadsheetChartSupportsTrendlines, workSpreadsheetChartSupportsSmoothLines, normalizeWorkSpreadsheetTrendline } from "./8715.js";
-import { createWorkSlideTransition } from "./0~work-presentation-transition.js";
+import { normalizeWorkSlideAnimation, createWorkSlideTransition } from "./0~5809.js";
 const PRESENTATION_NAMESPACE = 'http://schemas.openxmlformats.org/presentationml/2006/main';
 const DRAWING_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';
 const OFFICE_RELATIONSHIPS_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
@@ -904,6 +904,377 @@ function finiteNumber(value) {
 function work_pptx_chart_series_analysis_chartPartNumber(path) {
     return Number(/chart(\d+)\.xml$/.exec(path)?.[1] ?? Number.MAX_SAFE_INTEGER);
 }
+const PRESENTATIONML_NAMESPACE = 'http://schemas.openxmlformats.org/presentationml/2006/main';
+function readPptxAnimations(document, elementIdByPptxShapeId) {
+    const timing = directChild(document.documentElement, 'timing');
+    if (!timing) return {
+        animations: [],
+        diagnostics: []
+    };
+    const diagnostics = [];
+    if (elementNamespace(timing) !== PRESENTATIONML_NAMESPACE) return {
+        animations: [],
+        diagnostics: [
+            {
+                code: 'pptx.animation.namespace',
+                message: 'A namespace-spoofed animation timing tree was ignored instead of being treated as trusted PresentationML.'
+            }
+        ]
+    };
+    const animations = [];
+    const animatedElements = new Set();
+    const effectNodes = pptxDescendants(timing, 'cTn').filter((node)=>[
+            'clickEffect',
+            'withEffect',
+            'afterEffect'
+        ].includes(attribute(node, 'nodeType') ?? ''));
+    if (effectNodes.length > 256) diagnostics.push({
+        code: 'pptx.animation.limit',
+        message: "Only the first 256 object animation timing records on a slide are inspected and imported."
+    });
+    for (const node of effectNodes.slice(0, 256)){
+        if ('entr' !== attribute(node, 'presetClass')) {
+            diagnostics.push({
+                code: 'pptx.animation.class',
+                message: 'An emphasis, exit, motion-path, or malformed animation remains in the source PPTX only.'
+            });
+            continue;
+        }
+        const targets = Array.from(new Set(pptxDescendants(node, 'spTgt').map((target)=>attribute(target, 'spid')?.trim()).filter((target)=>Boolean(target))));
+        if (1 !== targets.length) {
+            diagnostics.push({
+                code: 'pptx.animation.target',
+                message: 'An entrance animation with a missing or ambiguous object target was ignored.'
+            });
+            continue;
+        }
+        const elementId = elementIdByPptxShapeId.get(targets[0]);
+        if (!elementId) {
+            diagnostics.push({
+                code: 'pptx.animation.target',
+                message: 'An entrance animation points to an unavailable slide object and was ignored.'
+            });
+            continue;
+        }
+        if (animatedElements.has(elementId)) {
+            diagnostics.push({
+                code: 'pptx.animation.duplicate-target',
+                message: 'Only the first supported entrance animation for an object is editable; additional effects remain in the source PPTX only.'
+            });
+            continue;
+        }
+        const effectResult = readPptxAnimationEffect(node);
+        if (!effectResult.effect) {
+            diagnostics.push({
+                code: 'pptx.animation.effect',
+                message: 'An entrance animation uses an unsupported or malformed effect and remains in the source PPTX only.'
+            });
+            continue;
+        }
+        const timingResult = readPptxAnimationTiming(node);
+        if (timingResult.normalized) diagnostics.push({
+            code: 'pptx.animation.timing',
+            message: 'An invalid or out-of-range animation duration or delay was normalized to safe editable bounds.'
+        });
+        const animation = normalizeWorkSlideAnimation({
+            id: createWorkId('slide-animation'),
+            elementId,
+            effect: effectResult.effect,
+            trigger: pptxAnimationTrigger(attribute(node, 'nodeType')),
+            durationMs: timingResult.durationMs,
+            delayMs: timingResult.delayMs,
+            direction: effectResult.direction
+        });
+        animations.push(animation);
+        animatedElements.add(elementId);
+    }
+    if (!effectNodes.length) diagnostics.push({
+        code: 'pptx.animation.structure',
+        message: 'The slide timing tree does not contain a supported object entrance sequence and remains in the source PPTX only.'
+    });
+    return {
+        animations,
+        diagnostics
+    };
+}
+async function patchPptxAnimations(buffer, slides, registry) {
+    if (!slides.some((slide)=>slide.animations?.length)) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    for (const [index, slide] of slides.entries()){
+        if (!slide.animations?.length) continue;
+        const path = `ppt/slides/slide${index + 1}.xml`;
+        const entry = archive.file(path);
+        if (!entry) throw new Error(`PPTX animation export is missing generated slide ${index + 1}.`);
+        const document = parseXml(await entry.async('text'), path);
+        normalizePptxShapeIds(document);
+        const targetByMarker = pptxTargetIdsByMarker(document);
+        const scope = `slide:${slide.id}`;
+        const targets = slide.animations.map((animation)=>{
+            const marker = registry.markerForElement(scope, animation.elementId);
+            const ids = marker ? targetByMarker.get(marker) : void 0;
+            if (!marker || ids?.length !== 1) throw new Error(`PPTX animation export expected one generated object for animation ${animation.id}, but found ${ids?.length ?? 0}.`);
+            return {
+                animation,
+                spid: ids[0]
+            };
+        });
+        writePptxAnimations(document, targets);
+        archive.file(path, new XMLSerializer().serializeToString(document));
+    }
+    return archive.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+}
+function writePptxAnimations(document, targets) {
+    const root = document.documentElement;
+    directChild(root, 'timing')?.remove();
+    if (!targets.length) return;
+    const source = parseXml(pptxAnimationTimingXml(targets), 'PPTX animations');
+    const timing = clonePptxAnimationElement(document, source.documentElement);
+    const extensionList = directChild(root, 'extLst') ?? null;
+    root.insertBefore(timing, extensionList);
+}
+function clonePptxAnimationElement(document, source) {
+    const element = document.createElementNS(PRESENTATIONML_NAMESPACE, `p:${source.localName}`);
+    for (const item of Array.from(source.attributes))if (!('xmlns' === item.name || item.name.startsWith('xmlns:'))) element.setAttribute(item.name, item.value);
+    for (const child of Array.from(source.childNodes))element.append(child instanceof Element ? clonePptxAnimationElement(document, child) : document.createTextNode(child.textContent ?? ''));
+    return element;
+}
+function readPptxAnimationEffect(node) {
+    const presetId = attribute(node, 'presetID');
+    const animationEffects = pptxDescendants(node, 'animEffect');
+    const filters = animationEffects.map((effect)=>attribute(effect, 'filter')?.trim()).filter((filter)=>Boolean(filter));
+    const attributes = new Set(pptxDescendants(node, 'attrName').map((name)=>name.textContent?.trim()));
+    if (filters.some((filter)=>'fade' === filter)) return {
+        effect: 'fade'
+    };
+    for (const filter of filters){
+        const direction = directionFromPptxSlideFilter(filter);
+        if (direction) return {
+            effect: 'fly-in',
+            direction
+        };
+    }
+    if ('23' === presetId || pptxDescendants(node, 'animScale').length > 0 || attributes.has('ppt_w') && attributes.has('ppt_h')) return {
+        effect: 'zoom'
+    };
+    if ('2' === presetId && (attributes.has('ppt_x') || attributes.has('ppt_y'))) return {
+        effect: 'fly-in',
+        direction: directionFromPptxMotion(node)
+    };
+    if ('1' === presetId && pptxDescendants(node, 'set').length > 0 && 0 === animationEffects.length && 0 === pptxDescendants(node, 'anim').length && 0 === pptxDescendants(node, 'animScale').length) return {
+        effect: 'appear'
+    };
+    return {};
+}
+function readPptxAnimationTiming(node) {
+    const directDuration = nonnegativeInteger(attribute(node, 'dur'));
+    const behaviorDurations = pptxDirectChildren(pptxDirectChild(node, 'childTnLst') ?? node).flatMap((behavior)=>pptxDescendants(behavior, 'cTn')).map((time)=>nonnegativeInteger(attribute(time, 'dur'))).filter((duration)=>void 0 !== duration);
+    const behaviorDuration = Math.max(0, ...behaviorDurations);
+    const rawDuration = directDuration ?? (behaviorDuration || 500);
+    const delayValue = attribute(pptxChildPath(node, 'stCondLst', 'cond') ?? node, 'delay');
+    const rawDelay = nonnegativeInteger(delayValue) ?? 0;
+    const normalized = normalizeWorkSlideAnimation({
+        id: 'timing',
+        elementId: 'timing',
+        effect: 'fade',
+        trigger: 'on-click',
+        durationMs: rawDuration,
+        delayMs: rawDelay
+    });
+    return {
+        durationMs: normalized.durationMs,
+        delayMs: normalized.delayMs,
+        normalized: normalized.durationMs !== rawDuration || normalized.delayMs !== rawDelay || null !== attribute(node, 'dur') && void 0 === directDuration || null !== delayValue && void 0 === nonnegativeInteger(delayValue)
+    };
+}
+function pptxAnimationTrigger(value) {
+    if ('withEffect' === value) return 'with-previous';
+    if ('afterEffect' === value) return 'after-previous';
+    return 'on-click';
+}
+function directionFromPptxSlideFilter(filter) {
+    if ('slide(fromLeft)' === filter) return 'left';
+    if ('slide(fromRight)' === filter) return 'right';
+    if ('slide(fromTop)' === filter) return 'up';
+    if ('slide(fromBottom)' === filter) return 'down';
+}
+function directionFromPptxMotion(node) {
+    const values = pptxDescendants(node, 'strVal').map((value)=>attribute(value, 'val') ?? '').join(' ');
+    if (values.includes('-#ppt_w/2')) return 'right';
+    if (values.includes('1+#ppt_h/2')) return 'down';
+    if (values.includes('-#ppt_h/2')) return 'up';
+    return 'left';
+}
+function pptxAnimationTimingXml(targets) {
+    let timeNodeId = 1;
+    const nextId = ()=>timeNodeId++;
+    const rootId = nextId();
+    const mainSequenceId = nextId();
+    const targetByAnimationId = new Map(targets.map((target)=>[
+            target.animation.id,
+            target
+        ]));
+    const groups = pptxAnimationGroups(targets.map((target)=>target.animation));
+    const groupXml = groups.map((group)=>{
+        const outerId = nextId();
+        const wrappers = group.wrappers.map((animations)=>{
+            const wrapperId = nextId();
+            const effects = animations.map((animation)=>{
+                const target = targetByAnimationId.get(animation.id);
+                if (!target) return '';
+                return pptxAnimationEffectXml(target, nextId);
+            }).join('');
+            return `<p:par><p:cTn id="${wrapperId}" fill="hold"><p:stCondLst><p:cond delay="0"/></p:stCondLst><p:childTnLst>${effects}</p:childTnLst></p:cTn></p:par>`;
+        }).join('');
+        const delay = group.automatic ? '0' : 'indefinite';
+        return `<p:par><p:cTn id="${outerId}" fill="hold"><p:stCondLst><p:cond delay="${delay}"/></p:stCondLst><p:childTnLst>${wrappers}</p:childTnLst></p:cTn></p:par>`;
+    }).join('');
+    const builds = targets.map(({ spid })=>`<p:bldP spid="${spid}" grpId="0" animBg="1"/>`).join('');
+    return `<p:timing xmlns:p="${PRESENTATIONML_NAMESPACE}"><p:tnLst><p:par><p:cTn id="${rootId}" dur="indefinite" restart="never" nodeType="tmRoot"><p:childTnLst><p:seq concurrent="1" nextAc="seek"><p:cTn id="${mainSequenceId}" dur="indefinite" nodeType="mainSeq"><p:childTnLst>${groupXml}</p:childTnLst></p:cTn><p:prevCondLst><p:cond evt="onPrev" delay="0"><p:tgtEl><p:sldTgt/></p:tgtEl></p:cond></p:prevCondLst><p:nextCondLst><p:cond evt="onNext" delay="0"><p:tgtEl><p:sldTgt/></p:tgtEl></p:cond></p:nextCondLst></p:seq></p:childTnLst></p:cTn></p:par></p:tnLst><p:bldLst>${builds}</p:bldLst></p:timing>`;
+}
+function pptxAnimationGroups(animations) {
+    const groups = [];
+    let current;
+    for (const animation of animations)if (current && 'on-click' !== animation.trigger) if ('with-previous' === animation.trigger) current.wrappers.at(-1)?.push(animation);
+    else current.wrappers.push([
+        animation
+    ]);
+    else {
+        current = {
+            automatic: 'on-click' !== animation.trigger,
+            wrappers: [
+                [
+                    animation
+                ]
+            ]
+        };
+        groups.push(current);
+    }
+    return groups;
+}
+function pptxAnimationEffectXml(target, nextId) {
+    const animation = normalizeWorkSlideAnimation(target.animation);
+    const preset = pptxAnimationPreset(animation);
+    const leafId = nextId();
+    const visibilityId = nextId();
+    const visibility = `<p:set><p:cBhvr><p:cTn id="${visibilityId}" dur="1" fill="hold"><p:stCondLst><p:cond delay="0"/></p:stCondLst></p:cTn><p:tgtEl><p:spTgt spid="${target.spid}"/></p:tgtEl><p:attrNameLst><p:attrName>style.visibility</p:attrName></p:attrNameLst></p:cBhvr><p:to><p:strVal val="visible"/></p:to></p:set>`;
+    const behavior = pptxAnimationBehaviorXml(animation, target.spid, nextId);
+    return `<p:par><p:cTn id="${leafId}" presetID="${preset.id}" presetClass="entr" presetSubtype="${preset.subtype}" fill="hold" nodeType="${pptxAnimationNodeType(animation.trigger)}" dur="${animation.durationMs}"><p:stCondLst><p:cond delay="${animation.delayMs}"/></p:stCondLst><p:childTnLst>${visibility}${behavior}</p:childTnLst></p:cTn></p:par>`;
+}
+function pptxAnimationBehaviorXml(animation, spid, nextId) {
+    if ('appear' === animation.effect) return '';
+    if ('zoom' === animation.effect) return [
+        'ppt_w',
+        'ppt_h'
+    ].map((attributeName)=>{
+        const id = nextId();
+        return `<p:anim calcMode="lin" valueType="num"><p:cBhvr><p:cTn id="${id}" dur="${animation.durationMs}" fill="hold"/><p:tgtEl><p:spTgt spid="${spid}"/></p:tgtEl><p:attrNameLst><p:attrName>${attributeName}</p:attrName></p:attrNameLst></p:cBhvr><p:tavLst><p:tav tm="0"><p:val><p:fltVal val="0"/></p:val></p:tav><p:tav tm="100000"><p:val><p:strVal val="#${attributeName}"/></p:val></p:tav></p:tavLst></p:anim>`;
+    }).join('');
+    const id = nextId();
+    const filter = 'fade' === animation.effect ? 'fade' : pptxSlideFilter(animation.direction ?? 'left');
+    return `<p:animEffect transition="in" filter="${filter}"><p:cBhvr><p:cTn id="${id}" dur="${animation.durationMs}"/><p:tgtEl><p:spTgt spid="${spid}"/></p:tgtEl></p:cBhvr></p:animEffect>`;
+}
+function pptxAnimationPreset(animation) {
+    if ('appear' === animation.effect) return {
+        id: 1,
+        subtype: 0
+    };
+    if ('fade' === animation.effect) return {
+        id: 10,
+        subtype: 0
+    };
+    if ('zoom' === animation.effect) return {
+        id: 23,
+        subtype: 16
+    };
+    const subtypes = {
+        up: 1,
+        right: 2,
+        down: 4,
+        left: 8
+    };
+    return {
+        id: 2,
+        subtype: subtypes[animation.direction ?? 'left']
+    };
+}
+function pptxAnimationNodeType(trigger) {
+    if ('with-previous' === trigger) return 'withEffect';
+    if ('after-previous' === trigger) return 'afterEffect';
+    return 'clickEffect';
+}
+function pptxSlideFilter(direction) {
+    if ('right' === direction) return 'slide(fromRight)';
+    if ('up' === direction) return 'slide(fromTop)';
+    if ('down' === direction) return 'slide(fromBottom)';
+    return 'slide(fromLeft)';
+}
+function normalizePptxShapeIds(document) {
+    for (const shapeTree of descendants(document, 'spTree')){
+        const used = new Set();
+        let candidate = 1;
+        for (const properties of descendants(shapeTree, 'cNvPr')){
+            const current = Number(attribute(properties, 'id'));
+            if (Number.isInteger(current) && current > 0 && !used.has(current)) {
+                used.add(current);
+                continue;
+            }
+            while(used.has(candidate))candidate += 1;
+            properties.setAttribute('id', String(candidate));
+            used.add(candidate);
+            candidate += 1;
+        }
+    }
+}
+function pptxTargetIdsByMarker(document) {
+    const targets = new Map();
+    for (const properties of descendants(document, 'cNvPr')){
+        const marker = attribute(properties, 'name');
+        const id = Number(attribute(properties, 'id'));
+        if (!marker || !Number.isInteger(id) || id <= 0) continue;
+        const ids = targets.get(marker) ?? [];
+        ids.push(id);
+        targets.set(marker, ids);
+    }
+    return targets;
+}
+function nonnegativeInteger(value) {
+    if (null === value || '' === value.trim()) return;
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number >= 0 ? number : void 0;
+}
+function elementNamespace(element) {
+    if (element.namespaceURI) return element.namespaceURI;
+    const separator = element.tagName.indexOf(':');
+    const prefix = element.prefix ?? (separator >= 0 ? element.tagName.slice(0, separator) : void 0);
+    const declaration = prefix ? `xmlns:${prefix}` : 'xmlns';
+    let current = element;
+    while(current){
+        const namespace = current.getAttribute(declaration);
+        if (namespace) return namespace;
+        current = current.parentElement;
+    }
+    return null;
+}
+function pptxDescendants(parent, localName) {
+    return descendants(parent, localName).filter((element)=>elementNamespace(element) === PRESENTATIONML_NAMESPACE);
+}
+function pptxDirectChildren(parent, localName) {
+    return directChildren(parent, localName).filter((element)=>elementNamespace(element) === PRESENTATIONML_NAMESPACE);
+}
+function pptxDirectChild(parent, localName) {
+    return pptxDirectChildren(parent, localName)[0];
+}
+function pptxChildPath(parent, ...localNames) {
+    let current = parent;
+    for (const localName of localNames){
+        if (!current) return;
+        current = pptxDirectChild(current, localName);
+    }
+    return current instanceof Element ? current : void 0;
+}
 const EFFECT_TYPES = new Set([
     'fade',
     'push',
@@ -956,7 +1327,7 @@ function readPptxTransition(document) {
         speed: readSpeed(element, diagnostics),
         advanceOnClick: readBoolean(attribute(element, 'advClick'), true)
     };
-    const advanceAfterMs = nonnegativeInteger(attribute(element, 'advTm'));
+    const advanceAfterMs = work_pptx_transition_nonnegativeInteger(attribute(element, 'advTm'));
     if (void 0 !== advanceAfterMs) transition.advanceAfterMs = advanceAfterMs;
     else if (null !== attribute(element, 'advTm')) diagnostics.push({
         code: 'pptx.transition.timing',
@@ -1030,9 +1401,9 @@ function readBoolean(value, fallback) {
     if (null === value) return fallback;
     return '1' === value || 'true' === value.toLowerCase();
 }
-function nonnegativeInteger(value) {
+function work_pptx_transition_nonnegativeInteger(value) {
     if (null === value) return;
     const number = Number(value);
     return Number.isSafeInteger(number) && number >= 0 ? number : void 0;
 }
-export { loadPptxCommentAuthors, patchPptxChartDataLabels, patchPptxChartLayoutAndSeriesStyles, patchPptxChartSeriesAnalysis, patchPptxComments, patchPptxTransitions, readPptxChartDataLabels, readPptxChartLayoutAndSeriesStyles, readPptxChartSeriesAnalysis, readPptxSlideComments, readPptxTransition };
+export { loadPptxCommentAuthors, patchPptxAnimations, patchPptxChartDataLabels, patchPptxChartLayoutAndSeriesStyles, patchPptxChartSeriesAnalysis, patchPptxComments, patchPptxTransitions, readPptxAnimations, readPptxChartDataLabels, readPptxChartLayoutAndSeriesStyles, readPptxChartSeriesAnalysis, readPptxSlideComments, readPptxTransition };

package/dist/0~pdf-viewer.js

@@ -2195,13 +2195,17 @@ function PdfToolbar({ annotationState, can, commands, editable, pageOrganization
                     className: "work-pdf-page-organizer-trigger",
                     "data-pdf-page-organizer-trigger": true,
                     "aria-label": "组织 PDF 页面",
+                    title: "组织 PDF 页面",
                     disabled: !can.openPageOrganizer(),
                     onClick: commands.openPageOrganizer,
                     children: [
                         /*#__PURE__*/ jsx(LayoutGrid, {
                             size: 15
                         }),
-                        "组织页面"
+                        /*#__PURE__*/ jsx("span", {
+                            className: "work-pdf-page-organizer-label",
+                            children: "组织页面"
+                        })
                     ]
                 })
             }),