pptx-vanilla-viewer 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { n, o, m, l, P, d, e, X, p, q, r, s, t, u, v, w, x, y, z, A, B, D, E, F, G, H, J, K, L, h, i, k, j, f, g } from './presentation-CLc4eS3z.js';
-export { P as PptxElement, l as PptxSlide } from './presentation-CLc4eS3z.js';
+import { n, o, m, P, a, e, f, X, p, q, r, s, t, u, v, w, x, y, z, A, B, D, E, F, G, H, J, K, L, i, j, l, k, g, h } from './presentation-BfnrtJV1.js';
+export { a as PptxElement, P as PptxSlide } from './presentation-BfnrtJV1.js';
 import { ViewerTheme } from './theme/index.js';
 export { ViewerTheme, ViewerThemeColors, defaultCssVars, defaultRadius, defaultThemeColors, themeToCssVars, vermilionDarkTheme, vermilionLightTheme } from './theme/index.js';
 export { TranslationKey, keyToLabel, translationsEn } from 'pptx-viewer-shared/i18n';
@@ -36,9 +36,9 @@ interface PptxThemePreset {
     /** Human-readable display name. */
     name: string;
     /** The 12-colour scheme. */
-    colorScheme: d;
+    colorScheme: e;
     /** Heading and body font families. */
-    fontScheme: e;
+    fontScheme: f;
 }
 
 /**
@@ -89,7 +89,7 @@ type FillInput = {
 interface StrokeInput {
     color?: string;
     width?: number;
-    dash?: h;
+    dash?: i;
     opacity?: number;
     join?: 'round' | 'bevel' | 'miter';
     cap?: 'flat' | 'rnd' | 'sq';
@@ -194,8 +194,8 @@ interface ChartOptions extends Partial<ElementPosition> {
 interface ConnectorOptions extends Partial<ElementPosition> {
     type?: 'straight' | 'bent' | 'curved';
     stroke?: StrokeInput;
-    startArrow?: i;
-    endArrow?: i;
+    startArrow?: j;
+    endArrow?: j;
     from?: {
         elementId: string;
         site: number;
@@ -230,14 +230,14 @@ type BackgroundInput = {
     source: string;
 };
 interface TransitionInput {
-    type: j;
+    type: k;
     duration?: number;
     direction?: string;
     advanceAfterMs?: number;
 }
 interface AnimationInput {
-    preset: f;
-    trigger?: g;
+    preset: g;
+    trigger?: h;
     duration?: number;
     delay?: number;
 }
@@ -321,13 +321,13 @@ declare class SlideBuilder {
     /** Add a table to the slide. */
     addTable(input: TableInput, options?: TableOptions): this;
     /** Add a chart to the slide. */
-    addChart(chartType: k, input: ChartInput, options?: ChartOptions): this;
+    addChart(chartType: l, input: ChartInput, options?: ChartOptions): this;
     /** Add a media element (video or audio) to the slide. */
     addMedia(mediaType: 'video' | 'audio', source: string, options?: MediaOptions): this;
     /** Add a group of elements to the slide. */
-    addGroup(children: P[], options?: GroupOptions): this;
+    addGroup(children: a[], options?: GroupOptions): this;
     /** Add a pre-built element directly. */
-    addElement(element: P): this;
+    addElement(element: a): this;
     /** Set slide background. */
     setBackground(bg: BackgroundInput): this;
     /** Set slide transition. */
@@ -376,7 +376,7 @@ declare class SlideBuilder {
      * ```
      */
     addBuilderElement(builder: {
-        build(): P;
+        build(): a;
     }): this;
     /**
      * Remove an element by its ID.
@@ -410,7 +410,7 @@ declare class SlideBuilder {
      * console.log(builder.getElements().length); // 1
      * ```
      */
-    getElements(): readonly P[];
+    getElements(): readonly a[];
     /**
      * Get the number of elements on this slide.
      *
@@ -440,7 +440,7 @@ declare class SlideBuilder {
      * }
      * ```
      */
-    getLastElement(): P | undefined;
+    getLastElement(): a | undefined;
     /**
      * Set the slide name/title for organizational purposes.
      *
@@ -460,7 +460,7 @@ declare class SlideBuilder {
      */
     setName(name: string): this;
     /** Return the built {@link PptxSlide}. */
-    build(): l;
+    build(): P;
 }
 
 /**
@@ -545,7 +545,7 @@ declare class PptxSlideBuilder {
      * @param slideValue - The slide data.
      * @param rootBuilder - The parent builder.
      */
