ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/presentation-show-order.d.ts

@@ -0,0 +1,163 @@
+/**
+ * presentation-show-order.ts: which slides a running slide show visits, and in
+ * what order.
+ *
+ * PowerPoint's "Hide Slide" marks a slide to be SKIPPED while presenting while
+ * keeping it in the deck, the editor, the thumbnail rail and the slide sorter.
+ * That single rule reaches into next, previous, Home, End, the end-of-show
+ * boundary and presenter view's next-slide preview, so every binding needs the
+ * same answer to "what comes after this slide". Four of the five bindings
+ * previously answered `currentIndex + 1` and presented slides their author had
+ * deliberately hidden; the rule lives here so they cannot drift again.
+ *
+ * Deliberately NOT covered here:
+ * - Jumping to a slide by typing its number. PowerPoint reaches a HIDDEN slide
+ *   that way on purpose (it is the documented escape hatch for backup slides),
+ *   so a direct jump must bypass this module and clamp against the whole deck.
+ * - Where a show STARTS. "From Current Slide" on a hidden slide is an explicit
+ *   request for that slide, exactly like a typed jump, so it is honoured; the
+ *   first forward press then escapes to the next slide the show visits.
+ * - The editor, the thumbnail rail and the slide sorter, which all keep showing
+ *   hidden slides (usually dimmed). Hiding is a slide-show rule, not a deck rule.
+ *
+ * Framework-agnostic: no React, Vue, Angular, Svelte or DOM imports.
+ */
+/**
+ * The slide fields the show-order rules read. Deliberately structural rather
+ * than `PptxSlide` so a binding can pass its own lighter view model.
+ */
+export interface ShowOrderSlide {
+    /** Relationship id (`r:id` in `p:sldIdLst`), how custom shows name slides. */
+    readonly rId?: string;
+    /** Slide id, the fallback key when a custom show stores ids instead. */
+    readonly id?: string;
+    /** `p:sld/@show="0"`: skip this slide during the show. */
+    readonly hidden?: boolean;
+}
+/**
+ * An active custom show's membership. Accepts either key the bindings carry:
+ * `slideRIds` (core's parsed `p:custShow`) or `slideIds`.
+ */
+export interface ShowOrderCustomShow {
+    readonly slideRIds?: readonly string[];
+    readonly slideIds?: readonly string[];
+}
+export interface NextShowSlideOptions {
+    /**
+     * PowerPoint's "Loop continuously until Esc". When set, running off the end
+     * wraps to the first slide of the show instead of ending it.
+     */
+    readonly loop?: boolean;
+}
+/**
+ * The ordered deck indexes a running show visits: the active custom show's
+ * membership (or the whole deck) with hidden slides removed.
+ *
+ * Hidden slides are dropped from a custom show too. Membership and the Hide
+ * Slide checkbox are independent switches in PowerPoint and hiding wins, so a
+ * slide pulled out of rotation stays out of every show it belongs to.
+ *
+ * When that leaves nothing to present the result falls back, first to the
+ * unfiltered membership and then to the whole deck. This is a deliberate
+ * deviation: PowerPoint would put up an immediate end-of-show screen, but an
+ * embedded viewer that answers "Present" with an inert black rectangle reads as
+ * a broken component, and a deck where EVERY slide is hidden is far more likely
+ * to be mis-tagged than genuinely unpresentable.
+ */
+export declare function resolveShowSlideIndexes(slides: readonly ShowOrderSlide[], activeCustomShow?: ShowOrderCustomShow | null, authoredRange?: AuthoredSlideRange | null): number[];
+/**
+ * The next slide the show visits after `deckIndex`, or `undefined` when the
+ * show has run off its end (the caller then raises the end-of-show screen or
+ * exits, per "End with black slide").
+ *
+ * From a slide the show does not include, "next" is the first show slide that
+ * comes later in the DECK, which is how a presenter escapes forward from a
+ * hidden slide they jumped to by number.
+ */
+export declare function nextShowSlideIndex(deckIndex: number, showIndexes: readonly number[], options?: NextShowSlideOptions): number | undefined;
+/**
+ * The slide the show returns to before `deckIndex`, or `undefined` at the
+ * start of the show (the caller then stays put; PowerPoint never wraps
+ * backward, not even with "Loop continuously").
+ */
+export declare function previousShowSlideIndex(deckIndex: number, showIndexes: readonly number[]): number | undefined;
+/**
+ * Whether the show has a slide after `deckIndex`.
+ *
+ * Distinct from `nextShowSlideIndex(...).loop`: a looping show ALWAYS has a
+ * next slide, but "is this the end of the deck" still decides whether a
+ * non-looping show puts up the end screen, so this ignores looping entirely.
+ */
+export declare function hasShowSlideAfter(deckIndex: number, showIndexes: readonly number[]): boolean;
+/**
+ * The slide a presenter view previews as "coming up next".
+ *
+ * It MUST be the slide the next forward press will actually land on, so this
+ * runs the same show-order rule rather than reading `slides[index + 1]`: a
+ * preview that shows a hidden slide the show is about to skip is worse than no
+ * preview, because the presenter rehearses a segue to a slide the room never
+ * sees.
+ *
+ * A running custom show is part of that rule, not an exception to it: while
+ * "Reverse" is playing, the slide after slide 3 is slide 2, and a presenter
+ * rail that previewed slide 4 would be previewing a slide the next press
+ * cannot reach. Pass the active show; omitting it presents the whole deck,
+ * which is the previous behaviour.
+ *
+ * The same holds for a `p:showPr/p:sldRg` range: on the last slide of a deck
+ * authored to play 2..3, the preview must be empty, not slide 4. Pass the
+ * resolved range (`resolveAuthoredSlideRange`) exactly as the show does.
+ */
+export declare function nextPresentedSlide<T extends ShowOrderSlide>(slides: readonly T[], deckIndex: number, activeCustomShow?: ShowOrderCustomShow | null, authoredRange?: AuthoredSlideRange | null): T | undefined;
+/** The `p:showPr` fields that name the show a deck is authored to open into. */
+export interface ShowSlidesSelection {
+    readonly showSlidesMode?: 'all' | 'customShow' | 'range';
+    readonly showSlidesCustomShowId?: string;
+    /** `p:showPr/p:sldRg/@st`: range start, 1-based, when `showSlidesMode === 'range'`. */
+    readonly showSlidesFrom?: number;
+    /** `p:showPr/p:sldRg/@end`: range end, 1-based, when `showSlidesMode === 'range'`. */
+    readonly showSlidesTo?: number;
+}
+/** A `p:showPr/p:sldRg` custom range, resolved to 0-based deck indexes. */
+export interface AuthoredSlideRange {
+    /** First slide of the range, 0-based, inclusive. */
+    readonly fromIndex: number;
+    /** Last slide of the range, 0-based, inclusive. */
+    readonly toIndex: number;
+}
+/** A custom show, as far as selecting one by id is concerned. */
+export interface SelectableCustomShow {
+    readonly id: string;
+}
+/**
+ * The custom show a deck asks to open into, or `undefined` for the whole deck.
+ *
+ * `p:showPr/p:custShow/@id` is what PowerPoint's "Set Up Slide Show > Custom
+ * show" radio writes, and it is authored intent: a deck saved that way plays
+ * that subset. Every binding parsed the two fields and then ignored them,
+ * driving playback from a separate viewer-only `activeCustomShowId`, so the
+ * radio was decorative and an authored deck played in full.
+ *
+ * An id that names no surviving show falls back to the whole deck rather than
+ * to an empty show, because a show deleted after `showPr` was written is far
+ * more likely than an author who meant "present nothing".
+ */
+export declare function resolveAuthoredCustomShowId(selection: ShowSlidesSelection | undefined, customShows: readonly SelectableCustomShow[] | undefined): string | undefined;
+/**
+ * The custom slide range (`p:showPr/p:sldRg`) a deck is authored to open
+ * into, resolved and clamped to 0-based deck indexes, or `undefined` when the
+ * deck is not in `'range'` mode or the range is unusable.
+ *
+ * `st`/`end` are 1-based in the file (`p:sldRg/@st="2" @end="5"` means slides
+ * 2 through 5), matching every other 1-based OOXML slide reference. A range
+ * whose bounds fall outside the deck (the file was edited after slides were
+ * deleted) is clamped rather than dropped, and a reversed range (`st > end`,
+ * which the schema permits) is normalised the same way PowerPoint reads it:
+ * by its lower and upper bound, not by authoring order.
+ */
+export declare function resolveAuthoredSlideRange(selection: ShowSlidesSelection | undefined, slideCount: number): AuthoredSlideRange | undefined;
+/** The show's first slide (PowerPoint's Home key), or `undefined` when empty. */
+export declare function firstShowSlideIndex(showIndexes: readonly number[]): number | undefined;
+/** The show's last slide (PowerPoint's End key), or `undefined` when empty. */
+export declare function lastShowSlideIndex(showIndexes: readonly number[]): number | undefined;
+//# sourceMappingURL=presentation-show-order.d.ts.map

