ooxml-ui 0.30.1 → 1.0.0

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

@@ -0,0 +1,56 @@
+/**
+ * presenter-mobile.ts
+ *
+ * Framework-agnostic geometry, labels, and time formatting for the
+ * mobile-adapted presenter view (a single-column phone layout shown when the
+ * speaker enters presenter/speaker view on a small screen). The desktop
+ * presenter view keeps its own split-screen helpers per binding; these pure
+ * helpers cover only the phone layout so React, Vue, and Angular can all share
+ * one implementation.
+ *
+ * Pure TypeScript (no framework imports, no DOM). Each binding renders the
+ * returned values into its own template / JSX.
+ *
+ * @module presenter-mobile
+ */
+/**
+ * Target on-screen width (CSS px) for the small "next slide" thumbnail in the
+ * mobile presenter layout. The thumbnail is rendered by scaling the full
+ * canvas down to this width; the height follows from the canvas aspect ratio.
+ */
+export declare const MOBILE_NEXT_THUMB_WIDTH = 132;
+/** A scaled thumbnail box (CSS px) plus the scale factor used to derive it. */
+export interface MobileThumbSize {
+    /** Thumbnail width in CSS px. */
+    width: number;
+    /** Thumbnail height in CSS px (canvas height * scale). */
+    height: number;
+    /** Scale factor applied to the full canvas to reach `width`. */
+    scale: number;
+}
+/**
+ * Compute the next-slide thumbnail box for the mobile presenter, scaling a
+ * `canvasWidth x canvasHeight` slide down to {@link MOBILE_NEXT_THUMB_WIDTH}.
+ * Falls back to a 1:1 box of the target width when the canvas size is unknown
+ * (non-positive), so callers never divide by zero or produce NaN.
+ */
+export declare function mobileNextThumbSize(canvasWidth: number, canvasHeight: number, targetWidth?: number): MobileThumbSize;
+/**
+ * Compact "3 / 12" slide-counter label for the mobile presenter header. Uses a
+ * one-based current index; renders "0 / 0" when the deck is empty.
+ */
+export declare function mobileSlideCounter(currentIndex: number, total: number): string;
+/**
+ * Compute the elapsed milliseconds between `startTime` (epoch ms, or null when
+ * the presentation has not started) and `now`. Returns 0 when no start time is
+ * set or the clock has not advanced past the start.
+ */
+export declare function mobileElapsedSince(startTime: number | null, now: number): number;
+/**
+ * Format a millisecond duration as `MM:SS`, or `HH:MM:SS` once the elapsed
+ * time reaches one hour. Sub-second values are floored; negative inputs are
+ * treated as zero. Mirrors the desktop presenter `formatElapsed` so the mobile
+ * timer reads identically.
+ */
+export declare function formatMobileElapsed(elapsedMs: number): string;
+//# sourceMappingURL=presenter-mobile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"presenter-mobile.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/presenter-mobile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C,+EAA+E;AAC/E,MAAM,WAAW,eAAe;IAC/B,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAClC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,WAAW,GAAE,MAAgC,GAC3C,eAAe,CAUjB;AAMD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAK9E;AAsBD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAMhF;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAU7D"}

package/dist/pptx/render/presenter-show-lifecycle.d.ts

