pptx-angular-viewer 3.12.0 → 3.13.0

package/types/pptx-angular-viewer.d.ts

@@ -6,9 +6,9 @@ import { Signal, WritableSignal, OnDestroy, OnInit, AfterViewInit, OnChanges, Si
 import * as AiSdk from 'ai';
 import { LanguageModel, ChatTransport, UIMessage, ToolSet } from 'ai';
 import * as pptx_angular_viewer from 'pptx-angular-viewer';
+import { SafeHtml } from '@angular/platform-browser';
 import { TranslateService } from '@ngx-translate/core';
 import { Options } from 'html2canvas-pro';
-import { SafeHtml } from '@angular/platform-browser';
 
 /**
  * Theme configuration types for the PowerPoint viewer.
@@ -4591,7 +4591,9 @@ interface SlideTransitionAnimations {
  * The faithful Office 2010 (`p14`) keyframes are appended (via
  * {@link P14_TRANSITION_KEYFRAMES_ALL}) so the exotic / 3-D transitions routed
  * through `getP14TransitionAnimations` animate wherever this block is injected,
- * with no per-binding wiring.
+ * with no per-binding wiring. {@link FRAGMENT_TRANSITION_KEYFRAMES} is appended
+ * last, backing the seven multi-fragment cinematic presets resolved by
+ * `getFragmentedTransitionDescriptor` (`slide-transition-fragments.ts`).
  *
  * @module render/slide-transition-keyframes
  */
@@ -4644,6 +4646,68 @@ declare const SLIDE_TRANSITION_KEYFRAMES: string;
  */
 declare function getSlideTransitionAnimations(type: PptxTransitionType, durationMs: number, direction: string | undefined, orient?: string | undefined, spokes?: number | undefined, pattern?: string | undefined): SlideTransitionAnimations;
 
+/**
+ * `slide-transition-fragment-types` - shared types and small pure helpers for
+ * the multi-fragment cinematic transitions (`vortex`, `honeycomb`, `glitter`,
+ * `shred`, `fracture`, `curtains`, `airplane`).
+ *
+ * These seven presets render in real PowerPoint as many independent
+ * fragments, tiles, particles, or (for `airplane`) folded panels, not a
+ * single animated layer - see `slide-transition-fragments.ts` for the
+ * COM `CreateVideo` measurement writeup. A `FragmentedTransitionDescriptor`
+ * is the pure, framework-neutral output every binding maps onto N clipped
+ * copies of its own `SlideLayer`/`SlideCanvas` component: each fragment is a
+ * full-size copy of the outgoing or incoming slide, clipped with `clip-path`
+ * to its slice and animated with a shared `@keyframes` block (from
+ * {@link FRAGMENT_TRANSITION_KEYFRAMES}) parameterised per fragment via CSS
+ * custom properties, so the whole set is transform/opacity-only and
+ * GPU-composited with no per-frame JS.
+ *
+ * @module render/slide-transition-fragment-types
+ */
+/** One fragment: a clipped, independently-animated copy of a slide layer. */
+interface TransitionFragment {
+    /** Stable id for keys / `data-*` attributes; unique within its layer. */
+    id: string;
+    /** `clip-path` value, in percentages of the full (unscaled) slide box. */
+    clipPath: string;
+    /**
+     * CSS custom properties consumed by the shared `@keyframes` named by the
+     * owning {@link FragmentedLayer.keyframesName}. Values are pre-formatted
+     * (already unit-suffixed, e.g. `'34deg'`, `'-120%'`) so bindings can copy
+     * them verbatim into an inline `style` object.
+     */
+    vars: Readonly<Record<string, string>>;
+    /** `animation-delay`, in ms. */
+    delayMs: number;
+    /** `transform-origin`, e.g. `'50% 50%'`, so rotate/scale pivot correctly. */
+    transformOrigin: string;
+}
+/** One layer (outgoing or incoming) rendered as N independent fragments. */
+interface FragmentedLayer {
+    /** Name of the shared `@keyframes` block every fragment in this layer runs. */
+    keyframesName: string;
+    /** Per-fragment `animation-duration`, in ms. */
+    durationMs: number;
+    /** Per-fragment `animation-timing-function`. */
+    easing: string;
+    fragments: readonly TransitionFragment[];
+}
+/**
+ * Resolved fragment plan for a cinematic transition. Either layer may be
+ * absent: a layer with no entry here renders as a single, non-fragmented
+ * copy exactly like every other transition (typically driven by the
+ * existing {@link getCinematicTransitionAnimations} / p14 resolvers, which
+ * remain the single-layer fallback for previews and any consumer that has
+ * not adopted fragment rendering).
+ */
+interface FragmentedTransitionDescriptor {
+    outgoing?: FragmentedLayer;
+    incoming?: FragmentedLayer;
+    /** Same semantics as `SlideTransitionAnimations.outgoingOnTop`. */
+    outgoingOnTop: boolean;
+}
+
 /**
  * `slide-transition-options` - the pure option catalogues backing every
  * binding's slide-transition inspector section.
@@ -7651,6 +7715,17 @@ interface ViewerAdvancedOptions {
      * for their machine. See `resolve3DRenderingFlags`.
      */
     disable3DRendering: boolean;
+    /**
+     * `p:animEffect/@filter="pixelate"` defaults to snapping the element to
+     * its end state (`cutIn`/`cutOut`), matching PowerPoint's own behaviour
+     * (COM `CreateVideo` frame-diffing shows PowerPoint performs no animation
+     * at all for this filter value). This turns on the blocky mosaic reveal
+     * this renderer can build instead, for a viewer that would rather show
+     * something animating than PowerPoint's own instant swap. See
+     * `resolveFilterEffect` in `animation-filter-effects.ts` and
+     * `docs/guide/visual-effects.md`.
+     */
+    pixelateMosaicAnimation: boolean;
     openDocumentsView: OpenDocumentsView;
     slideShowShowMenuOnRightClick: boolean;
     slideShowShowPopupToolbar: boolean;
@@ -8062,6 +8137,36 @@ interface CompatibilityWarningToast {
     readonly params?: Readonly<Record<string, string>>;
 }
 
+/**
+ * run-program-notice.ts: turn a resolved `ppaction://program` command string
+ * into the non-blocking notice a binding should show during a running show.
+ *
+ * PowerPoint's "Run program" action (`a:hlinkClick` -> `ppaction://program`,
+ * `packages/shared/src/render/presentation-action.ts`'s `runProgram` intent)
+ * names a free-text "Program to run:" command the author typed, e.g.
+ * `notepad.exe C:\temp\notes.txt`. Path and arguments are ONE unstructured
+ * string; OOXML has no separate arguments field, so this module does not try
+ * to split one out.
+ *
+ * A browser cannot launch a local executable, so the honest behavior on
+ * click is: show the presenter a small, dismissible notice naming the exact
+ * command PowerPoint would have run, with a Copy button, rather than doing
+ * nothing (silently) or blocking the show with a modal dialog.
+ *
+ * Framework-agnostic: no React, Vue, Angular, Svelte or DOM imports.
+ */
+/** A run-program notice ready for a binding's toast/notice UI to render. */
+interface RunProgramNotice {
+    /** Stable id for this invocation, so a binding can dedupe/key a toast list. */
+    readonly id: string;
+    /** The exact resolved command string (path plus whatever arguments the author typed). */
+    readonly target: string;
+    /** i18n key for the notice body. Interpolates `{{target}}`. */
+    readonly messageKey: string;
+    /** i18n key for the Copy button label. */
+    readonly copyLabelKey: string;
+}
+
 /**
  * Inspector option lists + pure patch builders for the three OOXML chart
  * subtype flags parsed/serialized in this wave: bar3D column/bar shape
@@ -8255,6 +8360,49 @@ declare function fpsToFrameIntervalMs(fps: number): number;
  */
 declare function segmentFrameCount(durationMs: number, fps: number): number;
 
+/**
+ * Strategy selection for rasterising one export window (the whole slide for
+ * a non-tiled export, or one tile's rectangle for a tiled export). Tries, in
+ * order: the SVG `foreignObject` path (preserves `backdrop-filter`, custom
+ * properties, 3D transforms because the browser's own engine paints it),
+ * then the existing vector-SVG export pipeline rasterised the same way
+ * (covers the case a resource could not be embedded as `data:`, so
+ * `foreignObject` would taint the canvas), then `html2canvas-pro` as the
+ * documented last resort. Every binding's `renderToCanvas` wrapper calls
+ * this once per window; only the `html2canvasFallback` driver (the
+ * `html2canvas-pro` import itself) stays per-binding.
+ */
+
+/** Which path actually produced the tile, for telemetry/tests. */
+type RasterStrategy = 'foreignObject' | 'vectorSvg' | 'html2canvas';
+
+/** One rasterised tile: its full-raster position/size plus the canvas and strategy that produced it. */
+interface RasterizedTile {
+    /** 0-based column index (tiles in the same row share increasing `col`). */
+    col: number;
+    /** 0-based row index. */
+    row: number;
+    /** Left edge, in full-raster device pixels. */
+    x: number;
+    /** Top edge, in full-raster device pixels. */
+    y: number;
+    width: number;
+    height: number;
+    canvas: HTMLCanvasElement;
+    strategy: RasterStrategy;
+}
+/** The full set of tiles covering one element's export, tiled or not. */
+interface RasterizeElementTilesResult {
+    /** Full raster width in device pixels (sum of every column's width). */
+    fullWidth: number;
+    /** Full raster height in device pixels (sum of every row's height). */
+    fullHeight: number;
+    /** `false` when a single tile already covers the whole export. */
+    tiled: boolean;
+    /** Every tile, row-major order. Exactly one entry when `tiled` is `false`. */
+    tiles: RasterizedTile[];
+}
+
 /**
  * Thin re-export shim → vendored `pptx-viewer-shared` (`render/embedded-fonts`).
  *
@@ -11230,6 +11378,111 @@ declare class ViewerDocumentPropertiesService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
 }
 
+declare class ExportService {
+    private static readonly PRESENTATION_MIME;
+    /** Build a resolution-independent SVG string directly from slide data. */
+    exportSlideToSvg(slide: PptxSlide, width: number, height: number, options?: SvgExportOptions): string;
+    /** Build an SVG Blob directly from slide data. */
+    exportSlideToSvgBlob(slide: PptxSlide, width: number, height: number, options?: SvgExportOptions): Blob;
+    /** Build SVG strings for all selected slides in a parsed presentation. */
+    exportAllSlidesToSvg(data: PptxData, options?: SvgExportOptions): string[];
+    /**
+     * Trigger a browser download of serialized `.pptx` bytes.
+     *
+     * @param bytes    - The serialized presentation (from the viewer's `getContent`).
+     * @param fileName - Suggested download file name (unsafe chars are stripped).
+     */
+    savePptx(bytes: Uint8Array, fileName: string): void;
+    /** Download serialized presentation bytes using the matching package MIME type. */
+    savePresentation(bytes: Uint8Array, fileName: string, format: PptxSaveFormat): void;
+    /**
+     * Rasterize a single DOM element to PNG and trigger a browser download.
+     *
+     * @param el       - The element to capture (e.g. the `.pptx-ng-canvas-stage`).
+     * @param fileName - Suggested download file name (unsafe chars are stripped).
+     * @param scale    - Device-pixel ratio multiplier (default 2 for sharp output).
+     */
+    exportElementToPng(el: HTMLElement, fileName: string, scale?: number): Promise<void>;
+    /** Rasterize an element and copy it to the system clipboard as a PNG image. */
+    copyElementAsPng(el: HTMLElement, scale?: number): Promise<void>;
+    /**
+     * Rasterize `el` to a PNG `Blob` via the shared `foreignObject` -> vector-SVG
+     * -> html2canvas fallback chain (preserves backdrop-filter, CSS custom
+     * properties and 3D transforms html2canvas cannot), tiling transparently
+     * for a resolution beyond the browser's canvas cap. Implementation in
+     * `export-raster-tiles.ts`, next to the other shared-driver entry points.
+     */
+    private rasterizeElementToPngBlob;
+    /**
+     * Rasterize a single element to a canvas via the shared `foreignObject`
+     * fidelity pipeline, clamped (scale reduced, never tiled) so the result is
+     * always one canvas - for GIF/video/print, which can only consume one
+     * image per frame/page. `html2canvas-pro` is kept only as the documented
+     * fallback driver. Capture each slide's canvas *while that slide is the
+     * live DOM*: the viewer reuses one stage node, so a deferred capture would
+     * yield the same (last) slide for every page. Implementation in
+     * `export-raster-tiles.ts` (kept this file under the size budget).
+     */
+    renderElement(el: HTMLElement, scale?: number): Promise<HTMLCanvasElement>;
+    /**
+     * Rasterize a single element to its raw per-tile canvases via the shared
+     * `foreignObject` fidelity pipeline, tiling transparently when the
+     * requested resolution exceeds the browser's canvas cap - for PDF pages,
+     * which have no canvas-size limit of their own and so can place several
+     * small tile images instead of needing one oversized canvas.
+     */
+    renderElementToTiles(el: HTMLElement, scale?: number): Promise<RasterizeElementTilesResult>;
+    /**
+     * Assemble a multi-page PDF from pre-rendered per-slide tile sets (one page
+     * per entry) and trigger a download. See `buildTiledPdf` in
+     * `export-raster-tiles.ts` for the full behaviour (placement, degrade to
+     * one-image-per-page for a single-tile slide, cap-escaping rationale).
+     *
+     * @param pages        - One entry per slide, in order, each captured while
+     *                       its slide was the live stage (`renderElementToTiles`).
+     * @param canvasWidth  - Slide canvas width in pixels (for aspect ratio).
+     * @param canvasHeight - Slide canvas height in pixels (for aspect ratio).
+     * @param fileName     - Suggested download file name (unsafe chars stripped).
+     */
+    exportTiledPagesToPdf(pages: RasterizeElementTilesResult[], canvasWidth: number, canvasHeight: number, fileName: string): void;
+    /**
+     * Assemble an animated GIF from pre-rendered slide canvases (one frame per
+     * slide) and trigger a download. Frame delay is derived from
+     * `slideDurationMs` via the pure {@link planGifFrames} planner.
+     *
+     * @param canvases        - One canvas per slide, in order.
+     * @param slideDurationMs - Display time per slide in milliseconds.
+     * @param fileName        - Suggested download file name.
+     */
+    exportCanvasesToGif(canvases: HTMLCanvasElement[], slideDurationMs: number, fileName: string): void;
+    /**
+     * Record a WebM video from pre-rendered slide canvases (each held for
+     * `slideDurationMs`) via the browser `MediaRecorder` and trigger a download.
+     *
+     * @param canvases        - One canvas per slide, in order.
+     * @param slideDurationMs - Display time per slide in milliseconds.
+     * @param fileName        - Suggested download file name.
+     * @param signal          - Optional abort signal to cancel recording.
+     * @param onProgress      - Optional per-slide recording progress callback
+     *                          `(currentSlide, totalSlides)`.
+     */
+    exportCanvasesToWebm(canvases: HTMLCanvasElement[], slideDurationMs: number, fileName: string, signal?: AbortSignal, onProgress?: (current: number, total: number) => void): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExportService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * Per-slide capture loops for `ViewerExportService`: flip the live stage to
+ * each slide in turn, let it settle, and rasterise it (plain canvas, raw
+ * tiles, or a PNG data URL), reporting progress and honouring cooperative
+ * cancellation. Split out of `viewer-export.service.ts` to keep that file
+ * under the file-size budget.
+ *
+ * Rasterisation itself is `ExportService`'s job (the shared `foreignObject`
+ * fidelity pipeline, see `export-raster-tiles.ts`); this module only owns
+ * the "make slide N the live DOM, then capture it" choreography.
+ */
+
 /** Live accessors the export loop needs from the host component. */
 interface ExportHost {
     /** The component's active-slide index (read + written to flip the live stage). */
@@ -11249,18 +11502,19 @@ interface ExportHost {
      */
     readonly imageExportScale?: () => number;
 }
+
 declare class ViewerExportService {
     private readonly exportSvc;
     private readonly loader;
     private readonly print;
     private readonly translate;
     /** True while a PNG/PDF export is in progress (disables the buttons). */
-    readonly exporting: WritableSignal<boolean>;
+    readonly exporting: _angular_core.WritableSignal<boolean>;
     /** Export-progress modal state (PDF / GIF / WebM). */
-    readonly modalOpen: WritableSignal<boolean>;
-    readonly modalTitle: WritableSignal<string>;
-    readonly progress: WritableSignal<number>;
-    readonly statusMessage: WritableSignal<string>;
+    readonly modalOpen: _angular_core.WritableSignal<boolean>;
+    readonly modalTitle: _angular_core.WritableSignal<string>;
+    readonly progress: _angular_core.WritableSignal<number>;
+    readonly statusMessage: _angular_core.WritableSignal<string>;
     /** Cooperative cancellation: the capture loop checks `signal.aborted`. */
     private abort;
     private host;
@@ -11296,17 +11550,12 @@ declare class ViewerExportService {
     private beginExport;
     private endExport;
     /**
-     * Render every slide to a canvas (each made the live stage in turn), reporting
-     * per-slide progress and bailing out cooperatively when `abortSignal.aborted`.
-     */
-    private captureSlideCanvases;
-    /**
-     * Flip the live stage to `index`, let it settle, and capture it to a PNG
-     * data URL. `scale` defaults to the host's own Image Size/Quality scale
-     * (matching PNG/PDF export); the print notes/handouts path passes a higher
-     * value when Options > Advanced > "High quality" is on.
+     * Progress-reporting sink handed to the extracted capture-loop functions
+     * in `viewer-export-capture.ts`, called directly at each export call site
+     * (`captureSlideCanvases`/`captureSlideTiles`/`captureSlideDataUrl`) rather
+     * than via a same-named private wrapper per method.
      */
-    private captureSlideDataUrl;
+    private readonly progressSinks;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ViewerExportService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
 }
@@ -12777,77 +13026,6 @@ declare class EmbeddedFontsService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
 }
 
-declare class ExportService {
-    private static readonly PRESENTATION_MIME;
-    /** Build a resolution-independent SVG string directly from slide data. */
-    exportSlideToSvg(slide: PptxSlide, width: number, height: number, options?: SvgExportOptions): string;
-    /** Build an SVG Blob directly from slide data. */
-    exportSlideToSvgBlob(slide: PptxSlide, width: number, height: number, options?: SvgExportOptions): Blob;
-    /** Build SVG strings for all selected slides in a parsed presentation. */
-    exportAllSlidesToSvg(data: PptxData, options?: SvgExportOptions): string[];
-    /**
-     * Trigger a browser download of serialized `.pptx` bytes.
-     *
-     * @param bytes    - The serialized presentation (from the viewer's `getContent`).
-     * @param fileName - Suggested download file name (unsafe chars are stripped).
-     */
-    savePptx(bytes: Uint8Array, fileName: string): void;
-    /** Download serialized presentation bytes using the matching package MIME type. */
-    savePresentation(bytes: Uint8Array, fileName: string, format: PptxSaveFormat): void;
-    /**
-     * Rasterize a single DOM element to PNG and trigger a browser download.
-     *
-     * @param el       - The element to capture (e.g. the `.pptx-ng-canvas-stage`).
-     * @param fileName - Suggested download file name (unsafe chars are stripped).
-     * @param scale    - Device-pixel ratio multiplier (default 2 for sharp output).
-     */
-    exportElementToPng(el: HTMLElement, fileName: string, scale?: number): Promise<void>;
-    /** Rasterize an element and copy it to the system clipboard as a PNG image. */
-    copyElementAsPng(el: HTMLElement, scale?: number): Promise<void>;
-    /**
-     * Rasterize a single element to a canvas (passthrough to html2canvas-pro).
-     * Capture each slide's canvas *while that slide is the live DOM*: the
-     * viewer reuses one stage node, so a deferred capture would yield the same
-     * (last) slide for every page.
-     */
-    renderElement(el: HTMLElement, scale?: number): Promise<HTMLCanvasElement>;
-    /**
-     * Assemble a multi-page PDF from pre-rendered slide canvases (one page per
-     * canvas, sized to the slide aspect ratio in pt) and trigger a download.
-     *
-     * @param canvases     - One canvas per slide, in order, each captured while
-     *                       its slide was the live stage.
-     * @param canvasWidth  - Slide canvas width in pixels (for aspect ratio).
-     * @param canvasHeight - Slide canvas height in pixels (for aspect ratio).
-     * @param fileName     - Suggested download file name (unsafe chars stripped).
-     */
-    exportCanvasesToPdf(canvases: HTMLCanvasElement[], canvasWidth: number, canvasHeight: number, fileName: string): void;
-    /**
-     * Assemble an animated GIF from pre-rendered slide canvases (one frame per
-     * slide) and trigger a download. Frame delay is derived from
-     * `slideDurationMs` via the pure {@link planGifFrames} planner.
-     *
-     * @param canvases        - One canvas per slide, in order.
-     * @param slideDurationMs - Display time per slide in milliseconds.
-     * @param fileName        - Suggested download file name.
-     */
-    exportCanvasesToGif(canvases: HTMLCanvasElement[], slideDurationMs: number, fileName: string): void;
-    /**
-     * Record a WebM video from pre-rendered slide canvases (each held for
-     * `slideDurationMs`) via the browser `MediaRecorder` and trigger a download.
-     *
-     * @param canvases        - One canvas per slide, in order.
-     * @param slideDurationMs - Display time per slide in milliseconds.
-     * @param fileName        - Suggested download file name.
-     * @param signal          - Optional abort signal to cancel recording.
-     * @param onProgress      - Optional per-slide recording progress callback
-     *                          `(currentSlide, totalSlides)`.
-     */
-    exportCanvasesToWebm(canvases: HTMLCanvasElement[], slideDurationMs: number, fileName: string, signal?: AbortSignal, onProgress?: (current: number, total: number) => void): Promise<void>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExportService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
-}
-
 /**
  * `FieldContextService`: viewer-scoped source of the OOXML field-substitution
  * context (slide number, date/time, header/footer, slide title, custom doc
@@ -14523,6 +14701,12 @@ declare class SlideCanvasComponent implements SlideContext {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlideCanvasComponent, "pptx-slide-canvas", never, { "slide": { "alias": "slide"; "required": false; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "showGrid": { "alias": "showGrid"; "required": false; "isSignal": true; }; "showRulers": { "alias": "showRulers"; "required": false; "isSignal": true; }; "rulerUnit": { "alias": "rulerUnit"; "required": false; "isSignal": true; }; "showGuides": { "alias": "showGuides"; "required": false; "isSignal": true; }; "snapToGrid": { "alias": "snapToGrid"; "required": false; "isSignal": true; }; "gridSpacing": { "alias": "gridSpacing"; "required": false; "isSignal": true; }; "snapToShape": { "alias": "snapToShape"; "required": false; "isSignal": true; }; "guideCommand": { "alias": "guideCommand"; "required": false; "isSignal": true; }; "spellCheck": { "alias": "spellCheck"; "required": false; "isSignal": true; }; "snapToGuides": { "alias": "snapToGuides"; "required": false; "isSignal": true; }; "autoFit": { "alias": "autoFit"; "required": false; "isSignal": true; }; "transparentBackground": { "alias": "transparentBackground"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "exposeElementIds": { "alias": "exposeElementIds"; "required": false; "isSignal": true; }; "presenting": { "alias": "presenting"; "required": false; "isSignal": true; }; "selectedIds": { "alias": "selectedIds"; "required": false; "isSignal": true; }; "editingId": { "alias": "editingId"; "required": false; "isSignal": true; }; "editTemplateMode": { "alias": "editTemplateMode"; "required": false; "isSignal": true; }; "templateElements": { "alias": "templateElements"; "required": false; "isSignal": true; }; "aiHighlights": { "alias": "aiHighlights"; "required": false; "isSignal": true; }; "aiActive": { "alias": "aiActive"; "required": false; "isSignal": true; }; "aiActiveSlideIndex": { "alias": "aiActiveSlideIndex"; "required": false; "isSignal": true; }; "aiChangeBatch": { "alias": "aiChangeBatch"; "required": false; "isSignal": true; }; "aiPickMode": { "alias": "aiPickMode"; "required": false; "isSignal": true; }; "drawTool": { "alias": "drawTool"; "required": false; "isSignal": true; }; "drawColor": { "alias": "drawColor"; "required": false; "isSignal": true; }; "drawWidth": { "alias": "drawWidth"; "required": false; "isSignal": true; }; }, { "elementSelect": "elementSelect"; "backgroundClick": "backgroundClick"; "transformStart": "transformStart"; "transformUpdate": "transformUpdate"; "transformEnd": "transformEnd"; "adjustUpdate": "adjustUpdate"; "connectorEndpointUpdate": "connectorEndpointUpdate"; "contextMenu": "contextMenu"; "textEditStart": "textEditStart"; "textCommit": "textCommit"; "textInput": "textInput"; "textCancel": "textCancel"; "textFormat": "textFormat"; "rotateUpdate": "rotateUpdate"; "marqueeSelect": "marqueeSelect"; "inkStrokeComplete": "inkStrokeComplete"; "eraserHit": "eraserHit"; "cellCommit": "cellCommit"; "tableChange": "tableChange"; }, never, ["*"], true, never>;
 }
 
+/** Injectable bevel lighting `<filter>` descriptor: id + sanitized markup. */
+interface BevelLightingFilterDef {
+    id: string;
+    markup: SafeHtml;
+}
+
 /**
  * Renderer-injected shape-effect definitions that need a companion DOM node
  * (a soft-edge `<filter>` def, a DAG fill-overlay tint layer), plus the helper
@@ -14578,6 +14762,8 @@ declare class ElementRendererComponent {
      */
     private readonly playback;
     private readonly translate;
+    /** For {@link bevelLightingFilter}'s injected `<filter>` markup. */
+    private readonly sanitizer;
     readonly smartArt3D: _angular_core.Signal<boolean>;
     /** Whether the Selection Pane has hidden this element; see the empty first `@case`. */
     readonly isHidden: _angular_core.Signal<boolean>;
@@ -14687,6 +14873,8 @@ declare class ElementRendererComponent {
      * resolves. Undefined otherwise.
      */
     readonly softEdgeFilter: _angular_core.Signal<SoftEdgeFilterDef | undefined>;
+    /** `a:sp3d` bevel lighting `<filter>` descriptor; see `bevel-lighting-filter.ts`. */
+    readonly bevelLightingFilter: _angular_core.Signal<BevelLightingFilterDef | undefined>;
     /**
      * `a:reflection` mirrored-sibling descriptor, or `undefined`. Used by the
      * `group` branch below (a group reflects its whole composited subtree);
@@ -15851,18 +16039,6 @@ declare class ZoomRendererComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZoomRendererComponent, "pptx-zoom-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "markElement": { "alias": "markElement"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-/**
- * presentation-overlay-chrome-styles.ts: the fixed-position inline styles for
- * the slide-show overlay's own chrome (close button, edge navigation buttons,
- * slide counter).
- *
- * These are `[ngStyle]` records rather than CSS classes because they must beat
- * whatever the host page's stylesheet does to a `<button>` inside a fullscreen
- * overlay, and because the safe-area `env()` offsets are read straight back by
- * the mobile e2e specs. They are static data with no dependency on component
- * state, so they live here instead of taking up a third of
- * {@link PresentationOverlayComponent}.
- */
 /** Inline style record as Angular's `[ngStyle]` consumes it. */
 type OverlayStyle = Record<string, string>;
 
@@ -15922,6 +16098,14 @@ declare class AnimationPlaybackService {
         slideHeightPx?: number;
         /** The deck's resolved theme colour map, for a scheme-colour (`a:schemeClr`) animation stop. */
         themeColorMap?: Readonly<Record<string, string>>;
+        /**
+         * `viewerOptions.advanced.pixelateMosaicAnimation`. `true` plays the
+         * blocky mosaic reveal for `p:animEffect/@filter="pixelate"`; omitted
+         * or `false` (the default, matching PowerPoint's own behaviour) snaps
+         * the element to its end state. See `resolveFilterEffect`'s doc in
+         * `pptx-viewer-shared`'s `animation-filter-effects.ts`.
+         */
+        pixelateMosaic?: boolean;
     }): void;
     /**
      * True while the active slide shows its builds as already complete because
@@ -16243,6 +16427,14 @@ interface ShowNavigatorDeps {
     };
     /** The deck's resolved theme colour map, for a scheme-colour (`a:schemeClr`) animation stop. */
     themeColorMap?: () => Readonly<Record<string, string>> | undefined;
+    /**
+     * `viewerOptions.advanced.pixelateMosaicAnimation`. `true` plays the
+     * blocky mosaic reveal for `p:animEffect/@filter="pixelate"`; omitted or
+     * `false` (the default, matching PowerPoint's own behaviour) snaps the
+     * element to its end state. See `resolveFilterEffect`'s doc in
+     * `pptx-viewer-shared`'s `animation-filter-effects.ts`.
+     */
+    pixelateMosaicAnimation?: () => boolean | undefined;
     playback: AnimationPlaybackService;
     annotations: PresentationAnnotationsService;
     /** Publish a committed index change to the host's `indexChange` output. */
@@ -16374,6 +16566,14 @@ interface PresentationInputDeps {
      * restores the origin show + slide once the sub-show runs off its end.
      */
     runCustomShow?: (customShowId: string, returnAfter: boolean) => void;
+    /**
+     * `ppaction://program`: PowerPoint's "Run program" action. A browser cannot
+     * launch a local executable, so the host is expected to surface a
+     * non-blocking notice naming the resolved command (see
+     * `buildRunProgramNotice` in `pptx-viewer-shared`) rather than doing
+     * nothing. Omitted means the click is still consumed, just silently.
+     */
+    runProgram?: (target: string) => void;
 }
 declare class PresentationInputController {
     private readonly deps;
@@ -16420,6 +16620,19 @@ declare class PresentationInputController {
     private toggleBlank;
 }
 
+declare class RunProgramNoticeStore {
+    /** Notices currently on screen, oldest first. */
+    readonly notices: _angular_core.WritableSignal<readonly RunProgramNotice[]>;
+    /**
+     * Build a fresh notice for `target` and append it. Every call adds a new
+     * notice (even for the same target clicked twice in a row): each click is
+     * its own event the presenter may want to copy independently.
+     */
+    add(target: string): void;
+    /** Dismiss one notice by id. */
+    dismiss(id: string): void;
+}
+
 /**
  * PresentationOverlayComponent: full-viewport black overlay that renders
  * slides in presentation (kiosk) mode.
@@ -16498,6 +16711,12 @@ declare class PresentationOverlayComponent implements OnInit {
      * once instead of sitting on the last slide swallowing every advance.
      */
     readonly endWithBlackSlide: _angular_core.InputSignal<boolean>;
+    /**
+     * File > Options > Advanced > "Show a mosaic effect for Pixelate
+     * transitions" (default false, matching PowerPoint's own instant-swap
+     * behaviour for `p:animEffect/@filter="pixelate"`).
+     */
+    readonly pixelateMosaicAnimation: _angular_core.InputSignal<boolean>;
     /** Whether presenter view is up (tints the toolbar's presenter-view toggle). */
     readonly presenterMode: _angular_core.InputSignal<boolean>;
     /**
@@ -16545,6 +16764,12 @@ declare class PresentationOverlayComponent implements OnInit {
     protected readonly playback: AnimationPlaybackService;
     /** Ink-annotation state (pen/highlighter/eraser/laser) for the show. */
     protected readonly annotations: PresentationAnnotationsService;
+    /**
+     * `ppaction://program` ("Run program") notices: a browser cannot launch the
+     * command, so the click surfaces a dismissible notice naming it instead.
+     * See `run-program-notice-store.ts`.
+     */
+    protected readonly runProgramNotices: RunProgramNoticeStore;
     /**
      * The show's navigation state machine (index, end-of-show screen, slide
      * transition, timed auto-advance). See `presentation-show-navigator.ts`.
@@ -16716,7 +16941,7 @@ declare class PresentationOverlayComponent implements OnInit {
     private runChromeAction;
     private emitClosed;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PresentationOverlayComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PresentationOverlayComponent, "pptx-presentation-overlay", never, { "slides": { "alias": "slides"; "required": true; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "startIndex": { "alias": "startIndex"; "required": false; "isSignal": true; }; "activeCustomShow": { "alias": "activeCustomShow"; "required": false; "isSignal": true; }; "authoredRange": { "alias": "authoredRange"; "required": false; "isSignal": true; }; "loopContinuously": { "alias": "loopContinuously"; "required": false; "isSignal": true; }; "showWithAnimation": { "alias": "showWithAnimation"; "required": false; "isSignal": true; }; "useTimings": { "alias": "useTimings"; "required": false; "isSignal": true; }; "subtitlesVisible": { "alias": "subtitlesVisible"; "required": false; "isSignal": true; }; "sessionEnded": { "alias": "sessionEnded"; "required": false; "isSignal": true; }; "endWithBlackSlide": { "alias": "endWithBlackSlide"; "required": false; "isSignal": true; }; "presenterMode": { "alias": "presenterMode"; "required": false; "isSignal": true; }; "showMenuOnRightClick": { "alias": "showMenuOnRightClick"; "required": false; "isSignal": true; }; "showPopupToolbar": { "alias": "showPopupToolbar"; "required": false; "isSignal": true; }; }, { "indexChange": "indexChange"; "closed": "closed"; "subtitlesChange": "subtitlesChange"; "presenterViewToggle": "presenterViewToggle"; "annotationsExit": "annotationsExit"; "customShowRequest": "customShowRequest"; "endOfShowChange": "endOfShowChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PresentationOverlayComponent, "pptx-presentation-overlay", never, { "slides": { "alias": "slides"; "required": true; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "startIndex": { "alias": "startIndex"; "required": false; "isSignal": true; }; "activeCustomShow": { "alias": "activeCustomShow"; "required": false; "isSignal": true; }; "authoredRange": { "alias": "authoredRange"; "required": false; "isSignal": true; }; "loopContinuously": { "alias": "loopContinuously"; "required": false; "isSignal": true; }; "showWithAnimation": { "alias": "showWithAnimation"; "required": false; "isSignal": true; }; "useTimings": { "alias": "useTimings"; "required": false; "isSignal": true; }; "subtitlesVisible": { "alias": "subtitlesVisible"; "required": false; "isSignal": true; }; "sessionEnded": { "alias": "sessionEnded"; "required": false; "isSignal": true; }; "endWithBlackSlide": { "alias": "endWithBlackSlide"; "required": false; "isSignal": true; }; "pixelateMosaicAnimation": { "alias": "pixelateMosaicAnimation"; "required": false; "isSignal": true; }; "presenterMode": { "alias": "presenterMode"; "required": false; "isSignal": true; }; "showMenuOnRightClick": { "alias": "showMenuOnRightClick"; "required": false; "isSignal": true; }; "showPopupToolbar": { "alias": "showPopupToolbar"; "required": false; "isSignal": true; }; }, { "indexChange": "indexChange"; "closed": "closed"; "subtitlesChange": "subtitlesChange"; "presenterViewToggle": "presenterViewToggle"; "annotationsExit": "annotationsExit"; "customShowRequest": "customShowRequest"; "endOfShowChange": "endOfShowChange"; }, never, never, true, never>;
 }
 
 /**
@@ -20305,7 +20530,7 @@ declare class AccountPageComponent {
     readonly accountAuth: _angular_core.InputSignal<AccountAuthConfig | undefined>;
     private readonly translate;
     protected readonly swatches: readonly string[];
-    protected readonly version = "3.11.0";
+    protected readonly version = "3.12.0";
     protected readonly profile: _angular_core.WritableSignal<ViewerProfile>;
     protected readonly initial: _angular_core.Signal<string>;
     protected readonly usage: _angular_core.WritableSignal<LocalStorageUsageSummary | null>;
@@ -20719,34 +20944,6 @@ declare class PresentationToolbarComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<PresentationToolbarComponent, "pptx-presentation-toolbar", never, { "currentSlideIndex": { "alias": "currentSlideIndex"; "required": true; "isSignal": true; }; "totalSlides": { "alias": "totalSlides"; "required": true; "isSignal": true; }; "presentationStartTime": { "alias": "presentationStartTime"; "required": false; "isSignal": true; }; "presenterMode": { "alias": "presenterMode"; "required": false; "isSignal": true; }; "popupToolbarEnabled": { "alias": "popupToolbarEnabled"; "required": false; "isSignal": true; }; }, { "move": "move"; "endPresentation": "endPresentation"; "presenterViewToggle": "presenterViewToggle"; }, never, never, true, never>;
 }
 
-/**
- * transition-helpers.ts
- *
- * Thin re-export shim over the framework-agnostic slide-transition CSS/keyframe
- * generator in `pptx-viewer-shared` (vendored via `../internal/shared`).
- *
- * The pure logic (direction/orientation resolution, the `pptx-tr-*` keyframe
- * block (`SLIDE_TRANSITION_KEYFRAMES`), and the type→`animation` resolver
- * (`getSlideTransitionAnimations`, including the exotic/3-D 2-D approximations
- * that originated here) now lives in shared and is consumed by every binding.
- *
- * The presentation overlay's duration comes from the shared resolver
- * (`resolveTransitionDurationMs`), exactly as in the other four bindings, so
- * an authored `p14:dur`, the legacy `spd` token and the COM-verified defaults
- * all play at PowerPoint's speed here too. The older local floor/default
- * policy (`MIN_TRANSITION_DURATION_MS` / `DEFAULT_TRANSITION_DURATION_MS` /
- * `resolveTransitionDuration`) stays exported for callers that adopted it, but
- * the overlay no longer consults it.
- */
-
-/**
- * Resolve an effective duration (ms) from an optional authored value, applying
- * the minimum floor and the local default. Kept as a public helper; the
- * presentation overlay resolves through the shared
- * {@link resolveOverlayDurationMs} instead, which is what plays on screen.
- */
-declare function resolveTransitionDuration(durationMs: number | undefined): number;
-
 /** One cross-dissolving pair, as the two single-element slides that paint it. */
 interface MorphCrossfadeGroupSlides {
     key: string;
@@ -20765,6 +20962,7 @@ interface MorphCrossfadeGroupSlides {
     outgoing: PptxSlide;
     incoming: PptxSlide;
 }
+
 /**
  * PresentationTransitionOverlayComponent: plays a PowerPoint slide transition
  * over the presentation stage.
@@ -20825,62 +21023,24 @@ declare class PresentationTransitionOverlayComponent {
     /** Owned `<style>` element carrying the active morph rules, if any. */
     private morphStyle;
     private applyMorphStyle;
-    /** Effective transition duration (ms), floored/defaulted. */
+    private readonly state;
     protected readonly resolvedDurationMs: _angular_core.Signal<number>;
-    /** Resolved CSS animation descriptors for the outgoing/incoming layers. */
-    protected readonly animations: _angular_core.Signal<SlideTransitionAnimations>;
-    /**
-     * Active Morph plan, or `undefined` for every other transition.
-     *
-     * Morph travels individual shapes between the two slides rather than wiping
-     * the surface, so it changes what this overlay paints: a per-shape copy of
-     * the outgoing slide, each one gliding onto its counterpart (dissolving into
-     * it when its appearance changed) or fading out in place when it has none.
-     * The incoming halves are animated on the live stage by document-level rules
-     * (see `morphStyleEffect`).
-     */
+    protected readonly animations: _angular_core.Signal<pptx_angular_viewer.SlideTransitionAnimations>;
+    protected readonly fragmented: _angular_core.Signal<FragmentedTransitionDescriptor | undefined>;
+    protected readonly fragmentedOutgoing: _angular_core.Signal<FragmentedLayer | undefined>;
+    protected readonly fragmentedIncoming: _angular_core.Signal<FragmentedLayer | undefined>;
+    protected readonly fragmentedOutgoingZIndex: _angular_core.Signal<number>;
+    protected readonly fragmentedIncomingZIndex: _angular_core.Signal<number>;
+    protected readonly incomingFragmentSlide: _angular_core.Signal<PptxSlide | undefined>;
     protected readonly morphPlan: _angular_core.Signal<MorphTransitionPlan | undefined>;
-    /**
-     * Whether this overlay is playing a morph.
-     *
-     * A morph layer paints only the departing slide's paired shapes over the live
-     * incoming stage, so its stage background must be dropped
-     * (`transparentBackground`). Every other transition animates a whole slide
-     * surface out and keeps its own background.
-     */
     protected readonly isMorph: _angular_core.Signal<boolean>;
-    /** The slide rendered in the animated layer (outgoing + its template). */
     protected readonly layerSlide: _angular_core.Signal<PptxSlide>;
-    /**
-     * The arriving shapes the morph has to paint over its own ghosts, or
-     * `undefined` when there are none (issue #146). They sit on the live stage
-     * below this overlay, where the departing layer would hide them for the whole
-     * transition; the plan holds that copy invisible and hands them here instead.
-     */
     protected readonly liftedSlide: _angular_core.Signal<PptxSlide | undefined>;
-    /**
-     * The cross-dissolving pairs this overlay paints both halves of, each in its
-     * own isolated group so the halves are summed rather than stacked.
-     */
     protected readonly crossfadeGroups: _angular_core.Signal<MorphCrossfadeGroupSlides[]>;
-    /** Layer container style: animation + stacking relative to the stage. */
-    protected readonly layerStyle: _angular_core.Signal<StyleMap>;
-    /**
-     * The arriving slide rendered ABOVE the outgoing layer for a classic
-     * transition, carrying the incoming animation (wipe/cover/fade/push), or
-     * `undefined` for morphs and the uncover family (which reveal the live
-     * stage instead).
-     */
+    protected readonly layerStyle: _angular_core.Signal<pptx_angular_viewer.StyleMap>;
     protected readonly incomingLayerSlide: _angular_core.Signal<PptxSlide | undefined>;
-    /** Style for that arriving layer: the incoming animation + its stacking. */
-    protected readonly incomingLayerStyle: _angular_core.Signal<StyleMap>;
-    /**
-     * Slide box sized to the ZOOMED slide footprint, matching the stage's own
-     * `pptx-slide-canvas`. The inner canvas renders at the same `zoom` with
-     * `autoFit` off, so the outgoing slide is pixel-for-pixel the size of the
-     * incoming one for the whole animation.
-     */
-    protected readonly slideBoxStyle: _angular_core.Signal<StyleMap>;
+    protected readonly incomingLayerStyle: _angular_core.Signal<pptx_angular_viewer.StyleMap>;
+    protected readonly slideBoxStyle: _angular_core.Signal<pptx_angular_viewer.StyleMap>;
     private armCompletion;
     private clearTimer;
     /**
@@ -21085,6 +21245,34 @@ declare class MobilePresenterViewComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<MobilePresenterViewComponent, "pptx-mobile-presenter-view", never, { "slides": { "alias": "slides"; "required": true; "isSignal": true; }; "currentSlideIndex": { "alias": "currentSlideIndex"; "required": true; "isSignal": true; }; "activeCustomShow": { "alias": "activeCustomShow"; "required": false; "isSignal": true; }; "authoredRange": { "alias": "authoredRange"; "required": false; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "templateElements": { "alias": "templateElements"; "required": false; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "presentationStartTime": { "alias": "presentationStartTime"; "required": false; "isSignal": true; }; }, { "movePresentationSlide": "movePresentationSlide"; "exit": "exit"; }, never, never, true, never>;
 }
 
+/**
+ * transition-helpers.ts
+ *
+ * Thin re-export shim over the framework-agnostic slide-transition CSS/keyframe
+ * generator in `pptx-viewer-shared` (vendored via `../internal/shared`).
+ *
+ * The pure logic (direction/orientation resolution, the `pptx-tr-*` keyframe
+ * block (`SLIDE_TRANSITION_KEYFRAMES`), and the type→`animation` resolver
+ * (`getSlideTransitionAnimations`, including the exotic/3-D 2-D approximations
+ * that originated here) now lives in shared and is consumed by every binding.
+ *
+ * The presentation overlay's duration comes from the shared resolver
+ * (`resolveTransitionDurationMs`), exactly as in the other four bindings, so
+ * an authored `p14:dur`, the legacy `spd` token and the COM-verified defaults
+ * all play at PowerPoint's speed here too. The older local floor/default
+ * policy (`MIN_TRANSITION_DURATION_MS` / `DEFAULT_TRANSITION_DURATION_MS` /
+ * `resolveTransitionDuration`) stays exported for callers that adopted it, but
+ * the overlay no longer consults it.
+ */
+
+/**
+ * Resolve an effective duration (ms) from an optional authored value, applying
+ * the minimum floor and the local default. Kept as a public helper; the
+ * presentation overlay resolves through the shared
+ * {@link resolveOverlayDurationMs} instead, which is what plays on screen.
+ */
+declare function resolveTransitionDuration(durationMs: number | undefined): number;
+
 /**
  * presenter-view-helpers.ts
  *