pptx-angular-viewer 1.1.18 → 1.1.20

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

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
-import { Signal, OnInit, OnDestroy, InjectionToken, Provider } from '@angular/core';
+import { Signal, OnInit, OnDestroy, OnChanges, SimpleChanges, InjectionToken, Provider } from '@angular/core';
 import * as pptx_viewer_core from 'pptx-viewer-core';
-import { PptxSlide, AccessibilityCheckOptions, AccessibilityIssue, PptxElement, PptxTheme, PptxSlideMaster, PptxEmbeddedFont, PptxCoreProperties, ParsedSignature, PptxComment, TextSegment, TextStyle, PptxTableCell, Model3DPptxElement, ZoomPptxElement, PptxSlideTransition, TablePptxElement, ChartPptxElement, XmlObject, SignatureStatus, AccessibilityIssueSeverity, AccessibilityIssueType, PptxElementAnimation, PptxTransitionType, ShapeStyle } from 'pptx-viewer-core';
+import { PptxSlide, AccessibilityCheckOptions, AccessibilityIssue, PptxElement, PptxTheme, PptxSlideMaster, PptxEmbeddedFont, PptxCoreProperties, ParsedSignature, PptxComment, PptxTextWarpPreset, TextSegment, TextStyle, PptxTableCell, Model3DPptxElement, ZoomPptxElement, PptxElementAnimation, PptxSlideTransition, TablePptxElement, ChartPptxElement, PptxAnimationPreset, PptxAnimationTrigger, PptxAnimationTimingCurve, PptxAnimationRepeatMode, PptxAnimationDirection, PptxAnimationSequence, XmlObject, SignatureStatus, AccessibilityIssueSeverity, AccessibilityIssueType, PptxTransitionType, ShapeStyle } from 'pptx-viewer-core';
 import * as pptx_angular_viewer from 'pptx-angular-viewer';
 import { Options } from 'html2canvas-pro';
 import { SafeHtml } from '@angular/platform-browser';