package/dist/pptx/render/presentation-show-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation-show-order.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/presentation-show-order.ts"],"names":[],"mappings":"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"}

package/dist/pptx/render/presentation-subtitles.d.ts

@@ -0,0 +1,33 @@
+export interface SpeechAlternative {
+    readonly transcript: string;
+    readonly confidence: number;
+}
+export interface SpeechResult {
+    readonly isFinal: boolean;
+    readonly length: number;
+    readonly [index: number]: SpeechAlternative;
+}
+export interface SpeechResultList {
+    readonly length: number;
+    readonly [index: number]: SpeechResult;
+}
+export interface SpeechRecognitionEventLite {
+    readonly resultIndex: number;
+    readonly results: SpeechResultList;
+}
+export interface SpeechRecognitionLite extends EventTarget {
+    continuous: boolean;
+    interimResults: boolean;
+    lang: string;
+    onresult: ((event: SpeechRecognitionEventLite) => void) | null;
+    onerror: ((event: Event) => void) | null;
+    onend: (() => void) | null;
+    start(): void;
+    stop(): void;
+}
+export type SpeechRecognitionCtor = new () => SpeechRecognitionLite;
+export type SpeechSupportState = 'unknown' | 'supported' | 'unsupported';
+export declare function mergeCaptionResults(resultIndex: number, results: SpeechResultList): string;
+export declare function getSpeechRecognitionCtor(): SpeechRecognitionCtor | null;
+export declare function captionDisplayText(supportState: SpeechSupportState, captionText: string, fallbackNotSupported: string, fallbackListening: string): string;
+//# sourceMappingURL=presentation-subtitles.d.ts.map