@@ -0,0 +1,85 @@
+/**
+ * `presenter-show-lifecycle` - keeping a slide show alive across the fullscreen
+ * bounce that opening the audience display causes.
+ *
+ * WHY this exists at all. A running show holds the Fullscreen API on the
+ * presenter's own screen. Opening the audience display is a `window.open` with
+ * `popup=yes`, and every engine drops the opener out of fullscreen when a popup
+ * takes focus. The `fullscreenchange` that announces it is dispatched on a
+ * later task, which puts a binding in a bind:
+ *
+ *   - Reading its own "am I presenting" state right after `window.open` reads a
+ *     value the pending event has not updated yet, so the code concludes the
+ *     show is still running and does not re-assert it. The event then lands,
+ *     the generic "the user left fullscreen, so end the show" handler fires,
+ *     and the presenter's deck collapses back to the editor the instant they
+ *     ask for presenter view. That is exactly the Vanilla defect: the console
+ *     mounts correctly and the show underneath it is torn down.
+ *   - Reading `document.fullscreenElement` instead is no better. It is
+ *     authoritative but it is sampled at a moment when the browser may or may
+ *     not have released fullscreen yet, so the answer is a coin toss.
+ *
+ * Neither reading is wrong; the mistake is asking a state question at all. The
+ * only thing that distinguishes "the popup stole fullscreen" from "the
+ * presenter pressed Escape" is INTENT, and intent is known at the call site
+ * that opened the popup. So the opener arms a one-shot latch here and the
+ * fullscreen handler asks this module what the exit meant.
+ *
+ * React already had a private version of this (`switchingToPresenterRef` in
+ * `usePresentationMode`), which is why React alone never lost its show. This
+ * module is that latch, made shared, time-bounded and testable, so all five
+ * bindings answer the question the same way.
+ *
+ * DOM-free by design: it holds no window, registers no listener, and only ever
+ * answers a question. Each binding keeps its own fullscreen plumbing.
+ *
+ * @module render/presenter-show-lifecycle
+ */
+/**
+ * How long after opening the audience display a fullscreen exit is still
+ * attributed to the popup rather than to the presenter.
+ *
+ * The latch is one-shot, so this bound only matters when the popup never
+ * triggers a bounce at all (a popup blocker, or an engine that keeps the opener
+ * fullscreen). Without it the latch would sit armed forever and silently
+ * swallow the presenter's next real Escape. A second is far longer than the
+ * event needs and far shorter than any deliberate follow-up action.
+ */
+export declare const AUDIENCE_FULLSCREEN_BOUNCE_MS = 1000;
+/** What a fullscreen exit during a running show should be taken to mean. */
+export type ShowFullscreenExitVerdict = 
+/** The presenter left: tear the show down. */
+'end-show'
+/** The audience popup stole fullscreen: re-assert the show instead. */
+ | 'restore-show';
+/** A one-shot latch describing why the show is about to leave fullscreen. */
+export interface PresenterShowGuard {
+    /**
+     * Call immediately BEFORE opening the audience display, from the same task
+     * as the `window.open`. Arming after the call is also safe (the event cannot
+     * be delivered until the current task yields) but reads worse.
+     */
+    expectAudienceBounce(now?: number): void;
+    /**
+     * Classify a fullscreen exit seen while the show is running, consuming the
+     * latch. Returns `'restore-show'` at most once per {@link expectAudienceBounce}.
+     */
+    classifyFullscreenExit(now?: number): ShowFullscreenExitVerdict;
+    /** Whether a bounce is still expected. For diagnostics and tests. */
+    isExpectingBounce(now?: number): boolean;
+    /**
+     * Drop the latch without consuming it: the presenter ended the show, or the
+     * console closed, so any later fullscreen exit is genuinely theirs.
+     */
+    disarm(): void;
+}
+/**
+ * Create a {@link PresenterShowGuard}.
+ *
+ * @param options.graceMs - Override {@link AUDIENCE_FULLSCREEN_BOUNCE_MS}; tests
+ * pass a tiny value to prove the latch expires.
+ */
+export declare function createPresenterShowGuard(options?: {
+    graceMs?: number;
+}): PresenterShowGuard;
+//# sourceMappingURL=presenter-show-lifecycle.d.ts.map

package/dist/pptx/render/presenter-show-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presenter-show-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/presenter-show-lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAElD,4EAA4E;AAC5E,MAAM,MAAM,yBAAyB;AACpC,8CAA8C;AAC5C,UAAU;AACZ,uEAAuE;GACrE,cAAc,CAAC;AAElB,6EAA6E;AAC7E,MAAM,WAAW,kBAAkB;IAClC;;;;OAIG;IACH,oBAAoB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC;;;OAGG;IACH,sBAAsB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,yBAAyB,CAAC;IAChE,qEAAqE;IACrE,iBAAiB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACzC;;;OAGG;IACH,MAAM,IAAI,IAAI,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,kBAAkB,CA4B3F"}

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