@@ -657,6 +657,62 @@ declare function replaceMatch(slides: readonly PptxSlide[], allResults: readonly
  */
 declare function replaceInSlides(slides: readonly PptxSlide[], query: string, replacement: string, opts?: FindOptions): ReplaceResult;
 
+/**
+ * Decide whether the current environment is "mobile" based on two signals:
+ * - `width` is the viewport / container width in pixels
+ * - `coarsePointer` is true when `(pointer: coarse)` matches
+ *
+ * Either condition alone is sufficient (narrow viewport OR touch device).
+ *
+ * @pure — no side effects, fully testable without a DOM.
+ */
+declare function computeIsMobile(width: number, coarsePointer: boolean): boolean;
+/**
+ * Decide whether the current environment is "tablet" based on width only.
+ * A coarse-pointer device at tablet width is still treated as mobile
+ * (handled by `computeIsMobile`).
+ *
+ * @pure
+ */
+declare function computeIsTablet(width: number, coarsePointer: boolean): boolean;
+/**
+ * `IsMobileService` — provides reactive signals for the current viewport /
+ * pointer kind so components can switch between mobile and desktop chrome
+ * without subscribing to resize events themselves.
+ *
+ * Inject at the component level (or provide at root) — the service cleans up
+ * its `MediaQueryList` listeners automatically via `DestroyRef`.
+ *
+ * ```ts
+ * providers: [IsMobileService]
+ * // or globally:
+ * // provideIsMobile()  (see factory below)
+ * ```
+ *
+ * ```ts
+ * protected readonly mobile = inject(IsMobileService);
+ * // in template:  @if (mobile.isMobile()) { … }
+ * ```
+ */
+declare class IsMobileService {
+    /** True when the primary pointer is coarse (touch / stylus). */
+    readonly isCoarsePointer: _angular_core.WritableSignal<boolean>;
+    /** True when the viewport width is below {@link MOBILE_BREAKPOINT}. */
+    readonly isNarrowViewport: _angular_core.WritableSignal<boolean>;
+    /**
+     * True when either the pointer is coarse OR the viewport is narrow.
+     * Use this as the single gate for showing mobile chrome.
+     */
+    readonly isMobile: _angular_core.WritableSignal<boolean>;
+    /** True when the viewport is in the tablet range (desktop pointer only). */
+    readonly isTablet: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /** Recompute derived `isMobile` signal from the two raw conditions. */
+    private _update;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IsMobileService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IsMobileService>;
+}
+
 /**
  * `LoadContentService` — Angular port of the React `useLoadContent` hook and
  * the Vue `useLoadContent` composable.
@@ -922,6 +978,7 @@ declare class PowerPointViewerComponent {
     protected readonly collab: CollaborationService;
     protected readonly accessibility: AccessibilityService;
     protected readonly print: PrintService;
+    protected readonly mobile: IsMobileService;
     /** The `<main>` host; used to locate the live `.pptx-ng-canvas-stage`. */
     private readonly mainEl;
     /** True while a PNG/PDF export is in progress (disables the buttons). */
@@ -944,6 +1001,8 @@ declare class PowerPointViewerComponent {
     protected readonly presenterStartTime: _angular_core.WritableSignal<number | null>;
     /** Slide-sorter grid overlay visibility. */
     protected readonly showSorter: _angular_core.WritableSignal<boolean>;
+    /** Open mobile bottom-sheet (slides / menu), or null. */
+    protected readonly mobileSheet: _angular_core.WritableSignal<"slides" | "menu" | null>;
     /** Speaker-notes strip visibility. */
     protected readonly showNotes: _angular_core.WritableSignal<boolean>;
     /** Find-in-slides bar visibility. */
@@ -1614,6 +1673,113 @@ declare function routeOrthogonalConnector(start: Point, end: Point, obstacles: R
  */
 declare function waypointsToPathD(waypoints: ReadonlyArray<Point>): string;
 
+/**
+ * Text-warp (WordArt) descriptor resolver for the Angular viewer.
+ *
+ * Angular port of:
+ *   packages/react/src/viewer/utils/text-warp-classifier.ts
+ *   packages/react/src/viewer/utils/text-warp-css.tsx
+ *   packages/react/src/viewer/utils/warp-text-renderer.tsx  (descriptor shape)
+ *
+ * `getTextWarp(element)` resolves an element's OOXML `prstTxWarp` preset into a
+ * `TextWarpDef` that the Angular template can consume without any React/HTML
+ * string injection.  The descriptor selects one of two rendering strategies:
+ *
+ *   - `'path'`    — SVG `<textPath>` along a curved/arc/circle path.
+ *                   The `pathLines` array contains one entry per paragraph with a
+ *                   pre-computed SVG `d` attribute.  The template renders an inline
+ *                   `<svg>` with `<defs><path>` + `<text><textPath href>`.
+ *
+ *   - `'css'`     — A whole-block CSS transform approximation.  The template
+ *                   applies `cssTransform` and `cssTransformOrigin` to the
+ *                   existing `div.pptx-ng-text` wrapper (or a parent div) via
+ *                   `[ngStyle]`.  No SVG required.
+ *
+ * Presets classified as `'none'` (textNoShape, textPlain, unknown) return
+ * `undefined` so callers can skip extra rendering without an allowlist check.
+ */
+
+/** The four rendering strategy families. */
+type WarpCategory = 'path' | 'envelope' | 'simple' | 'none';
+/**
+ * Classify a warp preset into a rendering strategy category.
+ *
+ * Returns `'none'` for unknown or empty presets so callers can safely
+ * skip rendering without an explicit allowlist check.
+ */
+declare function getWarpCategory(preset: string | undefined): WarpCategory;
+/**
+ * A single pre-computed SVG path line for one text paragraph.
+ *
+ * The template renders this as:
+ *   `<path [id]="pathId" [attr.d]="d" fill="none" />`
+ * inside `<defs>`, then references it with `<textPath [attr.href]="'#'+pathId">`.
+ */
+interface WarpPathLine {
+    /** Unique DOM id for this `<path>` element (safe to use as `href` fragment). */
+    pathId: string;
+    /** SVG path data (`d` attribute). */
+    d: string;
+    /** The text segments that flow along this path. */
+    segments: TextSegment[];
+}
+/**
+ * Descriptor for SVG `<textPath>`-based warp rendering.
+ *
+ * One `WarpPathLine` per paragraph.  The template renders an inline `<svg>`
+ * covering the element bounds, defines each path in `<defs>`, then lays
+ * `<text><textPath href="#pathId">` on each path.
+ */
+interface TextWarpPathDef {
+    readonly strategy: 'path';
+    /** OOXML preset name (e.g. `'textArchUp'`). */
+    readonly preset: PptxTextWarpPreset;
+    /** One entry per paragraph. */
+    readonly pathLines: WarpPathLine[];
+    /** Element pixel width (for `<svg width>`). */
+    readonly width: number;
+    /** Element pixel height (for `<svg height>`). */
+    readonly height: number;
+    /** SVG `text-anchor` value derived from paragraph alignment. */
+    readonly textAnchor: 'start' | 'middle' | 'end';
+    /** SVG `<textPath startOffset>` value (e.g. `"0%"`, `"50%"`, `"100%"`). */
+    readonly startOffset: string;
+    /** Base font size in points from the element's text style. */
+    readonly baseFontSize: number;
+    /** Base font family string (already CSS-ready). */
+    readonly baseFontFamily: string;
+    /** Base text fill colour (hex). */
+    readonly baseColor: string;
+}
+/**
+ * Descriptor for CSS-transform-based warp rendering.
+ *
+ * The template applies `cssTransform` + `cssTransformOrigin` on the
+ * `div.pptx-ng-text` wrapper (or a containing div) via `[ngStyle]`.
+ */
+interface TextWarpCssDef {
+    readonly strategy: 'css';
+    /** OOXML preset name (e.g. `'textSlantUp'`). */
+    readonly preset: PptxTextWarpPreset;
+    /** CSS `transform` string (e.g. `"perspective(500px) rotateY(8deg) skewY(-4deg)"`). */
+    readonly cssTransform: string;
+    /** CSS `transform-origin` string (e.g. `"left center"`). */
+    readonly cssTransformOrigin: string;
+}
+/** Union of the two warp rendering strategies. */
+type TextWarpDef = TextWarpPathDef | TextWarpCssDef;
+/**
+ * Resolve a `PptxElement`'s text warp preset into a `TextWarpDef` descriptor,
+ * or `undefined` when the element carries no warp (or the preset is `textNoShape` /
+ * `textPlain` / unknown).
+ *
+ * @param element  Any `PptxElement`.  Elements without text properties always
+ *                 return `undefined`.
+ * @returns  A `TextWarpDef` with `strategy: 'path'` for SVG textPath warps, or
+ *           `strategy: 'css'` for CSS-transform approximations.
+ */
+declare function getTextWarp(element: PptxElement): TextWarpDef | undefined;
+
 interface TextRun {
     text: string;
     style: StyleMap;
@@ -1671,6 +1837,12 @@ declare class ElementRendererComponent {
     readonly shapeContainerStyle: _angular_core.Signal<StyleMap>;
     readonly textStyle: _angular_core.Signal<StyleMap>;
     readonly imageSrc: _angular_core.Signal<string | undefined>;
+    /** Text-warp (WordArt) descriptor for the element, if any. */
+    readonly textWarp: _angular_core.Signal<pptx_angular_viewer.TextWarpDef | undefined>;
+    /** Only the SVG-textPath warp variant (for the `<svg>` overlay branch). */
+    readonly pathWarp: _angular_core.Signal<TextWarpPathDef | undefined>;
+    /** Text block style, folding in a CSS-transform warp when present. */
+    readonly warpedTextStyle: _angular_core.Signal<StyleMap>;
     readonly children: _angular_core.Signal<PptxElement[]>;
     readonly isShapeLike: _angular_core.Signal<boolean>;
     readonly isImageLike: _angular_core.Signal<boolean>;
@@ -2022,6 +2194,8 @@ interface SvgText {
     fontWeight?: 'normal' | 'bold';
     dominantBaseline?: string;
     opacity?: number;
+    /** Optional SVG transform (e.g. `rotate(-90, x, y)` for a vertical axis title). */
+    transform?: string;
 }
 interface SvgPolygon {
     kind: 'polygon';
@@ -2448,6 +2622,305 @@ 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; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * animation-playback-helpers.ts
+ *
+ * Pure functions backing {@link AnimationPlaybackService} and
+ * {@link AnimationPanelComponent}. Exported separately so they can be
+ * unit-tested without TestBed (vitest + happy-dom).
+ *
+ * A slide carries an ordered list of {@link PptxElementAnimation}s. PowerPoint
+ * groups them into "click groups": an animation triggered `onClick` /
+ * `onShapeClick` / `onHover` starts a new group, while `withPrevious` /
+ * `afterPrevious` / `afterDelay` animations fold into the group that precedes
+ * them (running together or sequentially within that group). Advancing the
+ * presentation one step reveals one more click group.
+ *
+ * Everything here is framework-light: only the preset → CSS mapping is
+ * delegated to {@link resolveAnimationCss} / {@link initialHiddenStyle} from
+ * the shared render layer.
+ */
+
+/** Minimal CSS-properties shape: kebab-case property → value. */
+type CSSProperties = Record<string, string>;
+/** A single click-triggered group of animations that play as one step. */
+interface AnimationClickGroup {
+    /** Animations belonging to this group, in document order. */
+    animations: PptxElementAnimation[];
+}
+/**
+ * Splits an ordered animation list into click groups. The first animation
+ * always begins a group even if it isn't explicitly `onClick` (PowerPoint shows
+ * the first build on the first advance). Subsequent `withPrevious` /
+ * `afterPrevious` animations attach to the group in progress.
+ */
+declare function buildClickGroups(animations: readonly PptxElementAnimation[]): AnimationClickGroup[];
+/** Clamp a step into `[0, count]`. */
+declare function clampStep(value: number, count: number): number;
+/**
+ * Reveal the next click group. Returns the next step, clamped to `count`.
+ * Equivalent to `clampStep(step + 1, count)`.
+ */
+declare function advanceStep(step: number, count: number): number;
+/** Parse the numeric ms duration out of a resolved style's `animation-duration`. */
+declare function durationOf(style: CSSProperties): number;
+/**
+ * Resolve the CSS for every animation in the revealed groups (the first `step`
+ * groups). Within a group, `afterPrevious` animations are pushed back by the
+ * accumulated duration of the preceding animations so sequential chains play in
+ * order; `withPrevious` shares the running delay. The last write for an element
+ * id wins (a later emphasis/exit overrides an earlier entrance), matching how a
+ * single CSS `animation` shorthand can only hold one running effect.
+ */
+declare function revealedElementStyles(groups: readonly AnimationClickGroup[], step: number): Map<string, CSSProperties>;
+/**
+ * Elements with a pending entrance (in a not-yet-revealed group, i.e. groups at
+ * or beyond `step`) that should be hidden until their group plays. An element
+ * an already-revealed group made visible is never re-hidden.
+ */
+declare function pendingElementStyles(groups: readonly AnimationClickGroup[], step: number): Map<string, CSSProperties>;
+
+declare class AnimationPlaybackService {
+    private readonly destroyRef;
+    /** The current slide's animations, in document/timeline order. */
+    private readonly animations;
+    /**
+     * Externally-controlled playback step (e.g. derived from a parent click
+     * counter). `undefined` means there is no external driver. The internal
+     * manual step (set via advance/play/reset) takes precedence when present.
+     */
+    private readonly externalIndex;
+    /**
+     * Internal, unclamped step. `null` means "follow the external index"; any
+     * number means the host has taken manual control via advance/play/reset.
+     */
+    private readonly manualStep;
+    /** Click groups for the current slide's animations. */
+    readonly groups: _angular_core.Signal<AnimationClickGroup[]>;
+    /** Number of click groups on this slide (i.e. how many `advance()` steps). */
+    readonly groupCount: _angular_core.Signal<number>;
+    /**
+     * The current playback step: how many click groups have been revealed.
+     * Always clamped to the current group count. The manual override wins;
+     * otherwise it follows the external index, defaulting to 0.
+     */
+    readonly step: _angular_core.Signal<number>;
+    /** True when every click group has been revealed. */
+    readonly isComplete: _angular_core.Signal<boolean>;
+    /**
+     * Reactive map of `elementId → CSS properties` to apply for the current step.
+     * Only elements in revealed click groups appear.
+     */
+    readonly elementStyles: _angular_core.Signal<Map<string, CSSProperties>>;
+    /**
+     * Reactive map of `elementId → CSS properties` for elements whose entrance
+     * has not yet been revealed (they should be hidden so they don't flash
+     * visible before their group plays).
+     */
+    readonly pendingStyles: _angular_core.Signal<Map<string, CSSProperties>>;
+    /** Handle of the scheduled rAF auto-advance, or null when idle. */
+    private rafHandle;
+    constructor();
+    /** Feed the current slide's animation list. Resets manual control. */
+    setAnimations(animations: readonly PptxElementAnimation[] | undefined): void;
+    /** Update the external playback index (parent-driven build counter). */
+    setExternalIndex(index: number | undefined): void;
+    /**
+     * Reveal the next click group. Returns `true` if a group was revealed,
+     * `false` if playback was already complete (so the caller can fall through
+     * to slide navigation).
+     */
+    advance(): boolean;
+    /** Reveal every click group at once (jump to the slide's final state). */
+    play(): void;
+    /** Reset playback to before the first click group. */
+    reset(): void;
+    /**
+     * Jump directly to a given step (clamped to the group count) and take manual
+     * control. Useful for scrubbing.
+     */
+    setStep(step: number): void;
+    /**
+     * Auto-advance through every remaining click group on the animation frame,
+     * one group per frame. Stops automatically once playback completes or the
+     * service is destroyed. A no-op when already complete or when
+     * `requestAnimationFrame` is unavailable (SSR).
+     */
+    autoPlay(): void;
+    /** Cancel any in-flight rAF auto-advance. */
+    cancelAutoPlay(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimationPlaybackService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AnimationPlaybackService>;
+}
+
+/**
+ * presentation-annotations-helpers.ts — Pure geometry helpers for presentation
+ * ink annotations (pen, highlighter, eraser, laser).
+ *
+ * Ported from React:
+ *   packages/react/src/viewer/components/PresentationAnnotationOverlay.tsx
+ *   packages/react/src/viewer/hooks/usePresentationAnnotations.ts
+ *
+ * No Angular dependencies — all functions are pure so they can be unit-tested
+ * without TestBed.
+ */
+/** A single {x, y} coordinate in slide-space pixels. */
+interface AnnotationPoint {
+    x: number;
+    y: number;
+}
+/** An ink stroke: a sequence of points with visual properties. */
+interface AnnotationStroke {
+    id: string;
+    points: AnnotationPoint[];
+    color: string;
+    width: number;
+    /** 1 = opaque (pen); 0.4 = semi-transparent (highlighter). */
+    opacity: number;
+}
+/** The tool currently armed in presentation mode. */
+type PresentationTool = 'none' | 'pen' | 'highlighter' | 'eraser' | 'laser';
+/** Per-slide annotation storage: slide index → strokes. */
+type SlideAnnotationMap = Map<number, AnnotationStroke[]>;
+/** Transient laser-pointer position in slide-space pixels. */
+interface LaserPosition {
+    x: number;
+    y: number;
+}
+
+declare class PresentationAnnotationsService {
+    private readonly destroyRef;
+    private readonly _tool;
+    private readonly _penColor;
+    private readonly _highlighterColor;
+    private readonly _currentStroke;
+    private readonly _laserPosition;
+    private readonly _toolbarVisible;
+    /**
+     * Strokes visible on the current slide. Cleared / populated whenever
+     * `setActiveSlide()` is called.
+     */
+    private readonly _annotationStrokes;
+    /**
+     * Per-slide annotation storage. Strokes for the current slide are also kept
+     * in `_annotationStrokes` for rendering convenience; they are synchronised
+     * back into this map on `setActiveSlide()` or `endStroke()`.
+     */
+    private readonly _slideAnnotations;
+    /** Tracks whether a pointer-down initiated an erase gesture. */
+    private _isErasing;
+    /** Toolbar auto-hide timer handle. */
+    private _toolbarTimer;
+    /** Index of the slide currently being annotated. */
+    private _activeSlideIndex;
+    /** The currently-armed presentation tool. */
+    readonly tool: _angular_core.Signal<PresentationTool>;
+    /** Stroke colour used by the pen tool. */
+    readonly penColor: _angular_core.Signal<string>;
+    /** Stroke colour used by the highlighter tool. */
+    readonly highlighterColor: _angular_core.Signal<string>;
+    /** Committed strokes on the active slide (does not include the live stroke). */
+    readonly annotationStrokes: _angular_core.Signal<AnnotationStroke[]>;
+    /** The stroke currently being drawn, or null when not drawing. */
+    readonly currentStroke: _angular_core.Signal<AnnotationStroke | null>;
+    /** Laser pointer position in slide-space pixels, or null when not visible. */
+    readonly laserPosition: _angular_core.Signal<LaserPosition | null>;
+    /** Whether the annotation toolbar should be visible. */
+    readonly toolbarVisible: _angular_core.Signal<boolean>;
+    /**
+     * `true` when any annotations exist on any slide (used for the
+     * "keep / discard" dialog when exiting presentation mode).
+     */
+    readonly hasAnyAnnotations: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Arm `tool`. If it is already armed, toggle back to `'none'` (matches
+     * the React behaviour of `setPresentationTool`).
+     */
+    setTool(tool: PresentationTool): void;
+    /** Set the pen colour directly (without toggling the tool). */
+    setPenColor(color: string): void;
+    /** Set the highlighter colour directly. */
+    setHighlighterColor(color: string): void;
+    /** Show / hide the toolbar programmatically. */
+    setToolbarVisible(visible: boolean): void;
+    /**
+     * Notify the service that the visible slide has changed. Saves the
+     * in-progress strokes for the previous slide and loads the strokes
+     * for `newIndex`.
+     */
+    setActiveSlide(newIndex: number): void;
+    /**
+     * Begin a stroke at `(x, y)` in slide-space coordinates.
+     * Called on pointer-down when the pen or highlighter is armed.
+     */
+    beginStroke(x: number, y: number): void;
+    /**
+     * Extend the active stroke by appending `(x, y)`.
+     * Called on pointer-move while drawing.
+     */
+    extendStroke(x: number, y: number): void;
+    /**
+     * Commit the active stroke to the slide's annotation list.
+     * Called on pointer-up or pointer-leave while drawing.
+     * Strokes with fewer than 2 points are discarded.
+     */
+    endStroke(): void;
+    /**
+     * Begin an eraser gesture at `(x, y)`.
+     * Must be called on pointer-down when the eraser is armed.
+     */
+    beginErase(x: number, y: number): void;
+    /**
+     * Continue erasing at `(x, y)` during a pointer-move.
+     */
+    continueErase(x: number, y: number): void;
+    /**
+     * End an eraser gesture. Called on pointer-up or pointer-leave.
+     */
+    endErase(): void;
+    /**
+     * Update the laser dot position (slide-space coords).
+     * Only takes effect when the laser tool is armed.
+     */
+    moveLaser(x: number, y: number): void;
+    /**
+     * Hide the laser dot (called on pointer-leave).
+     */
+    hideLaser(): void;
+    /**
+     * Clear all annotations on the active slide.
+     */
+    clearAnnotations(): void;
+    /**
+     * Clear all annotations across every slide.
+     */
+    clearAllAnnotations(): void;
+    /**
+     * Return a snapshot of all annotations across every slide.
+     * The current slide's in-progress committed strokes are folded in.
+     *
+     * Used by the "keep as ink elements" dialog handler.
+     */
+    getAllSlideAnnotations(): SlideAnnotationMap;
+    /**
+     * Show the toolbar and schedule it to auto-hide after `delayMs` (default 3 s).
+     * Resets the timer if called repeatedly (debounce on mouse-move).
+     */
+    showToolbarTemporarily(delayMs?: number): void;
+    /**
+     * Reset transient presentation state (tool, current stroke, laser, toolbar
+     * timer). Does NOT clear stored strokes — those persist for the
+     * keep/discard dialog.
+     */
+    resetForExit(): void;
+    private _applyErase;
+    private _flushCurrentSlide;
+    private _clearToolbarTimer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PresentationAnnotationsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PresentationAnnotationsService>;
+}
+
 /**
  * PresentationOverlayComponent — full-viewport black overlay that renders
  * slides in presentation (kiosk) mode.
@@ -2495,6 +2968,21 @@ declare class PresentationOverlayComponent implements OnInit, OnDestroy {
         outgoing: PptxSlide;
         transition: PptxSlideTransition;
     } | null>;
+    /** Click-stepped element-animation playback for the current slide. */
+    protected readonly playback: AnimationPlaybackService;
+    /** Ink-annotation state (pen/highlighter/eraser/laser) for the show. */
+    protected readonly annotations: PresentationAnnotationsService;
+    /** Whether the live-caption bar is shown. */
+    protected readonly subtitlesVisible: _angular_core.WritableSignal<boolean>;
+    /** The slide stage root — animation styles are applied to its elements. */
+    private readonly stageRef;
+    constructor();
+    /**
+     * Imperatively apply animation reveal / pending CSS to the slide's element
+     * nodes (mirrors the Vue `applyAnimationStyles`). Every renderer emits a
+     * `data-element-id`, so this needs no per-element renderer plumbing.
+     */
+    private applyAnimationStyles;
     /** Viewport dimensions — updated on resize. */
     private readonly viewportW;
     private readonly viewportH;
@@ -2528,6 +3016,10 @@ declare class PresentationOverlayComponent implements OnInit, OnDestroy {
     onKeyDown(event: KeyboardEvent): void;
     /** Left-click on the slide area advances to the next visible slide. */
     protected onBodyClick(event: MouseEvent): void;
+    /** Toggle an annotation tool (clicking the active one disarms it). */
+    protected selectTool(tool: 'pen' | 'highlighter' | 'eraser' | 'laser'): void;
+    /** Toggle the live-caption (subtitle) bar. */
+    protected toggleSubtitles(): void;
     /** Close button click — stop propagation so it does not also advance. */
     protected onClose(event: MouseEvent): void;
     /**
@@ -2741,6 +3233,10 @@ declare class InspectorPanelComponent {
     protected onPatch(patch: Partial<PptxElement>): void;
     /** Commit a fully-replaced element (table/chart data editors) as one history entry. */
     protected onElementReplace(updated: PptxElement): void;
+    /** The active slide's element-animation list (animations live on the slide). */
+    protected readonly slideAnimations: _angular_core.Signal<readonly PptxElementAnimation[]>;
+    /** Commit an updated slide-level animation list as one history entry. */
+    protected onAnimationsChange(animations: PptxElementAnimation[]): void;
     protected onPositionChange(event: Event, axis: 'x' | 'y'): void;
     protected onSizeChange(event: Event, dim: 'width' | 'height'): void;
     protected onRotationChange(event: Event): void;
@@ -3031,6 +3527,271 @@ declare class ChartDataEditorComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartDataEditorComponent, "pptx-chart-data-editor", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; }, { "elementChange": "elementChange"; }, never, never, true, never>;
 }
 
+declare class AnimationAuthorPanelComponent {
+    /** The selected element whose animation settings are being authored. */
+    readonly element: _angular_core.InputSignal<PptxElement>;
+    /** Zero-based index of the active slide (used by the orchestrator to commit). */
+    readonly slideIndex: _angular_core.InputSignal<number>;
+    /**
+     * The active slide's full `PptxElementAnimation[]` array. Animations are
+     * stored on the slide, NOT on the element — this component reads and
+     * emits the entire array.
+     */
+    readonly animations: _angular_core.InputSignal<readonly PptxElementAnimation[]>;
+    /**
+     * Whether editing controls are enabled. When `false` all selects/inputs are
+     * disabled. Defaults to `true`.
+     */
+    readonly canEdit: _angular_core.InputSignal<boolean>;
+    /**
+     * Emits the full updated `PptxElementAnimation[]` whenever a change is made.
+     * The orchestrator should apply this via:
+     *   `EditorStateService.updateSlide(slideIndex(), { animations: $event })`
+     */
+    readonly animationsChange: _angular_core.OutputEmitterRef<PptxElementAnimation[]>;
+    protected readonly entrancePresets: readonly {
+        value: PptxAnimationPreset;
+        label: string;
+    }[];
+    protected readonly exitPresets: readonly {
+        value: PptxAnimationPreset;
+        label: string;
+    }[];
+    protected readonly emphasisPresets: readonly {
+        value: PptxAnimationPreset;
+        label: string;
+    }[];
+    protected readonly triggerOptions: readonly {
+        value: PptxAnimationTrigger;
+        label: string;
+    }[];
+    protected readonly timingCurveOptions: readonly {
+        value: PptxAnimationTimingCurve;
+        label: string;
+    }[];
+    protected readonly repeatModeOptions: readonly {
+        value: "none" | PptxAnimationRepeatMode;
+        label: string;
+    }[];
+    protected readonly directionOptions: readonly {
+        value: PptxAnimationDirection;
+        label: string;
+        arrow: string;
+    }[];
+    protected readonly sequenceOptions: readonly {
+        value: PptxAnimationSequence;
+        label: string;
+    }[];
+    /**
+     * Changes only when a *different* element is selected. Used as the
+     * `data-el-key` attribute to key number inputs so Angular's [value]
+     * binding is never rewritten mid-edit.
+     */
+    protected readonly elementKey: _angular_core.Signal<string>;
+    /** The animation entry for the currently selected element, if any. */
+    protected readonly current: _angular_core.Signal<PptxElementAnimation | undefined>;
+    /** True when the element has at least one effect (entrance/exit/emphasis). */
+    protected readonly currentHasAnimation: _angular_core.Signal<boolean>;
+    /** True when the active preset exposes a direction picker. */
+    protected readonly currentShowDirection: _angular_core.Signal<boolean>;
+    /**
+     * Stable seed for number inputs — recomputed only on element change so
+     * live typing does not reset the input value while the user is mid-edit.
+     */
+    protected readonly seed: _angular_core.Signal<{
+        durationMs: number;
+        delayMs: number;
+        repeatCount: number;
+    }>;
+    /** Human-readable order label (1-based, e.g. "2 of 4"). */
+    protected readonly orderLabel: _angular_core.Signal<string>;
+    /**
+     * Elements on the slide excluding the selected element — used to populate
+     * the trigger-shape selector. The slide's elements are not available in this
+     * component's inputs, so the orchestrator must pass them in via
+     * `[animations]` indirectly; here we surface only what we have access to.
+     *
+     * NOTE: The trigger-shape dropdown is limited to element ids because this
+     * panel does not receive the full slide element list. The orchestrator can
+     * replace this with a richer element label by wrapping the component or
+     * projecting content. This matches the React implementation which used
+     * `activeSlide.elements`.
+     */
+    protected readonly otherElements: _angular_core.Signal<{
+        id: string;
+    }[]>;
+    private emit;
+    protected onEntranceChange(event: Event): void;
+    protected onExitChange(event: Event): void;
+    protected onEmphasisChange(event: Event): void;
+    protected onTriggerChange(event: Event): void;
+    protected onTriggerShapeChange(event: Event): void;
+    protected onDurationChange(event: Event): void;
+    protected onDelayChange(event: Event): void;
+    protected onTimingCurveChange(event: Event): void;
+    protected onRepeatCountChange(event: Event): void;
+    protected onRepeatModeChange(event: Event): void;
+    protected onDirectionChange(dir: PptxAnimationDirection): void;
+    protected onSequenceChange(event: Event): void;
+    protected onMoveUp(): void;
+    protected onMoveDown(): void;
+    protected onRemove(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimationAuthorPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AnimationAuthorPanelComponent, "pptx-animation-author-panel", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "slideIndex": { "alias": "slideIndex"; "required": true; "isSignal": true; }; "animations": { "alias": "animations"; "required": true; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; }, { "animationsChange": "animationsChange"; }, never, never, true, never>;
+}
+
+/** Internal action descriptor used to build the bar. */
+interface BarAction {
+    key: string;
+    label: string;
+    /** SVG path data for the icon (24 × 24 view-box). */
+    svgPath: string;
+    disabled: boolean;
+    active?: boolean;
+    badge?: number;
+    emit: () => void;
+}
+declare class MobileBottomBarComponent {
+    /** Zero-based index of the currently displayed slide. */
+    readonly activeIndex: _angular_core.InputSignal<number>;
+    /** Total number of slides in the presentation. */
+    readonly slideCount: _angular_core.InputSignal<number>;
+    /** Whether the "Present" action should be available. */
+    readonly canPresent: _angular_core.InputSignal<boolean>;
+    /** Whether the mobile-menu sheet is currently open (highlights the button). */
+    readonly menuOpen: _angular_core.InputSignal<boolean>;
+    /** Whether the slides thumbnail sheet is currently open. */
+    readonly slidesOpen: _angular_core.InputSignal<boolean>;
+    /** User tapped the previous-slide button. */
+    readonly prev: _angular_core.OutputEmitterRef<void>;
+    /** User tapped the next-slide button. */
+    readonly next: _angular_core.OutputEmitterRef<void>;
+    /** User tapped the Present button. */
+    readonly present: _angular_core.OutputEmitterRef<void>;
+    /** User tapped the Slide Sorter button. */
+    readonly openSorter: _angular_core.OutputEmitterRef<void>;
+    /** User tapped the Find button. */
+    readonly openFind: _angular_core.OutputEmitterRef<void>;
+    /** User tapped the Slides thumbnail strip button. */
+    readonly openSlides: _angular_core.OutputEmitterRef<void>;
+    /** User tapped the menu (⋯) button. */
+    readonly toggleMenu: _angular_core.OutputEmitterRef<void>;
+    readonly actions: _angular_core.Signal<BarAction[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MobileBottomBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MobileBottomBarComponent, "pptx-mobile-bottom-bar", never, { "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "slideCount": { "alias": "slideCount"; "required": false; "isSignal": true; }; "canPresent": { "alias": "canPresent"; "required": false; "isSignal": true; }; "menuOpen": { "alias": "menuOpen"; "required": false; "isSignal": true; }; "slidesOpen": { "alias": "slidesOpen"; "required": false; "isSignal": true; }; }, { "prev": "prev"; "next": "next"; "present": "present"; "openSorter": "openSorter"; "openFind": "openFind"; "openSlides": "openSlides"; "toggleMenu": "toggleMenu"; }, never, never, true, never>;
+}
+
+/** Descriptor for a single menu row. */
+interface MenuRow {
+    key: string;
+    label: string;
+    sublabel?: string;
+    /** SVG path data (24 × 24 view-box). */
+    svgPath: string;
+    disabled?: boolean;
+    active?: boolean;
+    danger?: boolean;
+    emit: () => void;
+}
+declare class MobileMenuSheetComponent {
+    /** Whether the sheet is visible. */
+    readonly open: _angular_core.InputSignal<boolean>;
+    /** Total slide count — gates export/present actions. */
+    readonly slideCount: _angular_core.InputSignal<number>;
+    /** True while an export is running (labels update, actions are disabled). */
+    readonly exporting: _angular_core.InputSignal<boolean>;
+    /** Whether the speaker-notes panel is currently open. */
+    readonly showNotes: _angular_core.InputSignal<boolean>;
+    /** Whether editor-only actions (find-replace etc.) are available. */
+    readonly canEdit: _angular_core.InputSignal<boolean>;
+    /** Sheet dismissed (backdrop tap, swipe, or Escape). */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /** Open the find-in-slides bar. */
+    readonly openFind: _angular_core.OutputEmitterRef<void>;
+    /** Open the slide-sorter overlay. */
+    readonly openSorter: _angular_core.OutputEmitterRef<void>;
+    /** Toggle the speaker-notes panel. */
+    readonly toggleNotes: _angular_core.OutputEmitterRef<void>;
+    /** Start the fullscreen presentation mode. */
+    readonly present: _angular_core.OutputEmitterRef<void>;
+    /** Export the current slide as PNG. */
+    readonly exportPng: _angular_core.OutputEmitterRef<void>;
+    /** Export the deck as PDF. */
+    readonly exportPdf: _angular_core.OutputEmitterRef<void>;
+    /** Export the deck as an animated GIF. */
+    readonly exportGif: _angular_core.OutputEmitterRef<void>;
+    /** Export the deck as a video. */
+    readonly exportVideo: _angular_core.OutputEmitterRef<void>;
+    /** Open the print dialog. */
+    readonly print: _angular_core.OutputEmitterRef<void>;
+    readonly rows: _angular_core.Signal<MenuRow[]>;
+    /**
+     * Emit the row's action and close the sheet so the user returns to the
+     * presentation immediately.
+     */
+    onRowClick(row: MenuRow): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MobileMenuSheetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MobileMenuSheetComponent, "pptx-mobile-menu-sheet", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "slideCount": { "alias": "slideCount"; "required": false; "isSignal": true; }; "exporting": { "alias": "exporting"; "required": false; "isSignal": true; }; "showNotes": { "alias": "showNotes"; "required": false; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "openFind": "openFind"; "openSorter": "openSorter"; "toggleNotes": "toggleNotes"; "present": "present"; "exportPng": "exportPng"; "exportPdf": "exportPdf"; "exportGif": "exportGif"; "exportVideo": "exportVideo"; "print": "print"; }, never, never, true, never>;
+}
+
+declare class MobileSlidesSheetComponent {
+    /** Whether the sheet is visible. */
+    readonly open: _angular_core.InputSignal<boolean>;
+    /** The full slide array to display as thumbnails. */
+    readonly slides: _angular_core.InputSignal<readonly PptxSlide[]>;
+    /** Natural (100 %) canvas dimensions forwarded to each SlideCanvasComponent. */
+    readonly canvasSize: _angular_core.InputSignal<CanvasSize>;
+    /** Media asset lookup table forwarded to each SlideCanvasComponent. */
+    readonly mediaDataUrls: _angular_core.InputSignal<Map<string, string>>;
+    /** Zero-based index of the currently active slide (highlighted). */
+    readonly activeIndex: _angular_core.InputSignal<number>;
+    /** Emits when the user dismisses the sheet without selecting a slide. */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emits the zero-based index of the slide the user tapped. The orchestrator
+     * should call `goTo(index)` and then close this sheet.
+     */
+    readonly jumpToSlide: _angular_core.OutputEmitterRef<number>;
+    /** Zoom level that fits THUMB_W pixels wide. */
+    readonly thumbZoom: _angular_core.Signal<number>;
+    /** Pixel height for the clip box (aspect-correct). */
+    readonly thumbH: _angular_core.Signal<number>;
+    /** ngStyle for the clipping wrapper. */
+    readonly clipStyle: _angular_core.Signal<Record<string, string>>;
+    onThumbClick(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MobileSlidesSheetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MobileSlidesSheetComponent, "pptx-mobile-slides-sheet", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "slides": { "alias": "slides"; "required": false; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "jumpToSlide": "jumpToSlide"; }, never, never, true, never>;
+}
+
+declare class MobileSheetComponent {
+    /** Controls whether the sheet is visible. */
+    readonly open: _angular_core.InputSignal<boolean>;
+    /** Optional header text displayed above the body. */
+    readonly title: _angular_core.InputSignal<string>;
+    /**
+     * Height of the sheet as a fraction of the viewport height (0–1).
+     * Ignored when `fullScreen` is true.
+     */
+    readonly heightFraction: _angular_core.InputSignal<number>;
+    /** When true, the sheet occupies the full viewport height. */
+    readonly fullScreen: _angular_core.InputSignal<boolean>;
+    /** Emits when the user closes the sheet (backdrop tap, swipe, or Escape). */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private _dragStartY;
+    private _dragPointerId;
+    /** Current translateY applied during an active drag (px). */
+    readonly dragY: _angular_core.WritableSignal<number>;
+    /** Whether a drag is in progress (suppresses CSS transition during drag). */
+    readonly isDragging: _angular_core.WritableSignal<boolean>;
+    readonly panelStyle: _angular_core.Signal<Record<string, string>>;
+    onDocumentKeydown(event: KeyboardEvent): void;
+    onPointerDown(event: PointerEvent): void;
+    onPointerMove(event: PointerEvent): void;
+    onPointerUp(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MobileSheetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MobileSheetComponent, "pptx-mobile-sheet", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "heightFraction": { "alias": "heightFraction"; "required": false; "isSignal": true; }; "fullScreen": { "alias": "fullScreen"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
+}
+
 /**
  * SlidesPanelComponent — vertical slide-strip for the editor sidebar.
  *
@@ -4228,64 +4989,6 @@ interface EmbeddedFontStyles {
  */
 declare function buildEmbeddedFontStyles(fonts: readonly PptxEmbeddedFont[] | null | undefined, mintObjectUrl: ObjectUrlFactory): EmbeddedFontStyles;
 
-/**
- * animation-playback-helpers.ts
- *
- * Pure functions backing {@link AnimationPlaybackService} and
- * {@link AnimationPanelComponent}. Exported separately so they can be
- * unit-tested without TestBed (vitest + happy-dom).
- *
- * A slide carries an ordered list of {@link PptxElementAnimation}s. PowerPoint
- * groups them into "click groups": an animation triggered `onClick` /
- * `onShapeClick` / `onHover` starts a new group, while `withPrevious` /
- * `afterPrevious` / `afterDelay` animations fold into the group that precedes
- * them (running together or sequentially within that group). Advancing the
- * presentation one step reveals one more click group.
- *
- * Everything here is framework-light: only the preset → CSS mapping is
- * delegated to {@link resolveAnimationCss} / {@link initialHiddenStyle} from
- * the shared render layer.
- */
-
-/** Minimal CSS-properties shape: kebab-case property → value. */
-type CSSProperties = Record<string, string>;
-/** A single click-triggered group of animations that play as one step. */
-interface AnimationClickGroup {
-    /** Animations belonging to this group, in document order. */
-    animations: PptxElementAnimation[];
-}
-/**
- * Splits an ordered animation list into click groups. The first animation
- * always begins a group even if it isn't explicitly `onClick` (PowerPoint shows
- * the first build on the first advance). Subsequent `withPrevious` /
- * `afterPrevious` animations attach to the group in progress.
- */
-declare function buildClickGroups(animations: readonly PptxElementAnimation[]): AnimationClickGroup[];
-/** Clamp a step into `[0, count]`. */
-declare function clampStep(value: number, count: number): number;
-/**
- * Reveal the next click group. Returns the next step, clamped to `count`.
- * Equivalent to `clampStep(step + 1, count)`.
- */
-declare function advanceStep(step: number, count: number): number;
-/** Parse the numeric ms duration out of a resolved style's `animation-duration`. */
-declare function durationOf(style: CSSProperties): number;
-/**
- * Resolve the CSS for every animation in the revealed groups (the first `step`
- * groups). Within a group, `afterPrevious` animations are pushed back by the
- * accumulated duration of the preceding animations so sequential chains play in
- * order; `withPrevious` shares the running delay. The last write for an element
- * id wins (a later emphasis/exit overrides an earlier entrance), matching how a
- * single CSS `animation` shorthand can only hold one running effect.
- */
-declare function revealedElementStyles(groups: readonly AnimationClickGroup[], step: number): Map<string, CSSProperties>;
-/**
- * Elements with a pending entrance (in a not-yet-revealed group, i.e. groups at
- * or beyond `step`) that should be hidden until their group plays. An element
- * an already-revealed group made visible is never re-hidden.
- */
-declare function pendingElementStyles(groups: readonly AnimationClickGroup[], step: number): Map<string, CSSProperties>;
-
 /** A single rendered playback step (one click group). */
 interface AnimationStepView {
     /** 1-based step number for display. */
@@ -4314,79 +5017,6 @@ declare class AnimationPanelComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AnimationPanelComponent, "pptx-animation-panel", never, { "groups": { "alias": "groups"; "required": true; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "isPlaying": { "alias": "isPlaying"; "required": false; "isSignal": true; }; }, { "playRequested": "playRequested"; "pauseRequested": "pauseRequested"; "stepRequested": "stepRequested"; "resetRequested": "resetRequested"; "seek": "seek"; }, never, never, true, never>;
 }
 
-declare class AnimationPlaybackService {
-    private readonly destroyRef;
-    /** The current slide's animations, in document/timeline order. */
-    private readonly animations;
-    /**
-     * Externally-controlled playback step (e.g. derived from a parent click
-     * counter). `undefined` means there is no external driver. The internal
-     * manual step (set via advance/play/reset) takes precedence when present.
-     */
-    private readonly externalIndex;
-    /**
-     * Internal, unclamped step. `null` means "follow the external index"; any
-     * number means the host has taken manual control via advance/play/reset.
-     */
-    private readonly manualStep;
-    /** Click groups for the current slide's animations. */
-    readonly groups: _angular_core.Signal<AnimationClickGroup[]>;
-    /** Number of click groups on this slide (i.e. how many `advance()` steps). */
-    readonly groupCount: _angular_core.Signal<number>;
-    /**
-     * The current playback step: how many click groups have been revealed.
-     * Always clamped to the current group count. The manual override wins;
-     * otherwise it follows the external index, defaulting to 0.
-     */
-    readonly step: _angular_core.Signal<number>;
-    /** True when every click group has been revealed. */
-    readonly isComplete: _angular_core.Signal<boolean>;
-    /**
-     * Reactive map of `elementId → CSS properties` to apply for the current step.
-     * Only elements in revealed click groups appear.
-     */
-    readonly elementStyles: _angular_core.Signal<Map<string, CSSProperties>>;
-    /**
-     * Reactive map of `elementId → CSS properties` for elements whose entrance
-     * has not yet been revealed (they should be hidden so they don't flash
-     * visible before their group plays).
-     */
-    readonly pendingStyles: _angular_core.Signal<Map<string, CSSProperties>>;
-    /** Handle of the scheduled rAF auto-advance, or null when idle. */
-    private rafHandle;
-    constructor();
-    /** Feed the current slide's animation list. Resets manual control. */
-    setAnimations(animations: readonly PptxElementAnimation[] | undefined): void;
-    /** Update the external playback index (parent-driven build counter). */
-    setExternalIndex(index: number | undefined): void;
-    /**
-     * Reveal the next click group. Returns `true` if a group was revealed,
-     * `false` if playback was already complete (so the caller can fall through
-     * to slide navigation).
-     */
-    advance(): boolean;
-    /** Reveal every click group at once (jump to the slide's final state). */
-    play(): void;
-    /** Reset playback to before the first click group. */
-    reset(): void;
-    /**
-     * Jump directly to a given step (clamped to the group count) and take manual
-     * control. Useful for scrubbing.
-     */
-    setStep(step: number): void;
-    /**
-     * Auto-advance through every remaining click group on the animation frame,
-     * one group per frame. Stops automatically once playback completes or the
-     * service is destroyed. A no-op when already complete or when
-     * `requestAnimationFrame` is unavailable (SSR).
-     */
-    autoPlay(): void;
-    /** Cancel any in-flight rAF auto-advance. */
-    cancelAutoPlay(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimationPlaybackService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AnimationPlaybackService>;
-}
-
 /** A positioned cursor view-model used by the template. */
 interface PositionedCursor {
     clientId: number | string;
@@ -4713,6 +5343,136 @@ declare class PrintSettingsPanelComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<PrintSettingsPanelComponent, "pptx-print-settings-panel", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; "totalSlides": { "alias": "totalSlides"; "required": true; "isSignal": true; }; "activeSlideIndex": { "alias": "activeSlideIndex"; "required": true; "isSignal": true; }; }, { "settingsChange": "settingsChange"; }, never, never, true, never>;
 }
 
+declare class PresentationAnnotationOverlayComponent {
+    /** Logical canvas dimensions (the slide's authored size in pixels). */
+    readonly canvasSize: _angular_core.InputSignal<CanvasSize>;
+    /**
+     * The zoom factor currently applied to the slide stage.
+     * Pointer-event coordinates are divided by this value to obtain
+     * slide-space coordinates.
+     */
+    readonly zoom: _angular_core.InputSignal<number>;
+    protected readonly service: PresentationAnnotationsService;
+    private readonly svgRef;
+    /** True while a pointer-down is active in eraser mode. */
+    private _isErasing;
+    /** True when any tool other than 'none' is armed. */
+    protected readonly isArmed: _angular_core.Signal<boolean>;
+    /** SVG viewBox string that covers the full canvas. */
+    protected readonly viewBox: _angular_core.Signal<string>;
+    /** CSS cursor for the outer wrapper div. */
+    protected readonly wrapperStyle: _angular_core.Signal<Record<string, string>>;
+    /** Transform the SVG to match the slide's zoom level. */
+    protected readonly svgStyle: _angular_core.Signal<Record<string, string>>;
+    /** All strokes to render: committed + the live in-progress stroke. */
+    protected readonly allStrokes: _angular_core.Signal<pptx_angular_viewer.AnnotationStroke[]>;
+    protected strokePath(points: Array<{
+        x: number;
+        y: number;
+    }>): string;
+    protected laserDotStyle(x: number, y: number): Record<string, string>;
+    protected onPointerDown(event: PointerEvent): void;
+    protected onPointerMove(event: PointerEvent): void;
+    protected onPointerUp(event: PointerEvent): void;
+    protected onPointerLeave(_event: PointerEvent): void;
+    /**
+     * Map a client-space pointer position to slide-space coordinates by
+     * subtracting the SVG element's bounding rect and dividing by the zoom.
+     * Returns `null` when the SVG ref is not yet available.
+     */
+    private _toSlideCoords;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PresentationAnnotationOverlayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PresentationAnnotationOverlayComponent, "pptx-presentation-annotation-overlay", never, { "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * presentation-subtitle-helpers.ts — Pure helpers for the subtitle/caption bar.
+ *
+ * Isolates all text-segment logic so it can be unit-tested without DOM or
+ * Angular dependencies.
+ *
+ * Ported from React:
+ *   packages/react/src/viewer/components/PresentationSubtitleBar.tsx
+ */
+/**
+ * A single speech recognition alternative (best-guess transcript + confidence).
+ * Matches the shape of the Web Speech API `SpeechRecognitionAlternative`.
+ */
+interface SpeechAlternative {
+    readonly transcript: string;
+    readonly confidence: number;
+}
+/**
+ * One result from the recognition engine — array of alternatives plus a
+ * `isFinal` flag that indicates whether this result is stable (true) or
+ * still being refined (false, i.e. interim).
+ */
+interface SpeechResult {
+    readonly isFinal: boolean;
+    readonly length: number;
+    readonly [index: number]: SpeechAlternative;
+}
+/**
+ * The list of all results accumulated in a recognition session.
+ */
+interface SpeechResultList {
+    readonly length: number;
+    readonly [index: number]: SpeechResult;
+}
+/**
+ * Subset of `SpeechRecognitionEvent` — just what we need.
+ */
+interface SpeechRecognitionEventLite {
+    readonly resultIndex: number;
+    readonly results: SpeechResultList;
+}
+/**
+ * Structural interface matching the Web Speech API `SpeechRecognition` object.
+ * Kept minimal so we only depend on what we actually use.
+ */
+interface SpeechRecognitionLite extends EventTarget {
+    continuous: boolean;
+    interimResults: boolean;
+    lang: string;
+    onresult: ((event: SpeechRecognitionEventLite) => void) | null;
+    onerror: ((event: Event) => void) | null;
+    onend: (() => void) | null;
+    start: () => void;
+    stop: () => void;
+}
+/** Constructor signature for the speech recognition object. */
+type SpeechRecognitionCtor = new () => SpeechRecognitionLite;
+
+declare class PresentationSubtitleBarComponent implements OnChanges {
+    /** Show the subtitle bar and start speech recognition when true. */
+    readonly visible: _angular_core.InputSignal<boolean>;
+    private readonly _captionText;
+    private readonly _supportState;
+    /** The text string rendered in the caption bar. */
+    protected readonly displayText: _angular_core.WritableSignal<string>;
+    /**
+     * Whether the recognition session should remain running.
+     * Toggled on `visible` changes; checked in `onend` to decide whether
+     * to restart.
+     */
+    private _shouldRun;
+    /** Active recognition instance, or null when stopped. */
+    private _recognition;
+    private readonly _destroyRef;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    private _startRecognition;
+    private _stopRecognition;
+    /**
+     * Thin wrapper around {@link getSpeechRecognitionCtor} so tests can spy on
+     * or override this method without patching `globalThis`.
+     */
+    protected _getSpeechCtor(): SpeechRecognitionCtor | null;
+    private _updateDisplayText;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PresentationSubtitleBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PresentationSubtitleBarComponent, "pptx-presentation-subtitle-bar", never, { "visible": { "alias": "visible"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 /**
  * transition-helpers.ts
  *
@@ -5010,6 +5770,31 @@ declare function getResolvedShapeClipPathFor(shapeType: string | undefined, widt
  */
 declare function getResolvedShapeClipPath(element: PptxElement, width?: number, height?: number): string | undefined;
 
+/**
+ * SVG path generators for WordArt text warp presets.
+ *
+ * Angular port of `packages/react/src/viewer/utils/warp-path-generators.ts`
+ * and `packages/react/src/viewer/utils/warp-path-cascade.ts`.
+ *
+ * Each generator produces an SVG path `d` attribute for a single text line
+ * at a given normalised vertical position (t: 0 = top, 1 = bottom).
+ * All functions are pure and deterministic — no side-effects, no random/date.
+ */
+
+/**
+ * Presets that require SVG `<textPath>` rendering along a curved/circular path.
+ * All other warp presets (envelope: inflate/deflate/can; simple: slant/fade/
+ * cascade) are rendered with CSS transforms instead — see `text-warp.ts`'s
+ * `getWarpCategory`, which this set must stay in sync with (the `'path'`
+ * category). Listing a CSS preset here would wrongly route it to `<textPath>`.
+ */
+declare const SVG_WARP_PRESETS: ReadonlySet<string>;
+/** Returns `true` when the preset should use SVG `<textPath>` rendering. */
+declare function shouldUseSvgWarp(preset: PptxTextWarpPreset | undefined): boolean;
+/** Generate an SVG path `d` attribute for a warp preset at a given line position.
+ *  Optional adj/adj2 are raw OOXML adjustment values (1/60000th units). */
+declare function getWarpPath(preset: PptxTextWarpPreset, width: number, height: number, lineIndex: number, lineCount: number, adj?: number, adj2?: number): string;
+
 /**
  * Slide-background style resolution.
  *
@@ -5178,5 +5963,5 @@ declare function themeStyle(theme: ViewerTheme | undefined): Record<string, stri
 type ClassValue = string | number | false | null | undefined;
 declare function cn(...values: ClassValue[]): string;
 
-export { AccessibilityPanelComponent, AccessibilityService, AnimationPanelComponent, AnimationPlaybackService, BroadcastDialogComponent, CURSOR_PALETTE, ChartDataEditorComponent, ChartRendererComponent, CollaborationCursorsComponent, CollaborationService, CommentsPanelComponent, CommentsService, ConnectorRendererComponent, ConnectorTextOverlayComponent, DEFAULT_BROADCAST_SERVER_URL, DEFAULT_CANVAS_HEIGHT, DEFAULT_CANVAS_WIDTH, DEFAULT_FILL_COLOR, DEFAULT_PRINT_SETTINGS, DEFAULT_SLIDE_BACKGROUND, DEFAULT_STROKE_COLOR, DEFAULT_TEXT_COLOR, EMBEDDED_FONTS_STYLE_ID, EditorContextMenuComponent, EditorHistory, EditorStateService, EditorToolbarComponent, EffectsPanelComponent, ElementRendererComponent, EmbeddedFontsService, EquationRendererComponent, ExportService, FindBarComponent, FindReplaceBarComponent, GradientPickerComponent, HANDOUT_OPTIONS, HyperlinkDialogComponent, InkRendererComponent, InspectorPanelComponent, LoadContentService, ModalDialogComponent, Model3DRendererComponent, OleRendererComponent, PowerPointViewerComponent, PresentationOverlayComponent, PresentationTransitionOverlayComponent, PresenterViewComponent, PrintDialogComponent, PrintService, PrintSettingsPanelComponent, PropertiesDialogComponent, RESIZE_HANDLES, SEVERITY_GROUPS, SEVERITY_LABELS, SLIDE_TRANSITION_KEYFRAMES, ShareDialogComponent, SignaturesPanelComponent, SignaturesService, SlideCanvasComponent, SlideSorterOverlayComponent, SlidesPanelComponent, SmartArtRendererComponent, TYPE_LABELS, TableDataEditorComponent, TableRendererComponent, TextAdvancedPanelComponent, VIEWER_THEME, WEBM_MIME_CANDIDATES, ZoomRendererComponent, addCommentToList, advanceStep, applyFindReplacements, applyMove, applyResize, assignUserColor, bringForward, bringToFront, buildBroadcastConfig, buildBroadcastViewerUrl, buildClearHyperlinkPatch, buildClickGroups, buildCollaborationConfig, buildCssGradientFromShapeStyle, buildDuotoneFilter, buildDuotoneFilterId, buildEmbeddedFontStyles, buildFontFaceRule, buildHyperlinkPatch, buildPatternFillCss, buildPrintDocument, buildPropertiesPatch, buildShareUrl, bulletIndentPx, canStartBroadcast, canStartShare, canUseClipboard, clampCursorPosition, clampGifDimensions, clampNotesFontSize, clampStep, cn, collectAccessibilityIssues, collectElementText, collectSlideText, computeHandoutLayout, computePageCount, computeSlideIndices, computeTimerProgress, convertOmmlToMathMl, countAccessibilityIssues, defaultCssVars, defaultRadius, defaultThemeColors, deleteElementsByIds, derivePresenceList, duplicateElementById, durationOf, encodeGif, estimatePageCount, findInSlides, fontMimeForFormat, formatAutoNumber, formatCursorLabel, formatElapsed, formatPropertyDate, formatTime, fpsToFrameIntervalMs, generateBroadcastRoomId, generateCommentId, getContainerStyle, getDuotoneFilterDef, getImageSrc, getPatternSvg, getResolvedShapeClipPath, getResolvedShapeClipPathFor, getShapeFillStrokeStyle, getSlideBackgroundStyle, getSlideTransitionAnimations, getTextBlockStyle, groupIssuesBySeverity, hasExistingLink, headerLabel, isInjectableUrl, isPpactionUrl, isSigned, isUrlSafe, isValidRoomId, issueTrackKey, issueTypeLabel, moveElementBy, msToFrameDelayCs, normalizeFontFormat, normalizeSlidesPerPage, ommlToMathml, overallStatus, pendingElementStyles, pickSupportedMimeType, planGifFrames, planVideoSegments, presenceToCursors, provideViewerTheme, recordWebm, removeCommentFromList, renderToCanvas, replaceInSlides, replaceMatch, resizeElement, resolveFontVariant, resolveHyperlinkHref, resolveParagraphBullet, resolvePresenterNotes, resolveTransitionDuration, revealedElementStyles, routeOrthogonalConnector, sanitizeColor, sanitizeSlideIndex, sanitizeUserName, searchSlides, seedBroadcastFields, seedHyperlinkDraft, seedPropertiesDraft, seedShareFields, segmentFrameCount, sendBackward, sendToBack, setElementPosition, signatureCountLabel, signatureKey, signatureTimestamp, signerName, statusKind, statusLabel, themeStyle, themeToCssVars, toggleCommentResolvedInList, updateElementById, validatePrintSettings, validateRoomId, waypointsToPathD, worstStatus };
-export type { AccessibilityIssueGroup, AnimationClickGroup, Box, BroadcastConfig, BroadcastDefaults, CSSProperties, CanvasSize, ClassValue, CollaborationConfig, CollaborationRole, Rect as ConnectorObstacle, Point as ConnectorPoint, ConnectorRouting, DocumentProperties, DuotoneFilterDef, EmbeddedFontStyles, FindOptions, FindResult, GifFrame, GifFramePlan, GifPlanOptions, HandoutSlidesPerPage, HyperlinkDraft, NotesSegmentViewModel, ObjectUrlFactory, OverallSignatureStatus, PresenterNotes, PrintColorMode, PrintDocumentOptions, PrintOrientation, PrintSettings, PrintSlideRange, PrintWhat, PropertiesDraft, RecordWebmOptions, RemoteCursor, RemotePresence, ReplaceResult, ResizeHandle, ResolvedFontVariant, ShareDefaults, ShareFormFields, SignatureStatusKind, SlideTransitionAnimations, StyleMap, TimerProgress, VideoPlanOptions, VideoSegmentPlan, ViewerTheme, ViewerThemeColors };
+export { AccessibilityPanelComponent, AccessibilityService, AnimationAuthorPanelComponent, AnimationPanelComponent, AnimationPlaybackService, BroadcastDialogComponent, CURSOR_PALETTE, ChartDataEditorComponent, ChartRendererComponent, CollaborationCursorsComponent, CollaborationService, CommentsPanelComponent, CommentsService, ConnectorRendererComponent, ConnectorTextOverlayComponent, DEFAULT_BROADCAST_SERVER_URL, DEFAULT_CANVAS_HEIGHT, DEFAULT_CANVAS_WIDTH, DEFAULT_FILL_COLOR, DEFAULT_PRINT_SETTINGS, DEFAULT_SLIDE_BACKGROUND, DEFAULT_STROKE_COLOR, DEFAULT_TEXT_COLOR, EMBEDDED_FONTS_STYLE_ID, EditorContextMenuComponent, EditorHistory, EditorStateService, EditorToolbarComponent, EffectsPanelComponent, ElementRendererComponent, EmbeddedFontsService, EquationRendererComponent, ExportService, FindBarComponent, FindReplaceBarComponent, GradientPickerComponent, HANDOUT_OPTIONS, HyperlinkDialogComponent, InkRendererComponent, InspectorPanelComponent, IsMobileService, LoadContentService, MobileBottomBarComponent, MobileMenuSheetComponent, MobileSheetComponent, MobileSlidesSheetComponent, ModalDialogComponent, Model3DRendererComponent, OleRendererComponent, PowerPointViewerComponent, PresentationAnnotationOverlayComponent, PresentationAnnotationsService, PresentationOverlayComponent, PresentationSubtitleBarComponent, PresentationTransitionOverlayComponent, PresenterViewComponent, PrintDialogComponent, PrintService, PrintSettingsPanelComponent, PropertiesDialogComponent, RESIZE_HANDLES, SEVERITY_GROUPS, SEVERITY_LABELS, SLIDE_TRANSITION_KEYFRAMES, SVG_WARP_PRESETS, ShareDialogComponent, SignaturesPanelComponent, SignaturesService, SlideCanvasComponent, SlideSorterOverlayComponent, SlidesPanelComponent, SmartArtRendererComponent, TYPE_LABELS, TableDataEditorComponent, TableRendererComponent, TextAdvancedPanelComponent, VIEWER_THEME, WEBM_MIME_CANDIDATES, ZoomRendererComponent, addCommentToList, advanceStep, applyFindReplacements, applyMove, applyResize, assignUserColor, bringForward, bringToFront, buildBroadcastConfig, buildBroadcastViewerUrl, buildClearHyperlinkPatch, buildClickGroups, buildCollaborationConfig, buildCssGradientFromShapeStyle, buildDuotoneFilter, buildDuotoneFilterId, buildEmbeddedFontStyles, buildFontFaceRule, buildHyperlinkPatch, buildPatternFillCss, buildPrintDocument, buildPropertiesPatch, buildShareUrl, bulletIndentPx, canStartBroadcast, canStartShare, canUseClipboard, clampCursorPosition, clampGifDimensions, clampNotesFontSize, clampStep, cn, collectAccessibilityIssues, collectElementText, collectSlideText, computeHandoutLayout, computeIsMobile, computeIsTablet, computePageCount, computeSlideIndices, computeTimerProgress, convertOmmlToMathMl, countAccessibilityIssues, defaultCssVars, defaultRadius, defaultThemeColors, deleteElementsByIds, derivePresenceList, duplicateElementById, durationOf, encodeGif, estimatePageCount, findInSlides, fontMimeForFormat, formatAutoNumber, formatCursorLabel, formatElapsed, formatPropertyDate, formatTime, fpsToFrameIntervalMs, generateBroadcastRoomId, generateCommentId, getContainerStyle, getDuotoneFilterDef, getImageSrc, getPatternSvg, getResolvedShapeClipPath, getResolvedShapeClipPathFor, getShapeFillStrokeStyle, getSlideBackgroundStyle, getSlideTransitionAnimations, getTextBlockStyle, getTextWarp, getWarpCategory, getWarpPath, groupIssuesBySeverity, hasExistingLink, headerLabel, isInjectableUrl, isPpactionUrl, isSigned, isUrlSafe, isValidRoomId, issueTrackKey, issueTypeLabel, moveElementBy, msToFrameDelayCs, normalizeFontFormat, normalizeSlidesPerPage, ommlToMathml, overallStatus, pendingElementStyles, pickSupportedMimeType, planGifFrames, planVideoSegments, presenceToCursors, provideViewerTheme, recordWebm, removeCommentFromList, renderToCanvas, replaceInSlides, replaceMatch, resizeElement, resolveFontVariant, resolveHyperlinkHref, resolveParagraphBullet, resolvePresenterNotes, resolveTransitionDuration, revealedElementStyles, routeOrthogonalConnector, sanitizeColor, sanitizeSlideIndex, sanitizeUserName, searchSlides, seedBroadcastFields, seedHyperlinkDraft, seedPropertiesDraft, seedShareFields, segmentFrameCount, sendBackward, sendToBack, setElementPosition, shouldUseSvgWarp, signatureCountLabel, signatureKey, signatureTimestamp, signerName, statusKind, statusLabel, themeStyle, themeToCssVars, toggleCommentResolvedInList, updateElementById, validatePrintSettings, validateRoomId, waypointsToPathD, worstStatus };
+export type { AccessibilityIssueGroup, AnimationClickGroup, AnnotationStroke, Box, BroadcastConfig, BroadcastDefaults, CSSProperties, CanvasSize, ClassValue, CollaborationConfig, CollaborationRole, Rect as ConnectorObstacle, Point as ConnectorPoint, ConnectorRouting, DocumentProperties, DuotoneFilterDef, EmbeddedFontStyles, FindOptions, FindResult, GifFrame, GifFramePlan, GifPlanOptions, HandoutSlidesPerPage, HyperlinkDraft, NotesSegmentViewModel, ObjectUrlFactory, OverallSignatureStatus, PresentationTool, PresenterNotes, PrintColorMode, PrintDocumentOptions, PrintOrientation, PrintSettings, PrintSlideRange, PrintWhat, PropertiesDraft, RecordWebmOptions, RemoteCursor, RemotePresence, ReplaceResult, ResizeHandle, ResolvedFontVariant, ShareDefaults, ShareFormFields, SignatureStatusKind, SlideTransitionAnimations, StyleMap, TextWarpCssDef, TextWarpDef, TextWarpPathDef, TimerProgress, VideoPlanOptions, VideoSegmentPlan, ViewerTheme, ViewerThemeColors };