package/dist/pptx/render/presentation-subtitles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation-subtitles.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/presentation-subtitles.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAAC;CAC5C;AAED,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAAC;CACvC;AAED,MAAM,WAAW,0BAA0B;IAC1C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;CACnC;AAED,MAAM,WAAW,qBAAsB,SAAQ,WAAW;IACzD,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,0BAA0B,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IAC/D,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IACzC,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC;IAC3B,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,IAAI,CAAC;CACb;AAED,MAAM,MAAM,qBAAqB,GAAG,UAAU,qBAAqB,CAAC;AACpE,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,WAAW,GAAG,aAAa,CAAC;AAEzE,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAa1F;AAED,wBAAgB,wBAAwB,IAAI,qBAAqB,GAAG,IAAI,CAKvE;AAED,wBAAgB,kBAAkB,CACjC,YAAY,EAAE,kBAAkB,EAChC,WAAW,EAAE,MAAM,EACnB,oBAAoB,EAAE,MAAM,EAC5B,iBAAiB,EAAE,MAAM,GACvB,MAAM,CAKR"}

package/dist/pptx/render/presentation-toolbar.d.ts

@@ -0,0 +1,29 @@
+/**
+ * presentation-toolbar.ts: pure presentation-toolbar helpers shared across
+ * bindings.
+ *
+ * Visibility (bottom-trigger-zone) math, auto-hide timing, pen/highlighter
+ * colour swatches, and slide-counter formatting. The pointer listeners and
+ * timers stay in each binding.
+ */
+/** Toolbar auto-hides after this many milliseconds of no mouse movement. */
+export declare const AUTO_HIDE_DELAY_MS = 3000;
+/**
+ * The toolbar is shown when the mouse is within this fraction of the screen
+ * height from the bottom (e.g., 0.15 = bottom 15%).
+ */
+export declare const BOTTOM_TRIGGER_FRACTION = 0.15;
+/** Pen-tool colour swatches. */
+export declare const PEN_COLORS: string[];
+/** Highlighter-tool colour swatches. */
+export declare const HIGHLIGHTER_COLORS: string[];
+/**
+ * Whether the toolbar should become visible based on mouse position relative to
+ * the container's bottom trigger zone.
+ */
+export declare function isInBottomTriggerZone(mouseY: number, containerHeight: number, containerTop: number): boolean;
+/** Whether enough time has passed since the last move to auto-hide. */
+export declare function shouldAutoHide(lastMoveTimestamp: number, now: number): boolean;
+/** Format a slide counter string like `"3 / 12"` (one-based). */
+export declare function formatSlideCounter(currentSlide: number, totalSlides: number): string;
+//# sourceMappingURL=presentation-toolbar.d.ts.map

package/dist/pptx/render/presentation-toolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation-toolbar.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/presentation-toolbar.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC;;;GAGG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAE5C,gCAAgC;AAChC,eAAO,MAAM,UAAU,UAStB,CAAC;AAEF,wCAAwC;AACxC,eAAO,MAAM,kBAAkB,UAS9B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,MAAM,GAClB,OAAO,CAIT;AAED,uEAAuE;AACvE,wBAAgB,cAAc,CAAC,iBAAiB,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED,iEAAiE;AACjE,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAEpF"}

package/dist/pptx/render/presentation-touch-controls.d.ts

@@ -0,0 +1,12 @@
+/** State consumed by the touch-only controls shown over a live slide show. */
+export interface PresentationTouchControlState {
+    previousDisabled: boolean;
+    nextDisabled: boolean;
+    counterLabel: string;
+}
+/**
+ * Build the stable presentation-control state shared by every UI binding.
+ * Empty presentations disable both directions and use the same 0 / 0 label.
+ */
+export declare function buildPresentationTouchControlState(currentSlideIndex: number, totalSlides: number): PresentationTouchControlState;
+//# sourceMappingURL=presentation-touch-controls.d.ts.map

package/dist/pptx/render/presentation-touch-controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation-touch-controls.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/presentation-touch-controls.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,MAAM,WAAW,6BAA6B;IAC7C,gBAAgB,EAAE,OAAO,CAAC;IAC1B,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,wBAAgB,kCAAkC,CACjD,iBAAiB,EAAE,MAAM,EACzB,WAAW,EAAE,MAAM,GACjB,6BAA6B,CAc/B"}

package/dist/pptx/render/presentation-visibility.d.ts

