pptx-angular-viewer 1.1.12 → 1.1.14

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

@@ -1,9 +1,10 @@
-import * as pptx_viewer_core from 'pptx-viewer-core';
-import { PptxSlide, PptxElement, PptxTheme, PptxSlideMaster, PptxTableCell, Model3DPptxElement, ZoomPptxElement, TextSegment, XmlObject, ShapeStyle } from 'pptx-viewer-core';
 import * as _angular_core from '@angular/core';
-import { OnInit, OnDestroy, InjectionToken, Provider } from '@angular/core';
+import { Signal, OnInit, OnDestroy, InjectionToken, Provider } from '@angular/core';
+import * as pptx_viewer_core from 'pptx-viewer-core';
+import { PptxSlide, AccessibilityCheckOptions, AccessibilityIssue, PptxElement, PptxTheme, PptxSlideMaster, PptxEmbeddedFont, PptxCoreProperties, PptxComment, PptxTableCell, Model3DPptxElement, ZoomPptxElement, TextSegment, XmlObject, ParsedSignature, SignatureStatus, AccessibilityIssueSeverity, AccessibilityIssueType, PptxElementAnimation, PptxTransitionType, PptxSlideTransition, ShapeStyle } from 'pptx-viewer-core';
 import { Options } from 'html2canvas-pro';
 import { SafeHtml } from '@angular/platform-browser';
+import * as pptx_angular_viewer from 'pptx-angular-viewer';
 
 /**
  * Theme configuration types for the PowerPoint viewer.
@@ -166,6 +167,194 @@ declare const DEFAULT_FILL_COLOR = "#3b82f6";
 /** Fallback shape stroke colour. */
 declare const DEFAULT_STROKE_COLOR = "#1f2937";
 
+declare class AccessibilityService {
+    /** Parsed slides of the current presentation. */
+    readonly slides: _angular_core.WritableSignal<PptxSlide[]>;
+    /** Check configuration mirroring {@link AccessibilityCheckOptions}. */
+    readonly options: _angular_core.WritableSignal<AccessibilityCheckOptions>;
+    /** All detected issues, sorted by slide index then severity. */
+    readonly issues: Signal<AccessibilityIssue[]>;
+    /** Total number of detected issues. */
+    readonly issueCount: Signal<number>;
+    /** Number of `error`-severity issues. */
+    readonly errorCount: Signal<number>;
+    /** Number of `warning`-severity issues. */
+    readonly warningCount: Signal<number>;
+    /** Number of `tip`-severity issues. */
+    readonly tipCount: Signal<number>;
+    /** True when the presentation passes every check. */
+    readonly isClean: Signal<boolean>;
+    /** Replace the slides to check. */
+    setSlides(slides: PptxSlide[]): void;
+    /** Replace the check options. */
+    setOptions(options: AccessibilityCheckOptions): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccessibilityService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AccessibilityService>;
+}
+
+/**
+ * collaboration-helpers.ts — Pure, framework-agnostic logic for the real-time
+ * collaboration subsystem (Yjs-backed presence + remote cursors).
+ *
+ * Everything here is a plain function with no Angular / Yjs dependency so it can
+ * be unit-tested in isolation (vitest + happy-dom, no TestBed, no live provider).
+ * The Angular service (`collaboration.service.ts`) and the cursors component
+ * (`collaboration-cursors.component.ts`) consume these helpers.
+ *
+ * Responsibilities:
+ *  - Validate/sanitise inbound awareness data (XSS, bounds, colour, room id).
+ *  - Map awareness state → a `RemoteCursor` view-model for rendering.
+ *  - Derive the presence list (remote users only, stale entries dropped).
+ *  - Deterministic per-user colour assignment + cursor label formatting.
+ *
+ * Mirrors the Vue composable (`useCollaboration.ts`) and the React
+ * `sanitize.ts` / `usePresenceTracking.ts` helpers.
+ */
+
+/** A single remote collaborator's cursor, in unscaled slide coordinates. */
+interface RemoteCursor {
+    /** Stable id for the remote client (awareness clientId or peer id). */
+    clientId: number | string;
+    /** Display name shown in the label chip. */
+    userName: string;
+    /** Cursor + chip colour (any CSS colour string). */
+    color: string;
+    /** Unscaled slide-space X coordinate (px). */
+    x: number;
+    /** Unscaled slide-space Y coordinate (px). */
+    y: number;
+    /** Optional ids of elements this user has selected. */
+    selectionIds?: string[];
+}
+/**
+ * Presence data for a remote (or local) collaborator, sanitised from the
+ * awareness protocol. Cursor position is in unscaled slide coordinates.
+ */
+interface RemotePresence {
+    /** Awareness client id. */
+    clientId: number;
+    /** Sanitised display name. */
+    userName: string;
+    /** Hex colour for the user's cursor/avatar. */
+    userColor: string;
+    /** Validated avatar URL, when present. */
+    userAvatar?: string;
+    /** Zero-based slide index the user is viewing. */
+    activeSlideIndex: number;
+    /** Cursor X (unscaled slide px, clamped to bounds). */
+    cursorX: number;
+    /** Cursor Y (unscaled slide px, clamped to bounds). */
+    cursorY: number;
+    /** ISO timestamp of the last update (for stale-presence cleanup). */
+    lastUpdated: string;
+    /** Currently selected element id, when present. */
+    selectedElementId?: string;
+    /** Session role. */
+    role?: CollaborationRole;
+}
+/**
+ * Palette used for deterministic per-user colour assignment. Distinct, legible
+ * hues with white text contrast. Mirrors the React default-colour set.
+ */
+declare const CURSOR_PALETTE: readonly string[];
+/** True when `roomId` is a safe 1–128 char alphanumeric/`-`/`_` token. */
+declare function isValidRoomId(roomId: string): boolean;
+/**
+ * Validate a room id, returning it when valid and throwing otherwise. Mirrors
+ * the React `validateRoomId`.
+ */
+declare function validateRoomId(roomId: string): string;
+/** Strip HTML tags, trim, and clamp to 64 chars; falls back to `'Anonymous'`. */
+declare function sanitizeUserName(name: unknown): string;
+/** Validate a 6-digit hex colour; returns `fallback` when invalid. */
+declare function sanitizeColor(color: unknown, fallback?: string): string;
+/** Coerce a value to a non-negative integer slide index. */
+declare function sanitizeSlideIndex(value: unknown): number;
+/** Clamp a cursor coordinate to `[min - margin, max + margin]`. */
+declare function clampCursorPosition(value: unknown, min: number, max: number): number;
+/**
+ * Deterministically pick a palette colour for a user. The same `seed` (client
+ * id or user name) always maps to the same colour so a peer keeps a stable hue.
+ */
+declare function assignUserColor(seed: number | string, palette?: readonly string[]): string;
+/** Clamp/format a cursor label so long names don't overflow the chip. */
+declare function formatCursorLabel(userName: string, maxChars?: number): string;
+/**
+ * Derive the remote-presence list from a raw awareness state map. Skips the
+ * local client, sanitises each entry, and drops stale entries (older than
+ * `staleMs`, evaluated against `now`).
+ */
+declare function derivePresenceList(states: Map<number, Record<string, unknown>>, localClientId: number, canvasWidth: number, canvasHeight: number, now?: number, staleMs?: number): RemotePresence[];
+/**
+ * Map a sanitised presence list into the cursor view-model for the overlay,
+ * optionally filtering to a single slide (so cursors only show on the slide the
+ * local user is viewing). Pass `activeSlideIndex` undefined to show all.
+ */
+declare function presenceToCursors(presence: readonly RemotePresence[], activeSlideIndex?: number): RemoteCursor[];
+
+/** Options the host viewer supplies when wiring collaboration. */
+interface ConnectOptions {
+    /** Called when a remote peer broadcasts a newer slide set. */
+    onRemoteSlides?: (slides: PptxSlide[]) => void;
+    /**
+     * Canvas dimensions (unscaled slide px) used to clamp incoming cursor
+     * coordinates. Defaults to a generous bound when omitted.
+     */
+    canvasWidth?: number;
+    canvasHeight?: number;
+}
+declare class CollaborationService {
+    /** True once the websocket provider reports a `connected` status. */
+    readonly connected: _angular_core.WritableSignal<boolean>;
+    /** True while a session is active (provider constructed, not yet stopped). */
+    readonly active: _angular_core.WritableSignal<boolean>;
+    /** Sanitised remote presence list (excludes the local user, stale dropped). */
+    readonly presence: _angular_core.WritableSignal<RemotePresence[]>;
+    /** Remote collaborators' live cursors, derived from presence. */
+    readonly cursors: _angular_core.Signal<RemoteCursor[]>;
+    /** Total connected participants (remote + self when active). */
+    readonly connectedCount: _angular_core.Signal<number>;
+    private ydoc;
+    private provider;
+    private ymap;
+    private awareness;
+    private selfId;
+    private applyingRemote;
+    private onRemoteSlides;
+    private canvasWidth;
+    private canvasHeight;
+    private userName;
+    private userColor;
+    private userAvatar;
+    private role;
+    private readonly refreshPresence;
+    constructor();
+    /**
+     * Connect to a room and begin syncing. Any existing session is torn down
+     * first. Returns when the session has been established (or silently when
+     * yjs/y-websocket are unavailable / the connection fails).
+     */
+    connect(config: CollaborationConfig, options?: ConnectOptions): Promise<void>;
+    /** Disconnect and tear down the session, resetting all reactive state. */
+    disconnect(): void;
+    /**
+     * Broadcast the local slide set to peers (no-op while applying a remote
+     * update, to avoid an echo loop). Call this whenever the editor's slides
+     * change.
+     */
+    broadcastSlides(slides: readonly PptxSlide[]): void;
+    /**
+     * Publish this user's cursor position (unscaled slide px) plus the slide
+     * they're viewing. Updates both the foundational `cursor` field and the full
+     * `presence` record so either consumer path sees it.
+     */
+    setCursor(x: number, y: number, activeSlideIndex?: number): void;
+    /** Broadcast the local user's currently selected element ids. */
+    setSelection(selectedElementId: string | undefined, activeSlideIndex?: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CollaborationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CollaborationService>;
+}
+
 /**
  * Pure geometry helpers for aligning and distributing selected editor elements.
  *
@@ -297,6 +486,14 @@ declare class LoadContentService {
     readonly slideMasters: _angular_core.WritableSignal<PptxSlideMaster[]>;
     /** Archive-path → displayable URL map for media + poster frames. */
     readonly mediaDataUrls: _angular_core.WritableSignal<Map<string, string>>;
+    /** Embedded font data (name + binary) extracted from the presentation. */
+    readonly embeddedFonts: _angular_core.WritableSignal<PptxEmbeddedFont[]>;
+    /** Core document properties from `docProps/core.xml`. */
+    readonly coreProperties: _angular_core.WritableSignal<PptxCoreProperties | undefined>;
+    /** Whether the presentation contains digital signatures. */
+    readonly hasDigitalSignatures: _angular_core.WritableSignal<boolean>;
+    /** Number of digital signatures found. */
+    readonly digitalSignatureCount: _angular_core.WritableSignal<number>;
     /** True while a load is in flight. */
     readonly loading: _angular_core.WritableSignal<boolean>;
     /** Error message from the last failed load, or null. */
@@ -324,6 +521,162 @@ declare class LoadContentService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<LoadContentService>;
 }
 