@@ -0,0 +1,54 @@
+/**
+ * presenter-view.ts: pure presenter-view helpers shared across bindings.
+ *
+ * Time formatting, notes font-size clamping, and rich-text notes -> render-spec
+ * conversion. DOM-free; each binding renders the returned `NotesSpan[]` spec
+ * into its own `<span>`/`<br>` nodes.
+ */
+import type { TextSegment } from 'ooxml-core/pptx';
+import type { PresentationPointerTool } from './presentation-session-types.js';
+/**
+ * Whether a click on the presenter console's current-slide pane should advance
+ * the show.
+ *
+ * PowerPoint's presenter console advances when you click the big slide, which
+ * is how presenters actually drive a deck - the Next button and the keyboard
+ * are the fallbacks, not the primary control. The exception is an active
+ * drawing tool: pen, highlighter and eraser own the pointer, so clicking then
+ * annotates instead of jumping the deck out from under the stroke. The laser
+ * only tracks the cursor and does not consume clicks, so it still advances.
+ */
+export declare function presenterPaneAdvancesOnClick(tool: PresentationPointerTool | undefined): boolean;
+/** Minimum font size (px) for speaker notes in presenter view. */
+export declare const NOTES_FONT_SIZE_MIN = 10;
+/** Maximum font size (px) for speaker notes in presenter view. */
+export declare const NOTES_FONT_SIZE_MAX = 32;
+/** Step increment (px) when increasing/decreasing notes font size. */
+export declare const NOTES_FONT_SIZE_STEP = 2;
+/** Default font size (px) for speaker notes. */
+export declare const NOTES_FONT_SIZE_DEFAULT = 14;
+/** Clamp a notes font size to the allowed range. */
+export declare function clampNotesFontSize(size: number): number;
+/** Format a Date as a locale time string (HH:MM:SS). */
+export declare function formatTime(date: Date): string;
+/**
+ * Format a millisecond duration as `MM:SS`, or `HH:MM:SS` once the elapsed time
+ * reaches one hour.
+ */
+export declare function formatElapsed(elapsedMs: number): string;
+/** A render-spec node for a rich-text notes segment. */
+export type NotesSpan = {
+    kind: 'break';
+    key: string;
+} | {
+    kind: 'text';
+    key: string;
+    text: string;
+    style: Record<string, string>;
+};
+/**
+ * Convert rich-text notes segments into a framework-agnostic render spec. Each
+ * binding maps each entry to a `<br>` or styled `<span>`.
+ */
+export declare function notesSegmentsToSpans(segments: TextSegment[]): NotesSpan[];
+//# sourceMappingURL=presenter-view.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"presenter-view.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/presenter-view.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5E;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,uBAAuB,GAAG,SAAS,GAAG,OAAO,CAE/F;AAED,kEAAkE;AAClE,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,kEAAkE;AAClE,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,sEAAsE;AACtE,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,gDAAgD;AAChD,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C,oDAAoD;AACpD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wDAAwD;AACxD,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAM7C;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CASvD;AAED,wDAAwD;AACxD,MAAM,MAAM,SAAS,GAClB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAC;AAE9E;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,SAAS,EAAE,CA6BzE"}

package/dist/pptx/render/preview-elements.d.ts

@@ -0,0 +1,49 @@
+import type { PptxElement, PptxSlide, SmartArtLayout, SmartArtPptxElement } from 'ooxml-core/pptx';
+/**
+ * Composition helper for slide previews and sidebar thumbnails.
+ *
+ * Every binding paints a preview from the same two sources as a real save:
+ * the inherited layout/master (template) elements first, then the slide-owned
+ * elements on top. Keeping that merge + cap in one place stops each binding's
+ * thumbnail path from drifting away from `buildSaveSlides` ordering.
+ */
+/**
+ * Default cap on the number of elements a preview renders. This guards against
+ * pathological decks (thousands of shapes on one slide) blowing up a tiny
+ * off-screen thumbnail; ordinary slides sit far below it, so normal content is
+ * never dropped.
+ */
+export declare const DEFAULT_PREVIEW_ELEMENT_CAP = 500;
+export interface BuildPreviewElementsOptions {
+    /**
+     * Maximum number of elements to include. Defaults to
+     * {@link DEFAULT_PREVIEW_ELEMENT_CAP}. A value <= 0 disables the cap.
+     */
+    cap?: number;
+}
+/**
+ * Ordered, capped element list for a slide preview/thumbnail. Inherited
+ * template (layout/master) elements come first so slide-owned elements paint
+ * on top, matching {@link import('./template-editing').buildSaveSlides}.
+ */
+export declare function buildPreviewElements(slide: PptxSlide, templateElements?: readonly PptxElement[], options?: BuildPreviewElementsOptions): PptxElement[];
+/** Element size the insert handler creates; previews render the same box. */
+export declare const SMARTART_PREVIEW_ELEMENT_WIDTH = 600;
+/** Element size the insert handler creates; previews render the same box. */
+export declare const SMARTART_PREVIEW_ELEMENT_HEIGHT = 340;
+/** Fallback node texts used when a layout's preset carries none. */
+export declare const SMARTART_PREVIEW_FALLBACK_ITEMS: readonly string[];
+/**
+ * Build the full-size (pre-scale) SmartArt element a gallery tile previews:
+ * the exact box + preset node data the "Insert" action would create for
+ * `layout`. Callers scale the returned element down to gallery-tile size
+ * themselves (a `transform: scale(...)` wrapper), matching every binding's
+ * existing gallery layout.
+ *
+ * `defaultItems` lets a caller (Svelte's gallery passes its own preset lookup
+ * result as a prop) supply the node texts directly; when omitted, the preset
+ * catalogue is consulted the same way React/Vue/Angular/Vanilla already do,
+ * falling back to {@link SMARTART_PREVIEW_FALLBACK_ITEMS}.
+ */
+export declare function buildSmartArtPreviewElement(layout: SmartArtLayout, defaultItems?: readonly string[]): SmartArtPptxElement;
+//# sourceMappingURL=preview-elements.d.ts.map