@@ -0,0 +1,20 @@
+/** Binding callbacks invoked alongside the built-in media pause/resume. */
+export interface PresentationVisibilityOptions {
+    /**
+     * Root that contains the presentation stage; only media inside it is
+     * paused. Defaults to `document`.
+     */
+    root?: ParentNode;
+    /** Cancel the pending auto-advance timer (show was backgrounded). */
+    onHidden?: () => void;
+    /** Re-arm the auto-advance timer for the current slide (show is live). */
+    onVisible?: () => void;
+}
+/**
+ * Attach the backgrounding handlers for a running presentation.
+ *
+ * @returns Detach function; it resumes nothing (a suspended show that exits
+ *          presentation mode tears its media down anyway).
+ */
+export declare function attachPresentationVisibilityPause(options?: PresentationVisibilityOptions): () => void;
+//# sourceMappingURL=presentation-visibility.d.ts.map

package/dist/pptx/render/presentation-visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation-visibility.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/presentation-visibility.ts"],"names":[],"mappings":"AAoBA,2EAA2E;AAC3E,MAAM,WAAW,6BAA6B;IAC7C;;;OAGG;IACH,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAChD,OAAO,GAAE,6BAAkC,GACzC,MAAM,IAAI,CAgDZ"}

package/dist/pptx/render/presenter-chrome-metrics.d.ts

@@ -0,0 +1,105 @@
+/**
+ * `presenter-chrome-metrics` - the presenter console's measurements, in the two
+ * representations the five bindings can consume.
+ *
+ * Split out of `presenter-chrome.ts` purely to keep both files inside the
+ * repo's 300-line ceiling; the inventory lives there, the geometry lives here,
+ * and `presenter-chrome.test.ts` asserts the Tailwind strings below still
+ * encode the numbers in {@link PRESENTER_LAYOUT_METRICS}.
+ *
+ * Every number here was a magic constant in at least three bindings before this
+ * module: the rail was 260..440 wide in React and Vue but 300..460 in Svelte,
+ * the navigator grid used three different track sizes and gaps, and the console
+ * root sat at `z-index` 50, 100 and 120 depending on which file you opened.
+ *
+ * @module render/presenter-chrome-metrics
+ */
+/** Presenter-console measurements, in CSS pixels unless the name says otherwise. */
+export declare const PRESENTER_LAYOUT_METRICS: {
+    /**
+     * Flex growth of the current-slide pane against the rail (`flex-[7]` /
+     * `flex-[3]`), i.e. PowerPoint's roughly 70/30 console split.
+     */
+    readonly mainFlex: 7;
+    readonly railFlex: 3;
+    /** Rail width bounds (`min-w-[260px] max-w-[440px]`). */
+    readonly railMinWidth: 260;
+    readonly railMaxWidth: 440;
+    /** Padding around the current-slide pane (`p-6`). */
+    readonly mainPadding: 24;
+    /** Stacking order of the console over the show stage (`z-50`). */
+    readonly zIndex: 50;
+    /** Stacking order of the "all slides" navigator over the console (`z-[120]`). */
+    readonly navigatorZIndex: 120;
+    /** Console strip control edge length (`h-9 min-w-9`). */
+    readonly controlSize: 36;
+    /** Icon edge length inside a strip control. */
+    readonly controlIconSize: 16;
+    /** Flex gap between strip children (`gap-1`). */
+    readonly stripGap: 4;
+    /** Strip padding (`px-3 py-2`). */
+    readonly stripPaddingX: 12;
+    readonly stripPaddingY: 8;
+    /** Control corner radius (`rounded-md`). */
+    readonly controlRadius: 6;
+    /** Divider width / height / margin (`w-px h-6 mx-1`). */
+    readonly dividerWidth: 1;
+    readonly dividerHeight: 24;
+    readonly dividerMarginX: 4;
+    /** Timer progress bar height (`h-1.5`). */
+    readonly progressHeight: 6;
+    /** Next-slide preview target width, before aspect-ratio scaling. */
+    readonly nextPreviewWidth: 240;
+    /** Navigator grid track minimum and gap (`minmax(220px,1fr)`, `gap-5`). */
+    readonly navigatorTrackMin: 220;
+    readonly navigatorGap: 20;
+    /** Navigator tile preview width. */
+    readonly navigatorTileWidth: 200;
+    /** Opacity of a hidden slide's navigator tile: dimmed, never omitted. */
+    readonly hiddenSlideOpacity: 0.45;
+};
+/**
+ * Tailwind tokens for the presenter console, applied by React, Vue and Angular.
+ *
+ * Whole class strings rather than per-call-site assembly, for the reason
+ * `present-chrome.ts` gives: three bindings hand-writing `h-9 min-w-9 rounded-md
+ * ...` is how one of them ended up with a differently sized strip.
+ */
+export declare const PRESENTER_CONSOLE_CLASSES: {
+    /** The console root, laid over the show stage. */
+    readonly root: 'absolute inset-0 z-50 flex flex-col bg-card text-foreground';
+    /** The control strip across the top. */
+    readonly strip: 'flex flex-wrap items-center gap-1 border-b border-border bg-card px-3 py-2';
+    /** A strip control, inactive. */
+    readonly control: 'inline-flex h-9 min-w-9 items-center justify-center gap-2 rounded-md px-2 text-xs transition-colors bg-muted text-foreground hover:bg-accent';
+    /** A strip control, active. */
+    readonly controlActive: 'inline-flex h-9 min-w-9 items-center justify-center gap-2 rounded-md px-2 text-xs transition-colors bg-primary text-primary-foreground';
+    /** Vertical hairline between strip groups. */
+    readonly divider: 'mx-1 h-6 w-px bg-border';
+    /** Flexible gap pushing the trailing group right. */
+    readonly spacer: 'flex-1';
+    /** The body row: current-slide pane plus rail. */
+    readonly body: 'flex flex-1 min-h-0';
+    /** The current-slide pane. */
+    readonly main: 'relative flex-[7] flex flex-col items-center justify-center bg-black p-6 min-w-0 overflow-hidden';
+    /** The right-hand rail. */
+    readonly rail: 'flex flex-[3] min-w-[260px] max-w-[440px] flex-col border-l border-border bg-background';
+    /** Rail section heading (Current Time / Next Slide / Speaker Notes). */
+    readonly railHeading: 'text-[10px] uppercase tracking-wider text-muted-foreground';
+    /** Timer progress bar track. */
+    readonly progressTrack: 'h-1.5 w-full bg-muted/60 flex-shrink-0';
+    /** Timer progress bar fill. */
+    readonly progressFill: 'h-full bg-primary transition-[width] duration-1000 ease-linear';
+    /** The "all slides" navigator overlay. */
+    readonly navigator: 'absolute inset-0 z-[120] overflow-auto bg-card p-6';
+    /** The navigator's tile grid. */
+    readonly navigatorGrid: 'grid gap-5 [grid-template-columns:repeat(auto-fill,minmax(220px,1fr))]';
+};
+/**
+ * The console metrics as CSS custom properties, for the two bindings that
+ * cannot read a Tailwind class (Vanilla's CSS-in-TS, Svelte's scoped style).
+ */
+export declare function presenterConsoleCssVars(): Record<string, string>;
+/** {@link presenterConsoleCssVars} flattened into an inline `style` attribute. */
+export declare function presenterConsoleStyleAttr(): string;
+//# sourceMappingURL=presenter-chrome-metrics.d.ts.map