-    constructor(slideValue: l, rootBuilder: PptxXmlBuilder);
+    constructor(slideValue: P, rootBuilder: PptxXmlBuilder);
     /** Navigate to the slide's notes builder (getter). */
     get Notes(): PptxSlideNotesBuilder;
     /** Navigate to the slide's notes builder. */
@@ -553,9 +553,9 @@ declare class PptxSlideBuilder {
     /** Navigate to the slide's elements builder. */
     elements(): PptxSlideElementsBuilder;
     /** Return the underlying slide data. */
-    project(): l;
+    project(): P;
     /** Pascal-case alias for {@link project}. */
-    Project(): l;
+    Project(): P;
     /** Navigate back to the root builder. */
     done(): PptxXmlBuilder;
     /** Pascal-case alias for {@link done}. */
@@ -572,13 +572,13 @@ declare class PptxSlideElementsBuilder {
      * @param slideValue - The slide whose elements are being modified.
      * @param slideBuilder - The parent slide builder for chaining.
      */
-    constructor(slideValue: l, slideBuilder: PptxSlideBuilder);
+    constructor(slideValue: P, slideBuilder: PptxSlideBuilder);
     /**
      * Append an element to the slide's element list.
      * @param element - The element to add.
      * @returns This builder for chaining.
      */
-    add(element: P): this;
+    add(element: a): this;
     /**
      * Remove an element from the slide by its ID.
      * @param elementId - The ID of the element to remove.
@@ -591,9 +591,9 @@ declare class PptxSlideElementsBuilder {
      * @param updater - A function that receives the current element and returns the replacement.
      * @returns This builder for chaining.
      */
-    updateById(elementId: string, updater: (current: P) => P): this;
+    updateById(elementId: string, updater: (current: a) => a): this;
     /** Return the current elements array. */
-    project(): P[];
+    project(): a[];
     /** Navigate back to the slide builder. */
     done(): PptxSlideBuilder;
 }
@@ -608,7 +608,7 @@ declare class PptxSlideNotesBuilder {
      * @param slideValue - The slide whose notes are being modified.
      * @param slideBuilder - The parent slide builder for chaining.
      */
-    constructor(slideValue: l, slideBuilder: PptxSlideBuilder);
+    constructor(slideValue: P, slideBuilder: PptxSlideBuilder);
     /**
      * Append text to existing notes (separated by newline).
      * @param text - The text to append.
@@ -757,10 +757,10 @@ interface IPptxHandlerRuntime {
     setTemplateBackground(path: string, backgroundColor: string | undefined): void;
     setPresentationTheme(themePath: string, applyToAllMasters?: boolean): Promise<void>;
     getTemplateBackgroundColor(path: string): string | undefined;
-    updateThemeColorScheme(colorScheme: d): Promise<void>;
-    updateThemeFontScheme(fontScheme: e): Promise<void>;
+    updateThemeColorScheme(colorScheme: e): Promise<void>;
+    updateThemeFontScheme(fontScheme: f): Promise<void>;
     updateThemeName(name: string): Promise<void>;
-    applyTheme(colorScheme: d, fontScheme: e, themeName?: string): Promise<void>;
+    applyTheme(colorScheme: e, fontScheme: f, themeName?: string): Promise<void>;
     load(data: ArrayBuffer, options?: PptxHandlerLoadOptions): Promise<m>;
     getChartDataForGraphicFrame(slidePath: string, graphicFrame: X | undefined): Promise<p | undefined>;
     getSmartArtDataForGraphicFrame(slidePath: string, graphicFrame: X | undefined): Promise<q | undefined>;
@@ -770,8 +770,8 @@ interface IPptxHandlerRuntime {
      * Returns undefined if the file is not found.
      */
     getMediaArrayBuffer(mediaPath: string): Promise<ArrayBuffer | undefined>;
-    save(slides: l[], options?: PptxHandlerSaveOptions): Promise<Uint8Array>;
-    exportSlides(slides: l[], options: L): Promise<Map<number, Uint8Array>>;
+    save(slides: P[], options?: PptxHandlerSaveOptions): Promise<Uint8Array>;
+    exportSlides(slides: P[], options: L): Promise<Map<number, Uint8Array>>;
     /**
      * Get the available slide layouts for a specific slide, based on the
      * slide's master. Scans the slide master's relationships to find all
@@ -781,7 +781,7 @@ interface IPptxHandlerRuntime {
      * @param slides - Current slides array.
      * @returns Array of layout options belonging to the same slide master.
      */
-    getAvailableLayoutsForSlide(slideIndex: number, slides: l[]): Promise<o[]>;
+    getAvailableLayoutsForSlide(slideIndex: number, slides: P[]): Promise<o[]>;
     /**
      * Resolve the editable template (master + layout) elements a slide
      * inherits, each carrying a `master-` / `layout-` prefixed id. Excludes
@@ -789,7 +789,7 @@ interface IPptxHandlerRuntime {
      *
      * @param slideId - The slide's archive path (`PptxSlide.id`).
      */
-    getTemplateElementsForSlide(slideId: string): Promise<P[]>;
+    getTemplateElementsForSlide(slideId: string): Promise<a[]>;
     /**
      * Scan the loaded PPTX archive for all theme parts.
      */
@@ -808,7 +808,7 @@ interface IPptxHandlerRuntime {
      * @param slides - Current slides array.
      * @returns The updated slide with new layout path, name, and background.
      */
-    applyLayoutToSlide(slideIndex: number, layoutPath: string, slides: l[]): Promise<l>;
+    applyLayoutToSlide(slideIndex: number, layoutPath: string, slides: P[]): Promise<P>;
 }
 
 /**
@@ -997,7 +997,7 @@ declare class PptxHandlerCore {
      * // => void — colour scheme updated in the in-memory theme XML
      * ```
      */
-    updateThemeColorScheme(colorScheme: d): Promise<void>;
+    updateThemeColorScheme(colorScheme: e): Promise<void>;
     /**
      * Update the theme’s font scheme (heading + body typefaces).
      *
@@ -1012,7 +1012,7 @@ declare class PptxHandlerCore {
      * // => void — font scheme updated in the in-memory theme XML
      * ```
      */
-    updateThemeFontScheme(fontScheme: e): Promise<void>;
+    updateThemeFontScheme(fontScheme: f): Promise<void>;
     /**
      * Rename the presentation theme.
      *
@@ -1039,7 +1039,7 @@ declare class PptxHandlerCore {
      * // => void — colour scheme, font scheme, and name applied atomically
      * ```
      */
-    applyTheme(colorScheme: d, fontScheme: e, themeName?: string): Promise<void>;
+    applyTheme(colorScheme: e, fontScheme: f, themeName?: string): Promise<void>;
     /**
      * Switch the presentation's theme, updating both the underlying XML and
      * re-resolving all element colours in-place.
@@ -1070,7 +1070,7 @@ declare class PptxHandlerCore {
      * // => PptxData with all colours updated to the Ion theme
      * ```
      */
-    switchTheme(data: m, colorScheme: d, fontScheme?: e, themeName?: string): Promise<m>;
+    switchTheme(data: m, colorScheme: e, fontScheme?: f, themeName?: string): Promise<m>;
     /**
      * Apply a built-in theme preset to the presentation.
      *
@@ -1155,7 +1155,7 @@ declare class PptxHandlerCore {
      * // => Uint8Array written to disk as a valid .pptx file
      * ```
      */
-    save(slides: l[], options?: PptxHandlerSaveOptions): Promise<Uint8Array>;
+    save(slides: P[], options?: PptxHandlerSaveOptions): Promise<Uint8Array>;
     /**
      * Serialise slides and then encrypt the output with a password.
      *
@@ -1175,7 +1175,7 @@ declare class PptxHandlerCore {
      * // => Encrypted OLE2 file requiring password to open
      * ```
      */
-    saveEncrypted(slides: l[], password: string, options?: PptxHandlerSaveOptions & {
+    saveEncrypted(slides: P[], password: string, options?: PptxHandlerSaveOptions & {
         encryption?: EncryptionOptions;
     }): Promise<Uint8Array>;
     /**
@@ -1196,7 +1196,7 @@ declare class PptxHandlerCore {
      * // => ["Title Slide", "Title and Content", "Blank", ...]
      * ```
      */
-    getAvailableLayoutsForSlide(slideIndex: number, slides: l[]): Promise<o[]>;
+    getAvailableLayoutsForSlide(slideIndex: number, slides: P[]): Promise<o[]>;
     /**
      * Resolve the editable template (master + layout) elements a slide
      * inherits, each carrying a `master-` / `layout-` prefixed id.
@@ -1227,7 +1227,7 @@ declare class PptxHandlerCore {
      * }
      * ```
      */
-    getTemplateElementsForSlide(slideId: string): Promise<P[]>;
+    getTemplateElementsForSlide(slideId: string): Promise<a[]>;
     /**
      * Apply a different layout to an existing slide.
      *
@@ -1253,7 +1253,7 @@ declare class PptxHandlerCore {
      * // => "Two Content"
      * ```
      */
-    applyLayoutToSlide(slideIndex: number, layoutPath: string, slides: l[]): Promise<l>;
+    applyLayoutToSlide(slideIndex: number, layoutPath: string, slides: P[]): Promise<P>;
     /**
      * Scan the loaded PPTX archive for all theme parts (`ppt/theme/theme*.xml`)
      * and return their paths and display names.
@@ -1283,7 +1283,7 @@ declare class PptxHandlerCore {
      * // => Map<number, Uint8Array> — one standalone .pptx per exported slide
      * ```
      */
-    exportSlides(slides: l[], options: L): Promise<Map<number, Uint8Array>>;
+    exportSlides(slides: P[], options: L): Promise<Map<number, Uint8Array>>;
 }
 
 /**
@@ -1394,8 +1394,87 @@ type TranslationMessages = Record<string, Record<string, string>>;
  */
 declare function createTranslator(locale?: string, messages?: TranslationMessages): Translator;
 
+/** State the panel needs to reflect: the slide to read notes from, and whether edits are allowed. */
+interface NotesPanelUpdate {
+    slide: P | undefined;
+    editable: boolean;
+}
+interface NotesPanel {
+    el: HTMLElement;
+    /**
+     * Sync the panel to the given slide/editable state. The textarea's value is
+     * only reseeded when the slide id actually changes (never on every render),
+     * so an in-progress edit is never interrupted mid-typing.
+     */
+    update(update: NotesPanelUpdate): void;
+    /** Expand or collapse the notes body (header stays visible either way). */
+    setExpanded(expanded: boolean): void;
+}
+
+interface ThumbnailRail {
+    el: HTMLElement;
+    /** Rebuild the rail for a new slide list (uses `renderStage` per slide). */
+    render(slides: P[], canvasSize: CanvasSize, renderStage: (slide: P, scale: number) => HTMLElement): void;
+    /** Highlight the active slide and scroll it into view. */
+    setActive(index: number): void;
+    /** Show or hide the rail. */
+    setVisible(visible: boolean): void;
+}
+
+interface ToolbarUpdate {
+    /** Zero-based current slide index. */
+    current: number;
+    /** Total slide count. */
+    total: number;
+    /** Effective zoom percentage (100 = 1:1). */
+    zoomPercent: number;
+}
+/** Editing-cluster state (Save / Undo / Redo buttons). */
+interface ToolbarEditState {
+    /** Shows/hides the whole editing cluster. */
+    editable: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+}
+interface Toolbar {
+    el: HTMLElement;
+    update(state: ToolbarUpdate): void;
+    setEditState(state: ToolbarEditState): void;
+    /** Reflect the notes panel's expanded/collapsed state on the Notes button. */
+    setNotesExpanded(expanded: boolean): void;
+}
+
+/** The viewer's static DOM skeleton plus the mutable overlay controls. */
+interface ViewerChrome {
+    /** `.pptxv` root (focusable; keyboard navigation attaches here). */
+    root: HTMLElement;
+    toolbar: Toolbar | null;
+    thumbnails: ThumbnailRail | null;
+    /** Scrollable centring viewport around the stage. */
+    viewport: HTMLElement;
+    /** Box sized to `canvasSize * scale`; the rendered stage goes inside. */
+    stageWrap: HTMLElement;
+    /** Collapsible speaker-notes panel docked below the slide area. */
+    notes: NotesPanel;
+    setLoading(loading: boolean): void;
+    setError(message: string | null): void;
+    setEmpty(empty: boolean): void;
+    setPresenting(presenting: boolean): void;
+}
+
+interface PresentationController {
+    /** Enter presentation mode (real Fullscreen API on the target element). */
+    enter(): Promise<void>;
+    /** Exit presentation mode. */
+    exit(): Promise<void>;
+    /** True while the target is the fullscreen element. */
+    isActive(): boolean;
+    /** Remove listeners. */
+    dispose(): void;
+}
+
 /** Discriminant values of the {@link PptxElement} union (`'text'`, `'chart'`, ...). */
-type PptxElementType = P['type'];
+type PptxElementType = a['type'];
 /**
  * Everything an element renderer may need, passed to every renderer call.
  *
@@ -1407,7 +1486,7 @@ interface ElementRenderContext {
     /** Document used for all DOM creation. */
     readonly document: Document;
     /** The slide being rendered. */
-    readonly slide: l;
+    readonly slide: P;
     /** Full slide canvas size in CSS px (elements are positioned in this space). */
     readonly canvasSize: CanvasSize;
     /**
@@ -1420,13 +1499,25 @@ interface ElementRenderContext {
     readonly mediaDataUrls: ReadonlyMap<string, string>;
     /** Shared-dictionary translator (`pptx.*` keys). */
     readonly t: Translator;
+    /**
+     * Opt-in flag: render `smartArt` elements as an extruded Three.js scene
+     * instead of flat SVG (see `PptxViewerOptions.smartArt3D`). Defaults to
+     * `false` when the option is unset.
+     */
+    readonly smartArt3D: boolean;
+    /**
+     * True only for the live presentation stage (real Fullscreen API active):
+     * media renderers use this to autoplay once mounted, matching PowerPoint's
+     * slideshow behaviour. `false` for the editor canvas and thumbnail rail.
+     */
+    readonly presenting: boolean;
     /** The registry in effect, for renderers that need to inspect it. */
     readonly registry: ElementRendererRegistry;
     /**
      * Render a child element through the registry (used by the group renderer
      * for recursion; custom renderers may nest elements the same way).
      */
-    renderElement(element: P, zIndex: number): HTMLElement | SVGElement | null;
+    renderElement(element: a, zIndex: number): HTMLElement | SVGElement | null;
 }
 /**
  * Renders one slide element to a DOM node (or `null` to render nothing).
@@ -1439,7 +1530,7 @@ interface ElementRenderContext {
  * - Create all DOM via `context.document`.
  * - Never mutate `element` or anything on the context.
  */
-type ElementRenderer = (element: P, zIndex: number, context: ElementRenderContext) => HTMLElement | SVGElement | null;
+type ElementRenderer = (element: a, zIndex: number, context: ElementRenderContext) => HTMLElement | SVGElement | null;
 /**
  * Registry dispatching elements to renderers by their `type` discriminant.
  *
@@ -1487,13 +1578,25 @@ declare function createSvgEl<K extends keyof SVGElementTagNameMap>(doc: Document
 
 interface SlideStageOptions {
     document: Document;
-    slide: l;
+    slide: P;
     canvasSize: CanvasSize;
     mediaDataUrls: ReadonlyMap<string, string>;
     registry: ElementRendererRegistry;
     t: Translator;
     /** Scale applied via CSS transform (default 1). */
     scale?: number;
+    /** Opt-in WebGL SmartArt renderer flag; see `PptxViewerOptions.smartArt3D`. */
+    smartArt3D?: boolean;
+    /** True only for the live presentation stage; see `ElementRenderContext.presenting`. */
+    presenting?: boolean;
+    /**
+     * True only for the main (interactive) canvas, never the thumbnail rail.
+     * Marks every rendered element (recursively, including group children) with
+     * `data-pptx-element="true"` and the stage itself with
+     * `role="region" aria-roledescription="slide"` - the framework-neutral e2e
+     * test hooks the React/Vue/Angular bindings also emit. Defaults to `false`.
+     */
+    interactive?: boolean;
 }
 /**
  * Render one slide as a fixed-size stage: the resolved slide background plus
@@ -1517,6 +1620,25 @@ declare function renderSlideStage(options: SlideStageOptions): HTMLElement;
  */
 declare function createDefaultRegistry(): ElementRendererRegistry;
 
+/**
+ * A tiny framework-free reactive store: `get` / `set(patch)` / `subscribe`.
+ *
+ * This is deliberately minimal (a few dozen lines, no external deps). It only
+ * carries the vanilla binding's *view state*; all domain logic (parsing,
+ * styles, geometry, text building) stays in `pptx-viewer-core` and
+ * `pptx-viewer-shared`.
+ */
+/** Listener invoked after every state change with the next and previous state. */
+type StoreListener<T> = (state: T, previous: T) => void;
+interface Store<T extends object> {
+    /** Current state snapshot (do not mutate). */
+    get(): T;
+    /** Shallow-merge a partial patch into the state and notify subscribers. */
+    set(patch: Partial<T>): void;
+    /** Subscribe to state changes; returns an unsubscribe function. */
+    subscribe(listener: StoreListener<T>): () => void;
+}
+
 /** `zoom` is either an explicit scale factor (1 = 100%) or fit-to-viewport. */
 type ZoomLevel = number | 'fit';
 /**
@@ -1525,7 +1647,7 @@ type ZoomLevel = number | 'fit';
  */
 interface ViewerState {
     /** Parsed slides (image/media URLs already patched in by the load pipeline). */
-    slides: l[];
+    slides: P[];
     /** Slide canvas size in CSS pixels. */
     canvasSize: CanvasSize;
     /** Archive-path to displayable URL map for media + poster frames. */
@@ -1551,6 +1673,32 @@ interface ViewerState {
      * re-renders are deferred until the gesture ends.
      */
     interactionActive: boolean;
+    /**
+     * True when the speaker-notes panel body is expanded. Persists across slide
+     * navigation for the life of the viewer instance (in-memory only).
+     */
+    notesExpanded: boolean;
+}
+
+interface RenderController {
+    /** Re-render everything (used after a chrome rebuild). */
+    renderAll(): void;
+    /** Re-render the main stage + toolbar counters at the current state. */
+    renderStage(): void;
+    /** Rebuild the thumbnail rail from the current slide list. */
+    renderThumbnails(): void;
+    /** Resolve the requested zoom into a concrete scale factor. */
+    effectiveScale(): number;
+}
+
+/** Per-slide progress callback: `(currentSlideIndex, totalSlides)`. */
+type ExportProgress = (current: number, total: number) => void;
+/** Options for the multi-slide PDF export (progress + cooperative cancel). */
+interface ExportPdfOptions {
+    /** Capture-phase progress callback: `(currentSlide, totalSlides)`. */
+    onProgress?: ExportProgress;
+    /** Abort the export early; the loop checks this between slides. */
+    signal?: AbortSignal;
 }
 
 /**
@@ -1627,6 +1775,15 @@ interface PptxViewerOptions extends PptxViewerCallbacks {
      * override element renderers.
      */
     registry?: ElementRendererRegistry;
+    /**
+     * Opt-in WebGL SmartArt renderer (default `false`): renders `smartArt`
+     * elements as an extruded Three.js scene instead of the flat SVG layout.
+     * `three` is an optional peer dependency, lazily imported only when this is
+     * `true`; when it is unavailable or the scene fails to mount, the SVG
+     * renderer is used instead. Set once at construction (no runtime setter,
+     * mirroring the Vue/React/Angular bindings).
+     */
+    smartArt3D?: boolean;
 }
 /** The viewer handle returned by `createPptxViewer`. */
 interface PptxViewerInstance {
@@ -1675,6 +1832,17 @@ interface PptxViewerInstance {
     deleteSelected(): void;
     /** Id of the selected element, or `null`. */
     getSelectedElementId(): string | null;
+    /**
+     * Export a slide as a PNG download (defaults to the current slide). Renders
+     * the slide off-screen at scale 1 and rasterises it with `html2canvas-pro`
+     * (dynamically imported), so the first call pays a one-time load cost.
+     */
+    exportSlidePng(index?: number): Promise<void>;
+    /**
+     * Export every slide as a multi-page PDF download (one slide per page).
+     * `jspdf` is dynamically imported on first use.
+     */
+    exportPdf(options?: ExportPdfOptions): Promise<void>;
     /** The element-renderer registry in effect (extension point). */
     getRegistry(): ElementRendererRegistry;
     /**
@@ -1687,6 +1855,66 @@ interface PptxViewerInstance {
     destroy(): void;
 }
 
+/** The mutable pieces `PptxViewer` owns for one chrome mount lifecycle. */
+interface ChromeLifecycle {
+    chrome: ViewerChrome;
+    presentation: PresentationController;
+    detachKeyboard: () => void;
+    resizeObserver: ResizeObserver | null;
+    appliedThemeVars: string[];
+}
+/** The subset of `PptxViewer` needed to build its `MountChromeDeps`. */
+interface ChromeHost {
+    doc: Document;
+    container: HTMLElement;
+    t: Translator;
+    options: PptxViewerOptions;
+    store: Store<ViewerState>;
+    renderer: RenderController;
+    lifecycle: ChromeLifecycle;
+    editor: {
+        commitNotes(notes: string): void;
+    };
+    prev(): void;
+    next(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    zoomToFit(): void;
+    undo(): void;
+    redo(): void;
+    downloadPptx(): Promise<void>;
+    toggleNotes(): void;
+    goToSlide(index: number): void;
+    getSlideCount(): number;
+    enterPresentation(): Promise<void>;
+    exitPresentation(): Promise<void>;
+}
+
+interface EditorController {
+    /** (Re)wire listeners + overlay into the current chrome (after mount). */
+    attachChrome(): void;
+    detachChrome(): void;
+    /** Called by the render controller after every stage render. */
+    onStageRendered(): void;
+    /** True while editing owns the keyboard (selection or inline editing). */
+    capturesKeyboard(): boolean;
+    /** Drop history/selection/dirty state (new content loaded). */
+    reset(): void;
+    setEditable(editable: boolean): void;
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    deleteSelected(): void;
+    duplicateSelected(): string | null;
+    getSelectedElementId(): string | null;
+    /** Commit the speaker-notes textarea's plain text onto the current slide. */
+    commitNotes(notes: string): void;
+    save(): Promise<Uint8Array>;
+    downloadPptx(fileName?: string): Promise<void>;
+    destroy(): void;
+}
+
 /**
  * The zero-framework PowerPoint viewer. Construct via {@link createPptxViewer}
  * (or `new PptxViewer(container, options)`): builds its chrome inside
@@ -1694,30 +1922,22 @@ interface PptxViewerInstance {
  * tiny reactive store. All parsing lives in `pptx-viewer-core`; all pure
  * render logic in `pptx-viewer-shared`.
  */
-declare class PptxViewer implements PptxViewerInstance {
-    private readonly container;
-    private readonly doc;
-    private readonly options;
-    private readonly store;
+declare class PptxViewer implements PptxViewerInstance, ChromeHost {
+    readonly container: HTMLElement;
+    readonly doc: Document;
+    readonly options: PptxViewerOptions;
+    readonly store: Store<ViewerState>;
+    readonly renderer: RenderController;
+    t: Translator;
+    lifecycle: ChromeLifecycle;
+    editor: EditorController;
+    private readonly loading;
+    private readonly exportLifecycle;
     private readonly registry;
-    private readonly renderer;
-    private t;
-    private chrome;
-    private presentation;
-    private detachKeyboard;
-    private resizeObserver;
-    private handler;
-    private blobUrls;
-    private appliedThemeVars;
-    private loadToken;
     private destroyed;
-    private editor;
     constructor(container: HTMLElement, options?: PptxViewerOptions);
     loadFile(file: Blob | ArrayBuffer | Uint8Array): Promise<void>;
     loadUrl(url: string): Promise<void>;
-    private load;
-    /** Dispose the previous handler + Blob URLs (before replacing or on destroy). */
-    private releaseLoaded;
     next(): void;
     prev(): void;
     goToSlide(index: number): void;
@@ -1728,6 +1948,8 @@ declare class PptxViewer implements PptxViewerInstance {
     zoomIn(): void;
     zoomOut(): void;
     zoomToFit(): void;
+    /** Expand/collapse the speaker-notes panel; persists for the instance's life. */
+    toggleNotes(): void;
     setTheme(theme: ViewerTheme | undefined): void;
     setLocale(locale: string): void;
     setEditable(editable: boolean): void;
@@ -1738,14 +1960,15 @@ declare class PptxViewer implements PptxViewerInstance {
     save(): Promise<Uint8Array>;
     downloadPptx(fileName?: string): Promise<void>;
     deleteSelected(): void;
+    exportSlidePng(index?: number): Promise<void>;
+    exportPdf(options?: ExportPdfOptions): Promise<void>;
     getSelectedElementId(): string | null;
     enterPresentation(): Promise<void>;
     exitPresentation(): Promise<void>;
     getRegistry(): ElementRendererRegistry;
     getHandler(): PptxHandler | null;
     destroy(): void;
-    private mountChrome;
-    private unmountChrome;
+    private remountChrome;
 }
 /**
  * Create a PowerPoint viewer inside `container`.
@@ -1763,4 +1986,4 @@ declare function createPptxViewer(container: HTMLElement, options?: PptxViewerOp
 /** The complete viewer stylesheet text (for hosts that self-manage CSS). */
 declare function getViewerCss(): string;
 
-export { type CssStyleMap, type ElementRenderContext, type ElementRenderer, type ElementRendererRegistry, type PptxElementType, PptxHandler, PptxViewer, type PptxViewerCallbacks, type PptxViewerInstance, type PptxViewerOptions, type PptxViewerSource, type SlideStageOptions, type TranslationMessages, type Translator, type ViewerState, type ZoomLevel, applyStyleMap, createDefaultRegistry, createEl, createElementRendererRegistry, createPptxViewer, createSvgEl, createTranslator, getViewerCss, renderSlideStage };
+export { type CssStyleMap, type ElementRenderContext, type ElementRenderer, type ElementRendererRegistry, type ExportPdfOptions, type ExportProgress, type PptxElementType, PptxHandler, PptxViewer, type PptxViewerCallbacks, type PptxViewerInstance, type PptxViewerOptions, type PptxViewerSource, type SlideStageOptions, type TranslationMessages, type Translator, type ViewerState, type ZoomLevel, applyStyleMap, createDefaultRegistry, createEl, createElementRendererRegistry, createPptxViewer, createSvgEl, createTranslator, getViewerCss, renderSlideStage };