package/dist/pptx/render/preview-elements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-elements.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/preview-elements.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAMnG;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAE/C,MAAM,WAAW,2BAA2B;IAC3C;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,SAAS,EAChB,gBAAgB,GAAE,SAAS,WAAW,EAAO,EAC7C,OAAO,CAAC,EAAE,2BAA2B,GACnC,WAAW,EAAE,CAOf;AAYD,6EAA6E;AAC7E,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAClD,6EAA6E;AAC7E,eAAO,MAAM,+BAA+B,MAAM,CAAC;AAEnD,oEAAoE;AACpE,eAAO,MAAM,+BAA+B,EAAE,SAAS,MAAM,EAAoB,CAAC;AAElF;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAC1C,MAAM,EAAE,cAAc,EACtB,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,GAC9B,mBAAmB,CAYrB"}

package/dist/pptx/render/read-only-recommendation.d.ts

@@ -0,0 +1,54 @@
+/** The `PptxData` fields this decision reads. Declared structurally. */
+export interface ReadOnlyRecommendationSource {
+    readonly modifyVerifier?: {
+        readonly hashData?: string;
+        readonly saltData?: string;
+        readonly algorithmName?: string;
+        /** Legacy algorithm ID extension; an alternate name-carrying attribute. */
+        readonly algIdExt?: string;
+        /**
+         * Legacy CryptoAPI ALG_SID hash identifier. PowerPoint's own "Set
+         * Password to Modify" writes ONLY this (no `algorithmName`), so it must
+         * be checked to recognise a real PowerPoint-authored verifier as
+         * checkable; see `resolveModifyVerifierAlgorithmName` (`ooxml-core/pptx`).
+         */
+        readonly cryptAlgorithmSid?: number;
+    };
+    readonly customProperties?: ReadonlyArray<{
+        readonly name: string;
+        readonly value: string;
+        readonly type?: string;
+    }>;
+}
+export type ReadOnlyRecommendationKind = 'modifyVerifier' | 'markedFinal' | null;
+export interface ReadOnlyRecommendation {
+    readonly kind: ReadOnlyRecommendationKind;
+    /** i18n key for the banner/toast a binding shows for this recommendation. */
+    readonly messageKey: string;
+    /** Whether a binding's "read-only" toggle should default to on. */
+    readonly defaultReadOnly: boolean;
+    /**
+     * Whether lifting this recommendation requires a correct password, rather
+     * than a plain "Edit anyway". True only for a `modifyVerifier` that carries
+     * a hash this viewer can actually check (`hashData` plus a resolvable
+     * algorithm, see `checkModifyPassword`; `saltData` is optional and NOT
+     * required, a missing salt is still checkable). "Mark as Final" is purely
+     * advisory and never requires one, and a `modifyVerifier` with no hash at
+     * all, or naming an algorithm this viewer does not implement, cannot be
+     * verified either way, so both fall back to the plain "Edit anyway" a
+     * binding already had.
+     */
+    readonly requiresPassword: boolean;
+}
+/**
+ * Whether a loaded deck recommends opening read-only, and why.
+ *
+ * `modifyVerifier` takes priority over "Mark as Final": a password-protected
+ * deck cannot be saved back over the original without the password even if
+ * the user dismisses the recommendation, while "Mark as Final" is purely
+ * advisory (PowerPoint's own "Edit Anyway" button removes it), so the
+ * stronger signal is the one a binding should lead with when a deck somehow
+ * carries both.
+ */
+export declare function readOnlyRecommendation(data: ReadOnlyRecommendationSource | undefined): ReadOnlyRecommendation;
+//# sourceMappingURL=read-only-recommendation.d.ts.map

package/dist/pptx/render/read-only-recommendation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-only-recommendation.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/read-only-recommendation.ts"],"names":[],"mappings":"AAoCA,wEAAwE;AACxE,MAAM,WAAW,4BAA4B;IAC5C,QAAQ,CAAC,cAAc,CAAC,EAAE;QACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;QAChC,2EAA2E;QAC3E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAC3B;;;;;WAKG;QACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;KACpC,CAAC;IACF,QAAQ,CAAC,gBAAgB,CAAC,EAAE,aAAa,CAAC;QACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC,CAAC;CACH;AAED,MAAM,MAAM,0BAA0B,GAAG,gBAAgB,GAAG,aAAa,GAAG,IAAI,CAAC;AAEjF,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,IAAI,EAAE,0BAA0B,CAAC;IAC1C,6EAA6E;IAC7E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;CACnC;AA8BD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,4BAA4B,GAAG,SAAS,GAC5C,sBAAsB,CA2BxB"}

package/dist/pptx/render/reading-view.d.ts