package/dist/pptx/render/presenter-chrome-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presenter-chrome-metrics.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/presenter-chrome-metrics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,oFAAoF;AACpF,eAAO,MAAM,wBAAwB;IACpC;;;OAGG;aACH,QAAQ,EAAE,CAAC;aACX,QAAQ,EAAE,CAAC;IACX,yDAAyD;aACzD,YAAY,EAAE,GAAG;aACjB,YAAY,EAAE,GAAG;IACjB,qDAAqD;aACrD,WAAW,EAAE,EAAE;IACf,kEAAkE;aAClE,MAAM,EAAE,EAAE;IACV,iFAAiF;aACjF,eAAe,EAAE,GAAG;IACpB,yDAAyD;aACzD,WAAW,EAAE,EAAE;IACf,+CAA+C;aAC/C,eAAe,EAAE,EAAE;IACnB,iDAAiD;aACjD,QAAQ,EAAE,CAAC;IACX,mCAAmC;aACnC,aAAa,EAAE,EAAE;aACjB,aAAa,EAAE,CAAC;IAChB,4CAA4C;aAC5C,aAAa,EAAE,CAAC;IAChB,yDAAyD;aACzD,YAAY,EAAE,CAAC;aACf,aAAa,EAAE,EAAE;aACjB,cAAc,EAAE,CAAC;IACjB,2CAA2C;aAC3C,cAAc,EAAE,CAAC;IACjB,oEAAoE;aACpE,gBAAgB,EAAE,GAAG;IACrB,2EAA2E;aAC3E,iBAAiB,EAAE,GAAG;aACtB,YAAY,EAAE,EAAE;IAChB,oCAAoC;aACpC,kBAAkB,EAAE,GAAG;IACvB,yEAAyE;aACzE,kBAAkB,EAAE,IAAI;CACf,CAAC;AAEX;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB;IACrC,kDAAkD;aAClD,IAAI,EAAE,6DAA6D;IACnE,wCAAwC;aACxC,KAAK,EAAE,4EAA4E;IACnF,iCAAiC;aACjC,OAAO,EACN,8IAA8I;IAC/I,+BAA+B;aAC/B,aAAa,EACZ,wIAAwI;IACzI,8CAA8C;aAC9C,OAAO,EAAE,yBAAyB;IAClC,qDAAqD;aACrD,MAAM,EAAE,QAAQ;IAChB,kDAAkD;aAClD,IAAI,EAAE,qBAAqB;IAC3B,8BAA8B;aAC9B,IAAI,EAAE,kGAAkG;IACxG,2BAA2B;aAC3B,IAAI,EAAE,yFAAyF;IAC/F,wEAAwE;aACxE,WAAW,EAAE,4DAA4D;IACzE,gCAAgC;aAChC,aAAa,EAAE,wCAAwC;IACvD,+BAA+B;aAC/B,YAAY,EAAE,gEAAgE;IAC9E,0CAA0C;aAC1C,SAAS,EAAE,oDAAoD;IAC/D,iCAAiC;aACjC,aAAa,EAAE,wEAAwE;CAC9E,CAAC;AAEX;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA0BhE;AAED,kFAAkF;AAClF,wBAAgB,yBAAyB,IAAI,MAAM,CAIlD"}