+/**
+ * Pure print helper utilities — no Angular, no DOM side effects, no
+ * `window.print()`. Everything here is deterministic and unit-testable in
+ * isolation (vitest + happy-dom, no TestBed).
+ *
+ * Mirrors the React print subsystem:
+ *   - `print-dialog-types.ts`        → print settings types / defaults / constants
+ *   - `usePrintHandlers.ts`          → slide-index, colour-filter, outline + handout markup
+ *   - `handout-layout-utils.ts`      → A4 page-layout / slides-per-page grid maths
+ *
+ * The {@link PrintService} consumes these helpers and applies the DOM /
+ * print-window side effects.
+ *
+ * ng-packagr constraints honoured here:
+ *   - NO `String.prototype.replaceAll` (use `.split(x).join(y)`).
+ *   - NO regex named-capture groups.
+ *   - All regexes carry the `/u` flag.
+ */
+
+/** What to print. */
+type PrintWhat = 'slides' | 'handouts' | 'notes' | 'outline';
+/** Page orientation for the printed output. */
+type PrintOrientation = 'portrait' | 'landscape';
+/** Colour mode for the printed output. */
+type PrintColorMode = 'color' | 'grayscale' | 'blackAndWhite';
+/** Handout slides-per-page options. */
+type HandoutSlidesPerPage = 1 | 2 | 3 | 4 | 6 | 9;
+/** Slide range mode. */
+type PrintSlideRange = 'all' | 'current' | 'custom';
+/** Resolved print settings emitted on confirm. */
+interface PrintSettings {
+    printWhat: PrintWhat;
+    orientation: PrintOrientation;
+    colorMode: PrintColorMode;
+    frameSlides: boolean;
+    slidesPerPage: HandoutSlidesPerPage;
+    slideRange: PrintSlideRange;
+    customRangeFrom: number;
+    customRangeTo: number;
+}
+/** Computed cell position within a handout page. */
+interface HandoutCellPosition {
+    /** Zero-based index of the slide in the source array (or -1 for empty). */
+    slideIndex: number;
+    /** Row in the grid (0-based). */
+    row: number;
+    /** Column in the grid (0-based). */
+    col: number;
+    /** X offset in mm from the printable area left edge. */
+    x: number;
+    /** Y offset in mm from the printable area top edge. */
+    y: number;
+    /** Width of the cell in mm. */
+    width: number;
+    /** Height of the cell in mm. */
+    height: number;
+}
+/** A single page of a handout layout. */
+interface HandoutPage {
+    pageIndex: number;
+    cells: HandoutCellPosition[];
+    /** Whether this layout includes note lines (3-per-page). */
+    hasNoteLines: boolean;
+}
+/** Available slides-per-page options for handouts. */
+declare const HANDOUT_OPTIONS: HandoutSlidesPerPage[];
+/** Default print settings used when the dialog opens. */
+declare const DEFAULT_PRINT_SETTINGS: PrintSettings;
+/**
+ * Coerce an arbitrary number to a supported {@link HandoutSlidesPerPage}.
+ * Falls back to 6 (the PowerPoint default) when the value is unsupported.
+ */
+declare function normalizeSlidesPerPage(value: number | undefined): HandoutSlidesPerPage;
+/**
+ * Validate and clamp partial print settings into a fully-resolved
+ * {@link PrintSettings}. Custom-range bounds are clamped to `[1, slideCount]`
+ * (with `from <= to`), and `notes`/`outline`/`handouts` force portrait
+ * orientation (matching the React dialog's `effectiveOrientation`).
+ *
+ * @param partial    - Caller-provided settings (any subset).
+ * @param slideCount - Total number of slides in the presentation.
+ */
+declare function validatePrintSettings(partial: Partial<PrintSettings>, slideCount: number): PrintSettings;
+/**
+ * Compute the zero-based slide indices to print from a slide-range setting.
+ * Custom ranges use 1-based, inclusive `from`/`to` and are clamped to bounds.
+ */
+declare function computeSlideIndices(slideRange: PrintSlideRange, activeSlideIndex: number, slideCount: number, customRangeFrom: number, customRangeTo: number): number[];
+/** Number of pages needed for `slideCount` slides at `slidesPerPage`. */
+declare function computePageCount(slideCount: number, slidesPerPage: HandoutSlidesPerPage): number;
+/**
+ * Estimate the printed page count for the full settings object — slides and
+ * notes are one page each; outline is a single page; handouts paginate.
+ */
+declare function estimatePageCount(printWhat: PrintWhat, slideCount: number, slidesPerPage: HandoutSlidesPerPage): number;
+/**
+ * Compute the complete handout layout: all pages with positioned cells,
+ * remapped to the actual source slide indices.
+ */
+declare function computeHandoutLayout(slideIndices: number[], slidesPerPage: HandoutSlidesPerPage, orientation?: PrintOrientation): HandoutPage[];
+/** Options for {@link buildPrintDocument}. */
+interface PrintDocumentOptions {
+    title: string;
+    bodyHtml: string;
+    orientation: PrintOrientation;
+    colorFilter: string;
+    frameSlides: boolean;
+}
+/**
+ * Assemble the complete printable HTML document string (doctype + head with
+ * print CSS + body). Pure: the caller writes it into a print window.
+ */
+declare function buildPrintDocument(options: PrintDocumentOptions): string;
+
+/**
+ * Captures the slide at `index` (zero-based) to a PNG `data:` URL. The viewer
+ * supplies this — it flips the live stage to `index` and rasterises it.
+ * Returning `null`/empty for a slide skips it.
+ */
+type CaptureSlideFn = (index: number) => Promise<string | null>;
+declare class PrintService {
+    /** Whether the print dialog is currently open. */
+    readonly isDialogOpen: _angular_core.WritableSignal<boolean>;
+    /** The current (validated) print settings. */
+    readonly settings: _angular_core.WritableSignal<PrintSettings>;
+    /** Open the print dialog. */
+    openDialog(): void;
+    /** Close the print dialog. */
+    closeDialog(): void;
+    /**
+     * Validate + store settings against the slide count. Returns the resolved
+     * settings so callers can use them immediately.
+     */
+    updateSettings(partial: Partial<PrintSettings>, slideCount: number): PrintSettings;
+    /**
+     * Run the full print flow for the given settings:
+     *   1. Resolve the slide index list.
+     *   2. Build the printable HTML (capturing slides as needed).
+     *   3. Open a print window and trigger `window.print()`.
+     *
+     * The outline path needs no rasterisation. All other modes call
+     * `captureSlide` once per slide (sequentially) and skip slides that fail.
+     *
+     * @returns `true` if a print window was opened, `false` if blocked (popup
+     *          blocker) or there was nothing to print.
+     */
+    print(rawSettings: PrintSettings, slides: PptxSlide[], activeSlideIndex: number, captureSlide: CaptureSlideFn): Promise<boolean>;
+    /**
+     * Open a print window, write the document, focus, and trigger printing.
+     * Returns `false` if the popup was blocked.
+     */
+    private _open;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PrintService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PrintService>;
+}
+
 /**
  * PowerPointViewerComponent — Angular port of the React `PowerPointViewer.tsx`
  * and Vue `PowerPointViewer.vue`.
@@ -350,26 +703,34 @@ declare class PowerPointViewerComponent {
     readonly class: _angular_core.InputSignal<string>;
     /** Theme configuration for customising the viewer's appearance. */
     readonly theme: _angular_core.InputSignal<ViewerTheme | undefined>;
-    /** Optional real-time collaboration config (accepted for API parity; not yet implemented). */
+    /** Optional real-time collaboration config; when set, connects and shows remote cursors. */
     readonly collaboration: _angular_core.InputSignal<CollaborationConfig | undefined>;
     /** Fired when the active slide changes. */
     readonly activeSlideChange: _angular_core.OutputEmitterRef<number>;
-    /** Fired when the unsaved-changes flag toggles. (Editing not yet ported.) */
+    /** Fired when the unsaved-changes flag toggles. */
     readonly dirtyChange: _angular_core.OutputEmitterRef<boolean>;
-    /** Fired when the in-memory content changes after edits. (Editing not yet ported.) */
+    /** Fired with freshly-serialised `.pptx` bytes whenever {@link getContent} materialises the deck. */
     readonly contentChange: _angular_core.OutputEmitterRef<Uint8Array<ArrayBufferLike>>;
+    /** Fired when the user edits document properties in the Info dialog. */
+    readonly propertiesChange: _angular_core.OutputEmitterRef<Partial<PptxCoreProperties>>;
     protected readonly loader: LoadContentService;
     private readonly exportSvc;
     protected readonly editor: EditorStateService;
+    private readonly fonts;
+    protected readonly collab: CollaborationService;
+    protected readonly accessibility: AccessibilityService;
+    protected readonly print: PrintService;
     /** 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). */
     protected readonly exporting: _angular_core.WritableSignal<boolean>;
     protected readonly activeSlideIndex: _angular_core.WritableSignal<number>;
     /** Slides to display: the editable deck when `canEdit`, else the loaded deck. */
-    protected readonly displaySlides: _angular_core.Signal<readonly pptx_viewer_core.PptxSlide[]>;
+    protected readonly displaySlides: _angular_core.Signal<readonly PptxSlide[]>;
     protected readonly slideCount: _angular_core.Signal<number>;
-    protected readonly activeSlide: _angular_core.Signal<pptx_viewer_core.PptxSlide>;
+    /** Mutable copy of the display deck for inputs that require a non-readonly array. */
+    protected readonly displaySlidesMut: _angular_core.Signal<PptxSlide[]>;
+    protected readonly activeSlide: _angular_core.Signal<PptxSlide>;
     protected readonly rootStyle: _angular_core.Signal<Record<string, string>>;
     protected readonly zoom: _angular_core.WritableSignal<number>;
     protected readonly zoomPercent: _angular_core.Signal<number>;