@@ -0,0 +1,125 @@
+import type { PresentationKeyBuffer, PresentationKeyInput } from './presentation-keymap.js';
+/**
+ * Marks the reading-view root in every binding.
+ *
+ * A neutral data attribute rather than a class or a test id: `e2e/` addresses
+ * all five viewers through one selector, and a class name is a styling decision
+ * each binding is entitled to make differently.
+ */
+export declare const READING_VIEW_ATTR = "data-pptx-reading-view";
+/** Marks the "3 / 12" slide counter inside the reading-view nav bar. */
+export declare const READING_VIEW_COUNTER_ATTR = "data-pptx-reading-view-counter";
+/** Marks the scaled slide surface inside the reading view. */
+export declare const READING_VIEW_STAGE_ATTR = "data-pptx-reading-view-stage";
+/** Whether the reading view is on screen, and which slide it is showing. */
+export interface ReadingViewState {
+    open: boolean;
+    /** Zero-based index into the deck's visible slides. */
+    slideIndex: number;
+}
+/** The reading view closed, showing nothing. */
+export declare const CLOSED_READING_VIEW: ReadingViewState;
+/**
+ * Open the reading view on `slideIndex`.
+ *
+ * Clamped rather than validated: entering from the ribbon while the deck is
+ * empty, or on a stale index after a slide was deleted, should show the first
+ * slide, not throw at the user.
+ */
+export declare function openReadingView(slideIndex: number, slideCount: number): ReadingViewState;
+/** The reading view closed, discarding its position. */
+export declare function closeReadingView(): ReadingViewState;
+/** A navigation intent a binding can raise from a key, a click or a tap. */
+export type ReadingViewCommand = {
+    command: 'next';
+} | {
+    command: 'previous';
+} | {
+    command: 'first';
+} | {
+    command: 'last';
+}
+/** Jump to a zero-based slide index. */
+ | {
+    command: 'goto';
+    slideIndex: number;
+} | {
+    command: 'exit';
+} | {
+    command: 'none';
+};
+/**
+ * Translate a key press into a reading-view command.
+ *
+ * Delegates to the slide-show key table so the two views cannot disagree about
+ * what Page Down does, then drops everything Reading View has no surface for.
+ * The slide-show-only keys (pen, laser, blackout, rehearsal, "All Slides") are
+ * mapped to `none` rather than silently falling through to navigation: a reader
+ * pressing Ctrl+P wants their browser's print dialog, and swallowing the chord
+ * to activate a pen that this view does not draw would be worse than ignoring
+ * it.
+ *
+ * `buffer` carries PowerPoint's "type a slide number, then Enter" jump. Pass
+ * one buffer for as long as the view stays open.
+ */
+export declare function mapReadingViewKey(input: PresentationKeyInput, buffer?: PresentationKeyBuffer): ReadingViewCommand;
+/** What a binding should do with a key press while the reading view is open. */
+export interface ReadingViewKeyHandling {
+    command: ReadingViewCommand;
+    /**
+     * Stop the key reaching the editor's own shortcut handler underneath.
+     *
+     * Reading View covers the editor but does not unmount it, and every binding
+     * listens for editor shortcuts on `window`. Without this, an arrow key both
+     * turned the page AND nudged the selected shape behind the overlay, so
+     * merely reading a deck silently edited it. Bindings must listen in the
+     * CAPTURE phase and call `stopPropagation()` when this is true.
+     */
+    swallow: boolean;
+    /** Also cancel the browser default, which for Space/arrows is scrolling. */
+    preventDefault: boolean;
+}
+/**
+ * Decide how to treat one key press while the reading view is open.
+ *
+ * Modifier chords are deliberately let through untouched: Ctrl+P must still
+ * reach the browser's print dialog and F12 its dev tools. Everything else is
+ * swallowed, because Reading View is modal over the editor and a bare Delete
+ * arriving at the canvas underneath would destroy a shape the reader cannot
+ * even see.
+ */
+export declare function handleReadingViewKey(input: PresentationKeyInput, buffer?: PresentationKeyBuffer): ReadingViewKeyHandling;
+/**
+ * Apply a command, returning the next state.
+ *
+ * Advancing past the last slide closes the view, which is what PowerPoint does:
+ * Reading View has no "end of slide show" screen, it simply hands the reader
+ * back to Normal. Going back from the first slide holds instead of closing, so
+ * an over-eager Page Up cannot lose someone's place.
+ */
+export declare function applyReadingViewCommand(state: ReadingViewState, command: ReadingViewCommand, slideCount: number): ReadingViewState;
+/** Whether the "previous" control should be available. */
+export declare function canGoPrevious(state: ReadingViewState): boolean;
+/**
+ * Whether the "next" control should be available.
+ *
+ * True on the last slide too: there, next means "leave", and PowerPoint keeps
+ * the arrow live for exactly that.
+ */
+export declare function canGoNext(state: ReadingViewState, slideCount: number): boolean;
+/** A width/height pair, in CSS pixels. */
+export interface ReadingViewBox {
+    width: number;
+    height: number;
+}
+/**
+ * Scale that fits `canvas` inside `viewport` without cropping it.
+ *
+ * Reading View letterboxes rather than fills: a 16:9 deck read in a 4:3 window
+ * must not have its edges cut off, because unlike a slide show there is no
+ * second monitor to blame and the reader cannot scroll. Returns 0 for a
+ * degenerate box so a binding rendering before its first layout pass draws
+ * nothing instead of an element scaled by Infinity.
+ */
+export declare function readingViewFitScale(canvas: ReadingViewBox, viewport: ReadingViewBox, padding?: number): number;
+//# sourceMappingURL=reading-view.d.ts.map