package/dist/pptx/render/presenter-chrome.d.ts

@@ -0,0 +1,166 @@
+/**
+ * The presenter view (PowerPoint's "presenter console"), described once for all
+ * five bindings.
+ *
+ * `presenter-view.ts` already shares the presenter console's ARITHMETIC (elapsed
+ * formatting, notes font-size clamping, rich-notes -> span spec) and
+ * `presenter-console.ts` its STATE helpers (timer, zoom, pointer, ink). What was
+ * never shared is the console's CONTENT, and that is what drifted, in exactly
+ * the way `present-chrome.ts` documents for the show toolbar:
+ *
+ *   - React ships a 16-slot strip whose accessible names are hard-coded English
+ *     `title` attributes, so the console is untranslatable in every locale.
+ *   - Vue renders its strip ONLY in the empty-deck branch, so with a real deck
+ *     the console has no timer, zoom, annotation, blackout, captions or end
+ *     control at all.
+ *   - Angular re-labels the same strip in a component with no `translate` pipe,
+ *     orders zoom `-` before `+` (React orders `+` first), and calls reset-zoom
+ *     "Fit".
+ *   - Vanilla has no presenter view whatsoever: `mountPresenterConsole` lays a
+ *     button strip over the live show, with no current slide, next-slide
+ *     preview, notes, clock or timer.
+ *   - Svelte drops the timer progress bar, renders notes as plain text (losing
+ *     every `notesSegments` run style) and clamps the notes font size to its own
+ *     12..36 instead of the shared 10..32.
+ *
+ * So the inventory, the order, the label KEYS and the measurements live here,
+ * and every binding derives its console from these constants:
+ *
+ *   - React, Vue and Angular apply {@link PRESENTER_CONSOLE_CLASSES} (Tailwind).
+ *   - Vanilla interpolates {@link PRESENTER_LAYOUT_METRICS} into its CSS-in-TS.
+ *   - Svelte reads {@link presenterConsoleCssVars} off an inline `style`
+ *     attribute, because its scoped `<style>` is compiled and cannot see a
+ *     TypeScript value.
+ *
+ * `presenter-chrome.test.ts` asserts the Tailwind tokens still encode exactly
+ * the numbers here, which is what stops the two representations drifting.
+ *
+ * @module render/presenter-chrome
+ */
+/** What a slot in the presenter console's strip is, structurally. */
+export type PresenterControlKind = 
+/** Plain action button. */
+'button'
+/** Stateful toggle (annotation tool, blackout, captions, audience). */
+ | 'toggle'
+/** Vertical hairline between groups. */
+ | 'divider'
+/** Flexible gap pushing the trailing group to the right edge. */
+ | 'spacer';
+/** One slot in the presenter console's strip, left to right. */
+export interface PresenterControl {
+    /** Stable id; also the `data-pptx-presenter-control` value each binding emits. */
+    id: string;
+    kind: PresenterControlKind;
+    /** i18n key for the accessible name. Dividers and spacers have none. */
+    labelKey?: string;
+    /**
+     * i18n key used instead of {@link labelKey} while the control is active, for
+     * the two slots whose name genuinely changes with state (the audience
+     * display opens or closes; nothing else does).
+     */
+    activeLabelKey?: string;
+    /** Lucide icon name in kebab-case, or `undefined` for text-only slots. */
+    icon?: string;
+    /** Lucide icon name while active, when it differs. */
+    activeIcon?: string;
+    /**
+     * Literal glyph rendered inside the control, for the two blackout switches
+     * PowerPoint labels `B` and `W`. These are NOT accessible names: every
+     * binding must still carry {@link labelKey} as an `aria-label`, or a screen
+     * reader announces the deck's black-screen switch as the letter "B".
+     */
+    glyph?: string;
+}
+/**
+ * The presenter console strip, in order.
+ *
+ * Order and ids follow React, which is the binding the parity specs measure
+ * against. The label KEYS are new: React's strings were hard-coded English, so
+ * adopting a key per slot is what makes the console translatable at all. Where
+ * an existing key already carried the exact English React rendered, it is
+ * reused rather than duplicated (`pptx.presentation.pen` and friends), because
+ * a near-miss duplicate is precisely how `pptx.presenter.elapsed` and
+ * `pptx.mpresenter.elapsed` came to coexist.
+ */
+export declare const PRESENTER_CONSOLE_CONTROLS: readonly PresenterControl[];
+/** The strip's control ids in render order, for tests and parity specs. */
+export declare const PRESENTER_CONSOLE_ORDER: readonly string[];
+/**
+ * The strip's accessible-name i18n keys, in order, skipping the slots that have
+ * none. A parity spec resolves these through the dictionary rather than
+ * hard-coding English, so the inventory survives a translation change.
+ */
+export declare const PRESENTER_CONSOLE_LABEL_KEYS: readonly string[];
+/** One slot in the presenter console's right-hand rail. */
+export interface PresenterRailControl {
+    id: string;
+    labelKey: string;
+    icon?: string;
+}
+/**
+ * The rail's navigation and notes controls, in order.
+ *
+ * `next` is deliberately absent from any "disabled on the last slide" rule; see
+ * {@link presenterNextDisabled}.
+ */
+export declare const PRESENTER_RAIL_CONTROLS: readonly PresenterRailControl[];
+/** Static headings and read-only readouts in the rail, keyed for translation. */
+export declare const PRESENTER_RAIL_LABEL_KEYS: {
+    readonly currentTime: 'pptx.presenter.currentTime';
+    readonly elapsed: 'pptx.presenter.elapsed';
+    readonly nextSlidePreview: 'pptx.presenter.nextSlidePreview';
+    readonly endOfPresentation: 'pptx.presenter.endOfPresentation';
+    readonly speakerNotes: 'pptx.presenter.speakerNotes';
+    readonly noNotes: 'pptx.presenter.noNotes';
+    readonly slideLabel: 'pptx.presenter.slideLabel';
+    readonly timerProgress: 'pptx.presenter.timerProgress';
+    readonly noSlides: 'pptx.presenter.noSlides';
+};
+/** Headings and controls of the "all slides" navigator overlay. */
+export declare const PRESENTER_NAVIGATOR_LABEL_KEYS: {
+    readonly title: 'pptx.presenter.slideNavigator';
+    readonly subtitle: 'pptx.presenter.seeAllSlides';
+    readonly close: 'pptx.presenter.closeNavigator';
+};
+/**
+ * Whether the rail's Next button should be disabled.
+ *
+ * Always `false`, and it is a function rather than a constant so the rule has
+ * one place to be read and cited. PowerPoint's console advances from the last
+ * slide to the end-of-show screen and then out of the show. Vue, Angular and
+ * Svelte each independently added `disabled={current >= slides.length - 1}`,
+ * which strands the presenter on the final slide with no way to finish, so the
+ * audience display never closes either. React's `PresenterNotesRail` carries a
+ * comment saying exactly this; the comment was not enough to stop three ports
+ * making the same call, so the rule is now code.
+ */
+export declare function presenterNextDisabled(): boolean;
+/**
+ * Whether the rail's Previous button should be disabled: only on the first
+ * slide, where there is genuinely nowhere to go back to.
+ */
+export declare function presenterPrevDisabled(currentIndex: number): boolean;
+/**
+ * How much elapsed time one fill of the console's progress bar represents.
+ *
+ * Five minutes, the interval PowerPoint's own console paces a talk in. It was
+ * inlined in React, re-derived in Vue and given a helper of its own in Angular,
+ * while Vanilla and Svelte had no bar at all.
+ */
+export declare const PRESENTER_TIMER_SEGMENT_MS: number;
+/** A progress-bar reading: how full the current segment is, and which one. */
+export interface PresenterTimerProgress {
+    /** 0..100, for `aria-valuenow` and the fill width. */
+    percent: number;
+    /** Zero-based segment index; bindings render it one-based. */
+    segment: number;
+}
+/**
+ * Split an elapsed duration into the console's progress-bar reading.
+ *
+ * Negative input is clamped: a snapshot restored from a peer can arrive with a
+ * start time in the future, and a negative `aria-valuenow` is invalid ARIA.
+ */
+export declare function presenterTimerProgress(elapsedMs: number): PresenterTimerProgress;
+//# sourceMappingURL=presenter-chrome.d.ts.map