@@ -381,6 +742,18 @@ declare class PowerPointViewerComponent {
     protected readonly showNotes: _angular_core.WritableSignal<boolean>;
     /** Find-in-slides bar visibility. */
     protected readonly showFind: _angular_core.WritableSignal<boolean>;
+    /** Active right-docked tool panel (comments / accessibility), or null. */
+    protected readonly activePanel: _angular_core.WritableSignal<"comments" | "accessibility" | null>;
+    /** Document-properties (Info) dialog visibility. */
+    protected readonly showProperties: _angular_core.WritableSignal<boolean>;
+    /** Hyperlink-edit dialog visibility. */
+    protected readonly showHyperlink: _angular_core.WritableSignal<boolean>;
+    /** Local overrides applied to document properties via the Info dialog. */
+    private readonly coreOverride;
+    /** Comments on the active slide. */
+    protected readonly activeComments: _angular_core.Signal<PptxComment[]>;
+    /** Document core properties (loaded, with any in-session edits merged in). */
+    protected readonly coreProperties: _angular_core.Signal<PptxCoreProperties>;
     /** Open editor context-menu position (client coords), or null. */
     protected readonly contextMenuPos: _angular_core.WritableSignal<{
         x: number;
@@ -433,6 +806,26 @@ declare class PowerPointViewerComponent {
     present(): void;
     /** Toggle the speaker-notes strip. */
     toggleNotes(): void;
+    /** Toggle a right-docked tool panel (clicking the active one closes it). */
+    togglePanel(panel: 'comments' | 'accessibility'): void;
+    /** Append a comment to the active slide (one history entry). */
+    onCommentAdd(text: string): void;
+    /** Remove a comment from the active slide. */
+    onCommentRemove(id: string): void;
+    /** Toggle a comment's resolved flag on the active slide. */
+    onCommentResolve(id: string): void;
+    /**
+     * Persist a document-properties edit from the Info dialog. Gated on
+     * {@link canEdit} — viewers may inspect properties but not mutate them
+     * (mirrors the comments / hyperlink edit paths).
+     */
+    onPropertiesSave(patch: Partial<PptxCoreProperties>): void;
+    /** Apply a hyperlink edit to the selected element (one history entry). */
+    onHyperlinkSave(patch: Partial<PptxElement>): void;
+    /** Run a print job for the chosen settings, rasterising each slide off the live stage. */
+    onPrint(settings: PrintSettings): Promise<void>;
+    /** Flip the live stage to `index`, let it settle, and capture it to a PNG data URL. */
+    private captureSlideDataUrl;
     /**
      * Handle an element press from the canvas. Additive (Shift/Ctrl) toggles
      * membership; a plain press selects the element (keeping it selected if it
@@ -474,7 +867,7 @@ declare class PowerPointViewerComponent {
      */
     exportPdf(): Promise<void>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PowerPointViewerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PowerPointViewerComponent, "pptx-viewer", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "collaboration": { "alias": "collaboration"; "required": false; "isSignal": true; }; }, { "activeSlideChange": "activeSlideChange"; "dirtyChange": "dirtyChange"; "contentChange": "contentChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PowerPointViewerComponent, "pptx-viewer", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "collaboration": { "alias": "collaboration"; "required": false; "isSignal": true; }; }, { "activeSlideChange": "activeSlideChange"; "dirtyChange": "dirtyChange"; "contentChange": "contentChange"; "propertiesChange": "propertiesChange"; }, never, never, true, never>;
 }
 
 /**
@@ -630,11 +1023,31 @@ declare class SlideCanvasComponent {
     readonly snapGuides: _angular_core.WritableSignal<readonly SnapGuide[]>;
     private readonly textEditor;
     private readonly stageRef;
+    private readonly viewportRef;
+    /**
+     * Auto-fit scale (≤ 1): how much the fixed-size slide must shrink to fit the
+     * scroll viewport. The authored slide is e.g. 1280×720, which overflows a
+     * phone; without this it renders off-screen at `zoom=1`. Mirrors the React
+     * viewer's `fitScale * scale` model (useZoomViewport.ts) so "100%" means "fit
+     * to viewport". Measured from the viewport via ResizeObserver below.
+     */
+    private readonly fitScale;
+    /**
+     * The on-screen scale used for ALL rendering and pointer→stage coordinate
+     * math: the user's zoom folded with the auto-fit. The parent keeps showing the
+     * raw user zoom as the percentage, so this stays internal to the canvas.
+     */
+    private readonly effectiveScale;
     /** The editing id we've already initialised the textarea for, to avoid re-seeding its value mid-edit. */
     private seededEditId;
     /** Last-tap timestamp + element id, for synthetic double-tap detection on touch. */
     private lastTap;
     constructor();
+    /**
+     * Compute the largest scale (≤ 1) at which the whole slide fits the viewport,
+     * reserving the 1rem gutter + drop shadow. Sets fitScale to 1 when unmeasured.
+     */
+    private recomputeFit;
     readonly elements: _angular_core.Signal<PptxElement[]>;
     /** Bounding boxes (stage coords) for the selected elements. */
     readonly selectionBoxes: _angular_core.Signal<{
@@ -2208,6 +2621,1172 @@ declare function convertOmmlToMathMl(ommlNode: OmmlNode): string;
  */
 declare function ommlToMathml(omml: Record<string, unknown> | string | undefined): string;
 
+declare class CommentsPanelComponent {
+    /** The active slide's comments (already filtered to the active slide). */
+    readonly comments: _angular_core.InputSignal<PptxComment[]>;
+    /** Display name shown in the compose label ("Commenting as …"). */
+    readonly authorName: _angular_core.InputSignal<string>;
+    /** Emits the trimmed comment text the user wants to add. */
+    readonly add: _angular_core.OutputEmitterRef<string>;
+    /** Emits the id of a comment the user wants to remove. */
+    readonly remove: _angular_core.OutputEmitterRef<string>;
+    /** Emits the id of a comment whose resolved flag should toggle. */
+    readonly resolve: _angular_core.OutputEmitterRef<string>;
+    /** Current text typed into the compose textarea. */
+    readonly draft: _angular_core.WritableSignal<string>;
+    /** Whether the draft has non-whitespace content (enables the submit button). */
+    readonly canAdd: _angular_core.Signal<boolean>;
+    onDraftInput(event: Event): void;
+    submit(event: Event): void;
+    formatTimestamp(value: string | undefined): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommentsPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommentsPanelComponent, "pptx-comments-panel", never, { "comments": { "alias": "comments"; "required": false; "isSignal": true; }; "authorName": { "alias": "authorName"; "required": false; "isSignal": true; }; }, { "add": "add"; "remove": "remove"; "resolve": "resolve"; }, never, never, true, never>;
+}
+
+/**
+ * comments-helpers.ts — Pure, framework-agnostic comment-array transforms.
+ *
+ * Mirrors the mutation logic in the Vue `useComments` composable and the React
+ * `useComments-helpers`, but operating on a single slide's comment list (the
+ * "active slide" slice). Each mutator returns the NEW full comment array, or
+ * `null` when nothing changed (blank text / id-not-found), so the host can write
+ * the result back history-aware.
+ *
+ * No `any`; all regexes use the `/u` flag; no `String.prototype.replaceAll`,
+ * no regex named-capture-groups (ng-packagr lib-target constraints).
+ */
+
+/** Generate a stable, collision-resistant comment id. */
+declare function generateCommentId(): string;
+/**
+ * Append a new comment to a comment list.
+ * @returns the NEW full comment array, or `null` when `text` is blank.
+ */
+declare function addCommentToList(comments: PptxComment[], text: string, authorName: string, x?: number, y?: number): PptxComment[] | null;
+/**
+ * Remove a comment (by id) from a comment list.
+ * @returns the NEW full comment array, or `null` when nothing changed.
+ */
+declare function removeCommentFromList(comments: PptxComment[], id: string): PptxComment[] | null;
+/**
+ * Toggle the `resolved` flag of a comment (by id) in a comment list.
+ * @returns the NEW full comment array, or `null` when nothing changed.
+ */
+declare function toggleCommentResolvedInList(comments: PptxComment[], id: string): PptxComment[] | null;
+
+declare class CommentsService {
+    /**
+     * The active slide's comments (the deck slice for `activeSlideIndex`).
+     * `PptxComment` has no slide field, so the host slices the per-slide
+     * `PptxSlide.comments` into this signal.
+     */
+    private readonly _comments;
+    /** Index of the slide whose comments these are. */
+    private readonly _activeSlideIndex;
+    /** Display name written as the `author` of newly-created comments. */
+    private readonly _authorName;
+    /** The active slide's comments (read-only mirror of the input signal). */
+    readonly slideComments: Signal<PptxComment[]>;
+    /** Index of the slide whose comments these are. */
+    readonly activeSlideIndex: Signal<number>;
+    /** Display name written as the `author` of newly-created comments. */
+    readonly authorName: Signal<string>;
+    /** Set the active slide's comments (the deck slice for `activeSlideIndex`). */
+    setComments(comments: PptxComment[] | null | undefined): void;
+    /** Set the index of the slide whose comments these are. */
+    setActiveSlideIndex(index: number): void;
+    /** Set the display name written as the `author` of newly-created comments. */
+    setAuthorName(name: string): void;
+    /**
+     * Append a new comment to the active slide.
+     * @returns the NEW full comment array for the active slide, or `null` when
+     *   `text` is blank.
+     */
+    addComment(text: string, x?: number, y?: number): PptxComment[] | null;
+    /**
+     * Remove a comment (by id) from the active slide.
+     * @returns the NEW full comment array, or `null` when nothing changed.
+     */
+    removeComment(id: string): PptxComment[] | null;
+    /**
+     * Toggle the `resolved` flag of a comment (by id) on the active slide.
+     * @returns the NEW full comment array, or `null` when nothing changed.
+     */
+    resolveComment(id: string): PptxComment[] | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommentsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CommentsService>;
+}
+
+declare class SignaturesPanelComponent {
+    /** Parsed signatures to inspect (host parses and supplies them). */
+    readonly signatures: _angular_core.InputSignal<ParsedSignature[]>;
+    /** True when the package carries at least one signature part. */
+    readonly signed: _angular_core.Signal<boolean>;
+    /** Coarse-grained "Signed / Invalid / Not signed" classification. */
+    readonly overall: _angular_core.Signal<pptx_angular_viewer.OverallSignatureStatus>;
+    /** Header label for the panel. */
+    readonly headerLabel: _angular_core.Signal<string>;
+    /** "N signature(s)" count label. */
+    readonly countLabel: _angular_core.Signal<string>;
+    key(sig: ParsedSignature, index: number): string;
+    kind(sig: ParsedSignature): string;
+    label(sig: ParsedSignature): string;
+    signer(sig: ParsedSignature): string;
+    timestamp(sig: ParsedSignature): string | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SignaturesPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SignaturesPanelComponent, "pptx-signatures-panel", never, { "signatures": { "alias": "signatures"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * signatures-helpers.ts — Pure functions for digital-signature status
+ * derivation and presentation.
+ *
+ * Angular port of the logic in the Vue `useSignatures` composable and
+ * `SignaturesPanel.vue`. These functions are framework-agnostic and fully
+ * unit-testable: they never sign, strip, or mutate anything — they only
+ * inspect a supplied list of already-parsed signatures and derive display
+ * state.
+ *
+ * Overall status precedence (worst-wins), mirroring how a signature panel
+ * should warn the user:
+ *   invalid  >  expired  >  unknownCA  >  unverified  >  valid
+ */
+
+/** Coarse-grained "Signed / Invalid / Not signed" classification. */
+type OverallSignatureStatus = 'signed' | 'invalid' | 'unsigned';
+/** Coarse validity bucket for per-signature styling. */
+type SignatureStatusKind = 'valid' | 'invalid' | 'unknown';
+/** True when the package carries at least one signature part. */
+declare function isSigned(signatures: readonly ParsedSignature[]): boolean;
+/**
+ * The single worst per-signature status across the package, or `undefined`
+ * when the package is unsigned. Useful for badge colouring.
+ */
+declare function worstStatus(signatures: readonly ParsedSignature[]): SignatureStatus | undefined;
+/** Coarse-grained "Signed / Invalid / Not signed" classification. */
+declare function overallStatus(signatures: readonly ParsedSignature[]): OverallSignatureStatus;
+/** Header label for the panel given the overall package status. */
+declare function headerLabel(overall: OverallSignatureStatus): string;
+/** Human-readable label for a per-signature status. */
+declare function statusLabel(status: SignatureStatus): string;
+/** Coarse validity bucket for styling: valid / invalid / unknown. */
+declare function statusKind(status: SignatureStatus): SignatureStatusKind;
+/** Best-effort signer name: certificate subject, else issuer, else path. */
+declare function signerName(sig: ParsedSignature): string;
+/**
+ * Best-effort signing timestamp. The parsed signature does not carry a
+ * dedicated signing-time field in the public shape, so we fall back to the
+ * certificate's validity window when present. Returns `undefined` when no
+ * timestamp can be derived.
+ */
+declare function signatureTimestamp(sig: ParsedSignature): string | undefined;
+/** Stable list key for a signature row. */
+declare function signatureKey(sig: ParsedSignature, index: number): string;
+/** Human-readable "N signature(s)" count label. */
+declare function signatureCountLabel(count: number): string;
+
+declare class SignaturesService {
+    /** Backing source of parsed signatures. */
+    private readonly _signatures;
+    /** The signatures currently being inspected (read-only). */
+    readonly signatures: _angular_core.Signal<ParsedSignature[]>;
+    /** True when the package carries at least one signature part. */
+    readonly isSigned: _angular_core.Signal<boolean>;
+    /**
+     * The single worst per-signature status across the package, or `undefined`
+     * when the package is unsigned. Useful for badge colouring.
+     */
+    readonly status: _angular_core.Signal<SignatureStatus | undefined>;
+    /** Coarse-grained "Signed / Invalid / Not signed" classification. */
+    readonly overall: _angular_core.Signal<OverallSignatureStatus>;
+    /** Number of signatures currently loaded. */
+    readonly signatureCount: _angular_core.Signal<number>;
+    /** Replace the inspected signature list (host parses and supplies it). */
+    setSignatures(signatures: readonly ParsedSignature[] | null | undefined): void;
+    /** Clear all inspected signatures (e.g. when a new file loads). */
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SignaturesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SignaturesService>;
+}
+
+/**
+ * accessibility-helpers.ts — Pure WCAG / PowerPoint-style accessibility checks
+ * for the PPTX viewer.
+ *
+ * No Angular imports; safe to use in web workers or server-side code.
+ *
+ * Mirrors `pptx-viewer-core`'s {@link checkPresentation} entry point, but
+ * `checkPresentation` consumes a full `PptxData` object (it reads
+ * `data.slides`). The viewer only has the slide array to hand, so
+ * {@link collectAccessibilityIssues} re-implements the same aggregation by
+ * calling the individual exported `check*` functions over the slides and
+ * sorting the result identically (by slide index, then severity:
+ * error → warning → tip).
+ *
+ * @module accessibility-helpers
+ */
+
+/** Severity groups in display order (errors first, then warnings, then tips). */
+declare const SEVERITY_GROUPS: readonly AccessibilityIssueSeverity[];
+/** Human-readable heading for each severity group. */
+declare const SEVERITY_LABELS: Record<AccessibilityIssueSeverity, string>;
+/** Human-readable label for each issue type. */
+declare const TYPE_LABELS: Record<AccessibilityIssueType, string>;
+/** A severity group with its (non-empty) issues, used for rendering. */
+interface AccessibilityIssueGroup {
+    severity: AccessibilityIssueSeverity;
+    label: string;
+    issues: AccessibilityIssue[];
+}
+/**
+ * Run all accessibility checks over the supplied slides and return the issues
+ * sorted by slide index, then severity (error → warning → tip).
+ *
+ * Equivalent to core's {@link checkPresentation}, but operates on a slide array
+ * rather than a full `PptxData` object.
+ *
+ * @param slides - Parsed slides for the current presentation.
+ * @param options - Optional check configuration mirroring
+ *   {@link AccessibilityCheckOptions}.
+ */
+declare function collectAccessibilityIssues(slides: readonly PptxSlide[], options?: AccessibilityCheckOptions): AccessibilityIssue[];
+/** Total number of issues in a collected list (trivial, but mirrors Vue). */
+declare function countAccessibilityIssues(issues: readonly AccessibilityIssue[]): number;
+/**
+ * Partition issues into non-empty severity groups in display order
+ * (errors → warnings → tips). Mirrors the `groups` computed in
+ * `AccessibilityPanel.vue`.
+ */
+declare function groupIssuesBySeverity(issues: readonly AccessibilityIssue[]): AccessibilityIssueGroup[];
+/** Human-readable label for an issue type. */
+declare function issueTypeLabel(type: AccessibilityIssueType): string;
+/**
+ * Stable-ish track key for an issue (issues have no id of their own).
+ * Mirrors the `issueKey` helper in `AccessibilityPanel.vue`.
+ */
+declare function issueTrackKey(issue: AccessibilityIssue, index: number): string;
+
+declare class AccessibilityPanelComponent {
+    /** Already-computed accessibility issues (see {@link AccessibilityService}). */
+    readonly issues: _angular_core.InputSignal<AccessibilityIssue[]>;
+    /** Emits the issue's zero-based slide index when an issue is clicked. */
+    readonly selectSlide: _angular_core.OutputEmitterRef<number>;
+    /** Non-empty severity groups in display order. */
+    readonly groups: _angular_core.Signal<AccessibilityIssueGroup[]>;
+    /** True when there is at least one issue. */
+    readonly hasIssues: _angular_core.Signal<boolean>;
+    typeLabel(type: AccessibilityIssueType): string;
+    /** Stable-ish track key; issues have no id of their own. */
+    issueKey(issue: AccessibilityIssue, index: number): string;
+    onSelect(issue: AccessibilityIssue): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccessibilityPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccessibilityPanelComponent, "pptx-accessibility-panel", never, { "issues": { "alias": "issues"; "required": false; "isSignal": true; }; }, { "selectSlide": "selectSlide"; }, never, never, true, never>;
+}
+
+declare class EmbeddedFontsService {
+    /** The generated `@font-face` stylesheet text (also injected into `<head>`). */
+    readonly fontFaceCss: _angular_core.WritableSignal<string>;
+    /**
+     * Distinct CSS `font-family` strings for the embedded families, each with
+     * substitution fallbacks resolved (e.g. `'"Calibri", "Carlito", …'`).
+     */
+    readonly fontFamilies: _angular_core.WritableSignal<string[]>;
+    private styleEl;
+    /** Object URLs minted on the most recent `setFonts`; revoked when superseded. */
+    private liveObjectUrls;
+    /** Mints a Blob object URL for de-obfuscated font bytes (impure side effect). */
+    private readonly mintObjectUrl;
+    constructor();
+    /**
+     * Resolve the supplied embedded fonts into `@font-face` rules, inject them
+     * into the managed `<style>` element, and update the exposed signals.
+     *
+     * Object URLs minted on the *previous* call are revoked here so they don't
+     * leak across re-parses. Pass an empty list (or `null`) to clear everything.
+     */
+    setFonts(fonts: readonly PptxEmbeddedFont[] | null | undefined): void;
+    /**
+     * Remove the injected `<style>` element, revoke all live object URLs, and
+     * reset the signals. Called automatically on destroy; safe to call manually.
+     */
+    dispose(): void;
+    /** Create / update / remove the managed `<style>` element to match `css`. */
+    private syncStyleElement;
+    private removeStyleElement;
+    private revokeObjectUrls;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmbeddedFontsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EmbeddedFontsService>;
+}
+
+/**
+ * embedded-fonts-helpers.ts — Pure (no Angular, no DOM-injection) helpers for
+ * the embedded-font subsystem.
+ *
+ * Angular port of the string-building / format-mapping half of the Vue
+ * `useEmbeddedFonts` composable (which itself ports the `@font-face` half of
+ * the React `useFontInjection` hook). All DOM side effects (injecting the
+ * managed `<style>` element, minting / revoking object URLs, signal wiring)
+ * live in `embedded-fonts.service.ts`; everything here is pure and unit-tested.
+ *
+ * The core load pipeline (`PptxHandlerRuntimeEmbeddedFonts`) already
+ * de-obfuscates the OOXML XOR layer and produces a ready-to-use `dataUrl` for
+ * each style variant, so one {@link PptxEmbeddedFont} corresponds to a single
+ * style variant (regular / bold / italic / boldItalic), distinguished by its
+ * `bold` and `italic` flags. As a defence-in-depth fallback, an entry without a
+ * usable `dataUrl` but carrying obfuscated `originalPartBytes` + `fontGuid`
+ * (or clear-text `rawFontData`) is de-obfuscated here and minted into a `Blob`
+ * object URL by the service.
+ */
+
+/** DOM id of the managed `<style>` element the service injects into `<head>`. */
+declare const EMBEDDED_FONTS_STYLE_ID = "pptx-angular-embedded-fonts";
+/**
+ * True when `url` is safe to interpolate into `src: url("…")`.
+ *
+ * Accepts `blob:` URLs (minted by the service from de-obfuscated bytes) and
+ * base64 `data:font/…` URLs produced by the core loader; everything else is
+ * rejected to prevent CSS-injection / exfiltration via a hostile PPTX.
+ */
+declare function isInjectableUrl(url: string): boolean;
+/** Map a resolved CSS font format to the MIME type for a minted `Blob`. */
+declare function fontMimeForFormat(format: string): string;
+/**
+ * Normalise an entry's declared format to one of the allowed `format()` hints,
+ * falling back to `truetype`.
+ */
+declare function normalizeFontFormat(format: string | undefined): string;
+/** A single resolved variant ready to be emitted as a `@font-face` rule. */
+interface ResolvedFontVariant {
+    name: string;
+    url: string;
+    format: string;
+    weight: string;
+    style: string;
+    /** Object URL minted for this variant (must be revoked on cleanup). */
+    objectUrl?: string;
+}
+/**
+ * Factory the (impure) object-URL minting is delegated to, so the resolution
+ * logic stays pure and testable. The service supplies a real implementation
+ * backed by `Blob` + `URL.createObjectURL`; tests can stub it. Returning
+ * `null` signals object URLs are unsupported in the current runtime.
+ */
+type ObjectUrlFactory = (bytes: Uint8Array, mime: string) => string | null;
+/**
+ * Resolve a single embedded-font entry to an injectable variant.
+ *
+ * Prefers the de-obfuscated `dataUrl` produced by the core loader. Falls back
+ * to de-obfuscating `originalPartBytes` with `fontGuid` (or using clear-text
+ * `rawFontData` directly) and minting an object URL via `mintObjectUrl` when no
+ * usable data URL is present. Returns `null` when the entry cannot be safely
+ * rendered.
+ *
+ * Pure aside from the injected `mintObjectUrl` callback (which the service owns).
+ */
+declare function resolveFontVariant(font: PptxEmbeddedFont, mintObjectUrl: ObjectUrlFactory): ResolvedFontVariant | null;
+/** Build the `@font-face` rule text for one resolved variant. */
+declare function buildFontFaceRule(variant: ResolvedFontVariant): string;
+/** The product of resolving an embedded-font list: CSS, families, live URLs. */
+interface EmbeddedFontStyles {
+    /** The generated `@font-face` stylesheet text. */
+    fontFaceCss: string;
+    /**
+     * Distinct CSS `font-family` strings for the embedded families, each with
+     * substitution fallbacks resolved (e.g. `'"Calibri", "Carlito", …'`).
+     */
+    fontFamilies: string[];
+    /** Object URLs minted while resolving (the caller must revoke these). */
+    objectUrls: string[];
+}
+/**
+ * Resolve a list of embedded fonts into the injectable `@font-face` stylesheet,
+ * the distinct substitution-resolved family strings, and any object URLs minted
+ * along the way (so the caller can track them for revocation).
+ *
+ * Pure aside from the injected `mintObjectUrl` callback.
+ */
+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. */
+    readonly index: number;
+    /** Human label for the step (first animation's preset, "+N more"). */
+    readonly label: string;
+    /** Human label for the step's start trigger. */
+    readonly trigger: string;
+    /** True when this step has been revealed at the current playback position. */
+    readonly revealed: boolean;
+}
+declare class AnimationPanelComponent {
+    readonly groups: _angular_core.InputSignal<AnimationClickGroup[]>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly isPlaying: _angular_core.InputSignal<boolean>;
+    readonly playRequested: _angular_core.OutputEmitterRef<void>;
+    readonly pauseRequested: _angular_core.OutputEmitterRef<void>;
+    readonly stepRequested: _angular_core.OutputEmitterRef<void>;
+    readonly resetRequested: _angular_core.OutputEmitterRef<void>;
+    /** Jump to a 1-based step index (the number of groups to reveal). */
+    readonly seek: _angular_core.OutputEmitterRef<number>;
+    protected readonly stepCount: _angular_core.Signal<number>;
+    protected readonly isComplete: _angular_core.Signal<boolean>;
+    protected readonly steps: _angular_core.Signal<AnimationStepView[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimationPanelComponent, never>;
+    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;
+    color: string;
+    label: string;
+    transform: string;
+}
+declare class CollaborationCursorsComponent {
+    /** Remote collaborators to render, in unscaled slide coordinates. */
+    readonly cursors: _angular_core.InputSignal<RemoteCursor[]>;
+    /** Current canvas zoom factor; cursor positions scale by this. */
+    readonly zoom: _angular_core.InputSignal<number>;
+    /** Precompute positions + labels so the template stays declarative. */
+    protected readonly positioned: _angular_core.Signal<PositionedCursor[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CollaborationCursorsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CollaborationCursorsComponent, "pptx-collaboration-cursors", never, { "cursors": { "alias": "cursors"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ModalDialogComponent {
+    /** Whether the dialog is visible. */
+    readonly open: _angular_core.InputSignal<boolean>;
+    /** Optional heading shown in the header bar. */
+    readonly title: _angular_core.InputSignal<string>;
+    /** Fired on backdrop click, the `×` button, and `Escape`. */
+    readonly close: _angular_core.OutputEmitterRef<void>;
+    /** Close on `Escape`, regardless of where focus currently sits. */
+    onDocumentKeydown(event: KeyboardEvent): void;
+    requestClose(): void;
+    /**
+     * Backdrop clicks close the dialog; clicks bubbling up from the panel are
+     * stopped in the template, so this only ever fires for the backdrop itself.
+     */
+    onBackdropClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalDialogComponent, "pptx-modal-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, { "close": "close"; }, never, ["*", "[footer]"], true, never>;
+}
+
+/**
+ * properties-dialog-helpers.ts — Pure (no Angular) helpers for the document
+ * properties dialog.
+ *
+ * Mirrors the read / format / diff logic of the Vue `PropertiesDialog.vue`:
+ * seed an editable draft from the core properties, format read-only
+ * timestamps, and build a minimal `Partial<PptxCoreProperties>` patch that
+ * carries only the fields the user actually changed.
+ *
+ * No `any`; all regexes use the `/u` flag; no `String.prototype.replaceAll`,
+ * no regex named-capture-groups (ng-packagr lib-target constraints).
+ */
+
+/**
+ * Subset of {@link PptxCoreProperties} surfaced by the Properties dialog: the
+ * editable metadata (title / creator / subject / keywords) plus read-only
+ * timestamps (created / modified).
+ */
+type DocumentProperties = Pick<PptxCoreProperties, 'title' | 'creator' | 'subject' | 'keywords' | 'created' | 'modified'>;
+/** The editable draft fields, all coerced to non-null strings. */
+interface PropertiesDraft {
+    title: string;
+    creator: string;
+    subject: string;
+    keywords: string;
+}
+/**
+ * Build an editable draft from the source properties, coercing each absent
+ * field to an empty string.
+ */
+declare function seedPropertiesDraft(properties: DocumentProperties): PropertiesDraft;
+/**
+ * Format a (possibly absent or invalid) ISO timestamp for display. Returns an
+ * em-dash for missing values and echoes the raw string for unparseable ones.
+ */
+declare function formatPropertyDate(value: string | undefined): string;
+/**
+ * Diff an edited draft against the source properties and produce a patch that
+ * contains only the changed editable fields. An untouched dialog yields `{}`.
+ */
+declare function buildPropertiesPatch(properties: DocumentProperties, draft: PropertiesDraft): Partial<PptxCoreProperties>;
+
+declare class PropertiesDialogComponent {
+    /** Whether the dialog is visible. */
+    readonly open: _angular_core.InputSignal<boolean>;
+    /** Current document metadata. */
+    readonly properties: _angular_core.InputSignal<DocumentProperties>;
+    /** Fired with the edited (changed-only) fields when the user saves. */
+    readonly save: _angular_core.OutputEmitterRef<Partial<PptxCoreProperties>>;
+    /** Fired when the dialog is dismissed. */
+    readonly close: _angular_core.OutputEmitterRef<void>;
+    readonly title: _angular_core.WritableSignal<string>;
+    readonly creator: _angular_core.WritableSignal<string>;
+    readonly subject: _angular_core.WritableSignal<string>;
+    readonly keywords: _angular_core.WritableSignal<string>;
+    constructor();
+    createdDisplay(): string;
+    modifiedDisplay(): string;
+    asValue(event: Event): string;
+    handleSave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PropertiesDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PropertiesDialogComponent, "pptx-properties-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "properties": { "alias": "properties"; "required": true; "isSignal": true; }; }, { "save": "save"; "close": "close"; }, never, never, true, never>;
+}
+
+/**
+ * share-helpers.ts — Pure (no Angular) helpers for the Share dialog.
+ *
+ * Mirrors the form-validation / config-assembly logic of the Vue
+ * `ShareDialog.vue` plus the share-link builder from the React `ShareDialog`.
+ *
+ * No `any`; all regexes use the `/u` flag; no `String.prototype.replaceAll`,
+ * no regex named-capture-groups (ng-packagr lib-target constraints).
+ */
+
+/** Prefilled values for the Share form fields. */
+interface ShareDefaults {
+    roomId?: string;
+    userName?: string;
+    serverUrl?: string;
+}
+/** The Share form's editable fields. */
+interface ShareFormFields {
+    roomId: string;
+    userName: string;
+    serverUrl: string;
+}
+/** Seed the form fields from the (optional) defaults, coercing absent values. */
+declare function seedShareFields(defaults?: ShareDefaults): ShareFormFields;
+/** Whether all three required fields are non-blank (after trimming). */
+declare function canStartShare(fields: ShareFormFields): boolean;
+/**
+ * Assemble a {@link CollaborationConfig} from the (trimmed) form fields, or
+ * `null` when the form is incomplete.
+ */
+declare function buildCollaborationConfig(fields: ShareFormFields): CollaborationConfig | null;
+/**
+ * Build a shareable join URL for a session. Returns just the room id when no
+ * `origin`/`pathname` are available (e.g. non-browser environments).
+ */
+declare function buildShareUrl(roomId: string, serverUrl: string, location?: {
+    origin: string;
+    pathname: string;
+}): string;
+
+declare class ShareDialogComponent {
+    /** Whether the dialog is visible. */
+    readonly open: _angular_core.InputSignal<boolean>;
+    /** Prefilled values for the form fields. */
+    readonly defaults: _angular_core.InputSignal<ShareDefaults | undefined>;
+    /** Whether a collaboration session is currently active. */
+    readonly active: _angular_core.InputSignal<boolean>;
+    /** Fired with the assembled config when the user starts sharing. */
+    readonly start: _angular_core.OutputEmitterRef<CollaborationConfig>;
+    /** Fired when the user stops an active session. */
+    readonly stop: _angular_core.OutputEmitterRef<void>;
+    /** Fired when the dialog is dismissed. */
+    readonly close: _angular_core.OutputEmitterRef<void>;
+    readonly roomId: _angular_core.WritableSignal<string>;
+    readonly userName: _angular_core.WritableSignal<string>;
+    readonly serverUrl: _angular_core.WritableSignal<string>;
+    readonly canStart: _angular_core.Signal<boolean>;
+    constructor();
+    asValue(event: Event): string;
+    handleStart(): void;
+    handleStop(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShareDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShareDialogComponent, "pptx-share-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaults": { "alias": "defaults"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; }, { "start": "start"; "stop": "stop"; "close": "close"; }, never, never, true, never>;
+}
+
+declare class HyperlinkDialogComponent {
+    /** Whether the dialog is open. */
+    readonly open: _angular_core.InputSignal<boolean>;
+    /** The element whose hyperlink is being edited, or `null`. */
+    readonly element: _angular_core.InputSignal<PptxElement | null>;
+    /** Emitted when the user applies a change. Payload is a merge patch. */
+    readonly save: _angular_core.OutputEmitterRef<Partial<PptxElement>>;
+    /** Emitted when the dialog should close without saving. */
+    readonly close: _angular_core.OutputEmitterRef<void>;
+    readonly url: _angular_core.WritableSignal<string>;
+    readonly tooltip: _angular_core.WritableSignal<string>;
+    /** Whether the current element already has a hyperlink set. */
+    readonly hasLink: _angular_core.Signal<boolean>;
+    constructor();
+    asValue(event: Event): string;
+    onEnter(event: Event): void;
+    onClose(): void;
+    apply(): void;
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HyperlinkDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HyperlinkDialogComponent, "pptx-hyperlink-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "element": { "alias": "element"; "required": false; "isSignal": true; }; }, { "save": "save"; "close": "close"; }, never, never, true, never>;
+}
+
+/**
+ * broadcast-helpers.ts — Pure (no Angular) helpers for the Broadcast dialog.
+ *
+ * A broadcast is a one-way collaboration session: the presenter drives slide
+ * navigation and viewers follow along via a shareable link. These helpers
+ * cover the testable, framework-agnostic parts of the Vue `BroadcastDialog.vue`
+ * and React `BroadcastDialog.tsx`: room-id generation, form validation, and
+ * the viewer-link builder.
+ *
+ * No `any`; all regexes use the `/u` flag; no `String.prototype.replaceAll`,
+ * no regex named-capture-groups (ng-packagr lib-target constraints).
+ */
+/** Default y-websocket server URL used when no default is supplied. */
+declare const DEFAULT_BROADCAST_SERVER_URL = "ws://localhost:1234";
+/** Optional seed values for the broadcast start form. */
+interface BroadcastDefaults {
+    roomId?: string;
+    serverUrl?: string;
+}
+/** The configuration emitted when a broadcast starts. */
+interface BroadcastConfig {
+    roomId: string;
+    serverUrl: string;
+}
+/** Generate a fresh, broadcast-scoped room id (`broadcast-<suffix>`). */
+declare function generateBroadcastRoomId(): string;
+/**
+ * Seed the start form from the (optional) defaults, generating a fresh room id
+ * when none is supplied and falling back to the default server URL.
+ */
+declare function seedBroadcastFields(defaults?: BroadcastDefaults): BroadcastConfig;
+/** Whether both required fields are non-blank (after trimming). */
+declare function canStartBroadcast(fields: BroadcastConfig): boolean;
+/**
+ * Assemble a {@link BroadcastConfig} from the (trimmed) form fields, or `null`
+ * when incomplete.
+ */
+declare function buildBroadcastConfig(fields: BroadcastConfig): BroadcastConfig | null;
+/**
+ * Build the shareable viewer follow-link for a broadcast. Returns just the
+ * room id when no `origin`/`pathname` are available (non-browser environments).
+ */
+declare function buildBroadcastViewerUrl(roomId: string, serverUrl: string, location?: {
+    origin: string;
+    pathname: string;
+}): string;
+/** Whether the runtime exposes a usable async clipboard write API. */
+declare function canUseClipboard(nav: Navigator | undefined): boolean;
+
+declare class BroadcastDialogComponent {
+    /** Whether the dialog is visible. */
+    readonly open: _angular_core.InputSignal<boolean>;
+    /** Optional `{ roomId, serverUrl }` seed for the start form. */
+    readonly defaults: _angular_core.InputSignal<BroadcastDefaults | undefined>;
+    /** Whether a broadcast is currently running. */
+    readonly active: _angular_core.InputSignal<boolean>;
+    /** The shareable follow link (shown while `active`). */
+    readonly viewerUrl: _angular_core.InputSignal<string | undefined>;
+    /** Fired when the presenter starts a broadcast. */
+    readonly start: _angular_core.OutputEmitterRef<BroadcastConfig>;
+    /** Fired when the presenter stops the active broadcast. */
+    readonly stop: _angular_core.OutputEmitterRef<void>;
+    /** Fired when the dialog is dismissed. */
+    readonly close: _angular_core.OutputEmitterRef<void>;
+    readonly roomId: _angular_core.WritableSignal<string>;
+    readonly serverUrl: _angular_core.WritableSignal<string>;
+    readonly copied: _angular_core.WritableSignal<boolean>;
+    readonly canStart: _angular_core.Signal<boolean>;
+    readonly dialogTitle: _angular_core.Signal<"Broadcasting" | "Broadcast to a live audience">;
+    readonly canCopy: _angular_core.Signal<boolean>;
+    constructor();
+    asValue(event: Event): string;
+    selectAll(event: Event): void;
+    onClose(): void;
+    onStart(): void;
+    onStop(): void;
+    onCopyLink(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BroadcastDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BroadcastDialogComponent, "pptx-broadcast-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaults": { "alias": "defaults"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "viewerUrl": { "alias": "viewerUrl"; "required": false; "isSignal": true; }; }, { "start": "start"; "stop": "stop"; "close": "close"; }, never, never, true, never>;
+}
+
+/**
+ * hyperlink-dialog-helpers.ts — Pure (no Angular) helpers for the hyperlink
+ * dialog.
+ *
+ * Mirrors the URL + tooltip editing of the Vue `HyperlinkDialog.vue`, which
+ * stores the link on the element-level `actionClick` field (a `PptxAction`).
+ * This module builds the `{ actionClick }` merge patch:
+ *  - **Set:** `{ actionClick: { ...existing, url, tooltip } }` (any preexisting
+ *    OOXML `action` verb on the element is preserved so slide-jump links
+ *    survive).
+ *  - **Clear:** `{ actionClick: undefined }` (empty URL, an unsafe URL, or an
+ *    explicit "Remove link").
+ *
+ * Reuses the viewer's URL-safety guard (`./hyperlink`) so the dialog never
+ * applies an unsafe href (e.g. `javascript:` / `data:`).
+ *
+ * No `any`; all regexes use the `/u` flag; no `String.prototype.replaceAll`,
+ * no regex named-capture-groups (ng-packagr lib-target constraints).
+ */
+
+/** Whether the element already has a hyperlink URL set. */
+declare function hasExistingLink(element: PptxElement | null): boolean;
+/** The current URL + tooltip seeded into the form from an element. */
+interface HyperlinkDraft {
+    url: string;
+    tooltip: string;
+}
+/** Read the element's current `actionClick.url` / `.tooltip` into a draft. */
+declare function seedHyperlinkDraft(element: PptxElement | null): HyperlinkDraft;
+/**
+ * Build the merge patch for applying the dialog's draft to an element.
+ *
+ * Returns `{ actionClick: undefined }` (a clearing patch) when:
+ *  - the trimmed URL is empty, or
+ *  - the URL is unsafe (blocked scheme) and is NOT a preserved `ppaction://`
+ *    verb.
+ *
+ * Otherwise returns `{ actionClick: { ...existing, url, tooltip } }`, dropping
+ * the tooltip when blank and preserving any existing OOXML `action` verb.
+ */
+declare function buildHyperlinkPatch(element: PptxElement, draft: HyperlinkDraft): Partial<PptxElement>;
+/** A patch that clears the element's hyperlink entirely. */
+declare function buildClearHyperlinkPatch(): Partial<PptxElement>;
+
+declare class PrintDialogComponent {
+    /** All slides in the current presentation. */
+    readonly slides: _angular_core.InputSignal<PptxSlide[]>;
+    /** Zero-based index of the active slide. */
+    readonly activeSlideIndex: _angular_core.InputSignal<number>;
+    /** Default slides-per-page from presentation properties. */
+    readonly defaultSlidesPerPage: _angular_core.InputSignal<number | undefined>;
+    /** Default frame-slides from presentation properties. */
+    readonly defaultFrameSlides: _angular_core.InputSignal<boolean | undefined>;
+    /** Emits the resolved, validated settings when the user clicks Print. */
+    readonly print: _angular_core.OutputEmitterRef<PrintSettings>;
+    /** Emits when the dialog is dismissed (Cancel / Escape / backdrop). */
+    readonly cancel: _angular_core.OutputEmitterRef<void>;
+    /** Authoritative print settings, seeded from defaults. */
+    readonly settings: _angular_core.WritableSignal<PrintSettings>;
+    private _seeded;
+    constructor();
+    /** Number of slides selected by the current range. */
+    readonly slideCount: _angular_core.Signal<number>;
+    /** Estimated printed page count for the current settings. */
+    readonly pageCount: _angular_core.Signal<number>;
+    /** Apply a partial patch from the settings panel and re-validate. */
+    patch(partial: Partial<PrintSettings>): void;
+    onConfirm(): void;
+    onCancel(): void;
+    onBackdropClick(event: MouseEvent): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PrintDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PrintDialogComponent, "pptx-print-dialog", never, { "slides": { "alias": "slides"; "required": true; "isSignal": true; }; "activeSlideIndex": { "alias": "activeSlideIndex"; "required": true; "isSignal": true; }; "defaultSlidesPerPage": { "alias": "defaultSlidesPerPage"; "required": false; "isSignal": true; }; "defaultFrameSlides": { "alias": "defaultFrameSlides"; "required": false; "isSignal": true; }; }, { "print": "print"; "cancel": "cancel"; }, never, never, true, never>;
+}
+
+declare class PrintSettingsPanelComponent {
+    /** Current print settings (parent-owned). */
+    readonly settings: _angular_core.InputSignal<PrintSettings>;
+    /** Total number of slides in the presentation. */
+    readonly totalSlides: _angular_core.InputSignal<number>;
+    /** Zero-based index of the active slide (for the "current" range label). */
+    readonly activeSlideIndex: _angular_core.InputSignal<number>;
+    /** Emits a partial patch whenever the user changes a field. */
+    readonly settingsChange: _angular_core.OutputEmitterRef<Partial<PrintSettings>>;
+    protected readonly handoutOptions: HandoutSlidesPerPage[];
+    protected readonly printWhatOptions: {
+        value: PrintWhat;
+        label: string;
+    }[];
+    protected readonly orientationOptions: {
+        value: PrintOrientation;
+        label: string;
+    }[];
+    protected readonly colorModeOptions: {
+        value: PrintColorMode;
+        label: string;
+    }[];
+    /** Emit a settings patch. */
+    emit(patch: Partial<PrintSettings>): void;
+    onRangeChange(event: Event, edge: 'from' | 'to'): void;
+    onFrameChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PrintSettingsPanelComponent, never>;
+    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>;
+}
+
+/**
+ * transition-helpers.ts
+ *
+ * Pure logic for mapping a PowerPoint slide transition (`PptxSlideTransition`
+ * / `PptxTransitionType` from `pptx-viewer-core`) to concrete CSS animation
+ * descriptors for the outgoing (old) and incoming (new) slide layers.
+ *
+ * Angular port of the React `utils/transition-keyframes.ts`,
+ * `utils/transition-helpers.ts`, and `utils/transition-resolver.ts`. Kept
+ * framework-free so it can be unit-tested without TestBed (vitest + happy-dom).
+ *
+ * The CSS `@keyframes` block (`SLIDE_TRANSITION_KEYFRAMES`) is injected once by
+ * `PresentationTransitionOverlayComponent` so the named animations resolve.
+ *
+ * ng-packagr lib-target constraints respected here:
+ *   - no `String.prototype.replaceAll`
+ *   - no regex named-capture-groups (no regexes used at all)
+ */
+
+interface SlideTransitionAnimations {
+    /** CSS animation string for the outgoing (old) slide layer. */
+    outgoing: string;
+    /** CSS animation string for the incoming (new) slide layer. */
+    incoming: string;
+    /** Whether the outgoing layer should render on top of the incoming layer. */
+    outgoingOnTop: boolean;
+}
+/**
+ * Resolve the effective transition duration (ms) from an optional authored
+ * value, applying the minimum floor and a sensible default. Mirrors the React
+ * `executeSlideTransition` clamping (`Math.max(120, durationMs || 320)`).
+ */
+declare function resolveTransitionDuration(durationMs: number | undefined): number;
+declare const SLIDE_TRANSITION_KEYFRAMES = "\n/* Fade */\n@keyframes pptx-tr-fade-in {\n\tfrom { opacity: 0; }\n\tto   { opacity: 1; }\n}\n@keyframes pptx-tr-fade-out {\n\tfrom { opacity: 1; }\n\tto   { opacity: 0; }\n}\n\n/* Push */\n@keyframes pptx-tr-push-in-from-right {\n\tfrom { transform: translateX(100%); }\n\tto   { transform: translateX(0); }\n}\n@keyframes pptx-tr-push-out-to-left {\n\tfrom { transform: translateX(0); }\n\tto   { transform: translateX(-100%); }\n}\n@keyframes pptx-tr-push-in-from-left {\n\tfrom { transform: translateX(-100%); }\n\tto   { transform: translateX(0); }\n}\n@keyframes pptx-tr-push-out-to-right {\n\tfrom { transform: translateX(0); }\n\tto   { transform: translateX(100%); }\n}\n@keyframes pptx-tr-push-in-from-bottom {\n\tfrom { transform: translateY(100%); }\n\tto   { transform: translateY(0); }\n}\n@keyframes pptx-tr-push-out-to-top {\n\tfrom { transform: translateY(0); }\n\tto   { transform: translateY(-100%); }\n}\n@keyframes pptx-tr-push-in-from-top {\n\tfrom { transform: translateY(-100%); }\n\tto   { transform: translateY(0); }\n}\n@keyframes pptx-tr-push-out-to-bottom {\n\tfrom { transform: translateY(0); }\n\tto   { transform: translateY(100%); }\n}\n\n/* Cover (incoming slides over stationary outgoing) */\n@keyframes pptx-tr-cover-from-right {\n\tfrom { transform: translateX(100%); }\n\tto   { transform: translateX(0); }\n}\n@keyframes pptx-tr-cover-from-left {\n\tfrom { transform: translateX(-100%); }\n\tto   { transform: translateX(0); }\n}\n@keyframes pptx-tr-cover-from-bottom {\n\tfrom { transform: translateY(100%); }\n\tto   { transform: translateY(0); }\n}\n@keyframes pptx-tr-cover-from-top {\n\tfrom { transform: translateY(-100%); }\n\tto   { transform: translateY(0); }\n}\n@keyframes pptx-tr-cover-from-lu {\n\tfrom { transform: translate(-100%, -100%); }\n\tto   { transform: translate(0, 0); }\n}\n@keyframes pptx-tr-cover-from-ld {\n\tfrom { transform: translate(-100%, 100%); }\n\tto   { transform: translate(0, 0); }\n}\n@keyframes pptx-tr-cover-from-ru {\n\tfrom { transform: translate(100%, -100%); }\n\tto   { transform: translate(0, 0); }\n}\n@keyframes pptx-tr-cover-from-rd {\n\tfrom { transform: translate(100%, 100%); }\n\tto   { transform: translate(0, 0); }\n}\n\n/* Uncover (outgoing slides away revealing stationary incoming) */\n@keyframes pptx-tr-uncover-to-left {\n\tfrom { transform: translateX(0); }\n\tto   { transform: translateX(-100%); }\n}\n@keyframes pptx-tr-uncover-to-right {\n\tfrom { transform: translateX(0); }\n\tto   { transform: translateX(100%); }\n}\n@keyframes pptx-tr-uncover-to-top {\n\tfrom { transform: translateY(0); }\n\tto   { transform: translateY(-100%); }\n}\n@keyframes pptx-tr-uncover-to-bottom {\n\tfrom { transform: translateY(0); }\n\tto   { transform: translateY(100%); }\n}\n@keyframes pptx-tr-uncover-to-lu {\n\tfrom { transform: translate(0, 0); }\n\tto   { transform: translate(-100%, -100%); }\n}\n@keyframes pptx-tr-uncover-to-ld {\n\tfrom { transform: translate(0, 0); }\n\tto   { transform: translate(-100%, 100%); }\n}\n@keyframes pptx-tr-uncover-to-ru {\n\tfrom { transform: translate(0, 0); }\n\tto   { transform: translate(100%, -100%); }\n}\n@keyframes pptx-tr-uncover-to-rd {\n\tfrom { transform: translate(0, 0); }\n\tto   { transform: translate(100%, 100%); }\n}\n\n/* Wipe (clip-path reveal) */\n@keyframes pptx-tr-wipe-from-left {\n\tfrom { clip-path: inset(0 100% 0 0); }\n\tto   { clip-path: inset(0 0 0 0); }\n}\n@keyframes pptx-tr-wipe-from-right {\n\tfrom { clip-path: inset(0 0 0 100%); }\n\tto   { clip-path: inset(0 0 0 0); }\n}\n@keyframes pptx-tr-wipe-from-top {\n\tfrom { clip-path: inset(0 0 100% 0); }\n\tto   { clip-path: inset(0 0 0 0); }\n}\n@keyframes pptx-tr-wipe-from-bottom {\n\tfrom { clip-path: inset(100% 0 0 0); }\n\tto   { clip-path: inset(0 0 0 0); }\n}\n\n/* Split */\n@keyframes pptx-tr-split-h-out {\n\tfrom { clip-path: inset(0 50%); }\n\tto   { clip-path: inset(0 0); }\n}\n@keyframes pptx-tr-split-v-out {\n\tfrom { clip-path: inset(50% 0); }\n\tto   { clip-path: inset(0 0); }\n}\n@keyframes pptx-tr-split-h-in {\n\tfrom { clip-path: inset(0 0); }\n\tto   { clip-path: inset(0 50%); }\n}\n@keyframes pptx-tr-split-v-in {\n\tfrom { clip-path: inset(0 0); }\n\tto   { clip-path: inset(50% 0); }\n}\n\n/* Dissolve */\n@keyframes pptx-tr-dissolve-in {\n\tfrom { opacity: 0; filter: blur(4px); }\n\tto   { opacity: 1; filter: blur(0px); }\n}\n\n/* Circle / Diamond / Plus (clip-path shapes) */\n@keyframes pptx-tr-circle-in {\n\tfrom { clip-path: circle(0% at 50% 50%); }\n\tto   { clip-path: circle(75% at 50% 50%); }\n}\n@keyframes pptx-tr-diamond-in {\n\tfrom { clip-path: polygon(50% 50%, 50% 50%, 50% 50%, 50% 50%); }\n\tto   { clip-path: polygon(50% 0%, 100% 50%, 50% 100%, 0% 50%); }\n}\n@keyframes pptx-tr-plus-in {\n\tfrom {\n\t\tclip-path: polygon(\n\t\t\t50% 50%, 50% 50%, 50% 50%, 50% 50%,\n\t\t\t50% 50%, 50% 50%, 50% 50%, 50% 50%,\n\t\t\t50% 50%, 50% 50%, 50% 50%, 50% 50%\n\t\t);\n\t}\n\tto {\n\t\tclip-path: polygon(\n\t\t\t33% 0%, 66% 0%, 66% 33%, 100% 33%,\n\t\t\t100% 66%, 66% 66%, 66% 100%, 33% 100%,\n\t\t\t33% 66%, 0% 66%, 0% 33%, 33% 33%\n\t\t);\n\t}\n}\n\n/* Wedge */\n@keyframes pptx-tr-wedge-in {\n\tfrom { clip-path: polygon(50% 0%, 50% 0%, 50% 0%); }\n\tto   { clip-path: polygon(50% 0%, 100% 100%, 0% 100%); }\n}\n\n/* Zoom */\n@keyframes pptx-tr-zoom-in {\n\tfrom { transform: scale(0); opacity: 0; }\n\tto   { transform: scale(1); opacity: 1; }\n}\n@keyframes pptx-tr-zoom-out {\n\tfrom { transform: scale(1); opacity: 1; }\n\tto   { transform: scale(2); opacity: 0; }\n}\n\n/* Blinds */\n@keyframes pptx-tr-blinds-h {\n\tfrom { clip-path: inset(0 0 100% 0); }\n\tto   { clip-path: inset(0); }\n}\n@keyframes pptx-tr-blinds-v {\n\tfrom { clip-path: inset(0 100% 0 0); }\n\tto   { clip-path: inset(0); }\n}\n\n/* Checker (approximate with dissolve + contrast) */\n@keyframes pptx-tr-checker-in {\n\tfrom { opacity: 0; filter: contrast(2) blur(2px); }\n\tto   { opacity: 1; filter: contrast(1) blur(0); }\n}\n\n/* Comb */\n@keyframes pptx-tr-comb-h {\n\tfrom { clip-path: inset(0 100% 0 0); }\n\tto   { clip-path: inset(0); }\n}\n@keyframes pptx-tr-comb-v {\n\tfrom { clip-path: inset(100% 0 0 0); }\n\tto   { clip-path: inset(0); }\n}\n\n/* Strips (diagonal) */\n@keyframes pptx-tr-strips-lu {\n\tfrom { clip-path: polygon(0% 0%, 0% 0%, 0% 0%); }\n\tto   { clip-path: polygon(0% 0%, 100% 0%, 100% 100%, 0% 100%); }\n}\n@keyframes pptx-tr-strips-ld {\n\tfrom { clip-path: polygon(0% 100%, 0% 100%, 0% 100%); }\n\tto   { clip-path: polygon(0% 0%, 100% 0%, 100% 100%, 0% 100%); }\n}\n@keyframes pptx-tr-strips-ru {\n\tfrom { clip-path: polygon(100% 0%, 100% 0%, 100% 0%); }\n\tto   { clip-path: polygon(0% 0%, 100% 0%, 100% 100%, 0% 100%); }\n}\n@keyframes pptx-tr-strips-rd {\n\tfrom { clip-path: polygon(100% 100%, 100% 100%, 100% 100%); }\n\tto   { clip-path: polygon(0% 0%, 100% 0%, 100% 100%, 0% 100%); }\n}\n\n/* RandomBar */\n@keyframes pptx-tr-randombar-h {\n\tfrom { opacity: 0; clip-path: inset(0 0 100% 0); }\n\tto   { opacity: 1; clip-path: inset(0); }\n}\n@keyframes pptx-tr-randombar-v {\n\tfrom { opacity: 0; clip-path: inset(0 100% 0 0); }\n\tto   { opacity: 1; clip-path: inset(0); }\n}\n\n/* Newsflash */\n@keyframes pptx-tr-newsflash-in {\n\tfrom { transform: rotate(720deg) scale(0); opacity: 0; }\n\tto   { transform: rotate(0deg) scale(1); opacity: 1; }\n}\n\n/* Wheel */\n@keyframes pptx-tr-wheel-in {\n\tfrom { clip-path: circle(0% at 50% 50%); transform: rotate(-180deg); }\n\tto   { clip-path: circle(75% at 50% 50%); transform: rotate(0deg); }\n}\n";
+/**
+ * Return CSS animation descriptors for the outgoing (old) and incoming (new)
+ * slide layers based on the transition type, duration, and direction.
+ *
+ * Mirrors the React `getSlideTransitionAnimations` resolver one-for-one.
+ */
+declare function getSlideTransitionAnimations(type: PptxTransitionType, durationMs: number, direction: string | undefined, orient?: string | undefined, spokes?: number | undefined): SlideTransitionAnimations;
+
+/**
+ * PresentationTransitionOverlayComponent — plays a PowerPoint slide transition
+ * over the presentation stage.
+ *
+ * Renders the *outgoing* (previous) slide as an absolutely-positioned layer
+ * with the resolved CSS exit animation; the *incoming* slide is rendered by the
+ * underlying stage (the existing `pptx-presentation-overlay`). The `outgoingOnTop`
+ * descriptor controls whether the outgoing layer sits above or below the stage,
+ * letting cover/uncover/push read correctly. Fires `complete` once the animation
+ * finishes so the orchestrator can tear the overlay down.
+ *
+ * Selector: `pptx-presentation-transition-overlay`
+ *
+ * Inputs:
+ *   - `outgoingSlide`    (required) — the leaving slide to animate
+ *   - `canvasSize`       (required) — logical slide dimensions (px)
+ *   - `transition`       (required) — the transition definition (from the slide)
+ *   - `templateElements` — master/layout elements behind the outgoing slide
+ *   - `mediaDataUrls`    — data-URL map for media assets
+ *   - `durationMs`       — explicit override; otherwise derived from `transition`
+ *
+ * Outputs:
+ *   - `complete` — emits void when the transition animation completes
+ *
+ * Designed to compose with `PresentationOverlayComponent` WITHOUT editing it:
+ * the orchestrator stacks this overlay on top of the stage while a transition
+ * is in flight and removes it on `complete`.
+ */
+declare class PresentationTransitionOverlayComponent {
+    readonly outgoingSlide: _angular_core.InputSignal<PptxSlide>;
+    readonly canvasSize: _angular_core.InputSignal<CanvasSize>;
+    readonly transition: _angular_core.InputSignal<PptxSlideTransition>;
+    readonly templateElements: _angular_core.InputSignal<readonly PptxElement[]>;
+    readonly mediaDataUrls: _angular_core.InputSignal<Map<string, string>>;
+    /** Explicit duration override (ms). When omitted, derived from `transition`. */
+    readonly durationMs: _angular_core.InputSignal<number | undefined>;
+    readonly complete: _angular_core.OutputEmitterRef<void>;
+    private readonly destroyRef;
+    /** Active completion timer handle, so re-running re-arms cleanly. */
+    private completeTimer;
+    /** Active transition-sound element, paused on teardown. */
+    private audio;
+    /** Whether `complete` has already fired for the current run. */
+    private fired;
+    constructor();
+    /** Effective transition duration (ms), floored/defaulted. */
+    protected readonly resolvedDurationMs: _angular_core.Signal<number>;
+    /** Resolved CSS animation descriptors for the outgoing/incoming layers. */
+    protected readonly animations: _angular_core.Signal<SlideTransitionAnimations>;
+    /** The slide rendered in the animated layer (outgoing + its template). */
+    protected readonly layerSlide: _angular_core.Signal<PptxSlide>;
+    /** Layer container style — animation + stacking relative to the stage. */
+    protected readonly layerStyle: _angular_core.Signal<StyleMap>;
+    /** Fixed-size slide box (the SlideCanvas auto-fits within it). */
+    protected readonly slideBoxStyle: _angular_core.Signal<StyleMap>;
+    private armCompletion;
+    private clearTimer;
+    private playSound;
+    private stopSound;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PresentationTransitionOverlayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PresentationTransitionOverlayComponent, "pptx-presentation-transition-overlay", never, { "outgoingSlide": { "alias": "outgoingSlide"; "required": true; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "transition": { "alias": "transition"; "required": true; "isSignal": true; }; "templateElements": { "alias": "templateElements"; "required": false; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "durationMs": { "alias": "durationMs"; "required": false; "isSignal": true; }; }, { "complete": "complete"; }, never, never, true, never>;
+}
+
+/**
+ * PresenterViewComponent — split-screen presenter layout with the current
+ * slide, a next-slide preview, speaker notes (rich or plain), a live clock +
+ * elapsed timer, font-size controls, and navigation controls.
+ *
+ * Angular port of the React `PresenterView.tsx`. Keyboard navigation is owned
+ * by the orchestrator (mirroring React, where `usePresentationKeyboard` handles
+ * keys) — this component registers no document keydown listener. Slide previews
+ * reuse `pptx-slide-canvas` (the master/layout elements are prepended to each
+ * slide's own elements, like the React `templateElements` merge).
+ *
+ * Selector: `pptx-presenter-view`
+ *
+ * Inputs:
+ *   - `slides`                (required) — all slides in the deck
+ *   - `currentSlideIndex`     (required) — zero-based active slide index
+ *   - `canvasSize`            (required) — logical slide dimensions (px)
+ *   - `templateElements`      — master/layout elements behind every slide
+ *   - `mediaDataUrls`         — data-URL map for media assets
+ *   - `presentationStartTime` — epoch ms when the presentation began (or null)
+ *   - `isAudienceWindowOpen`  — whether a separate audience window is open
+ *
+ * Outputs:
+ *   - `movePresentationSlide` — emits +1 / -1 to step the active slide
+ *   - `exit`                  — emits void to end the presentation
+ *   - `openAudienceWindow`    — request opening the audience display window
+ *   - `closeAudienceWindow`   — request closing the audience display window
+ */
+declare class PresenterViewComponent {
+    protected readonly NOTES_FONT_SIZE_MIN = 10;
+    protected readonly NOTES_FONT_SIZE_MAX = 32;
+    readonly slides: _angular_core.InputSignal<PptxSlide[]>;
+    readonly currentSlideIndex: _angular_core.InputSignal<number>;
+    readonly canvasSize: _angular_core.InputSignal<CanvasSize>;
+    readonly templateElements: _angular_core.InputSignal<readonly PptxElement[]>;
+    readonly mediaDataUrls: _angular_core.InputSignal<Map<string, string>>;
+    readonly presentationStartTime: _angular_core.InputSignal<number | null>;
+    readonly isAudienceWindowOpen: _angular_core.InputSignal<boolean>;
+    readonly movePresentationSlide: _angular_core.OutputEmitterRef<1 | -1>;
+    readonly exit: _angular_core.OutputEmitterRef<void>;
+    readonly openAudienceWindow: _angular_core.OutputEmitterRef<void>;
+    readonly closeAudienceWindow: _angular_core.OutputEmitterRef<void>;
+    /** Live wall-clock (epoch ms), advanced once per second. */
+    private readonly now;
+    /** Speaker-notes font size (px), clamped to the allowed range. */
+    protected readonly notesFontSize: _angular_core.WritableSignal<number>;
+    constructor();
+    protected readonly currentSlide: _angular_core.Signal<PptxSlide | undefined>;
+    protected readonly nextSlide: _angular_core.Signal<PptxSlide | undefined>;
+    /** Current slide with master/layout elements prepended for preview. */
+    protected readonly currentPreviewSlide: _angular_core.Signal<PptxSlide | undefined>;
+    /** Next slide with master/layout elements prepended for preview. */
+    protected readonly nextPreviewSlide: _angular_core.Signal<PptxSlide | undefined>;
+    protected readonly notes: _angular_core.Signal<pptx_angular_viewer.PresenterNotes>;
+    protected readonly clockLabel: _angular_core.Signal<string>;
+    protected readonly elapsedMs: _angular_core.Signal<number>;
+    protected readonly elapsedLabel: _angular_core.Signal<string>;
+    private readonly timerProgress;
+    protected readonly timerPercent: _angular_core.Signal<number>;
+    protected readonly progressValue: _angular_core.Signal<number>;
+    protected readonly slideBadge: _angular_core.Signal<string>;
+    protected readonly counterLabel: _angular_core.Signal<string>;
+    protected readonly notesBodyStyle: _angular_core.Signal<StyleMap>;
+    protected increaseNotesFontSize(): void;
+    protected decreaseNotesFontSize(): void;
+    protected onToggleAudienceWindow(): void;
+    private withTemplate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PresenterViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PresenterViewComponent, "pptx-presenter-view", never, { "slides": { "alias": "slides"; "required": true; "isSignal": true; }; "currentSlideIndex": { "alias": "currentSlideIndex"; "required": true; "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; }; "isAudienceWindowOpen": { "alias": "isAudienceWindowOpen"; "required": false; "isSignal": true; }; }, { "movePresentationSlide": "movePresentationSlide"; "exit": "exit"; "openAudienceWindow": "openAudienceWindow"; "closeAudienceWindow": "closeAudienceWindow"; }, never, never, true, never>;
+}
+
+/**
+ * presenter-view-helpers.ts
+ *
+ * Pure (framework-free) helpers for `PresenterViewComponent` — time/elapsed
+ * formatting, notes font-size clamping, rich-notes segment → view-model
+ * derivation, and current/next-slide selection.
+ *
+ * Angular port of the React `components/presenter-view-utils.ts`. The React
+ * `renderNotesSegments` produced React nodes; here we instead derive a plain
+ * `NotesSegmentViewModel[]` (text + style + break flag) so the logic stays
+ * testable without a renderer and the component template owns the markup.
+ *
+ * Kept TestBed-free (vitest + happy-dom). ng-packagr lib-target constraints:
+ * no `String.prototype.replaceAll`, no regex named-capture-groups.
+ */
+
+/**
+ * Clamp a notes font size value to the allowed range.
+ */
+declare function clampNotesFontSize(size: number): number;
+/**
+ * Format a Date as a locale time string (HH:MM:SS).
+ */
+declare function formatTime(date: Date): string;
+/**
+ * Format a millisecond duration as MM:SS, or HH:MM:SS when the elapsed
+ * time is one hour or longer. Sub-second values are floored; negative inputs
+ * are treated as zero.
+ */
+declare function formatElapsed(elapsedMs: number): string;
+interface TimerProgress {
+    /** Fill percentage of the current segment, clamped to [0, 100]. */
+    percent: number;
+    /** Zero-based index of the current 5-minute segment. */
+    segment: number;
+}
+/**
+ * Derive the timer progress-bar fill (percent within the current 5-minute
+ * segment) and the segment index from an elapsed duration. Mirrors the React
+ * PresenterView `timerProgress` / `timerSegment` computation.
+ */
+declare function computeTimerProgress(elapsedMs: number): TimerProgress;
+/** A single rendered notes token for the presenter notes pane. */
+interface NotesSegmentViewModel {
+    /** Stable key for `@for` tracking. */
+    key: string;
+    /** True when this token is a paragraph break (rendered as a line break). */
+    isBreak: boolean;
+    /** Plain text to render (empty for breaks). */
+    text: string;
+    /** Inline style derived from the segment's text style. */
+    style: StyleMap;
+}
+interface PresenterNotes {
+    /** True when rich-text segments are available and non-empty. */
+    hasRichNotes: boolean;
+    /** Derived rich-text view-model tokens (empty when no rich notes). */
+    segments: NotesSegmentViewModel[];
+    /** Plain notes text (used when no rich segments are present). */
+    plainText: string;
+    /** True when there is any displayable notes content (rich or plain). */
+    hasAnyNotes: boolean;
+}
+/**
+ * Resolve the presenter notes for a slide: prefer rich `notesSegments`, else
+ * fall back to the plain `notes` string. Mirrors the React PresenterView's
+ * `hasRichNotes` / `notesText` branching.
+ */
+declare function resolvePresenterNotes(slide: PptxSlide | undefined): PresenterNotes;
+
 /**
  * Shape-geometry clip-path helper.
  *
@@ -2427,5 +4006,5 @@ declare function themeStyle(theme: ViewerTheme | undefined): Record<string, stri
 type ClassValue = string | number | false | null | undefined;
 declare function cn(...values: ClassValue[]): string;
 
-export { ChartRendererComponent, ConnectorRendererComponent, DEFAULT_CANVAS_HEIGHT, DEFAULT_CANVAS_WIDTH, DEFAULT_FILL_COLOR, DEFAULT_SLIDE_BACKGROUND, DEFAULT_STROKE_COLOR, DEFAULT_TEXT_COLOR, EditorContextMenuComponent, EditorHistory, EditorStateService, EditorToolbarComponent, ElementRendererComponent, EquationRendererComponent, ExportService, FindBarComponent, InkRendererComponent, InspectorPanelComponent, LoadContentService, Model3DRendererComponent, OleRendererComponent, PowerPointViewerComponent, PresentationOverlayComponent, RESIZE_HANDLES, SlideCanvasComponent, SlideSorterOverlayComponent, SlidesPanelComponent, SmartArtRendererComponent, TableRendererComponent, VIEWER_THEME, ZoomRendererComponent, applyMove, applyResize, bringForward, bringToFront, buildCssGradientFromShapeStyle, buildPatternFillCss, bulletIndentPx, cn, collectElementText, collectSlideText, convertOmmlToMathMl, defaultCssVars, defaultRadius, defaultThemeColors, deleteElementsByIds, duplicateElementById, formatAutoNumber, getContainerStyle, getImageSrc, getPatternSvg, getResolvedShapeClipPath, getResolvedShapeClipPathFor, getShapeFillStrokeStyle, getSlideBackgroundStyle, getTextBlockStyle, isPpactionUrl, isUrlSafe, moveElementBy, ommlToMathml, provideViewerTheme, renderToCanvas, resizeElement, resolveHyperlinkHref, resolveParagraphBullet, searchSlides, sendBackward, sendToBack, setElementPosition, themeStyle, themeToCssVars, updateElementById };
-export type { Box, CanvasSize, ClassValue, CollaborationConfig, CollaborationRole, ResizeHandle, StyleMap, ViewerTheme, ViewerThemeColors };
+export { AccessibilityPanelComponent, AccessibilityService, AnimationPanelComponent, AnimationPlaybackService, BroadcastDialogComponent, CURSOR_PALETTE, ChartRendererComponent, CollaborationCursorsComponent, CollaborationService, CommentsPanelComponent, CommentsService, ConnectorRendererComponent, 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, ElementRendererComponent, EmbeddedFontsService, EquationRendererComponent, ExportService, FindBarComponent, 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, TableRendererComponent, VIEWER_THEME, ZoomRendererComponent, addCommentToList, advanceStep, applyMove, applyResize, assignUserColor, bringForward, bringToFront, buildBroadcastConfig, buildBroadcastViewerUrl, buildClearHyperlinkPatch, buildClickGroups, buildCollaborationConfig, buildCssGradientFromShapeStyle, buildEmbeddedFontStyles, buildFontFaceRule, buildHyperlinkPatch, buildPatternFillCss, buildPrintDocument, buildPropertiesPatch, buildShareUrl, bulletIndentPx, canStartBroadcast, canStartShare, canUseClipboard, clampCursorPosition, clampNotesFontSize, clampStep, cn, collectAccessibilityIssues, collectElementText, collectSlideText, computeHandoutLayout, computePageCount, computeSlideIndices, computeTimerProgress, convertOmmlToMathMl, countAccessibilityIssues, defaultCssVars, defaultRadius, defaultThemeColors, deleteElementsByIds, derivePresenceList, duplicateElementById, durationOf, estimatePageCount, fontMimeForFormat, formatAutoNumber, formatCursorLabel, formatElapsed, formatPropertyDate, formatTime, generateBroadcastRoomId, generateCommentId, getContainerStyle, getImageSrc, getPatternSvg, getResolvedShapeClipPath, getResolvedShapeClipPathFor, getShapeFillStrokeStyle, getSlideBackgroundStyle, getSlideTransitionAnimations, getTextBlockStyle, groupIssuesBySeverity, hasExistingLink, headerLabel, isInjectableUrl, isPpactionUrl, isSigned, isUrlSafe, isValidRoomId, issueTrackKey, issueTypeLabel, moveElementBy, normalizeFontFormat, normalizeSlidesPerPage, ommlToMathml, overallStatus, pendingElementStyles, presenceToCursors, provideViewerTheme, removeCommentFromList, renderToCanvas, resizeElement, resolveFontVariant, resolveHyperlinkHref, resolveParagraphBullet, resolvePresenterNotes, resolveTransitionDuration, revealedElementStyles, sanitizeColor, sanitizeSlideIndex, sanitizeUserName, searchSlides, seedBroadcastFields, seedHyperlinkDraft, seedPropertiesDraft, seedShareFields, sendBackward, sendToBack, setElementPosition, signatureCountLabel, signatureKey, signatureTimestamp, signerName, statusKind, statusLabel, themeStyle, themeToCssVars, toggleCommentResolvedInList, updateElementById, validatePrintSettings, validateRoomId, worstStatus };
+export type { AccessibilityIssueGroup, AnimationClickGroup, Box, BroadcastConfig, BroadcastDefaults, CSSProperties, CanvasSize, ClassValue, CollaborationConfig, CollaborationRole, DocumentProperties, EmbeddedFontStyles, HandoutSlidesPerPage, HyperlinkDraft, NotesSegmentViewModel, ObjectUrlFactory, OverallSignatureStatus, PresenterNotes, PrintColorMode, PrintDocumentOptions, PrintOrientation, PrintSettings, PrintSlideRange, PrintWhat, PropertiesDraft, RemoteCursor, RemotePresence, ResizeHandle, ResolvedFontVariant, ShareDefaults, ShareFormFields, SignatureStatusKind, SlideTransitionAnimations, StyleMap, TimerProgress, ViewerTheme, ViewerThemeColors };