package/dist/pptx/render/reading-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reading-view.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/reading-view.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAMzF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,2BAA2B,CAAC;AAE1D,wEAAwE;AACxE,eAAO,MAAM,yBAAyB,mCAAmC,CAAC;AAE1E,8DAA8D;AAC9D,eAAO,MAAM,uBAAuB,iCAAiC,CAAC;AAMtE,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,OAAO,CAAC;IACd,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,gDAAgD;AAChD,eAAO,MAAM,mBAAmB,EAAE,gBAAiD,CAAC;AAEpF;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,gBAAgB,CAExF;AAED,wDAAwD;AACxD,wBAAgB,gBAAgB,IAAI,gBAAgB,CAEnD;AAMD,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAC3B;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GACnB;IAAE,OAAO,EAAE,UAAU,CAAA;CAAE,GACvB;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GACpB;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE;AACrB,wCAAwC;GACtC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GACvC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GACnB;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAChC,KAAK,EAAE,oBAAoB,EAC3B,MAAM,CAAC,EAAE,qBAAqB,GAC5B,kBAAkB,CAmBpB;AAED,gFAAgF;AAChF,MAAM,WAAW,sBAAsB;IACtC,OAAO,EAAE,kBAAkB,CAAC;IAC5B;;;;;;;;OAQG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,4EAA4E;IAC5E,cAAc,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,oBAAoB,EAC3B,MAAM,CAAC,EAAE,qBAAqB,GAC5B,sBAAsB,CASxB;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACtC,KAAK,EAAE,gBAAgB,EACvB,OAAO,EAAE,kBAAkB,EAC3B,UAAU,EAAE,MAAM,GAChB,gBAAgB,CAuBlB;AAED,0DAA0D;AAC1D,wBAAgB,aAAa,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAE9E;AAMD,0CAA0C;AAC1C,MAAM,WAAW,cAAc;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAClC,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,cAAc,EACxB,OAAO,SAAI,GACT,MAAM,CASR"}

package/dist/pptx/render/recent-colors.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Recent-colours ("Most Recently Used") support for every binding's colour
+ * picker.
+ *
+ * `PptxData.mruColors` (parsed from `p:clrMru` / `CT_ColorMRU`, and already
+ * saved back the same way) never actually reached a colour picker's "Recent
+ * colours" row: React's `FillStrokeProperties` threads a `recentColors` prop
+ * all the way down to `StrokeEffectsSection`, but every call site feeds it a
+ * hard-coded empty array. This module is the pure, framework-neutral piece
+ * that seeds that row from the deck's own MRU list and folds a newly picked
+ * colour back into it; a binding owns the (small) state that holds the
+ * array between picks and passes `mruColorsPatch`'s result to `save()`.
+ *
+ * @module render/recent-colors
+ */
+import type { PptxData } from 'ooxml-core/pptx';
+/**
+ * How many recent colours a picker shows, matching PowerPoint's own "Recent
+ * Colors" row. (React previously kept this as a local constant in
+ * `viewer/constants/scalar.ts`; that copy is unused by any picker yet and is
+ * left alone here, for the binding wiring to repoint at this one.)
+ */
+export declare const RECENT_COLOR_LIMIT = 8;
+/**
+ * Seed a colour picker's "Recent colours" row from the deck's own MRU list.
+ *
+ * `data.mruColors` is read in its stored order (index 0 = most recent),
+ * matching what {@link pushRecentColor} produces going forward. Invalid or
+ * duplicate entries are dropped rather than surfaced, since a picker has
+ * nothing useful to do with either.
+ */
+export declare function seedRecentColors(data: Pick<PptxData, 'mruColors'>): string[];
+/**
+ * Fold a newly picked colour into a picker's recent-colours list: the colour
+ * moves to the front (or is inserted there, if new), any earlier occurrence
+ * is removed rather than left as a stale duplicate further down, and the
+ * list is capped at {@link RECENT_COLOR_LIMIT}.
+ *
+ * Returns `recent` UNCHANGED (same reference) when `hex` is not a valid
+ * 6-digit colour, so a caller can use the identity of the result to decide
+ * whether anything changed.
+ */
+export declare function pushRecentColor(recent: readonly string[], hex: string): string[];
+/**
+ * The `PptxData` patch that persists a picker's current recent-colours list
+ * as the deck's `p:clrMru`, ready to pass through as (or merge into)
+ * `presentationProperties` on the next `save()`. Stored in the same
+ * most-recent-first order {@link seedRecentColors} reads back.
+ */
+export declare function mruColorsPatch(recent: readonly string[]): Pick<PptxData, 'mruColors'>;
+//# sourceMappingURL=recent-colors.d.ts.map