package/dist/pptx/render/presenter-chrome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presenter-chrome.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/presenter-chrome.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,qEAAqE;AACrE,MAAM,MAAM,oBAAoB;AAC/B,2BAA2B;AACzB,QAAQ;AACV,uEAAuE;GACrE,QAAQ;AACV,wCAAwC;GACtC,SAAS;AACX,iEAAiE;GAC/D,QAAQ,CAAC;AAEZ,gEAAgE;AAChE,MAAM,WAAW,gBAAgB;IAChC,kFAAkF;IAClF,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,oBAAoB,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,gBAAgB,EA2DxD,CAAC;AAEX,2EAA2E;AAC3E,eAAO,MAAM,uBAAuB,EAAE,SAAS,MAAM,EAEpD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,MAAM,EAEzD,CAAC;AAEF,2DAA2D;AAC3D,MAAM,WAAW,oBAAoB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,oBAAoB,EAKzD,CAAC;AAEX,iFAAiF;AACjF,eAAO,MAAM,yBAAyB;aACrC,WAAW,EAAE,4BAA4B;aACzC,OAAO,EAAE,wBAAwB;aACjC,gBAAgB,EAAE,iCAAiC;aACnD,iBAAiB,EAAE,kCAAkC;aACrD,YAAY,EAAE,6BAA6B;aAC3C,OAAO,EAAE,wBAAwB;aACjC,UAAU,EAAE,2BAA2B;aACvC,aAAa,EAAE,8BAA8B;aAC7C,QAAQ,EAAE,yBAAyB;CAC1B,CAAC;AAEX,mEAAmE;AACnE,eAAO,MAAM,8BAA8B;aAC1C,KAAK,EAAE,+BAA+B;aACtC,QAAQ,EAAE,6BAA6B;aACvC,KAAK,EAAE,+BAA+B;CAC7B,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAE/C;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,QAAgB,CAAC;AAExD,8EAA8E;AAC9E,MAAM,WAAW,sBAAsB;IACtC,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,sBAAsB,CAShF"}

