pptx-vanilla-viewer 0.5.1 → 0.6.0

package/dist/index.d.cts

@@ -1,2918 +0,0 @@
-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, a0, ca } 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';
-
-/**
- * Built-in theme presets modelled after common PowerPoint themes.
- *
- * Each preset provides:
- * - A display name
- * - A 12-colour scheme (dk1, dk2, lt1, lt2, accent1-6, hlink, folHlink)
- * - A font scheme (major/heading + minor/body font families)
- *
- * These presets can be passed directly to
- * {@link PptxHandlerCore.switchTheme} or the React `useThemeSwitching` hook
- * to apply a complete theme in one step.
- *
- * @module pptx-types/theme-presets
- */
-
-/**
- * A complete theme preset that can be applied to a presentation.
- *
- * @example
- * ```ts
- * import { THEME_PRESETS } from "pptx-viewer-core";
- *
- * const office = THEME_PRESETS.find(p => p.id === "office");
- * await handler.switchTheme(office.colorScheme, office.fontScheme, office.name);
- * ```
- */
-interface PptxThemePreset {
-    /** Unique identifier for the preset. */
-    id: string;
-    /** Human-readable display name. */
-    name: string;
-    /** The 12-colour scheme. */
-    colorScheme: e;
-    /** Heading and body font families. */
-    fontScheme: f;
-}
-
-/**
- * SDK input types for the headless PPTX builder API.
- *
- * These types provide a simplified, ergonomic interface for creating
- * presentation elements programmatically. Internal types (PptxElement,
- * ShapeStyle, TextStyle) are the canonical model; these types are
- * convenience wrappers that get mapped to the internal model by
- * the builder functions.
- *
- * @module sdk/types
- */
-
-/** Position and size in pixels. Converted to EMU internally when needed. */
-interface ElementPosition {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    rotation?: number;
-}
-type FillInput = {
-    type: 'solid';
-    color: string;
-    opacity?: number;
-} | {
-    type: 'gradient';
-    angle?: number;
-    gradientType?: 'linear' | 'radial';
-    stops: Array<{
-        color: string;
-        position: number;
-        opacity?: number;
-    }>;
-} | {
-    type: 'pattern';
-    preset: string;
-    foreground?: string;
-    background?: string;
-} | {
-    type: 'image';
-    url: string;
-    mode?: 'stretch' | 'tile';
-} | {
-    type: 'none';
-};
-interface StrokeInput {
-    color?: string;
-    width?: number;
-    dash?: i;
-    opacity?: number;
-    join?: 'round' | 'bevel' | 'miter';
-    cap?: 'flat' | 'rnd' | 'sq';
-}
-interface ShadowInput {
-    color?: string;
-    blur?: number;
-    offsetX?: number;
-    offsetY?: number;
-    opacity?: number;
-}
-interface TextStyleInput {
-    fontSize?: number;
-    fontFamily?: string;
-    bold?: boolean;
-    italic?: boolean;
-    underline?: boolean;
-    strikethrough?: boolean;
-    color?: string;
-    alignment?: 'left' | 'center' | 'right' | 'justify';
-    verticalAlignment?: 'top' | 'middle' | 'bottom';
-    lineSpacing?: number;
-    spaceBefore?: number;
-    spaceAfter?: number;
-}
-interface TextSegmentInput {
-    text: string;
-    style?: Partial<TextStyleInput>;
-}
-interface TextOptions extends Partial<ElementPosition> {
-    fontSize?: number;
-    fontFamily?: string;
-    bold?: boolean;
-    italic?: boolean;
-    underline?: boolean;
-    strikethrough?: boolean;
-    color?: string;
-    alignment?: 'left' | 'center' | 'right' | 'justify';
-    verticalAlignment?: 'top' | 'middle' | 'bottom';
-    lineSpacing?: number;
-    fill?: FillInput;
-    stroke?: StrokeInput;
-    shadow?: ShadowInput;
-    opacity?: number;
-}
-interface ShapeOptions extends Partial<ElementPosition> {
-    fill?: FillInput;
-    stroke?: StrokeInput;
-    text?: string;
-    textStyle?: Partial<TextStyleInput>;
-    adjustments?: Record<string, number>;
-    shadow?: ShadowInput;
-    opacity?: number;
-}
-interface ImageOptions extends Partial<ElementPosition> {
-    altText?: string;
-    cropLeft?: number;
-    cropTop?: number;
-    cropRight?: number;
-    cropBottom?: number;
-    opacity?: number;
-}
-interface TableInput {
-    rows: TableRowInput[];
-    columnWidths?: number[];
-    style?: string;
-    bandRows?: boolean;
-    bandColumns?: boolean;
-    firstRow?: boolean;
-    lastRow?: boolean;
-    firstCol?: boolean;
-    lastCol?: boolean;
-}
-interface TableRowInput {
-    cells: TableCellInput[];
-    height?: number;
-}
-interface TableCellInput {
-    text: string;
-    style?: Partial<TextStyleInput>;
-    fill?: FillInput;
-    gridSpan?: number;
-    rowSpan?: number;
-}
-interface TableOptions extends Partial<ElementPosition> {
-}
-interface ChartSeriesInput {
-    name: string;
-    values: number[];
-    color?: string;
-}
-interface ChartInput {
-    series: ChartSeriesInput[];
-    categories: string[];
-    title?: string;
-    hasLegend?: boolean;
-    legendPosition?: 't' | 'b' | 'l' | 'r' | 'tr';
-    grouping?: 'clustered' | 'stacked' | 'percentStacked';
-}
-interface ChartOptions extends Partial<ElementPosition> {
-}
-interface ConnectorOptions extends Partial<ElementPosition> {
-    type?: 'straight' | 'bent' | 'curved';
-    stroke?: StrokeInput;
-    startArrow?: j;
-    endArrow?: j;
-    from?: {
-        elementId: string;
-        site: number;
-    };
-    to?: {
-        elementId: string;
-        site: number;
-    };
-}
-interface MediaOptions extends Partial<ElementPosition> {
-    autoPlay?: boolean;
-    loop?: boolean;
-    volume?: number;
-    trimStartMs?: number;
-    trimEndMs?: number;
-    posterFrame?: string;
-}
-interface GroupOptions extends Partial<ElementPosition> {
-}
-type BackgroundInput = {
-    type: 'solid';
-    color: string;
-} | {
-    type: 'gradient';
-    angle?: number;
-    stops: Array<{
-        color: string;
-        position: number;
-    }>;
-} | {
-    type: 'image';
-    source: string;
-};
-interface TransitionInput {
-    type: k;
-    duration?: number;
-    direction?: string;
-    advanceAfterMs?: number;
-}
-interface AnimationInput {
-    preset: g;
-    trigger?: h;
-    duration?: number;
-    delay?: number;
-}
-interface PresentationOptions {
-    /** Slide width in EMU. Default: 12192000 (16:9 widescreen). */
-    width?: number;
-    /** Slide height in EMU. Default: 6858000 (16:9 widescreen). */
-    height?: number;
-    /** Theme configuration. */
-    theme?: PresentationThemeInput;
-    /** Presentation title (stored in docProps/core.xml). */
-    title?: string;
-    /** Presentation author. */
-    creator?: string;
-    /**
-     * Number of blank slides to include in the initial presentation.
-     * Default: 0 (no slides). Slides use the "Blank" layout.
-     */
-    initialSlideCount?: number;
-}
-interface PresentationThemeInput {
-    name?: string;
-    colors?: {
-        dk1?: string;
-        lt1?: string;
-        dk2?: string;
-        lt2?: string;
-        accent1?: string;
-        accent2?: string;
-        accent3?: string;
-        accent4?: string;
-        accent5?: string;
-        accent6?: string;
-        hlink?: string;
-        folHlink?: string;
-    };
-    fonts?: {
-        majorFont?: string;
-        minorFont?: string;
-    };
-}
-
-/**
- * Fluent builder for constructing slides with elements.
- *
- * Provides a chainable API for adding elements, setting slide properties,
- * and building a complete {@link PptxSlide}.
- *
- * @module sdk/SlideBuilder
- */
-
-/**
- * Fluent builder for a single slide.
- *
- * @example
- * ```ts
- * const slide = new SlideBuilder(1)
- *   .addText("Hello World", { fontSize: 36, bold: true, x: 100, y: 50 })
- *   .addShape("roundRect", { fill: { type: "solid", color: "#4472C4" } })
- *   .setNotes("Remember to mention key points")
- *   .setBackground({ type: "solid", color: "#F5F5F5" })
- *   .build();
- * ```
- */
-declare class SlideBuilder {
-    private readonly slide;
-    /**
-     * @param slideNumber - 1-based slide number.
-     * @param layoutPath - Optional layout archive path.
-     * @param layoutName - Optional layout display name.
-     */
-    constructor(slideNumber: number, layoutPath?: string, layoutName?: string);
-    /** Add a text box to the slide. */
-    addText(text: string | TextSegmentInput[], options?: TextOptions): this;
-    /** Add a shape to the slide. */
-    addShape(shapeType: string, options?: ShapeOptions): this;
-    /** Add a connector (line) to the slide. */
-    addConnector(options?: ConnectorOptions): this;
-    /** Add an image to the slide. */
-    addImage(source: string, options?: ImageOptions): this;
-    /** Add a table to the slide. */
-    addTable(input: TableInput, options?: TableOptions): this;
-    /** Add a chart to the slide. */
-    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: a[], options?: GroupOptions): this;
-    /** Add a pre-built element directly. */
-    addElement(element: a): this;
-    /** Set slide background. */
-    setBackground(bg: BackgroundInput): this;
-    /** Set slide transition. */
-    setTransition(input: TransitionInput): this;
-    /** Add an animation to an element on this slide. */
-    addAnimation(elementId: string, input: AnimationInput): this;
-    /** Set speaker notes. */
-    setNotes(text: string): this;
-    /** Mark the slide as hidden. */
-    setHidden(hidden: boolean): this;
-    /** Assign the slide to a section. */
-    setSection(name: string, id?: string): this;
-    /**
-     * Add a freeform shape from SVG path data.
-     *
-     * Creates a custom-geometry shape element using the provided SVG path
-     * string and appends it to the slide's element list.
-     *
-     * @param pathData - An SVG path data string (e.g. `"M 0 0 L 100 50 L 50 100 Z"`).
-     * @param options - Optional position, styling, and size overrides.
-     * @returns The builder instance for chaining.
-     *
-     * @example
-     * ```ts
-     * new SlideBuilder(1)
-     *   .addFreeform("M 0 0 C 33 0 66 100 100 100", {
-     *     stroke: { color: "#FF0000", width: 2 },
-     *   })
-     *   .build();
-     * ```
-     */
-    addFreeform(pathData: string, options?: ShapeOptions): this;
-    /**
-     * Add a pre-built element from any element builder (calls `.build()` for you).
-     *
-     * Accepts any object with a `build()` method that returns a {@link PptxElement},
-     * such as {@link TextBuilder}, {@link ShapeBuilder}, {@link ImageBuilder}, etc.
-     *
-     * @param builder - An element builder with a `.build()` method.
-     * @returns The builder instance for chaining.
-     *
-     * @example
-     * ```ts
-     * const title = TextBuilder.create("Hello").fontSize(36).bold();
-     * new SlideBuilder(1).addBuilderElement(title).build();
-     * ```
-     */
-    addBuilderElement(builder: {
-        build(): a;
-    }): this;
-    /**
-     * Remove an element by its ID.
-     *
-     * Filters out the element with the given ID from the slide's element list.
-     * If no element matches, the slide is left unchanged.
-     *
-     * @param elementId - The unique ID of the element to remove.
-     * @returns The builder instance for chaining.
-     *
-     * @example
-     * ```ts
-     * const slide = new SlideBuilder(1)
-     *   .addText("temp", { x: 0, y: 0 })
-     *   .removeElement("txt_abc123_1")
-     *   .build();
-     * ```
-     */
-    removeElement(elementId: string): this;
-    /**
-     * Get the current list of elements on this slide.
-     *
-     * Returns a readonly view of the elements array. Useful for inspecting
-     * what has been added so far during the build process.
-     *
-     * @returns A readonly array of the slide's current elements.
-     *
-     * @example
-     * ```ts
-     * const builder = new SlideBuilder(1).addText("Hi");
-     * console.log(builder.getElements().length); // 1
-     * ```
-     */
-    getElements(): readonly a[];
-    /**
-     * Get the number of elements on this slide.
-     *
-     * @returns The count of elements currently added to the slide.
-     *
-     * @example
-     * ```ts
-     * const builder = new SlideBuilder(1)
-     *   .addText("A").addText("B");
-     * console.log(builder.elementCount); // 2
-     * ```
-     */
-    get elementCount(): number;
-    /**
-     * Get the last added element (useful for getting its ID for animations).
-     *
-     * Returns `undefined` if the slide has no elements yet.
-     *
-     * @returns The most recently added element, or `undefined`.
-     *
-     * @example
-     * ```ts
-     * const builder = new SlideBuilder(1).addShape("rect");
-     * const shape = builder.getLastElement();
-     * if (shape) {
-     *   builder.addAnimation(shape.id, { preset: "fadeIn" });
-     * }
-     * ```
-     */
-    getLastElement(): a | undefined;
-    /**
-     * Set the slide name/title for organizational purposes.
-     *
-     * Stores an arbitrary name string on the slide object. This is useful
-     * for labeling slides in tooling or custom workflows.
-     *
-     * @param name - The display name to assign to the slide.
-     * @returns The builder instance for chaining.
-     *
-     * @example
-     * ```ts
-     * new SlideBuilder(1)
-     *   .setName("Introduction")
-     *   .addText("Welcome!")
-     *   .build();
-     * ```
-     */
-    setName(name: string): this;
-    /** Return the built {@link PptxSlide}. */
-    build(): P;
-}
-
-/**
- * Factory for creating PPTX presentations from scratch.
- *
- * Generates a minimal valid OpenXML package (ZIP) containing all
- * required parts (presentation.xml, theme, slide master, layouts,
- * content types, relationships, and document properties). The
- * generated package is then loaded by {@link PptxHandler} so that
- * all existing editing and save operations work transparently.
- *
- * @module sdk/PresentationBuilder
- */
-
-/** Result returned by {@link PresentationBuilder.create}. */
-interface PresentationBuilderResult {
-    /** Initialized handler ready for editing and saving. */
-    handler: PptxHandler;
-    /** Parsed presentation data. */
-    data: m;
-    /** Convenience slide builder factory. */
-    createSlide: (layoutName?: string) => SlideBuilder;
-}
-
-/**
- * Fluent interface for navigating and mutating a {@link PptxData} structure.
- * Provides method-chaining access to slides, elements, and notes.
- */
-interface IPptxXmlBuilder {
-    /** Navigate to a slide by zero-based index (Pascal-case alias). */
-    Slides(index: number): PptxSlideBuilder;
-    /** Navigate to a slide by zero-based index. */
-    slide(index: number): PptxSlideBuilder;
-    /** Navigate to a slide by zero-based index (plural alias). */
-    slides(index: number): PptxSlideBuilder;
-    /** Return the underlying presentation data. */
-    project(): m;
-}
-/**
- * Root builder of the fluent PPTX editing API.
- *
- * Wraps a {@link PptxData} object and provides chainable accessors
- * to navigate into slides, elements, and notes for in-place mutation.
- */
-declare class PptxXmlBuilder implements IPptxXmlBuilder {
-    /** The presentation data being mutated. */
-    private readonly data;
-    /** @param data - The presentation data to wrap. */
-    constructor(data: m);
-    /**
-     * Factory method to create a builder from presentation data.
-     * @param data - The presentation data to wrap.
-     * @returns A new {@link PptxXmlBuilder} instance.
-     */
-    static from(data: m): PptxXmlBuilder;
-    /** @inheritdoc */
-    Slides(index: number): PptxSlideBuilder;
-    /**
-     * Navigate to a slide by zero-based index.
-     * @param index - Zero-based slide index.
-     * @returns A {@link PptxSlideBuilder} for the requested slide.
-     * @throws Error if index is not an integer or is out of range.
-     */
-    slide(index: number): PptxSlideBuilder;
-    /** @inheritdoc */
-    slides(index: number): PptxSlideBuilder;
-    /** Return the underlying {@link PptxData}. */
-    project(): m;
-    /** Pascal-case alias for {@link project}. */
-    Project(): m;
-}
-/**
- * Fluent builder scoped to a single slide.
- * Provides navigation to the slide's elements and notes.
- */
-declare class PptxSlideBuilder {
-    /** The slide being operated on. */
-    private readonly slideValue;
-    /** Reference back to the root builder for chaining. */
-    private readonly rootBuilder;
-    /**
-     * @param slideValue - The slide data.
-     * @param rootBuilder - The parent builder.
-     */
-    constructor(slideValue: P, rootBuilder: PptxXmlBuilder);
-    /** Navigate to the slide's notes builder (getter). */
-    get Notes(): PptxSlideNotesBuilder;
-    /** Navigate to the slide's notes builder. */
-    notes(): PptxSlideNotesBuilder;
-    /** Navigate to the slide's elements builder. */
-    elements(): PptxSlideElementsBuilder;
-    /** Return the underlying slide data. */
-    project(): P;
-    /** Pascal-case alias for {@link project}. */
-    Project(): P;
-    /** Navigate back to the root builder. */
-    done(): PptxXmlBuilder;
-    /** Pascal-case alias for {@link done}. */
-    Done(): PptxXmlBuilder;
-}
-/**
- * Fluent builder for manipulating the elements array of a single slide.
- * Supports adding, removing, and updating elements by ID.
- */
-declare class PptxSlideElementsBuilder {
-    private readonly slideValue;
-    private readonly slideBuilder;
-    /**
-     * @param slideValue - The slide whose elements are being modified.
-     * @param slideBuilder - The parent slide builder for chaining.
-     */
-    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: a): this;
-    /**
-     * Remove an element from the slide by its ID.
-     * @param elementId - The ID of the element to remove.
-     * @returns This builder for chaining.
-     */
-    removeById(elementId: string): this;
-    /**
-     * Update an element in-place by ID using a transform function.
-     * @param elementId - The ID of the element to update.
-     * @param updater - A function that receives the current element and returns the replacement.
-     * @returns This builder for chaining.
-     */
-    updateById(elementId: string, updater: (current: a) => a): this;
-    /** Return the current elements array. */
-    project(): a[];
-    /** Navigate back to the slide builder. */
-    done(): PptxSlideBuilder;
-}
-/**
- * Fluent builder for manipulating speaker notes on a single slide.
- * Supports adding, setting, clearing, and retrieving notes text.
- */
-declare class PptxSlideNotesBuilder {
-    private readonly slideValue;
-    private readonly slideBuilder;
-    /**
-     * @param slideValue - The slide whose notes are being modified.
-     * @param slideBuilder - The parent slide builder for chaining.
-     */
-    constructor(slideValue: P, slideBuilder: PptxSlideBuilder);
-    /**
-     * Append text to existing notes (separated by newline).
-     * @param text - The text to append.
-     * @returns This builder for chaining.
-     */
-    add(text: string): this;
-    /** Pascal-case alias for {@link add}. */
-    Add(text: string): this;
-    /**
-     * Replace all notes with the given text.
-     * @param text - The replacement notes text. Empty string clears notes.
-     * @returns This builder for chaining.
-     */
-    set(text: string): this;
-    /** Pascal-case alias for {@link set}. */
-    Set(text: string): this;
-    /** Remove all notes from the slide. */
-    clear(): this;
-    /** Pascal-case alias for {@link clear}. */
-    Clear(): this;
-    /** Return the current notes text, or `undefined` if none. */
-    get(): string | undefined;
-    /** Pascal-case alias for {@link get}. */
-    Get(): string | undefined;
-    /** Navigate back to the slide builder. */
-    done(): PptxSlideBuilder;
-    /** Pascal-case alias for {@link done}. */
-    Done(): PptxSlideBuilder;
-    /**
-     * Synchronize the `notesSegments` array from the plain-text notes string.
-     * Splits text on newlines and creates corresponding {@link TextSegment} entries
-     * with paragraph break markers between lines.
-     */
-    private syncSegmentsFromNotes;
-}
-
-interface PptxHandlerLoadOptions {
-    eagerDecodeImages?: boolean;
-    password?: string;
-    /**
-     * Maximum total uncompressed bytes accepted from the input ZIP archive.
-     * Defaults to 500 MiB. When the sum of `_data.uncompressedSize` across
-     * all archive entries exceeds this cap, `load()` rejects with a
-     * {@link ZipBombError}. A hard cap of 65 536 archive entries also
-     * applies.
-     */
-    maxUncompressedBytes?: number;
-    /**
-     * When `false` (default), relationship targets that resolve to
-     * `http://` or `https://` URLs are dropped from rendered slides
-     * (image, picture, background). Set to `true` to allow external image
-     * URLs to flow through to `<img src>`.
-     *
-     * Disabled by default to mitigate SSRF / privacy-leak vectors in
-     * server-side rendering and headless export pipelines.
-     */
-    allowExternalImages?: boolean;
-}
-/** Output format for the save pipeline. */
-type PptxSaveFormat = 'pptx' | 'ppsx' | 'pptm';
-interface PptxHandlerSaveOptions {
-    headerFooter?: r;
-    presentationProperties?: s;
-    customShows?: t[];
-    sections?: u[];
-    coreProperties?: v;
-    appProperties?: w;
-    customProperties?: x[];
-    /** Updated notes master data to save back to notesMaster1.xml. */
-    notesMaster?: y;
-    /** Updated handout master data to save back to handoutMaster1.xml. */
-    handoutMaster?: z;
-    /**
-     * Updated slide masters to save back to ppt/slideMasters/slideMaster*.xml.
-     * Each entry in the array applies typed mutations (clrMap, hf flags,
-     * background) to the master at its `path`. Masters not listed here pass
-     * through verbatim from the original load.
-     */
-    slideMasters?: A[];
-    /**
-     * Updated slide layouts to save back to ppt/slideLayouts/slideLayout*.xml.
-     * Each entry applies typed mutations (clrMapOverride, attrs, hf flags,
-     * background) to the layout at its `path`. Layouts not listed here pass
-     * through verbatim from the original load.
-     */
-    slideLayouts?: B[];
-    /** Updated tag collections to save back to ppt/tags/tag*.xml. */
-    tags?: D[];
-    /** Photo album metadata to save back to `p:photoAlbum`. */
-    photoAlbum?: E;
-    /** East Asian line-break settings to save back to `p:kinsoku`. */
-    kinsoku?: F;
-    /** Write-protection verifier. Set to `null` to remove, `undefined` to preserve existing. */
-    modifyVerifier?: G | null;
-    /** View properties to save back to ppt/viewProps.xml. */
-    viewProperties?: H;
-    /**
-     * Table style edits to save back to `ppt/tableStyles.xml`. Pass the
-     * `tableStyleMap` from `PptxData` (optionally with edited entries)
-     * to persist user edits. The `def` GUID and any unmodelled XML are
-     * preserved verbatim. Omitting the option round-trips the original
-     * part untouched.
-     */
-    tableStyles?: J;
-    /**
-     * Target output format.
-     * - `'pptx'` (default): Standard presentation.
-     * - `'ppsx'`: Slide-show file (opens in presentation mode).
-     * - `'pptm'`: Macro-enabled presentation (requires VBA data).
-     */
-    outputFormat?: PptxSaveFormat;
-    /**
-     * Embedded fonts to write back (or add) to the saved PPTX.
-     *
-     * Pass the `embeddedFonts` array from `PptxData` to preserve existing
-     * embedded fonts during save. You can also add new fonts by including
-     * entries with `rawFontData` populated.
-     *
-     * When omitted, the save pipeline will automatically re-embed any
-     * fonts that were loaded from the original PPTX and have `rawFontData`
-     * preserved (i.e. the default is lossless round-trip).
-     */
-    embeddedFonts?: K[];
-    /**
-     * OOXML conformance class for the saved output.
-     * - `'preserve'` (default): use the same conformance as the loaded file.
-     * - `'strict'`: force Strict Open XML (ISO/IEC 29500) namespace URIs.
-     * - `'transitional'`: force Transitional (ECMA-376) namespace URIs.
-     */
-    conformance?: 'strict' | 'transitional' | 'preserve';
-}
-interface IPptxHandlerRuntime {
-    /**
-     * Release all resources held by this runtime (Blob URLs, caches, ZIP).
-     * After calling, the runtime cannot be used further.
-     */
-    dispose(): void;
-    /**
-     * Revoke all Blob URLs created during image loading.
-     */
-    revokeBlobUrls(): void;
-    getCompatibilityWarnings(): n[];
-    getLayoutOptions(): o[];
-    createXmlBuilder(data: m): PptxXmlBuilder;
-    Builder(data: m): PptxXmlBuilder;
-    setTemplateBackground(path: string, backgroundColor: string | undefined): void;
-    setPresentationTheme(themePath: string, applyToAllMasters?: boolean): Promise<void>;
-    getTemplateBackgroundColor(path: string): string | undefined;
-    updateThemeColorScheme(colorScheme: e): Promise<void>;
-    updateThemeFontScheme(fontScheme: f): Promise<void>;
-    updateThemeName(name: 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>;
-    getImageData(imagePath: string): Promise<string | undefined>;
-    /**
-     * Extract a media file from the PPTX archive as an ArrayBuffer.
-     * Returns undefined if the file is not found.
-     */
-    getMediaArrayBuffer(mediaPath: string): Promise<ArrayBuffer | undefined>;
-    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
-     * layouts that belong to it.
-     *
-     * @param slideIndex - Zero-based slide index.
-     * @param slides - Current slides array.
-     * @returns Array of layout options belonging to the same slide master.
-     */
-    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
-     * placeholders; returns only decorative shapes/pictures/graphic frames.
-     *
-     * @param slideId - The slide's archive path (`PptxSlide.id`).
-     */
-    getTemplateElementsForSlide(slideId: string): Promise<a[]>;
-    /**
-     * Scan the loaded PPTX archive for all theme parts.
-     */
-    getAvailableThemes(): Promise<Array<{
-        path: string;
-        name?: string;
-    }>>;
-    /**
-     * Apply a different layout to an existing slide by updating the slide's
-     * relationship to point to the new layout and re-parsing layout
-     * placeholders / background.
-     *
-     * @param slideIndex - Zero-based slide index.
-     * @param layoutPath - Archive path of the target layout
-     *                     (e.g. `ppt/slideLayouts/slideLayout2.xml`).
-     * @param slides - Current slides array.
-     * @returns The updated slide with new layout path, name, and background.
-     */
-    applyLayoutToSlide(slideIndex: number, layoutPath: string, slides: P[]): Promise<P>;
-}
-
-/**
- * Abstract factory contract for creating {@link IPptxHandlerRuntime}
- * instances.
- *
- * Implement this interface to supply a custom runtime (e.g. a
- * WASM-backed or test-double runtime) to {@link PptxHandlerCore}.
- */
-interface IPptxHandlerRuntimeFactory {
-    /** Instantiate and return a new runtime implementation. */
-    createRuntime(): IPptxHandlerRuntime;
-}
-
-/**
- * Type definitions for OOXML encryption and decryption.
- *
- * Contains all interfaces and type aliases used by the OOXML crypto modules.
- *
- * @module ooxml-crypto-types
- */
-/** Supported encryption algorithms. */
-type EncryptionAlgorithm = 'AES128' | 'AES256';
-/** Encryption options for creating encrypted files. */
-interface EncryptionOptions {
-    /** The encryption algorithm to use (defaults to AES256). */
-    algorithm?: EncryptionAlgorithm;
-    /** Number of hash iterations for key derivation (defaults to 100000). Lower values speed up tests. */
-    spinCount?: number;
-}
-
-/**
- * Dependency injection options for {@link PptxHandlerCore}.
- *
- * Provide either `runtime` (an already-constructed runtime) or
- * `runtimeFactory` (a factory that will be called once). When neither
- * is supplied the default runtime is created automatically.
- *
- * @example
- * ```ts
- * // Use the default runtime:
- * const core = new PptxHandlerCore();
- *
- * // Inject a custom runtime:
- * const core = new PptxHandlerCore({ runtime: myRuntime });
- *
- * // Supply a factory for lazy creation:
- * const core = new PptxHandlerCore({ runtimeFactory: myFactory });
- * // => PptxHandlerCore instance with injected runtime
- * ```
- */
-interface PptxHandlerCoreDependencies {
-    runtime?: IPptxHandlerRuntime;
-    runtimeFactory?: IPptxHandlerRuntimeFactory;
-}
-/**
- * Thin facade over the PPTX runtime implementation.
- *
- * All heavy parsing, serialisation, and XML manipulation is delegated to an
- * {@link IPptxHandlerRuntime}. This surface stays stable and small so that
- * callers remain decoupled from the runtime internals and host-specific
- * runtime swaps (e.g. WASM vs Node) can be done transparently.
- *
- * @remarks
- * - Constructed once per open document.
- * - Errors from encrypted files are caught at `load()` time via
- *   {@link EncryptedFileError}.
- * - `PptxXmlBuilder` instances returned by `createXmlBuilder()` / `Builder()`
- *   operate directly on the runtime’s in-memory ZIP.
- *
- * @example
- * ```ts
- * const handler = new PptxHandlerCore();
- * const data    = await handler.load(arrayBuffer);
- * // ... mutate slides ...
- * const out     = await handler.save(data.slides);
- * // => Uint8Array of the modified .pptx file
- * ```
- */
-declare class PptxHandlerCore {
-    private readonly runtime;
-    /**
-     * Create a new handler, optionally injecting a custom runtime.
-     *
-     * Resolution order:
-     * 1. `dependencies.runtime` — use as-is.
-     * 2. `dependencies.runtimeFactory` — call `createRuntime()` once.
-     * 3. Fall back to {@link createDefaultPptxHandlerRuntime}.
-     *
-     * @param dependencies - Optional runtime or factory override.
-     *
-     * @example
-     * ```ts
-     * const core = new PptxHandlerCore();
-     * // => PptxHandlerCore instance with default runtime
-     * ```
-     */
-    constructor(dependencies?: PptxHandlerCoreDependencies);
-    /**
-     * Release all resources held by this handler instance.
-     *
-     * Revokes every Blob URL created for images/media, clears all
-     * in-memory caches, and releases the in-memory ZIP archive.
-     *
-     * Call this when the handler is no longer needed (e.g. component
-     * unmount) to free memory immediately rather than waiting for GC.
-     *
-     * After calling `dispose()`, do not call any other methods — create
-     * a new `PptxHandler` instance instead.
-     */
-    dispose(): void;
-    /**
-     * Return any compatibility warnings detected during the most recent load.
-     *
-     * Warnings indicate features the editor cannot fully represent (e.g.
-     * SmartArt, 3-D effects, embedded OLE objects).
-     *
-     * @returns Array of {@link PptxCompatibilityWarning} objects.
-     */
-    getCompatibilityWarnings(): n[];
-    /**
-     * Get the slide layout options available in the loaded presentation.
-     *
-     * Each option maps to a `<p:sldLayout>` inside the PPTX archive.
-     *
-     * @returns Array of {@link PptxLayoutOption} entries.
-     */
-    getLayoutOptions(): o[];
-    /**
-     * Create a fluent XML builder scoped to the given presentation data.
-     *
-     * The builder provides a chainable API for constructing and inserting
-     * OpenXML nodes directly into the runtime’s in-memory ZIP.
-     *
-     * @param data - The parsed {@link PptxData} to bind the builder to.
-     * @returns A new {@link PptxXmlBuilder} instance.
-     */
-    createXmlBuilder(data: m): PptxXmlBuilder;
-    /**
-     * Shorthand alias for {@link createXmlBuilder}.
-     *
-     * @param data - Parsed presentation data.
-     * @returns A {@link PptxXmlBuilder} instance.
-     */
-    Builder(data: m): PptxXmlBuilder;
-    /**
-     * Register a background image for a specific template layout path.
-     *
-     * @param path - The internal PPTX path (e.g. `ppt/slideLayouts/slideLayout1.xml`).
-     * @param backgroundColor - Optional hex colour to render behind the image.
-     */
-    setTemplateBackground(path: string, backgroundColor: string | undefined): void;
-    /**
-     * Retrieve the background colour previously set for a template layout.
-     *
-     * @param path - The internal PPTX layout path.
-     * @returns Hex colour string, or `undefined` if none was set.
-     */
-    getTemplateBackgroundColor(path: string): string | undefined;
-    /**
-     * Replace the presentation’s theme by loading an external `.thmx` file.
-     *
-     * @param themePath - Absolute or relative path to the `.thmx` file.
-     * @param applyToAllMasters - Apply to every slide master (default `true`).
-     *
-     * @example
-     * ```ts
-     * await handler.setPresentationTheme("./themes/corporate.thmx");
-     * // => void — theme XML replaced in the in-memory ZIP
-     * ```
-     */
-    setPresentationTheme(themePath: string, applyToAllMasters?: boolean): Promise<void>;
-    /**
-     * Modify the theme’s colour scheme (accent colours, background, text, etc.).
-     *
-     * @param colorScheme - A {@link PptxThemeColorScheme} with hex colour values.
-     *
-     * @example
-     * ```ts
-     * await handler.updateThemeColorScheme({
-     *   dk1: "#1A1A2E", dk2: "#16213E",
-     *   lt1: "#FFFFFF", lt2: "#E8E8E8",
-     *   accent1: "#0F3460", accent2: "#533483",
-     *   accent3: "#E94560", accent4: "#F0A500",
-     * });
-     * // => void — colour scheme updated in the in-memory theme XML
-     * ```
-     */
-    updateThemeColorScheme(colorScheme: e): Promise<void>;
-    /**
-     * Update the theme’s font scheme (heading + body typefaces).
-     *
-     * @param fontScheme - A {@link PptxThemeFontScheme} with font family names.
-     *
-     * @example
-     * ```ts
-     * await handler.updateThemeFontScheme({
-     *   majorFont: "Montserrat",
-     *   minorFont: "Open Sans",
-     * });
-     * // => void — font scheme updated in the in-memory theme XML
-     * ```
-     */
-    updateThemeFontScheme(fontScheme: f): Promise<void>;
-    /**
-     * Rename the presentation theme.
-     *
-     * @param name - New display name for the theme.
-     */
-    updateThemeName(name: string): Promise<void>;
-    /**
-     * Apply a complete theme in one call (colour scheme + font scheme + optional name).
-     *
-     * This is a convenience wrapper over {@link updateThemeColorScheme},
-     * {@link updateThemeFontScheme}, and {@link updateThemeName}.
-     *
-     * @param colorScheme - Colour definitions.
-     * @param fontScheme  - Font definitions.
-     * @param themeName   - Optional theme display name.
-     *
-     * @example
-     * ```ts
-     * await handler.applyTheme(
-     *   { dk1: "#000", lt1: "#FFF", accent1: "#0066CC", /* … *\/ },
-     *   { majorFont: "Helvetica", minorFont: "Arial" },
-     *   "Corporate 2025",
-     * );
-     * // => void — colour scheme, font scheme, and name applied atomically
-     * ```
-     */
-    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.
-     *
-     * This is the high-level API for theme switching: it updates the theme
-     * data in the ZIP, then patches all resolved colours in the provided
-     * `PptxData` so that elements immediately reflect the new colour scheme
-     * without requiring a re-parse.
-     *
-     * @param data - The current parsed presentation data (mutated in-place for
-     *   convenience, but a new `PptxData` object is also returned).
-     * @param colorScheme - New colour scheme (12 colours).
-     * @param fontScheme - Optional new font scheme.
-     * @param themeName - Optional theme display name.
-     * @returns The updated PptxData with re-resolved colours.
-     *
-     * @example
-     * ```ts
-     * import { THEME_PRESETS } from "pptx-viewer-core";
-     *
-     * const ion = THEME_PRESETS.find(p => p.id === "ion")!;
-     * const newData = await handler.switchTheme(
-     *   data,
-     *   ion.colorScheme,
-     *   ion.fontScheme,
-     *   ion.name,
-     * );
-     * // => PptxData with all colours updated to the Ion theme
-     * ```
-     */
-    switchTheme(data: m, colorScheme: e, fontScheme?: f, themeName?: string): Promise<m>;
-    /**
-     * Apply a built-in theme preset to the presentation.
-     *
-     * Convenience wrapper around {@link switchTheme} that accepts a
-     * {@link PptxThemePreset} directly.
-     *
-     * @param data - The current parsed presentation data.
-     * @param preset - One of the built-in presets from {@link THEME_PRESETS}.
-     * @returns The updated PptxData.
-     *
-     * @example
-     * ```ts
-     * import { THEME_PRESETS } from "pptx-viewer-core";
-     *
-     * const preset = THEME_PRESETS.find(p => p.id === "facet")!;
-     * const newData = await handler.switchThemePreset(data, preset);
-     * ```
-     */
-    switchThemePreset(data: m, preset: PptxThemePreset): Promise<m>;
-    /**
-     * Parse a PPTX file from an `ArrayBuffer` and return structured data.
-     *
-     * If the file is encrypted and a `password` is provided in `options`,
-     * the file will be decrypted before parsing. If no password is provided
-     * for an encrypted file, throws {@link EncryptedFileError}.
-     *
-     * @param data    - Raw bytes of the `.pptx` file (may be encrypted OLE2).
-     * @param options - Optional load-time settings, including `password`.
-     * @returns Parsed {@link PptxData} containing slides, theme, layouts, etc.
-     *
-     * @example
-     * ```ts
-     * // Load an unencrypted file:
-     * const pptx = await handler.load(buf.buffer);
-     *
-     * // Load a password-protected file:
-     * const pptx = await handler.load(buf.buffer, { password: "secret" });
-     * console.log(`${pptx.slides.length} slides loaded`);
-     * ```
-     */
-    load(data: ArrayBuffer, options?: PptxHandlerLoadOptions): Promise<m>;
-    /**
-     * Extract chart data from a graphic-frame XML node.
-     *
-     * @param slidePath    - Internal archive path of the slide (e.g. `ppt/slides/slide1.xml`).
-     * @param graphicFrame - Parsed XML object for the `<p:graphicFrame>` node.
-     * @returns Chart data, or `undefined` if the frame is not a chart.
-     */
-    getChartDataForGraphicFrame(slidePath: string, graphicFrame: X | undefined): Promise<p | undefined>;
-    /**
-     * Extract SmartArt data from a graphic-frame XML node.
-     *
-     * @param slidePath    - Internal archive path of the slide.
-     * @param graphicFrame - Parsed XML object for the `<p:graphicFrame>` node.
-     * @returns SmartArt data, or `undefined` if the frame is not SmartArt.
-     */
-    getSmartArtDataForGraphicFrame(slidePath: string, graphicFrame: X | undefined): Promise<q | undefined>;
-    /**
-     * Get the base64-encoded data URL for an embedded image.
-     *
-     * @param imagePath - Archive-relative path (e.g. `ppt/media/image1.png`).
-     * @returns A `data:image/...;base64,...` string, or `undefined` if not found.
-     */
-    getImageData(imagePath: string): Promise<string | undefined>;
-    /**
-     * Extract a media file from the PPTX archive as an ArrayBuffer.
-     * Avoids the 33% base64 overhead of getImageData — prefer this for
-     * audio/video media that will be played via Blob URLs.
-     */
-    getMediaArrayBuffer(mediaPath: string): Promise<ArrayBuffer | undefined>;
-    /**
-     * Serialise current slides back into a PPTX byte array.
-     *
-     * @param slides  - The (possibly mutated) slide array.
-     * @param options - Optional save-time settings (e.g. thumbnail generation).
-     * @returns `Uint8Array` of the complete `.pptx` file.
-     *
-     * @example
-     * ```ts
-     * const bytes = await handler.save(data.slides);
-     * await fs.writeFile("output.pptx", Buffer.from(bytes));
-     * // => Uint8Array written to disk as a valid .pptx file
-     * ```
-     */
-    save(slides: P[], options?: PptxHandlerSaveOptions): Promise<Uint8Array>;
-    /**
-     * Serialise slides and then encrypt the output with a password.
-     *
-     * This is a convenience method that calls {@link save} followed by
-     * {@link encryptPptx}. The result is an OLE2 container suitable for
-     * opening in Microsoft PowerPoint with a password prompt.
-     *
-     * @param slides   - The (possibly mutated) slide array.
-     * @param password - The password to encrypt with.
-     * @param options  - Optional save-time and encryption settings.
-     * @returns `Uint8Array` of the encrypted OLE2 file.
-     *
-     * @example
-     * ```ts
-     * const bytes = await handler.saveEncrypted(data.slides, "secret");
-     * await fs.writeFile("protected.pptx", Buffer.from(bytes));
-     * // => Encrypted OLE2 file requiring password to open
-     * ```
-     */
-    saveEncrypted(slides: P[], password: string, options?: PptxHandlerSaveOptions & {
-        encryption?: EncryptionOptions;
-    }): Promise<Uint8Array>;
-    /**
-     * Get the slide layouts available for a specific slide.
-     *
-     * Returns layouts belonging to the same slide master as the given slide.
-     * This is useful for building a layout picker UI scoped to the current
-     * slide's master.
-     *
-     * @param slideIndex - Zero-based slide index.
-     * @param slides     - Current slides array.
-     * @returns Array of {@link PptxLayoutOption} entries for the slide's master.
-     *
-     * @example
-     * ```ts
-     * const layouts = await handler.getAvailableLayoutsForSlide(0, data.slides);
-     * console.log(layouts.map(l => l.name));
-     * // => ["Title Slide", "Title and Content", "Blank", ...]
-     * ```
-     */
-    getAvailableLayoutsForSlide(slideIndex: number, slides: P[]): Promise<o[]>;
-    /**
-     * Resolve the editable template (master + layout) elements a slide
-     * inherits, each carrying a `master-` / `layout-` prefixed id.
-     *
-     * This is the foundation for an "edit template/master" feature. The
-     * returned elements are the decorative master/layout shapes the loader
-     * already merges behind slide-authored content (master shapes behind,
-     * layout shapes on top); placeholders are excluded. The same elements are
-     * shared by every slide inheriting the layout/master, so editing one and
-     * saving updates the shared part.
-     *
-     * To persist an edit, keep the mutated template element inside the
-     * `slide.elements` array passed to {@link save}; the save writer reads
-     * template elements from there and writes their shape XML back into the
-     * owning layout/master `p:spTree`.
-     *
-     * @param slideId - The slide's archive path (the `PptxSlide.id`).
-     * @returns Master + layout elements with prefixed ids (may be empty).
-     *
-     * @example
-     * ```ts
-     * const templateEls = await handler.getTemplateElementsForSlide(slide.id);
-     * const logo = templateEls.find((e) => e.id.startsWith("master-"));
-     * if (logo) {
-     *   logo.x += 10;
-     *   slide.elements = [...slide.elements, logo];
-     *   await handler.save(data.slides);
-     * }
-     * ```
-     */
-    getTemplateElementsForSlide(slideId: string): Promise<a[]>;
-    /**
-     * Apply a different layout to an existing slide.
-     *
-     * Updates the slide's relationship to point to the new layout and
-     * refreshes layout-derived properties (background, layout name).
-     * The slide's own content elements are preserved.
-     *
-     * @param slideIndex - Zero-based slide index.
-     * @param layoutPath - Archive path of the target layout
-     *                     (e.g. `ppt/slideLayouts/slideLayout2.xml`).
-     * @param slides     - Current slides array (the slide at `slideIndex`
-     *                     is replaced in-place).
-     * @returns The updated {@link PptxSlide} with new layout metadata.
-     *
-     * @example
-     * ```ts
-     * const updated = await handler.applyLayoutToSlide(
-     *   0,
-     *   "ppt/slideLayouts/slideLayout3.xml",
-     *   data.slides,
-     * );
-     * console.log(updated.layoutName);
-     * // => "Two Content"
-     * ```
-     */
-    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.
-     */
-    getAvailableThemes(): Promise<Array<{
-        path: string;
-        name?: string;
-    }>>;
-    /**
-     * Export selected slides as individual PPTX files.
-     *
-     * Each entry in the returned map is keyed by slide index and contains a
-     * standalone `Uint8Array` PPTX with only that slide.
-     *
-     * @param slides  - Full slide array.
-     * @param options - Export options (slide indexes, format, etc.).
-     * @returns A `Map<slideIndex, Uint8Array>` of exported files.
-     *
-     * @example
-     * ```ts
-     * const exports = await handler.exportSlides(data.slides, {
-     *   slideIndexes: [0, 2],
-     * });
-     * for (const [idx, bytes] of exports) {
-     *   await fs.writeFile(`slide_${idx}.pptx`, Buffer.from(bytes));
-     * }
-     * // => Map<number, Uint8Array> — one standalone .pptx per exported slide
-     * ```
-     */
-    exportSlides(slides: P[], options: L): Promise<Map<number, Uint8Array>>;
-}
-
-/**
- * Public facade for the PPTX editor handler.
- *
- * The implementation lives in `PptxHandlerCore` so this surface can stay small,
- * stable, and easy to replace with alternate implementations in the future.
- */
-declare class PptxHandler extends PptxHandlerCore {
-    /**
-     * Create a new blank PPTX presentation from scratch.
-     *
-     * This is a convenience static method that delegates to
-     * {@link PresentationBuilder.create}. The returned handler is fully
-     * initialized and ready for editing, adding slides, and saving.
-     *
-     * @param options - Optional slide dimensions, theme, and metadata.
-     * @returns Handler, parsed data, and a slide builder factory.
-     *
-     * @example
-     * ```ts
-     * const { handler, data, createSlide } = await PptxHandler.createBlank({
-     *   title: "My Deck",
-     *   theme: { colors: { accent1: "#FF6B6B" } },
-     * });
-     *
-     * data.slides.push(
-     *   createSlide("Blank")
-     *     .addText("Hello", { fontSize: 36 })
-     *     .build()
-     * );
-     *
-     * const bytes = await handler.save(data.slides);
-     * ```
-     */
-    static createBlank(options?: PresentationOptions): Promise<PresentationBuilderResult>;
-    /**
-     * Create a new PPTX presentation from scratch.
-     *
-     * Alias for {@link createBlank}. Generates a valid minimal OpenXML
-     * package and returns a fully initialized handler ready for editing,
-     * adding slides, and saving.
-     *
-     * @param options - Optional slide dimensions, theme, metadata,
-     *   and initial slide count.
-     * @returns Handler, parsed data, and a slide builder factory.
-     *
-     * @example
-     * ```ts
-     * const { handler, data, createSlide } = await PptxHandler.create({
-     *   title: "Q4 Report",
-     *   initialSlideCount: 3,
-     *   theme: { colors: { accent1: "#FF6B6B" } },
-     * });
-     *
-     * // The presentation already has 3 blank slides
-     * console.log(data.slides.length); // => 3
-     *
-     * // Add more slides with content
-     * data.slides.push(
-     *   createSlide("Blank")
-     *     .addText("Hello", { fontSize: 36 })
-     *     .build()
-     * );
-     *
-     * const bytes = await handler.save(data.slides);
-     * ```
-     */
-    static create(options?: PresentationOptions): Promise<PresentationBuilderResult>;
-}
-
-/**
- * Framework-agnostic public types shared by the viewer bindings.
- *
- * These were duplicated in the React (`types-ui.ts`) and Vue (`viewer/types.ts`)
- * packages; this is the canonical copy. Each binding layers its own
- * framework-specific prop/event/handle types on top of these.
- */
-
-/** Canvas dimensions in pixels. */
-interface CanvasSize {
-    width: number;
-    height: number;
-}
-/** Collaboration role within a session. */
-type CollaborationRole = 'owner' | 'collaborator' | 'viewer';
-/**
- * Collaboration transport.
- *
- * - `'websocket'` (default): y-websocket against `serverUrl`.
- * - `'webrtc'`: y-webrtc peer-to-peer; needs no document server. Peers meet
- *   through the `signaling` servers (WebRTC signaling only, no document data)
- *   and same-browser tabs additionally sync via BroadcastChannel even without
- *   any signaling server, which makes this mode usable from static hosting.
- */
-type CollaborationTransport = 'websocket' | 'webrtc';
-/**
- * Real-time collaboration configuration.
- *
- * The same shape is accepted by the React, Vue, and Angular bindings.
- */
-interface CollaborationConfig {
-    /** Unique identifier for the collaboration room (alphanumeric, hyphens, underscores). */
-    roomId: string;
-    /**
-     * WebSocket server URL for the Yjs provider (e.g. "wss://collab.example.com").
-     * Ignored (may be empty) when `transport` is `'webrtc'`.
-     */
-    serverUrl: string;
-    /** Transport to use. Defaults to `'websocket'`. */
-    transport?: CollaborationTransport;
-    /**
-     * WebRTC signaling server URLs (only used when `transport` is `'webrtc'`).
-     * Defaults to y-webrtc's built-in public signaling list. Same-browser tabs
-     * sync via BroadcastChannel regardless of signaling availability.
-     */
-    signaling?: string[];
-    /** Display name for the local user. */
-    userName: string;
-    /** Avatar URL for the local user (optional). */
-    userAvatar?: string;
-    /** Hex colour for the local user's cursor/presence indicator. */
-    userColor?: string;
-    /** Optional authentication token sent with the WebSocket handshake. */
-    authToken?: string;
-    /** Role in the session; defaults to `'collaborator'`. */
-    role?: CollaborationRole;
-    /**
-     * Elected-writer write-back callback (Area 3 of the C3 hardening plan).
-     *
-     * When the local user has `role: 'owner'`, the binding debounces changes and
-     * serializes the current Y.Doc state to a PPTX byte array, then calls this
-     * callback so the host can persist the snapshot. Only one writer (the owner)
-     * does this; other collaborators never trigger write-back, eliminating the
-     * last-save-wins problem.
-     */
-    onWriteBack?: (bytes: Uint8Array) => void;
-    /**
-     * Debounce delay (ms) between the last Y.Doc change and the write-back
-     * invocation. Defaults to 5000 ms. Set to 0 to write back on every change
-     * (not recommended for large documents).
-     */
-    writeBackDebounceMs?: number;
-}
-/** A neutral CSS map (framework `CSSProperties` are structurally compatible). */
-type CssStyleMap = Record<string, string | number>;
-
-/**
- * `animation-authoring` — pure, immutable helpers for the editor's element
- * animation authoring UI (the Animations ribbon tab / animation panel).
- *
- * Animation data lives on the SLIDE (`PptxSlide.animations`), keyed by
- * `elementId`, NOT on the element itself. The authoring UI reads and emits the
- * entire slide-level `animations` array. Every function here returns a new
- * `PptxElementAnimation[]` without mutating its input, so they're trivially
- * unit-testable and safe to drive editor undo/redo from.
- *
- * Two families coexist here, both used across the bindings:
- *
- *  - **Granular field setters** (`setAnimationEntrance` / `setTrigger` /
- *    `setDuration` / … plus `reorderAnimationUp` / `removeAnimation`): the
- *    Angular authoring panel + React's `useAnimationHandlers` model. They
- *    upsert a single field on the element's entry, creating the entry with
- *    sensible defaults when absent and removing it when all three effect
- *    buckets become empty.
- *  - **Group preset apply/remove** (`applyAnimationPreset` /
- *    `removeElementAnimation`): the Vue ribbon model, a coarser
- *    "set one of entrance/emphasis/exit, keep the rest" upsert.
- *
- * The option *catalogs* here are intentionally **value-only** (preset id +
- * nothing else): the human label / icon / i18n key for each option is
- * framework-specific (React uses `react-icons` + label keys, Angular uses
- * Unicode arrow glyphs + plain labels), so each binding maps these ids to its
- * own display metadata.
- *
- * Pure: imports only `pptx-viewer-core` types; no framework, no DOM.
- *
- * @module render/animation-authoring
- */
-
-/** One of the three animation buckets a preset can occupy on an element. */
-type AnimationGroup = 'entrance' | 'emphasis' | 'exit';
-
-/**
- * Pure geometry helpers for the align / distribute editor operations.
- *
- * These functions operate over a list of slide elements (anything carrying the
- * `{ id, x, y, width, height }` bounding-box fields of {@link PptxElement}) and
- * return a `Map` keyed by element `id` describing the *new* position(s) for the
- * elements that need to move. Elements that already sit on the target edge (or
- * the two outer-most elements during distribution) are still included with
- * their unchanged coordinate so callers can apply the whole map uniformly — the
- * map only ever contains the axis that the operation touches.
- *
- * The helpers are deliberately framework-agnostic: no DOM, no Vue reactivity,
- * no side effects. The host wires them into the editor by feeding the current
- * selection in and applying the returned `Map` via its element-transform
- * operation (one batched history entry per call).
- */
-/** Edge / centre that {@link alignElements} can snap a selection to. */
-type AlignEdge = 'left' | 'centerH' | 'right' | 'top' | 'middle' | 'bottom';
-
-/**
- * "Change Case" text mutation (PowerPoint's Aa dropdown: Sentence case, lower,
- * UPPER, Capitalize Each Word, tOGGLE cASE). Unlike `textCaps` (a purely
- * visual `text-transform`-style render hint), these modes rewrite the actual
- * characters, matching PowerPoint's own behaviour. Framework-agnostic; no
- * framework imports.
- */
-
-type ChangeCaseMode = 'sentence' | 'lower' | 'upper' | 'capitalize' | 'toggle';
-
-/**
- * collaboration-presence.ts: Pure, framework-agnostic logic for the real-time
- * collaboration subsystem (Yjs-backed presence + remote cursors).
- *
- * Everything here is a plain function with no framework / Yjs dependency, so it
- * can be unit-tested in isolation and shared across the React, Vue, and Angular
- * bindings. The bindings own the stateful provider lifecycle (creating the
- * Y.Doc / WebsocketProvider, wiring awareness listeners) and call into these
- * helpers to validate config, sanitise inbound awareness data, and project it
- * into render-ready view-models.
- *
- * Responsibilities:
- *  - Validate the room id and detect mixed-content (ws:// from https) up front.
- *  - Sanitise inbound awareness data (XSS, bounds, colour, avatar, room id).
- *  - Map awareness state into a `RemoteCursor` view-model for rendering.
- *  - Derive the presence list (remote users only, stale entries dropped).
- *  - Deterministic per-user colour assignment + cursor label formatting.
- *
- * This mirrors the React `sanitize.ts` / `usePresenceTracking.ts` helpers and
- * the Angular `collaboration-helpers.ts` (which predates this shared copy).
- */
-
-/** Connection lifecycle states for the Yjs WebSocket provider. */
-type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
-/** 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 collaborator, sanitised from the awareness
- * protocol. Returned by {@link sanitizePresence}; coordinates are in unscaled
- * slide pixels, clamped to the supplied canvas bounds.
- */
-interface SanitizedPresence {
-    clientId: number;
-    userName: string;
-    userAvatar?: string;
-    userColor: string;
-    activeSlideIndex: number;
-    cursorX: number;
-    cursorY: number;
-    lastUpdated: string;
-    selectedElementId?: string;
-    role?: CollaborationRole;
-}
-
-/**
- * Pure, framework-agnostic helpers for freehand ink drawing, shared by every
- * binding. No framework imports, so these can be unit-tested without TestBed.
- */
-
-/** A 2D point in stage-local coordinates. */
-interface InkPoint {
-    x: number;
-    y: number;
-}
-/** Options for {@link strokeToInkElement}. */
-interface StrokeToInkElementOpts {
-    points: InkPoint[];
-    color: string;
-    width: number;
-    tool: 'pen' | 'highlighter' | 'freeform';
-}
-
-/**
- * Pure helpers for the gradient picker editor control, shared by every binding.
- *
- * Readers extract current gradient values from a PptxElement (falling back to
- * sensible defaults), and patch-builders produce shallow-merge-ready
- * `Partial<PptxElement>` objects safe to pass to each binding's element-update
- * action.
- *
- * No framework imports; every type is concrete or `unknown` + narrowed.
- */
-
-/** A single gradient stop, mirroring the ShapeStyle array item shape. */
-interface GradientStop {
-    color: string;
-    position: number;
-    opacity?: number;
-}
-/** The editable gradient state surfaced to the component. */
-interface GradientState {
-    type: 'linear' | 'radial';
-    /** Angle in degrees (only meaningful for linear). */
-    angle: number;
-    stops: GradientStop[];
-}
-/** In-memory clipboard payload stored when an element is copied or cut. */
-interface ElementClipboardPayload {
-    element: a;
-    isTemplate: boolean;
-}
-
-/**
- * shape-preset-catalog.ts: the Insert > Shape picker catalogue shared by every
- * binding's toolbar/inspector.
- *
- * Pure data: each entry carries the preset geometry `type` (OOXML `a:prstGeom`
- * value the editor can insert), an English fallback `label`, the shared-i18n
- * `i18nKey`, and a framework-neutral icon descriptor ({@link ShapePresetGlyph}
- * name + optional utility-class modifier for rotation/skew). Each binding maps
- * the glyph name onto its own icon component/SVG.
- *
- * Order matters: bindings surface the first 12 entries as the quick "top
- * shapes" row, so new presets should be appended, not inserted.
- *
- * @module render/shape-preset-catalog
- */
-/** Shape preset geometry types offered by the insert picker. */
-type ShapePresetType = 'rect' | 'roundRect' | 'ellipse' | 'cylinder' | 'rtArrow' | 'leftArrow' | 'upArrow' | 'downArrow' | 'triangle' | 'rtTriangle' | 'diamond' | 'parallelogram' | 'trapezoid' | 'pentagon' | 'hexagon' | 'octagon' | 'chevron' | 'star5' | 'star6' | 'star8' | 'plus' | 'heart' | 'cloud' | 'sun' | 'moon' | 'pie' | 'plaque' | 'teardrop' | 'line' | 'connector';
-interface AutosaveRecord {
-    key: string;
-    data: Uint8Array;
-    timestamp: number;
-    size: number;
-}
-
-/**
- * Pure handout layout calculations, shared by every binding's print path.
- *
- * Handles distributing slides across pages, computing grid dimensions, and
- * positioning cells within A4 page space. No DOM/framework dependency: callers
- * render the resulting rectangles however their view layer prefers.
- */
-/** Supported slides-per-page values. */
-type HandoutSlidesPerPage = 1 | 2 | 3 | 4 | 6 | 9;
-
-/**
- * Pure print helpers shared by every binding's print path: settings validation,
- * slide-range / colour-filter resolution, page-count estimation, HTML markup
- * builders, escaping, and the full print-document assembler.
- *
- * No DOM side effects and no `window.print()`: everything is deterministic and
- * the binding writes the returned HTML string into a print window. The handout
- * grid geometry lives in `handout-layout`; this module reuses it.
- *
- * ng-packagr constraint honoured here (the Angular binding inlines this source
- * and compiles it through ng-packagr): NO `String.prototype.replaceAll`
- * (`escapeHtml` uses `.split(x).join(y)` instead).
- */
-
-/** 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';
-/** 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;
-}
-
-/**
- * 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';
-/**
- * The Draw ribbon tab's active tool. `'select'` means normal editing gestures
- * (move/resize/rotate/inline-edit) apply on the stage; every other value
- * routes stage pointer events to the ink-drawing gesture controller instead
- * (see `editor-draw-gestures.ts`).
- */
-type DrawTool = 'select' | 'pen' | 'highlighter' | 'eraser';
-/**
- * The vanilla viewer's reactive view state. Kept intentionally flat and small;
- * everything here is what the DOM render layer consumes.
- */
-interface ViewerState {
-    /** Parsed slides (image/media URLs already patched in by the load pipeline). */
-    slides: P[];
-    /** Slide canvas size in CSS pixels. */
-    canvasSize: CanvasSize;
-    /** Archive-path to displayable URL map for media + poster frames. */
-    mediaDataUrls: Map<string, string>;
-    /** Zero-based index of the visible slide. */
-    currentSlide: number;
-    /** Requested zoom (explicit factor or fit-to-viewport). */
-    zoom: ZoomLevel;
-    /** True while a load is in flight. */
-    loading: boolean;
-    /** Error message from the last failed load, or null. */
-    error: string | null;
-    /** True while presentation (fullscreen) mode is active. */
-    presenting: boolean;
-    /** True when editing interactions (select/move/resize/...) are enabled. */
-    editable: boolean;
-    /** Id of the selected element on the current slide, or null. */
-    selectedElementId: string | null;
-    /** True when the document has unsaved edits (cleared by a save). */
-    dirty: boolean;
-    /**
-     * True while a pointer gesture (drag/resize/rotate) is in flight. Thumbnail
-     * 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;
-    /** Remote collaborators currently in the session (empty when not collaborating). */
-    remotePresences: SanitizedPresence[];
-    /** Remote cursors visible on the current slide, projected from `remotePresences`. */
-    cursors: RemoteCursor[];
-    /** Client id of the peer the local user is following, or null when free. */
-    followedClientId: number | null;
-    /** In-memory clipboard payload from the last copy/cut, or null. */
-    clipboardPayload: ElementClipboardPayload | null;
-    /** Active Draw ribbon tool; `'select'` disables the ink-drawing gesture controller. */
-    drawTool: DrawTool;
-    /** Stroke colour for the pen/highlighter tools. */
-    drawColor: string;
-    /** Stroke width (px) for the pen/highlighter tools. */
-    drawWidth: number;
-}
-
-/**
- * Element-animation actions for the ribbon's Animations tab.
- *
- * Animation data lives on the SLIDE (`PptxSlide.animations`, keyed by
- * `elementId`), not on the element itself, matching how the presentation
- * playback state machine reads it (`buildClickGroups(slide.animations)` in
- * `animation/presentation-playback.ts`). Both actions target the currently
- * selected element and route through the shared `animation-authoring.ts`
- * "coarse group preset" model (`applyAnimationPreset` / `removeElementAnimation`),
- * the same one the Vue ribbon uses: applying a preset sets one of
- * entrance/emphasis/exit without touching the others; remove drops the whole
- * entry.
- */
-interface AnimationActions {
-    addAnimation(group: AnimationGroup, preset: g): void;
-    removeAnimation(): void;
-}
-
-/**
- * Z-order, align, flip, and group/ungroup actions for the ribbon's
- * Home > Arrange group.
- *
- * Align/distribute: the vanilla editor's selection model is single-element
- * only (see `state/viewer-state.ts`), so `alignElements` reaches the
- * single-selection "align to slide" mode ({@link alignToCanvas}), matching
- * PowerPoint's own behaviour when nothing else is selected. Multi-selection
- * "align to selection bounding box" / distribute (needing >= 2 / >= 3
- * elements, see `editor-arrange-mutations.ts`) is unreachable until a
- * multi-select model lands; `canDistribute` is therefore always `false` today
- * (see `editing-chrome-sync.ts`), a documented limitation rather than a bug.
- *
- * Group: needs >= 2 selected elements to be meaningful, so it too is
- * unreachable under single selection; `groupSelected` is a deliberate no-op
- * kept only so the ribbon button (permanently disabled, with an explanatory
- * title) has something to call. Ungroup works today: it applies to whichever
- * single `group` element is selected.
- */
-interface ArrangeActions {
-    bringForward(): void;
-    sendBackward(): void;
-    bringToFront(): void;
-    sendToBack(): void;
-    alignElements(edge: AlignEdge): void;
-    flipHorizontal(): void;
-    flipVertical(): void;
-    groupSelected(): void;
-    ungroupSelected(): void;
-}
-
-/**
- * Slide-background actions for the ribbon's Design > Format Background panel.
- * Solid-colour fill only (matches the docked panel's scope: a single colour
- * input); clearing removes every background field so the slide falls back to
- * its layout/master background. Both mutations are history-integrated,
- * mirroring `editor-slide-actions.ts`.
- */
-interface SlideBackgroundActions {
-    setSlideBackgroundColor(color: string): void;
-    clearSlideBackground(): void;
-}
-
-/**
- * Cut/copy/paste actions for the ribbon's Home > Clipboard group, backed by
- * the shared `element-clipboard.ts` codec. The in-memory clipboard payload
- * lives on `ViewerState.clipboardPayload` (not a module-level variable) so
- * the ribbon's selection sync can reactively enable/disable the Paste button.
- */
-interface ClipboardActions {
-    copy(): void;
-    cut(): void;
-    paste(): void;
-}
-
-/**
- * Ink stroke actions for the Draw ribbon tab: commit a freehand pen/
- * highlighter stroke as a new `InkPptxElement`, or erase an existing one.
- * Both mutations are history-integrated (push -> mutate -> commit), mirroring
- * `editor-background-actions.ts` and the `insertElement` helper in
- * `editor-edit-ops.ts`. The pointer-event lifecycle that accumulates a
- * stroke's points lives separately in `editor-draw-gestures.ts`; this module
- * only owns the resulting slide/history mutation.
- */
-interface InkActions {
-    /**
-     * Build an `InkPptxElement` from a completed stroke (via the shared
-     * `strokeToInkElement`) and append it to the current slide, selected.
-     * A no-op when not editable, there is no current slide, or the stroke has
-     * fewer than 2 points (shared helper returns `null`, matching a plain tap).
-     */
-    commitStroke(stroke: StrokeToInkElementOpts): void;
-    /**
-     * Remove the ink element with `id` from the current slide (Draw tab's
-     * eraser tool). Returns `true` when an ink element was found and removed;
-     * `false` for a missing id, a non-ink element, or a read-only viewer (safe
-     * to call from a generic stage hit-test without a pre-check).
-     */
-    eraseInkElement(id: string): boolean;
-}
-
-/**
- * Insert-element factories for the vanilla editor.
- *
- * The pure builders wrap the framework-agnostic core/shared factories
- * (`createTextElement`, `createShapeElement`, `createConnectorElement`,
- * `newTableElement`) and centre the new element on the slide canvas. The one
- * async helper (`pickImageElement`) owns the file-picker + `FileReader` DOM
- * side effects needed to turn a chosen image file into a data-URL image
- * element; it too returns a centred, ready-to-insert element.
- */
-/** The element kinds the Insert ribbon tab can create directly. */
-type InsertKind = 'text' | 'table' | 'shape';
-
-/**
- * Element-type-aware inspector actions: text vertical-align/wrap/autofit,
- * gradient fill + fill/stroke opacity, image brightness/contrast/saturation +
- * crop, and table-level header-row/banded-rows/cell-padding. Every method is a
- * thin `applyToSelected` wrapper around pure builders from `pptx-viewer-shared`
- * (or the local `patchShapeStyle`), mirroring `editor-text-actions.ts`.
- *
- * These extend the base position/size/rotation + flat fill/stroke inspector
- * that `editor-edit-ops.ts` already exposes; see `ui/inspector/` for the
- * per-element-type panels that call these.
- */
-interface InspectorActions {
-    setTextVerticalAlign(vAlign: NonNullable<a0['vAlign']>): void;
-    setTextWrap(wrap: NonNullable<a0['textWrap']>): void;
-    setAutoFitMode(mode: NonNullable<a0['autoFitMode']>): void;
-    setFillOpacity(opacity: number): void;
-    setStrokeOpacity(opacity: number): void;
-    setGradientFill(state: GradientState): void;
-    addGradientStop(color: string, position: number): void;
-    removeGradientStop(index: number): void;
-    updateGradientStop(index: number, changes: Partial<GradientState['stops'][number]>): void;
-    setImageBrightness(value: number): void;
-    setImageContrast(value: number): void;
-    setImageSaturation(value: number): void;
-    setImageCrop(edge: 'left' | 'top' | 'right' | 'bottom', value: number): void;
-    setTableHeaderRow(enabled: boolean): void;
-    setTableBandedRows(enabled: boolean): void;
-    setTableCellPadding(padding: number): void;
-}
-
-/**
- * New/duplicate/delete-slide actions for the ribbon's Home > Slides group,
- * backed by the shared `slide-operations.ts` factory. Every mutation is
- * history-integrated (matches the element-level actions in `editor-edit-ops`)
- * and renumbers `slideNumber` across the whole deck so it always matches the
- * array index (mirrors the Vue `useSlideOperations` contract).
- */
-interface SlideActions {
-    addSlide(): void;
-    duplicateSlide(): void;
-    deleteSlide(): void;
-}
-
-/**
- * Character + paragraph formatting actions for the ribbon's Home > Font and
- * Home > Paragraph groups. Every method is a thin `applyToSelected` wrapper
- * around the pure builders in `editor-format-mutations.ts` /
- * `editor-paragraph-mutations.ts`; this file owns none of the mutation logic
- * itself, only the selection/history wiring shared by the whole action set.
- */
-interface TextActions {
-    toggleBold(): void;
-    toggleItalic(): void;
-    toggleUnderline(): void;
-    toggleStrikethrough(): void;
-    toggleTextShadow(): void;
-    changeFontSize(delta: number): void;
-    setFontSize(size: number): void;
-    setFontFamily(family: string): void;
-    setTextColor(color: string): void;
-    setHighlightColor(color: string): void;
-    setCharacterSpacing(value: number): void;
-    changeCase(mode: ChangeCaseMode): void;
-    clearFormatting(): void;
-    toggleBulletList(): void;
-    toggleNumberedList(): void;
-    increaseIndent(): void;
-    decreaseIndent(): void;
-    setTextAlign(align: a0['align']): void;
-    setLineSpacing(value: number): void;
-}
-
-/**
- * Slide-transition actions for the ribbon's Transitions tab. Playback already
- * reads `PptxSlide.transition` (see `animation/presentation-playback.ts`), so
- * this only needs to write that same field, history-integrated like every
- * other ribbon mutation.
- *
- * `applyTransition` covers both the preset gallery buttons and the duration
- * input (the tab re-applies the currently-selected preset whenever the
- * duration changes), plus the "Apply to All Slides" checkbox: when
- * `applyToAll` is true every slide gets the same fresh `{ type, durationMs }`
- * transition; otherwise only the current slide is patched, preserving any
- * advanced fields (direction, sound, ...) it already carried.
- */
-interface TransitionActions {
-    applyTransition(type: k, durationMs: number, applyToAll: boolean): void;
-}
-
-/** A geometry patch from the inspector (all fields optional). */
-interface GeometryPatch {
-    x?: number;
-    y?: number;
-    width?: number;
-    height?: number;
-    rotation?: number;
-}
-/**
- * The full set of formatting / insert / arrange / clipboard / slide actions
- * exposed to the editing chrome (ribbon, inspector). Composed from the
- * focused per-concern action files (`editor-text-actions.ts`,
- * `editor-arrange-actions.ts`, `editor-clipboard-actions.ts`,
- * `editor-slide-actions.ts`) plus the shape/geometry/insert actions owned
- * directly here. Every mutating action is history-integrated (push -> mutate
- * -> commit) via the shared {@link EditorOps}.
- */
-interface EditActions extends TextActions, ArrangeActions, ClipboardActions, SlideActions, SlideBackgroundActions, TransitionActions, AnimationActions, InspectorActions, InkActions {
-    setShapeFill(color: string): void;
-    setShapeStroke(color: string): void;
-    setShapeStrokeWidth(width: number): void;
-    /** Commit an inspector geometry edit (X/Y/W/H/rotation). */
-    setGeometry(patch: GeometryPatch): void;
-    insert(kind: InsertKind, shapeType?: ShapePresetType): void;
-    insertImage(): Promise<void>;
-    insertMedia(): Promise<void>;
-    insertChart(chartType: l): void;
-    insertSmartArt(layout: ca, defaultItems: string[]): void;
-    insertEquation(omml: Record<string, unknown>): void;
-    insertActionButton(shapeType: string): void;
-    insertField(fieldType: string, value?: string): void;
-    duplicateSelected(): void;
-    deleteSelected(): void;
-}
-
-/**
- * Find & Replace actions for the ribbon's Home > Editing group, backed by the
- * shared `find-replace.ts` helpers. A lean, docked-panel implementation:
- * `search` reports a match count for the query, `replaceCurrent` replaces the
- * first match, and `replaceAll` replaces every match; there is no in-canvas
- * match highlighting or "next/previous match" cursor (that needs per-match
- * selection/scroll wiring into the renderer, out of scope for this wave).
- * Every replace is history-integrated like every other editor action.
- */
-interface FindReplaceActions {
-    /** Count occurrences of `query` across all slides (does not mutate). */
-    search(query: string, matchCase: boolean): number;
-    /** Replace the first match of `query`; returns the number replaced (0 or 1). */
-    replaceCurrent(query: string, replacement: string, matchCase: boolean): number;
-    /** Replace every match of `query`; returns the number replaced. */
-    replaceAll(query: string, replacement: string, matchCase: boolean): number;
-}
-
-/**
- * Minimal i18n for the vanilla binding.
- *
- * The other bindings delegate to their framework's i18n runtime (react-i18next,
- * vue-i18n, ngx-translate) fed by the shared `pptx.*` dictionary. The vanilla
- * binding has no framework, so this module provides the one missing piece: a
- * `t(key, params)` lookup with `{{param}}` interpolation over the same shared
- * English dictionary, plus per-locale overrides supplied by the host.
- *
- * Resolution order: host dictionary for the active locale, then the built-in
- * English dictionary, then a humanised fallback derived from the key (shared
- * `keyToLabel`), so a missing key never renders as a raw `pptx.*` string.
- */
-/** Translate a dotted `pptx.*` key with optional `{{param}}` interpolation. */
-type Translator = (key: string, params?: Record<string, string | number>) => string;
-/** Locale to flat `key: message` dictionary map supplied by the host. */
-type TranslationMessages = Record<string, Record<string, string>>;
-/**
- * Build a {@link Translator} for a locale. `messages[locale]` (when provided)
- * wins over the built-in English dictionary; English is always the fallback.
- */
-declare function createTranslator(locale?: string, messages?: TranslationMessages): Translator;
-
-/** Selection-derived state the inspector reflects, computed by `buildInspectorState`. */
-interface InspectorState {
-    hasSelection: boolean;
-    canShape: boolean;
-    canText: boolean;
-    isImage: boolean;
-    isTable: boolean;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    rotation: number;
-    fillColor: string | undefined;
-    strokeColor: string | undefined;
-    strokeWidth: number;
-    fillOpacity: number;
-    strokeOpacity: number;
-    gradientEnabled: boolean;
-    gradient: GradientState;
-    vAlign: 'top' | 'middle' | 'bottom';
-    textWrap: 'square' | 'none';
-    autoFitMode: 'shrink' | 'normal' | 'none';
-    imageBrightness: number;
-    imageContrast: number;
-    imageSaturation: number;
-    cropLeft: number;
-    cropTop: number;
-    cropRight: number;
-    cropBottom: number;
-    tableHeaderRow: boolean;
-    tableBandedRows: boolean;
-    tableCellPadding: number;
-}
-interface Inspector {
-    el: HTMLElement;
-    update(state: InspectorState): void;
-    setEditable(editable: boolean): void;
-}
-
-/** 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;
-}
-
-/** Draw tab state to reflect (current tool/colour/width). */
-interface RibbonDrawState {
-    tool: DrawTool;
-    color: string;
-    width: number;
-}
-/** Nav-row state (prev/next/counter/zoom label). */
-interface RibbonNavState {
-    current: number;
-    total: number;
-    zoomPercent: number;
-}
-/** Primary-row + tab-bar visibility state. */
-interface RibbonEditState {
-    editable: boolean;
-    canUndo: boolean;
-    canRedo: boolean;
-}
-/** Selection-derived state the Home tab's Font/Paragraph/Arrange groups reflect. */
-interface RibbonSelectionState {
-    hasClipboard: boolean;
-    slideCount: number;
-}
-
-interface Ribbon {
-    el: HTMLElement;
-    update(state: RibbonNavState): void;
-    setEditState(state: RibbonEditState): void;
-    setNotesExpanded(expanded: boolean): void;
-    setAutosaveStatus(label: string, kind: 'idle' | 'saving' | 'saved' | 'error'): void;
-    /** Show/hide the whole editing surface (Home/Insert tab content + find/replace). */
-    setEditable(editable: boolean): void;
-    /** Reflect the current selection across the Home tab's Font/Paragraph/Arrange groups. */
-    updateSelection(selectedElement: a | undefined, extra: RibbonSelectionState): void;
-    /** Reflect the current Draw tab tool/colour/width (store-driven). */
-    setDrawState(state: RibbonDrawState): 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;
-}
-
-/** The viewer's static DOM skeleton plus the mutable overlay controls. */
-interface ViewerChrome {
-    /** `.pptxv` root (focusable; keyboard navigation attaches here). */
-    root: HTMLElement;
-    /** The tabbed ribbon (primary row, nav row, tab bar + File/Home/Insert/View content); null when disabled. */
-    ribbon: Ribbon | null;
-    /** Property inspector panel; null when disabled. */
-    inspector: Inspector | 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;
-}
-
-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;
-    /** Switch the Draw ribbon tab's active tool (also clears selection when leaving `'select'`). */
-    setDrawTool(tool: DrawTool): void;
-    /** Set the pen/highlighter stroke colour used by the next committed stroke. */
-    setDrawColor(color: string): void;
-    /** Set the pen/highlighter stroke width used by the next committed stroke. */
-    setDrawWidth(width: number): void;
-    /** The formatting / insert / arrange actions for the editing chrome. */
-    getEditActions(): EditActions;
-    /** The Find & Replace actions for the ribbon's docked panel. */
-    getFindReplaceActions(): FindReplaceActions;
-    /** 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;
-}
-
-/** Everything the controller needs after a stage (re)render. */
-interface SyncStageParams {
-    doc: Document;
-    /** The stage host (position: relative), for layering a transition overlay. */
-    stageWrap: HTMLElement;
-    /** The freshly rendered, fully-visible main stage node. */
-    stage: HTMLElement;
-    /** The slide the stage renders, or `undefined` when empty. */
-    slide: P | undefined;
-    /** Zero-based index of the rendered slide. */
-    slideIndex: number;
-    /** True only when the live (fullscreen) presentation stage is active. */
-    presenting: boolean;
-}
-/**
- * The presentation-mode playback state machine for the vanilla binding.
- *
- * It owns the click-stepped animation cursor and the slide-transition overlay,
- * both driven by the shared framework-agnostic helpers. It is consulted from
- * two seams in the rebuild-per-change render flow:
- *
- *  - {@link PresentationPlayback.syncStage} runs after every stage render:
- *    on a slide entry it rebuilds the click groups, resets the step, hides
- *    pending entrances, and (when the slide changed mid-show) plays the
- *    incoming slide's transition over a snapshot of the outgoing stage.
- *  - {@link PresentationPlayback.advance} runs on each forward navigation
- *    key/tap while presenting: it reveals the next animation build in place
- *    (no rebuild) and reports whether a build remained, so the caller only
- *    advances the slide once the timeline is exhausted.
- */
-interface PresentationPlayback {
-    /**
-     * Reveal the next on-click animation build for the current slide. Returns
-     * `true` if a build was revealed (stay on the slide); `false` when the
-     * slide's builds are exhausted (the caller should advance to the next slide).
-     */
-    advance(): boolean;
-    /** True when every click group on the current slide has been revealed. */
-    isComplete(): boolean;
-    /** Sync playback + transitions after a stage (re)render. */
-    syncStage(params: SyncStageParams): void;
-    /** Cancel any running transition and forget all per-slide state. */
-    reset(): void;
-}
-
-/** Discriminant values of the {@link PptxElement} union (`'text'`, `'chart'`, ...). */
-type PptxElementType = a['type'];
-/**
- * Everything an element renderer may need, passed to every renderer call.
- *
- * The context is immutable per slide render. Renderers must create DOM through
- * `context.document` (never the global `document`) so slides can render into
- * detached documents (tests, export pipelines).
- */
-interface ElementRenderContext {
-    /** Document used for all DOM creation. */
-    readonly document: Document;
-    /** The slide being rendered. */
-    readonly slide: P;
-    /** Full slide canvas size in CSS px (elements are positioned in this space). */
-    readonly canvasSize: CanvasSize;
-    /**
-     * The scale the stage is rendered at (1 = 100%). The stage applies it via a
-     * CSS transform, so renderers should lay out in unscaled canvas px; `scale`
-     * is informational (e.g. for raster density decisions).
-     */
-    readonly scale: number;
-    /** Archive-path to displayable URL map for media + poster frames. */
-    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: a, zIndex: number): HTMLElement | SVGElement | null;
-}
-/**
- * Renders one slide element to a DOM node (or `null` to render nothing).
- *
- * Contract:
- * - Position absolutely within the stage: apply the shared
- *   `getContainerStyle(element, zIndex)` map (or equivalent) to the returned
- *   root node.
- * - Set `dataset.elementId = element.id` on the root node.
- * - Create all DOM via `context.document`.
- * - Never mutate `element` or anything on the context.
- */
-type ElementRenderer = (element: a, zIndex: number, context: ElementRenderContext) => HTMLElement | SVGElement | null;
-/**
- * Registry dispatching elements to renderers by their `type` discriminant.
- *
- * Additional element types are supported by registering a renderer for the
- * type; unregistered types fall through to the fallback renderer (a typed
- * placeholder box by default). See `render/elements/README.md` for the
- * step-by-step contract.
- */
-interface ElementRendererRegistry {
-    /** Register (or replace) the renderer for an element type. */
-    register(type: PptxElementType, renderer: ElementRenderer): void;
-    /** Remove the renderer for an element type (falls back afterwards). */
-    unregister(type: PptxElementType): void;
-    /** The renderer registered for a type, or `undefined`. */
-    get(type: PptxElementType): ElementRenderer | undefined;
-    /** True when a dedicated (non-fallback) renderer is registered. */
-    has(type: PptxElementType): boolean;
-    /** Replace the fallback renderer used for unregistered types. */
-    setFallback(renderer: ElementRenderer): void;
-    /** The renderer to use for a type: registered renderer or fallback. */
-    resolve(type: PptxElementType): ElementRenderer;
-    /** All types with a dedicated renderer (sorted, for tests/debugging). */
-    registeredTypes(): PptxElementType[];
-}
-
-/**
- * Create an empty {@link ElementRendererRegistry}.
- *
- * The default fallback renders nothing; `createDefaultRegistry()` (in
- * `./elements`) installs the built-in renderers plus the typed placeholder
- * fallback.
- */
-declare function createElementRendererRegistry(): ElementRendererRegistry;
-
-/**
- * Apply a shared `CssStyleMap` to an element. The shared builders emit a mix
- * of camelCase (`backgroundColor`) and kebab-case (`background-color`) keys;
- * both are normalised to `style.setProperty` calls.
- */
-declare function applyStyleMap(el: HTMLElement | SVGElement, style: CssStyleMap): void;
-/** Create an element with an optional class and style map. */
-declare function createEl<K extends keyof HTMLElementTagNameMap>(doc: Document, tag: K, className?: string, style?: CssStyleMap): HTMLElementTagNameMap[K];
-/** Create a namespaced SVG element with optional attributes. */
-declare function createSvgEl<K extends keyof SVGElementTagNameMap>(doc: Document, tag: K, attrs?: Record<string, string | number | undefined>): SVGElementTagNameMap[K];
-
-interface SlideStageOptions {
-    document: Document;
-    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
- * every element dispatched through the registry, scaled with a CSS transform
- * (`transform-origin: top left`), exactly like the other bindings' stages.
- *
- * The returned node is `canvasSize * scale` ON SCREEN but laid out at the
- * unscaled canvas size, so the caller should wrap it in a box sized to
- * `canvasSize * scale` (the viewer's stage host and thumbnails both do).
- */
-declare function renderSlideStage(options: SlideStageOptions): HTMLElement;
-
-/**
- * The registry the viewer uses by default.
- *
- * Dedicated renderers: `text`, `shape`, `image`, `picture`, `group`,
- * `connector`, `table`, `chart`, `smartArt`, `media`, `ink`, `ole`. The
- * remaining types (`contentPart`, `zoom`, `model3d`, `unknown`) fall through
- * to the typed placeholder fallback until their renderers land; see
- * `./README.md` for the contract to add one.
- */
-declare function createDefaultRegistry(): ElementRendererRegistry;
-
-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;
-    /**
-     * Presentation-mode animation/transition playback, driven by the stage
-     * rebuild flow. Navigation (`viewer-controls`) consults `advance()` so a
-     * "next" first steps the on-click animation timeline before advancing slides.
-     */
-    readonly presentationPlayback: PresentationPlayback;
-}
-
-/**
- * Debounced autosave for the vanilla viewer, layered on the shared IndexedDB
- * recovery store (`pptx-viewer-shared/autosave-store`).
- *
- * Semantics mirror the React/Vue bindings: a local edit marks the document
- * dirty; a debounce timer then re-serializes the deck through
- * `PptxHandler.save` and persists it under `filePath` via
- * `saveAutosaveSnapshot` (evicting the oldest record on quota exhaustion). The
- * recovery blob is a crash-safety net only; it never clears the editor's dirty
- * flag or stands in for the user's real Save.
- *
- * On construction it probes `getAutosaveSnapshot(filePath)` and, when a snapshot
- * from a previous session exists, offers it back through `onRecovery` so the
- * host can decide whether to restore it (e.g. via `loadFile`).
- */
-type AutosaveStatus = 'idle' | 'saving' | 'saved' | 'error';
-
-/**
- * share-helpers.ts: pure (framework-free) helpers for the Share dialog.
- *
- * Mirrors the Vue `ShareDialog.vue` / Angular `share-helpers.ts` form
- * validation and config-assembly logic (see `useCollaborationWiring.onShareStart`
- * for the `role: 'collaborator'` config this produces). No DOM here so it is
- * trivially unit-testable; the DOM builder lives in `ui/share-dialog.ts`.
- */
-/** Prefilled values for the Share form fields. */
-interface ShareDefaults {
-    roomId?: string;
-    userName?: string;
-    serverUrl?: string;
-}
-
-/** Per-slide progress callback: `(currentSlideIndex, totalSlides)`. */
-type ExportProgress = (current: number, total: number) => void;
-
-/**
- * Animated-GIF export for the vanilla binding. All slides are captured (one
- * frame per slide) via the injected `rasterizeSlide`, then encoded with the
- * shared pure-JS GIF89a encoder (`pptx-viewer-shared` `gif-encoder`: median-cut
- * quantisation + LZW). Frame timing comes from the shared `planGifFrames`
- * planner and oversized captures are downscaled via `clampGifDimensions`; only
- * the DOM capture / canvas scaling / Blob download driver lives here.
- */
-/** Options for the animated-GIF export (all slides, one frame per slide). */
-interface ExportGifOptions {
-    /**
-     * Duration each slide is shown, in milliseconds (default 2000). Per-slide
-     * overrides can be supplied via {@link ExportGifOptions.slideTimingsMs}.
-     */
-    slideDurationMs?: number;
-    /**
-     * Per-slide duration overrides in milliseconds (index maps to slide index,
-     * e.g. rehearsed timings). Flows through the shared `planGifFrames` plan
-     * into per-frame GIF delays.
-     */
-    slideTimingsMs?: number[];
-    /**
-     * Cap on the longer side of the encoded frames, in pixels (default 1920).
-     * Captured canvases larger than this are downscaled before quantisation,
-     * keeping encode time and file size manageable.
-     */
-    maxDimension?: number;
-    /** Capture-phase progress callback: `(currentSlide, totalSlides)`. */
-    onProgress?: ExportProgress;
-    /** Abort the export early; the capture loop checks this between slides. */
-    signal?: AbortSignal;
-}
-
-/**
- * Print for the vanilla binding, assembled entirely from the shared print
- * module (`pptx-viewer-shared` `print-document`): `validatePrintSettings`,
- * `computeSlideIndices` / `computeColorFilter`, the `build*Html` body markup
- * builders, and the DOMPurify-hardened `buildPrintHtmlDocument` assembler.
- * Only the drivers live here: rasterising the selected slides to data URLs and
- * writing the document into a print window. Vanilla port of Vue's `usePrint`
- * raster path (slides / notes / handouts / outline).
- */
-/**
- * Open a print window for a complete HTML document and trigger printing.
- * Returns `false` when the window could not be opened (popup blocker).
- */
-type OpenPrintWindow = (htmlDocument: string) => boolean;
-/**
- * Options for `print`: any subset of the shared `PrintSettings` (unspecified
- * fields fall back to `DEFAULT_PRINT_SETTINGS`, i.e. all slides, landscape,
- * full colour) plus progress/abort and a print-window override.
- */
-interface PrintOptions extends Partial<PrintSettings> {
-    /** Rasterisation progress callback: `(currentSlide, totalSlidesToPrint)`. */
-    onProgress?: ExportProgress;
-    /** Abort before the window opens; checked between slide captures. */
-    signal?: AbortSignal;
-    /**
-     * Override how the assembled document is opened (e.g. write it into a
-     * hidden iframe). Popup-blocker caveat: the default opener uses
-     * `window.open`, which browsers typically only allow inside a user
-     * gesture, so call `print()` from a click handler; when the popup is
-     * blocked the returned promise resolves `false`.
-     */
-    openPrintWindow?: OpenPrintWindow;
-}
-
-/**
- * WebM video export for the vanilla binding, driven by the shared `video-plan`
- * module: `planVideoSegments` (per-slide segment timing + frame counts),
- * `fpsToFrameIntervalMs` (draw-loop pacing), and `pickSupportedMimeType` over
- * `WEBM_MIME_CANDIDATES` (MediaRecorder codec selection). Only the browser
- * driver lives here: capture each slide to a canvas, replay the canvases onto
- * a recording canvas fed to `captureStream()` + `MediaRecorder`, and download
- * the resulting Blob. Vanilla port of React's `exportAllSlidesAsVideo`.
- */
-/** Options for the WebM video export (all slides). */
-interface ExportVideoOptions {
-    /** Duration each slide is held, in milliseconds (default 3000). */
-    slideDurationMs?: number;
-    /** Per-slide duration overrides in milliseconds (index maps to slide index). */
-    slideTimingsMs?: number[];
-    /** Recording frame rate in frames per second (default 30). */
-    fps?: number;
-    /** MediaRecorder video bitrate in bits per second (default 5,000,000). */
-    videoBitsPerSecond?: number;
-    /** Capture-phase progress callback: `(currentSlide, totalSlides)`. */
-    onProgress?: ExportProgress;
-    /** Recording-phase progress callback: `(currentSlide, totalSlides)`. */
-    onRecordProgress?: ExportProgress;
-    /** Abort the export early; checked between slides and between frames. */
-    signal?: AbortSignal;
-}
-
-/** 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;
-}
-
-/**
- * Content sources accepted by the vanilla viewer: raw bytes, a Blob/File, or
- * a URL string to fetch.
- */
-type PptxViewerSource = ArrayBuffer | Uint8Array | Blob | string;
-
-/** Callbacks mirroring the Vue component's emits. */
-interface PptxViewerCallbacks {
-    /** Fired after a presentation loads successfully. */
-    onLoad?: (info: {
-        slideCount: number;
-        canvasSize: CanvasSize;
-    }) => void;
-    /** Fired when a load fails (message is already localised/best-effort). */
-    onError?: (message: string, error: unknown) => void;
-    /** Fired when the active slide changes (zero-based index). */
-    onSlideChange?: (index: number) => void;
-    /** Fired when the effective zoom scale changes (1 = 100%). */
-    onZoomChange?: (scale: number) => void;
-    /** Fired when presentation (fullscreen) mode is entered or exited. */
-    onPresentationChange?: (presenting: boolean) => void;
-    /** Fired after any document mutation (move, resize, edit, undo, ...). */
-    onChange?: () => void;
-    /** Fired when the unsaved-edits flag flips (a save resets it). */
-    onDirtyChange?: (dirty: boolean) => void;
-    /** Fired when the selected element changes (`null` = no selection). */
-    onSelectionChange?: (elementId: string | null) => void;
-    /** Fired on every autosave lifecycle transition (`saving`/`saved`/`error`). */
-    onAutosaveStatus?: (status: AutosaveStatus) => void;
-    /**
-     * Offered a recovery snapshot found in the shared IndexedDB store on start
-     * (a previous session's autosave for the same `autosaveFilePath`). The host
-     * decides whether to restore it, e.g. `viewer.loadFile(record.data)`.
-     */
-    onAutosaveRecovery?: (record: AutosaveRecord) => void;
-    /** Fired on every collaboration connection-status transition. */
-    onCollaborationStatus?: (status: ConnectionStatus) => void;
-}
-interface PptxViewerOptions extends PptxViewerCallbacks {
-    /**
-     * The presentation to open: raw `.pptx` bytes (ArrayBuffer / Uint8Array),
-     * a Blob/File, or a URL string to fetch. Omit to start empty and call
-     * `loadFile` / `loadUrl` later.
-     */
-    source?: PptxViewerSource;
-    /** Viewer chrome theme (shared `ViewerTheme`: colors, radius, CSS vars). */
-    theme?: ViewerTheme;
-    /** UI locale (default `'en'`). Dictionaries come from `messages`. */
-    locale?: string;
-    /**
-     * Per-locale `pptx.*` message dictionaries. English falls back to the
-     * built-in shared dictionary; other locales fall back to English.
-     */
-    messages?: TranslationMessages;
-    /** Zero-based slide to show after load (default 0). */
-    initialSlide?: number;
-    /**
-     * Enable editing (default `false`): click to select, drag/resize/rotate,
-     * inline text editing, keyboard shortcuts, undo/redo, and the toolbar
-     * Save button. Toggle later via `setEditable`.
-     */
-    editable?: boolean;
-    /**
-     * Legacy flag superseded by {@link editable}; kept so existing option
-     * objects stay type-valid. It has no effect.
-     */
-    readOnly?: boolean;
-    /** Show the toolbar (default `true`). */
-    showToolbar?: boolean;
-    /** Show the thumbnail sidebar (default `true`). */
-    showThumbnails?: boolean;
-    /**
-     * Build the editing format toolbar row (bold/fill/insert/z-order); default
-     * `true`. The row is only *visible* while editing is enabled.
-     */
-    showFormatToolbar?: boolean;
-    /**
-     * Build the property inspector panel (position/size/fill/line); default
-     * `true`. Only *visible* while editing is enabled.
-     */
-    showInspector?: boolean;
-    /**
-     * Custom element-renderer registry. Defaults to `createDefaultRegistry()`;
-     * pass your own (or mutate the default via `getRegistry()`) to add or
-     * 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;
-    /**
-     * Enable debounced autosave (default `false`): after each local edit the deck
-     * is re-serialized and stashed in the shared IndexedDB recovery store as a
-     * crash-safety net (it never replaces the user's real Save). The toolbar shows
-     * a small status pill; a snapshot from a prior session is offered through
-     * {@link PptxViewerCallbacks.onAutosaveRecovery}.
-     */
-    autosave?: boolean;
-    /** Debounce window (ms) between an edit and the persisted snapshot (default 2000). */
-    autosaveIntervalMs?: number;
-    /** IndexedDB recovery key for autosave (default `'presentation.pptx'`). */
-    autosaveFilePath?: string;
-    /**
-     * Start a real-time collaboration session immediately (Yjs over y-websocket
-     * or serverless y-webrtc). Local edits publish to peers and remote edits
-     * merge in granularly; a `role: 'viewer'` config forces read-only. Start or
-     * stop a session later with {@link PptxViewerInstance.startCollaboration} /
-     * {@link PptxViewerInstance.stopCollaboration}.
-     *
-     * Note: media/OLE/3D/ink binary payloads are not carried over the wire (a
-     * shared codec limitation), and a remote update replaces the whole local
-     * slide array, so a joiner's host-provided media can degrade.
-     */
-    collaboration?: CollaborationConfig;
-    /**
-     * Prefilled values for the built-in Share/Broadcast dialogs' form fields
-     * (e.g. a host-generated display name), mirroring the Vue binding's
-     * `shareDefaults` prop. The broadcast dialog uses `userName` as the
-     * presenter's display name.
-     */
-    shareDefaults?: ShareDefaults;
-}
-/** The viewer handle returned by `createPptxViewer`. */
-interface PptxViewerInstance {
-    /** Load a presentation from bytes or a Blob/File (replaces the current one). */
-    loadFile(file: Blob | ArrayBuffer | Uint8Array): Promise<void>;
-    /** Fetch and load a presentation from a URL. */
-    loadUrl(url: string): Promise<void>;
-    /** Go to the next slide (no-op on the last slide). */
-    next(): void;
-    /** Go to the previous slide (no-op on the first slide). */
-    prev(): void;
-    /** Jump to a zero-based slide index (clamped). */
-    goToSlide(index: number): void;
-    /** Number of slides in the loaded presentation (0 when none). */
-    getSlideCount(): number;
-    /** Zero-based index of the visible slide. */
-    getCurrentSlide(): number;
-    /** Effective zoom scale (1 = 100%), after fit resolution. */
-    getZoom(): number;
-    /** Set an explicit zoom scale, or `'fit'` for fit-to-viewport. */
-    setZoom(zoom: ZoomLevel): void;
-    zoomIn(): void;
-    zoomOut(): void;
-    zoomToFit(): void;
-    /** Apply a new viewer theme (pass `undefined` to reset to defaults). */
-    setTheme(theme: ViewerTheme | undefined): void;
-    /** Switch the UI locale (rebuilds the chrome labels). */
-    setLocale(locale: string): void;
-    /** Enter presentation mode (real Fullscreen API). */
-    enterPresentation(): Promise<void>;
-    /** Exit presentation mode. */
-    exitPresentation(): Promise<void>;
-    /** Enable or disable editing at runtime (disabling clears the selection). */
-    setEditable(editable: boolean): void;
-    /** Undo the last edit (no-op when the undo stack is empty). */
-    undo(): void;
-    /** Redo the last undone edit (no-op when the redo stack is empty). */
-    redo(): void;
-    canUndo(): boolean;
-    canRedo(): boolean;
-    /** Serialise the (edited) presentation to `.pptx` bytes and clear dirty. */
-    save(): Promise<Uint8Array>;
-    /** `save()` + trigger a browser download (default `presentation.pptx`). */
-    downloadPptx(fileName?: string): Promise<void>;
-    /** Delete the selected element (no-op without a selection). */
-    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>;
-    /**
-     * Export every slide as an animated GIF download (one frame per slide,
-     * `slideDurationMs` per frame). Slides are captured off-screen like
-     * `exportSlidePng` and encoded with the shared pure-JS GIF89a encoder.
-     */
-    exportGif(options?: ExportGifOptions): Promise<void>;
-    /**
-     * Export every slide as a WebM video download: each captured slide is held
-     * for its configured duration on a canvas stream recorded by
-     * `MediaRecorder` (codec picked from the shared WebM candidates).
-     */
-    exportVideo(options?: ExportVideoOptions): Promise<void>;
-    /**
-     * Assemble the printable document (slides / notes / handouts / outline)
-     * and open it in a new print window. Resolves `false` when the popup was
-     * blocked: browsers typically only allow `window.open` inside a user
-     * gesture, so call this from a click handler (or pass a custom
-     * `openPrintWindow` that writes into an iframe you own).
-     */
-    print(options?: PrintOptions): Promise<boolean>;
-    /** The element-renderer registry in effect (extension point). */
-    getRegistry(): ElementRendererRegistry;
-    /**
-     * Escape hatch: the live `pptx-viewer-core` handler for the loaded file
-     * (or `null`). Enables advanced operations (save, markdown conversion,
-     * archive access) without extra APIs here.
-     */
-    getHandler(): PptxHandler | null;
-    /**
-     * Start (or restart) a real-time collaboration session. Resolves once the
-     * transport is created; connection status arrives via
-     * {@link PptxViewerCallbacks.onCollaborationStatus}.
-     */
-    startCollaboration(config: CollaborationConfig): Promise<void>;
-    /** Stop the active collaboration session (no-op when none is running). */
-    stopCollaboration(): void;
-    /** Current collaboration connection status (`'disconnected'` when inactive). */
-    getCollaborationStatus(): ConnectionStatus;
-    /** Force an immediate autosave snapshot (no-op when autosave is disabled). */
-    autosaveNow(): Promise<void>;
-    /** Tear down DOM, listeners, Blob URLs, and the core handler. */
-    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;
-        getEditActions(): EditActions;
-        getFindReplaceActions(): FindReplaceActions;
-        setDrawTool(tool: DrawTool): void;
-        setDrawColor(color: string): void;
-        setDrawWidth(width: number): 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>;
-    exportSlidePng(): Promise<void>;
-    exportPdf(): Promise<void>;
-    exportGif(): Promise<void>;
-    exportVideo(): Promise<void>;
-    print(): Promise<boolean>;
-    setTheme(theme: ViewerTheme | undefined): void;
-}
-
-/** The export slice of the public viewer API (see `PptxViewerInstance`). */
-interface ViewerExportApi {
-    /** Export a single slide as a PNG download. Defaults to the current slide. */
-    exportSlidePng(index?: number): Promise<void>;
-    /** Export every slide as a multi-page PDF download (one slide per page). */
-    exportPdf(options?: ExportPdfOptions): Promise<void>;
-    /** Export every slide as an animated GIF download (one frame per slide). */
-    exportGif(options?: ExportGifOptions): Promise<void>;
-    /** Export every slide as a WebM video download (MediaRecorder). */
-    exportVideo(options?: ExportVideoOptions): Promise<void>;
-    /** Open the assembled print document in a print window (`false` = blocked). */
-    print(options?: PrintOptions): Promise<boolean>;
-}
-interface ExportLifecycle extends ViewerExportApi {
-    /** Remove the off-screen capture stage from the DOM. */
-    destroy(): void;
-}
-/**
- * Base class implementing the export slice of `PptxViewerInstance` by
- * delegating to the instance's {@link ExportLifecycle}. `PptxViewer` extends
- * this, so new export formats are wired here (and in the export controller)
- * without growing the size-capped `PptxViewer.ts`.
- */
-declare abstract class ViewerExportHost implements ViewerExportApi {
-    protected abstract readonly exporter: ExportLifecycle;
-    exportSlidePng(index?: number): Promise<void>;
-    exportPdf(options?: ExportPdfOptions): Promise<void>;
-    exportGif(options?: ExportGifOptions): Promise<void>;
-    exportVideo(options?: ExportVideoOptions): Promise<void>;
-    print(options?: PrintOptions): Promise<boolean>;
-}
-
-/**
- * The zero-framework PowerPoint viewer. Construct via {@link createPptxViewer}:
- * builds chrome inside `container`, loads `options.source` when given, and
- * re-renders through a tiny reactive store.
- */
-declare class PptxViewer extends ViewerExportHost 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;
-    protected readonly exporter: ExportLifecycle;
-    private readonly loading;
-    private readonly registry;
-    private readonly sessions;
-    private readonly controls;
-    private destroyed;
-    constructor(container: HTMLElement, options?: PptxViewerOptions);
-    loadFile(file: Blob | ArrayBuffer | Uint8Array): Promise<void>;
-    loadUrl(url: string): Promise<void>;
-    next(): void;
-    prev(): void;
-    goToSlide(index: number): void;
-    getSlideCount(): number;
-    getCurrentSlide(): number;
-    getZoom(): number;
-    setZoom(zoom: ZoomLevel): void;
-    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;
-    undo(): void;
-    redo(): void;
-    canUndo(): boolean;
-    canRedo(): boolean;
-    save(): Promise<Uint8Array>;
-    downloadPptx(fileName?: string): Promise<void>;
-    deleteSelected(): void;
-    getSelectedElementId(): string | null;
-    enterPresentation(): Promise<void>;
-    exitPresentation(): Promise<void>;
-    getRegistry(): ElementRendererRegistry;
-    getHandler(): PptxHandler | null;
-    startCollaboration(config: CollaborationConfig): Promise<void>;
-    stopCollaboration(): void;
-    getCollaborationStatus(): ConnectionStatus;
-    autosaveNow(): Promise<void>;
-    destroy(): void;
-    private remountChrome;
-}
-/** Create a PowerPoint viewer inside `container` (see {@link PptxViewerOptions}). */
-declare function createPptxViewer(container: HTMLElement, options?: PptxViewerOptions): PptxViewerInstance;
-
-/** The complete viewer stylesheet text (for hosts that self-manage CSS). */
-declare function getViewerCss(): string;
-
-export { type AutosaveRecord, type AutosaveStatus, type CollaborationConfig, type CollaborationRole, type CollaborationTransport, type ConnectionStatus, type CssStyleMap, type ElementRenderContext, type ElementRenderer, type ElementRendererRegistry, type ExportGifOptions, type ExportPdfOptions, type ExportProgress, type ExportVideoOptions, type OpenPrintWindow, type PptxElementType, PptxHandler, PptxViewer, type PptxViewerCallbacks, type PptxViewerInstance, type PptxViewerOptions, type PptxViewerSource, type PrintOptions, type SlideStageOptions, type TranslationMessages, type Translator, type ViewerState, type ZoomLevel, applyStyleMap, createDefaultRegistry, createEl, createElementRendererRegistry, createPptxViewer, createSvgEl, createTranslator, getViewerCss, renderSlideStage };