package/dist/pptx/render/recent-colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recent-colors.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/recent-colors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAmCpC;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,MAAM,EAAE,CAS5E;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAMhF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CASrF"}

package/dist/pptx/render/reflection.d.ts

@@ -0,0 +1,111 @@
+/**
+ * `a:reflection` compositing: a real, cross-browser mirrored copy of an
+ * element rather than `-webkit-box-reflect`.
+ *
+ * `-webkit-box-reflect` is Chromium/WebKit only - Firefox does not implement
+ * it at all, so every reflected picture/shape in this app rendered nothing
+ * whatsoever in Firefox. It also cannot express `@sx`/`@sy` (scale),
+ * `@kx`/`@ky` (skew), `@rot` (independent reflection rotation), `@fadeDir`
+ * (fade axis), or `@algn` (anchor), so those five attributes were parsed and
+ * round-tripped but never rendered even in a browser that DID support the
+ * property.
+ *
+ * This module replaces it with a wrapper style for a mirrored SIBLING node a
+ * binding renders just below (or per `@algn`, from) the source element:
+ *   - `transform: scale(@sx, @sy)` does BOTH the mirror and the size: OOXML's
+ *     `@sy` (ST_Percentage) carries the flip in its SIGN, not as a separate
+ *     always-on negation. PowerPoint's own "Reflection, touching" gallery
+ *     preset - byte-for-byte what this module's tests and the `audit-text`
+ *     COM corpus use - emits `sy="-100000"` (-100%) for an ordinary full
+ *     mirror; there is no separate flip flag. Hardcoding an unconditional
+ *     `scaleY(-1)` AND then layering `scale(sx, sy)` on top of it (the
+ *     pre-fix code) double-applied the flip for every reflection authored
+ *     this way: `scaleY(-1) scale(1, -1)` composes to the identity matrix,
+ *     so the "reflected" copy rendered as a plain, unmirrored, faded
+ *     duplicate - confirmed live in the React demo against `audit-text`
+ *     slide 14 ("REFLECTION" rendered twice, both right-side up) before this
+ *     fix. `@sy` defaults to `-100000` (not OOXML's own generic
+ *     `ST_Percentage` default of `100000`) so a bare `<a:reflection/>` with
+ *     no authored scale still mirrors, matching every reflection preset
+ *     PowerPoint's gallery actually emits.
+ *   - `mask-image`/`-webkit-mask-image` with a `linear-gradient` alpha ramp
+ *     reproduces the fade (`@stA`/`@endA`/`@stPos`/`@endPos`/`@blurRad`), at
+ *     an angle driven by `@fadeDir` (falling back to the same "fades toward
+ *     the far edge" default `-webkit-box-reflect` always used). `mask-image`
+ *     is supported unprefixed in Firefox and Chromium alike (Safari still
+ *     wants the `-webkit-` form, hence both properties).
+ *   - `transform-origin` encodes `@algn`.
+ *
+ * The wrapper only supplies POSITION/TRANSFORM/MASK; the binding paints the
+ * mirrored CONTENT inside it (the resolved fill CSS from
+ * `getComputedFillStyle` for a shape, or a cloned `<img>` for a picture) -
+ * this module has no opinion on that, so it stays framework- and
+ * content-agnostic like every other decision function in this package.
+ *
+ * `getTextReflectionWrapperStyle` reuses the same computation for a text run's
+ * `a:rPr/a:effectLst/a:reflection`: the OOXML element is identical
+ * (`CT_ReflectionEffect`), and core's text-run parser
+ * (`PptxHandlerRuntimeTextRunEffects.ts`) now extracts the same attribute set
+ * onto {@link TextStyle} (`textReflection*`) that the shape parser extracts
+ * onto {@link ShapeStyle} - `@dist`/`@stA`/`@endA`/`@blurRad` plus
+ * `@sx`/`@sy`/`@kx`/`@ky`/`@rot`/`@fadeDir`/`@algn` - via the same
+ * `extractReflectionAttributes` helper, so a text run's reflection composes
+ * the identical scale/skew/rotation/fade-direction/anchor transform a
+ * shape's does. No fork was needed to reuse {@link getReflectionWrapperStyle}:
+ * every `textReflection*` field maps onto the exact same {@link ShapeStyle}
+ * field name it already reads.
+ *
+ * @module render/reflection
+ */
+import type { ShapeStyle, TextStyle } from 'ooxml-core/pptx';
+/**
+ * CSS `mask-image`/`-webkit-mask-image` value plus the raw `transform` for a
+ * mirrored reflection sibling. Every value is a ready-to-apply CSS string (or
+ * `'none'` sentinel avoided - fields are omitted when the browser default
+ * already matches), so a binding can spread this directly onto its own style
+ * object with no further per-framework logic.
+ */
+export interface ReflectionWrapperStyle {
+    position: 'absolute';
+    left: string;
+    /** `calc(100% + <dist>px)`: sits `@dist` px below the source element's box. */
+    top: string;
+    width: string;
+    height: string;
+    /** `scale(@sx, @sy)` (the sign of `@sy` IS the mirror) composed with `@kx`/`@ky`/`@rot`. */
+    transform: string;
+    /** Anchor point for the transform above, from `@algn` (default `center top`). */
+    transformOrigin: string;
+    maskImage: string;
+    WebkitMaskImage: string;
+    pointerEvents: 'none';
+}
+/**
+ * Compute the reflection wrapper style for a {@link ShapeStyle}, given the
+ * element height (needed to convert `@endPos`'s fraction into a px fade
+ * length, matching the OOXML semantics).
+ *
+ * @returns `undefined` when the element has no reflection.
+ */
+export declare function getReflectionWrapperStyle(style: ShapeStyle | undefined, elementHeight: number): ReflectionWrapperStyle | undefined;
+/**
+ * {@link getReflectionWrapperStyle} for a text run's `TextStyle`, so a
+ * binding's text renderer paints the SAME cross-browser mirrored-sibling
+ * wrapper a shape/picture does, rather than a second, `-webkit-box-reflect`
+ * based implementation.
+ *
+ * Maps every `textReflection*` field core's text-run parser extracts onto the
+ * identically-named {@link ShapeStyle} fields {@link getReflectionWrapperStyle}
+ * already reads, then delegates entirely - no reflection maths is duplicated
+ * here. `textReflectionStartOpacity` defaults to `0.5` (matching the CSS this
+ * replaces) so a bare `<a:reflection/>` with no attributes still renders,
+ * exactly as it did through `-webkit-box-reflect`'s implicit default. A run
+ * with no authored scale/skew/rotation/fade-direction/anchor attributes falls
+ * through to {@link getReflectionWrapperStyle}'s own defaults (no
+ * scale/skew/rotation, fade toward the far edge, top-centre anchor), same as
+ * an unadorned `a:reflection` on a shape.
+ *
+ * @returns `undefined` when the run has no reflection.
+ */
+export declare function getTextReflectionWrapperStyle(style: TextStyle | undefined, elementHeight: number): ReflectionWrapperStyle | undefined;
+//# sourceMappingURL=reflection.d.ts.map