package/dist/pptx/render/presenter-console.d.ts

@@ -0,0 +1,34 @@
+import type { PresentationInkPoint, PresentationInkStroke, PresentationPointerState, PresentationPointerTool, PresentationSnapshot, PresentationZoomState } from './presentation-session.js';
+export declare const PRESENTER_ZOOM_MIN = 1;
+export declare const PRESENTER_ZOOM_MAX = 4;
+export declare const PRESENTER_ZOOM_STEP = 0.5;
+export interface PresenterTimerState {
+    elapsedMs: number;
+    paused: boolean;
+    lastStartedAt: number;
+}
+export declare function createPresenterTimer(now?: number): PresenterTimerState;
+export declare function presenterElapsed(timer: PresenterTimerState, now?: number): number;
+export declare function togglePresenterTimer(timer: PresenterTimerState, now?: number): PresenterTimerState;
+export declare function resetPresenterTimer(now?: number): PresenterTimerState;
+export declare function clampPresenterZoom(zoom: Partial<PresentationZoomState>): PresentationZoomState;
+export declare function stepPresenterZoom(zoom: PresentationZoomState, direction: 1 | -1): PresentationZoomState;
+export declare function createPresenterPointer(tool?: PresentationPointerTool, color?: string): PresentationPointerState;
+export declare function movePresenterPointer(pointer: PresentationPointerState, x: number, y: number): PresentationPointerState;
+export declare function appendPresentationInkPoint(stroke: PresentationInkStroke, point: PresentationInkPoint): PresentationInkStroke;
+export declare function erasePresentationInkAt(strokes: readonly PresentationInkStroke[], slideIndex: number, point: PresentationInkPoint, radius?: number): PresentationInkStroke[];
+/**
+ * Merge a patch into a presentation snapshot.
+ *
+ * Returns `current` UNCHANGED when the patch conveys nothing new. Without that
+ * guard the merge was a guaranteed re-render trigger in all five bindings: it
+ * always allocated a fresh object and always bumped `sequence`, so no consumer
+ * could ever bail out, however well memoised it was. That is what let a
+ * once-a-second presenter tick re-render an entire idle editor (issue #145).
+ *
+ * `sequence` therefore only advances on a real change, which is also what makes
+ * it meaningful: it now counts state transitions rather than merge calls.
+ */
+export declare function mergePresentationSnapshot(current: PresentationSnapshot, patch: Partial<PresentationSnapshot>): PresentationSnapshot;
+export declare function presentationInkPath(points: readonly PresentationInkPoint[]): string;
+//# sourceMappingURL=presenter-console.d.ts.map

package/dist/pptx/render/presenter-console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presenter-console.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/presenter-console.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,oBAAoB,EACpB,qBAAqB,EACrB,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,MAAM,wBAAwB,CAAC;AAGhC,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC,MAAM,WAAW,mBAAmB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,oBAAoB,CAAC,GAAG,SAAa,GAAG,mBAAmB,CAE1E;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,mBAAmB,EAAE,GAAG,SAAa,GAAG,MAAM,CAErF;AAED,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,mBAAmB,EAC1B,GAAG,SAAa,GACd,mBAAmB,CAKrB;AAED,wBAAgB,mBAAmB,CAAC,GAAG,SAAa,GAAG,mBAAmB,CAEzE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,CAAC,qBAAqB,CAAC,GAAG,qBAAqB,CAM9F;AAED,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,qBAAqB,EAC3B,SAAS,EAAE,CAAC,GAAG,CAAC,CAAC,GACf,qBAAqB,CAEvB;AAED,wBAAgB,sBAAsB,CACrC,IAAI,GAAE,uBAAgC,EACtC,KAAK,SAAY,GACf,wBAAwB,CAE1B;AAED,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,wBAAwB,EACjC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACP,wBAAwB,CAE1B;AAED,wBAAgB,0BAA0B,CACzC,MAAM,EAAE,qBAAqB,EAC7B,KAAK,EAAE,oBAAoB,GACzB,qBAAqB,CAMvB;AAED,wBAAgB,sBAAsB,CACrC,OAAO,EAAE,SAAS,qBAAqB,EAAE,EACzC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,oBAAoB,EAC3B,MAAM,SAAQ,GACZ,qBAAqB,EAAE,CAWzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACxC,OAAO,EAAE,oBAAoB,EAC7B,KAAK,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAClC,oBAAoB,CAQtB;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,oBAAoB,EAAE,GAAG,MAAM,CAQnF"}