package/dist/pptx/render/reflection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflection.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/reflection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAO7D;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACtC,QAAQ,EAAE,UAAU,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,+EAA+E;IAC/E,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,4FAA4F;IAC5F,SAAS,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;CACtB;AAiDD;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACxC,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,aAAa,EAAE,MAAM,GACnB,sBAAsB,GAAG,SAAS,CA8EpC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,6BAA6B,CAC5C,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,aAAa,EAAE,MAAM,GACnB,sBAAsB,GAAG,SAAS,CAoBpC"}

package/dist/pptx/render/remap-empty-paragraph.d.ts

@@ -0,0 +1,2 @@
+export { remapEmptyParagraph } from 'ooxml-core/pptx/editor/render/remap-empty-paragraph';
+//# sourceMappingURL=remap-empty-paragraph.d.ts.map

package/dist/pptx/render/remap-empty-paragraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remap-empty-paragraph.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/remap-empty-paragraph.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC"}

package/dist/pptx/render/remap-paragraph-sources.d.ts

@@ -0,0 +1,3 @@
+export { restoreParagraphMetadata, alignParagraphSources, } from 'ooxml-core/pptx/editor/render/remap-paragraph-sources';
+export type { RemapSourceParagraph } from 'ooxml-core/pptx/editor/render/remap-paragraph-sources';
+//# sourceMappingURL=remap-paragraph-sources.d.ts.map

package/dist/pptx/render/remap-paragraph-sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remap-paragraph-sources.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/remap-paragraph-sources.ts"],"names":[],"mappings":"AACA,OAAO,EACN,wBAAwB,EACxB,qBAAqB,GACrB,MAAM,uDAAuD,CAAC;AAC/D,YAAY,EAAE,oBAAoB,EAAE,MAAM,uDAAuD,CAAC"}

package/dist/pptx/render/remap-text-bullets.d.ts

@@ -0,0 +1,2 @@
+export { renumberRemappedParagraphs, dedicatedBulletMarker, withAutoNumberIndex, withoutRenderedBulletPrefix, continueListParagraph, } from 'ooxml-core/pptx/editor/render/remap-text-bullets';
+//# sourceMappingURL=remap-text-bullets.d.ts.map