ooxml-ui 0.30.0 → 0.31.0

package/dist/pptx/render/animation-timeline-text-range.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `animation-timeline-text-range`  -  scopes an animation carrying a `p:txEl`
+ * text-level target (`p:pRg` paragraph range or `p:charRg` character range,
+ * ECMA-376 S19.5.86 CT_TLTextTargetElement) to just the paragraphs/characters
+ * it names, instead of the whole text-box element.
+ *
+ * Reuses the SAME `<elementId>::p<i>` / `<elementId>::c<p>-<c>` composite-id
+ * scheme `expandTextBuildAnimations` already emits for staged text builds:
+ * every binding's text renderer already knows how to look up those ids (see
+ * `text-build-spans.ts`), so scoping a plain entrance/emphasis/exit effect
+ * to a paragraph or character range needs no new rendering plumbing, only
+ * this expansion.
+ *
+ * @module render/animation-timeline-text-range
+ */
+import type { PptxNativeAnimation } from 'ooxml-core/pptx';
+import type { TextBuildSegmentCounts } from './animation-timeline-text-build.js';
+/**
+ * Expand every animation carrying a `p:txEl` (`textTarget`) into per-paragraph
+ * or per-character sub-animations scoped to the named range, using the
+ * element's segment counts to clamp/interpret the range. Animations without a
+ * `textTarget`, or whose target element has no known segment counts, pass
+ * through unchanged (falling back to the pre-existing whole-element scope).
+ *
+ * @param animations - Native animations, some carrying `textTarget`.
+ * @param segmentCounts - Map of elementId -> segment counts (see
+ *        `countTextSegments`); the SAME map `expandTextBuildAnimations` uses.
+ */
+export declare function expandTextRangeAnimations(animations: ReadonlyArray<PptxNativeAnimation>, segmentCounts: ReadonlyMap<string, TextBuildSegmentCounts>): PptxNativeAnimation[];
+//# sourceMappingURL=animation-timeline-text-range.d.ts.map

package/dist/pptx/render/animation-timeline-text-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-timeline-text-range.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-timeline-text-range.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAG3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAyE9E;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACxC,UAAU,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAC9C,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,GACxD,mBAAmB,EAAE,CA0CvB"}

package/dist/pptx/render/animation-timeline-types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `animation-timeline-types` - pure interfaces for the native-animation
+ * (OOXML `p:timing` tree) playback engine shared by every binding.
+ *
+ * These describe the *parsed* native animation model (`PptxNativeAnimation`,
+ * driven by `presetClass` / `presetId`), as opposed to the editor-level
+ * {@link import('./animation-css').AnimationCssResult} model in `animation-css`
+ * (driven by `PptxElementAnimation` preset strings). Both coexist in shared.
+ *
+ * This module is a pure re-export barrel: the actual type groups live in
+ * sibling files (split out to keep each file under the repo's file-size
+ * limit). Import from here as before; nothing about the public surface
+ * changed.
+ *
+ * @module render/animation-timeline-types
+ */
+export type { EffectName } from './animation-timeline-effect-names.js';
+export type { ChartBuildMode, DiagramBuildMode, StepBuildDescriptor, TimelineStepGraphicElement, ChartRevealPoint, ChartRevealDescriptor, DiagramRevealDescriptor, ElementBuildState, ColorAnimationTarget, } from './animation-timeline-build-descriptors.js';
+export type { AnimationStep, TimelineStepCommand, TimelineStep } from './animation-timeline-step.js';
+export type { TimelineClickGroup, AnimationTimeline, ElementAnimationState, AnimationStyle, } from './animation-timeline-group.js';
+//# sourceMappingURL=animation-timeline-types.d.ts.map

package/dist/pptx/render/animation-timeline-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-timeline-types.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-timeline-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,YAAY,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AACpE,YAAY,EACX,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,0BAA0B,EAC1B,gBAAgB,EAChB,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,GACpB,MAAM,wCAAwC,CAAC;AAChD,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAClG,YAAY,EACX,kBAAkB,EAClB,iBAAiB,EACjB,qBAAqB,EACrB,cAAc,GACd,MAAM,4BAA4B,CAAC"}

package/dist/pptx/render/animation-transform-keyframes.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Compose authored motion, rotation, and scale behaviours into one CSS
+ * keyframe block. OOXML permits those behaviours to share one effect wrapper,
+ * while CSS animations that each write `transform` would overwrite each other.
+ *
+ * @module render/animation-transform-keyframes
+ */
+import type { PptxNativeAnimation } from 'ooxml-core/pptx';
+import type { AnimationElementBox } from './animation-render-context.js';
+export interface TransformKeyframePrefixes {
+    motion: string;
+    rotationAbsolute: string;
+    rotationRelative: string;
+    scaleAbsolute: string;
+    scaleRelative: string;
+    transform: string;
+}
+/**
+ * `p:animMotion/@_origin` (ST_TLAnimateMotionBehaviorOrigin, ECMA-376
+ * S19.5.7): `layout` (the default) scales the path's percentage coordinates
+ * against the SLIDE; `parent` scales them against the immediate PARENT
+ * GROUP's box when the animated shape sits inside a group. A binding that
+ * renders a grouped shape sets `--pptx-parent-w`/`--pptx-parent-h` (in px) on
+ * that shape (or an ancestor it inherits from) to the group's own rendered
+ * size; until a binding sets it, this falls back to the same default canvas
+ * size `--pptx-slide-w`/`-h` uses, matching this module's existing
+ * unset-custom-property behaviour rather than silently using the wrong box.
+ */
+export declare function slideOffset(percent: number, axis: 'w' | 'h', origin: string | undefined): string;
+/**
+ * True when the parsed animation contains an authored transform behaviour.
+ * `box` is the animated shape's real rendered geometry (slide-fraction
+ * units), when the caller has it; see `animation-render-context.ts`.
+ */
+export declare function hasAuthoredTransform(anim: PptxNativeAnimation, box?: AnimationElementBox): boolean;
+export declare function formatNumber(value: number, fractionDigits?: number): string;
+/**
+ * Build one keyframe block so simultaneous transform behaviours remain
+ * simultaneous instead of competing for the CSS `transform` property. `box`
+ * is the animated shape's real rendered geometry (slide-fraction units),
+ * when the caller has it; see `animation-render-context.ts`.
+ */
+export declare function buildTransformKeyframes(anim: PptxNativeAnimation, uid: number, prefixes: TransformKeyframePrefixes, box?: AnimationElementBox): {
+    keyframeName: string;
+    css: string;
+} | undefined;
+//# sourceMappingURL=animation-transform-keyframes.d.ts.map

package/dist/pptx/render/animation-transform-keyframes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-transform-keyframes.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-transform-keyframes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAK3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,MAAM,WAAW,yBAAyB;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAIhG;AAqBD;;;;GAIG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,mBAAmB,EACzB,GAAG,CAAC,EAAE,mBAAmB,GACvB,OAAO,CAOT;AA0BD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,GAAE,MAAU,GAAG,MAAM,CAE9E;AAkED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,mBAAmB,EACzB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,yBAAyB,EACnC,GAAG,CAAC,EAAE,mBAAmB,GACvB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAqEnD"}

package/dist/pptx/render/animation-wedge-reveal.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `animation-wedge-reveal`: the Wedge entrance/exit (`presetID` 20,
+ * `p:animEffect filter="wedge"`) as a two-sided angular sweep.
+ *
+ * Ground truth (PowerPoint 365, COM `AddEffect(msoAnimEffectWedge)` then
+ * `Presentation.CreateVideo` at 62.5 fps, frame-diffed on a 200x200 red
+ * rectangle): the entrance opens two wedges from 12 o'clock about the box
+ * centre, one sweeping clockwise and one anticlockwise, until they meet at
+ * 6 o'clock. The half-alpha edge advances linearly with the effect's
+ * progress and is feathered over about 24 degrees. The exit is NOT the
+ * entrance reversed: the HIDDEN region is the same pair of wedges opening
+ * from 12 o'clock, so the last visible sliver closes at 6 o'clock.
+ *
+ * A conic gradient's angle is not interpolable in CSS, so each keyframe block
+ * steps through {@link WEDGE_STEPS} discrete stops (the same technique
+ * `animation-pixelate-filter` uses), about one change per frame for a
+ * default-length effect.
+ *
+ * @module render/animation-wedge-reveal
+ */
+/** Feather width, as a fraction of the 180-degree half-turn. */
+export declare const WEDGE_BAND = 0.133;
+/** Discrete keyframe stops per wedge keyframe block. */
+export declare const WEDGE_STEPS = 40;
+/** Half-alpha edge angle (0-180 degrees from 12 o'clock) at linear progress `p`. */
+export declare function wedgeEdgeAngle(progress: number): number;
+/** Kebab-case declarations for the Wedge mask at linear progress `p` (0-1). */
+export declare function wedgeDecl(progress: number, isExit: boolean): string;
+/** CamelCase inline-style map for a Wedge entrance's HIDDEN state. */
+export declare function wedgeInitialStyle(): Record<string, string | number>;
+/** Static `@keyframes` for the Wedge entrance and exit. */
+export declare const WEDGE_KEYFRAME_DEFINITIONS: Readonly<Record<'wedgeIn' | 'wedgeOut', string>>;
+//# sourceMappingURL=animation-wedge-reveal.d.ts.map

package/dist/pptx/render/animation-wedge-reveal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-wedge-reveal.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-wedge-reveal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,gEAAgE;AAChE,eAAO,MAAM,UAAU,QAAQ,CAAC;AAEhC,wDAAwD;AACxD,eAAO,MAAM,WAAW,KAAK,CAAC;AAM9B,oFAAoF;AACpF,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGvD;AAmBD,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,CAKnE;AAED,sEAAsE;AACtE,wBAAgB,iBAAiB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAQnE;AAWD,2DAA2D;AAC3D,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,GAAG,UAAU,EAAE,MAAM,CAAC,CAGvF,CAAC"}

package/dist/pptx/render/annotation-overlay.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Presentation-mode ink-annotation overlay helpers (pen / highlighter /
+ * eraser / laser).
+ *
+ * React, Vue and Angular each carried a byte-identical `buildPathD`/
+ * `getCursorForTool` pair (Angular's copy, already framework-free in
+ * `presentation-annotations-helpers.ts`, additionally names them
+ * `buildStrokePathD`/`cursorForTool` - the names this module keeps). This is
+ * the one copy of the two pure functions; each binding's own annotation
+ * overlay/composable/service can import them instead of redefining them.
+ *
+ * @module render/annotation-overlay
+ */
+/** A single {x, y} coordinate in slide-space pixels. */
+export interface AnnotationOverlayPoint {
+    x: number;
+    y: number;
+}
+/** The tool currently armed in the presentation annotation overlay. */
+export type AnnotationOverlayTool = 'none' | 'pen' | 'highlighter' | 'eraser' | 'laser';
+/**
+ * Build the SVG path `d` attribute for a polyline of stroke points, using
+ * `M`/`L` commands (no bezier smoothing). Returns an empty string for an
+ * empty point array.
+ *
+ * @example
+ * buildStrokePathD([{x:0,y:0},{x:10,y:5}]) // "M 0 0 L 10 5"
+ */
+export declare function buildStrokePathD(points: readonly AnnotationOverlayPoint[]): string;
+/** Return the CSS `cursor` value that matches the armed annotation `tool`. */
+export declare function cursorForTool(tool: AnnotationOverlayTool): string;
+//# sourceMappingURL=annotation-overlay.d.ts.map

package/dist/pptx/render/annotation-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotation-overlay.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/annotation-overlay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,wDAAwD;AACxD,MAAM,WAAW,sBAAsB;IACtC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,uEAAuE;AACvE,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,KAAK,GAAG,aAAa,GAAG,QAAQ,GAAG,OAAO,CAAC;AAExF;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,sBAAsB,EAAE,GAAG,MAAM,CAWlF;AAED,8EAA8E;AAC9E,wBAAgB,aAAa,CAAC,IAAI,EAAE,qBAAqB,GAAG,MAAM,CAWjE"}

package/dist/pptx/render/arrange-extras.d.ts

@@ -0,0 +1,23 @@
+import type { PptxElement } from 'ooxml-core/pptx';
+/** Outline thickness the renderer assumes when the shape declares none. */
+export declare const DEFAULT_STROKE_WIDTH = 1;
+/**
+ * Grouping needs an editable deck, at least two selected elements, and (when
+ * the caller can supply it) none of those elements locked against grouping.
+ *
+ * `selectionGroupable` defaults to `true` so callers that only know the
+ * selection count (not yet the elements themselves) keep their previous
+ * behaviour; a caller that HAS the selected elements should pass
+ * `selectedElements.every((el) => canInteractWithElement(el, 'group'))`.
+ */
+export declare function canGroupSelection(canEdit: boolean, selectedCount: number, selectionGroupable?: boolean): boolean;
+/**
+ * Ungrouping needs an editable deck, a selection that IS a group, and that
+ * group's own `a:grpSpLocks/@noGrp` allowing it.
+ */
+export declare function canUngroupSelection(canEdit: boolean, element: PptxElement | null): boolean;
+/** An outline width only exists on an element that carries shape properties. */
+export declare function canSetStrokeWidth(canEdit: boolean, element: PptxElement | null): boolean;
+/** The stroke width to show for a selection, defaulted for a shape without one. */
+export declare function strokeWidthOf(element: PptxElement | null): number;
+//# sourceMappingURL=arrange-extras.d.ts.map

package/dist/pptx/render/arrange-extras.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrange-extras.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/arrange-extras.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAInD,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,MAAM,EACrB,kBAAkB,UAAO,GACvB,OAAO,CAET;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,OAAO,CAE1F;AAED,gFAAgF;AAChF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,OAAO,CAExF;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,MAAM,CAKjE"}

package/dist/pptx/render/audience-content-store.d.ts

@@ -0,0 +1,37 @@
+/**
+ * audience-content-store: IndexedDB-based storage for sharing PPTX content
+ * between the presenter tab and audience tab.
+ *
+ * When the presenter opens an audience window, the PPTX bytes are stored in
+ * IndexedDB. The audience tab retrieves them on load and then cleans up.
+ *
+ * Framework-agnostic: every binding (React/Vue/Angular) re-exports these
+ * symbols through a thin shim. The database, store, and key names are kept
+ * identical across bindings so the cross-tab handoff stays wire-compatible
+ * regardless of which binding opened the presenter window or renders the
+ * audience tab.
+ */
+/** URL hash that marks the current tab as the audience display. */
+export declare const AUDIENCE_HASH = "#pptx-audience";
+/** Returns true if the current page was opened as an audience tab. */
+export declare function isAudienceTab(): boolean;
+/**
+ * Parse the session nonce from the current page URL hash. Returns `null` if the
+ * hash is not in the expected `#pptx-audience&nonce=<uuid>` form.
+ */
+export declare function parseAudienceNonce(): string | null;
+/**
+ * Store PPTX content bytes so the audience tab can retrieve them.
+ * Called by the presenter before opening the audience window.
+ */
+export declare function storeAudienceContent(content: ArrayBuffer | Uint8Array, sessionId?: string): Promise<void>;
+/**
+ * Load PPTX content bytes stored by the presenter tab.
+ * Returns `null` if nothing is stored.
+ */
+export declare function loadAudienceContent(sessionId?: string): Promise<Uint8Array | null>;
+/**
+ * Remove stored audience content (cleanup).
+ */
+export declare function clearAudienceContent(sessionId?: string): Promise<void>;
+//# sourceMappingURL=audience-content-store.d.ts.map

package/dist/pptx/render/audience-content-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audience-content-store.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/audience-content-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAeH,mEAAmE;AACnE,eAAO,MAAM,aAAa,mBAAmB,CAAC;AAgC9C,sEAAsE;AACtE,wBAAgB,aAAa,IAAI,OAAO,CAKvC;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,GAAG,IAAI,CAKlD;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,WAAW,GAAG,UAAU,EACjC,SAAS,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAqBf;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CA0CxF;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAsB5E"}

package/dist/pptx/render/audience-display.d.ts

@@ -0,0 +1,64 @@
+/**
+ * `audience-display`: the policy that governs a tab opened as a presenter's
+ * **audience display** (the second window a presenter puts on the projector).
+ *
+ * That tab is a mirror of the presenter's screen, not an editor. It is the same
+ * viewer application as the presenter's, so without an explicit policy every
+ * ordinary "leave the slide show" path (Escape, the exit button, leaving
+ * fullscreen, the presenter's end-of-session signal) drops the audience into
+ * the full editing chrome: ribbon, thumbnails and inspector, live in front of
+ * the room (issue #106).
+ *
+ * The rule is therefore absolute: **an audience display never returns to edit
+ * mode.** When the presenter ends the show the tab closes itself; browsers that
+ * refuse `window.close()` (a tab the script did not open, or one the user
+ * re-navigated) leave the end-of-slide-show screen up instead.
+ *
+ * Framework-agnostic: every binding routes its exit paths through
+ * {@link mayLeaveSlideShow} and its presenter-exit handler through
+ * {@link endAudienceDisplay}.
+ *
+ * @module render/audience-display
+ */
+/**
+ * Whether a URL hash marks the tab as an audience display.
+ *
+ * Accepts the bare hash and the `#pptx-audience&nonce=<uuid>` form the
+ * presenter opens. Safe to call with `undefined` (non-browser contexts).
+ */
+export declare function isAudienceDisplayHash(hash: string | undefined): boolean;
+/** Whether the current tab is an audience display. False outside a browser. */
+export declare function isAudienceDisplayTab(): boolean;
+/**
+ * Whether a tab may leave the slide show for the editor.
+ *
+ * Bindings call this from EVERY exit path (Escape, the toolbar's end button,
+ * the advance past the end-of-show screen, fullscreen change). An audience
+ * display always answers `false`, so its editing chrome is unreachable.
+ *
+ * @param isAudienceDisplay - Pass the binding's audience-tab check; defaults to
+ *        {@link isAudienceDisplayTab} so callers with no state can omit it.
+ */
+export declare function mayLeaveSlideShow(isAudienceDisplay?: boolean): boolean;
+/**
+ * Whether this tab may drive the deck from its own input.
+ *
+ * An audience display mirrors the presenter's screen, so its keyboard, clicks,
+ * taps and swipes must not navigate. When they did, a stray key moved the
+ * audience off the presenter's slide and the next presenter snapshot yanked it
+ * straight back, which reads as the display refusing to turn the page.
+ *
+ * @param isAudienceDisplay - Pass the binding's audience-tab check; defaults to
+ *        {@link isAudienceDisplayTab} so callers with no state can omit it.
+ */
+export declare function acceptsPresentationInput(isAudienceDisplay?: boolean): boolean;
+/**
+ * Act on the presenter's `presenter-exit` signal inside an audience tab.
+ *
+ * Attempts to close the tab. Returns `true` when the binding must raise its
+ * end-of-slide-show screen because the tab is still open: `window.close()` is
+ * refused for tabs the script did not open, and closing is asynchronous, so the
+ * caller always shows the screen and simply never sees it if the tab goes away.
+ */
+export declare function endAudienceDisplay(win?: Window | undefined): boolean;
+//# sourceMappingURL=audience-display.d.ts.map

package/dist/pptx/render/audience-display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audience-display.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/audience-display.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAEvE;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,IAAI,OAAO,CAK9C;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,iBAAiB,GAAE,OAAgC,GAAG,OAAO,CAE9F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACvC,iBAAiB,GAAE,OAAgC,GACjD,OAAO,CAET;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAM,GAAG,SAA6B,GAAG,OAAO,CAUvF"}

package/dist/pptx/render/autosave-file-key.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Keep autosave, version history and snapshot cleanup on the same document key.
+ * A named document must use its name when the host has not supplied a path,
+ * matching the lookup performed when a demo restores its tab after refresh.
+ */
+export declare function resolveAutosaveFileKey(filePath: string | undefined, fileName: string | undefined): string;
+//# sourceMappingURL=autosave-file-key.d.ts.map

package/dist/pptx/render/autosave-file-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autosave-file-key.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/autosave-file-key.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,sBAAsB,CACrC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC1B,MAAM,CAER"}

package/dist/pptx/render/autosave-policy.d.ts

@@ -0,0 +1,131 @@
+/**
+ * @fileoverview Who decides whether recovery autosave runs, and how often.
+ *
+ * ## The rule: the host prop is a ceiling, the toggle is a preference
+ *
+ * Two things can speak about autosave, and until now each binding invented its
+ * own answer for what happens when both do:
+ *
+ *  - the **host** passes an `autosave` prop. That is a POLICY: the embedder is
+ *    stating what its application permits.
+ *  - the **user** flips the title-bar AutoSave switch, or File > Options > Save
+ *    > AutoSave. That is a PREFERENCE, expressed inside whatever the host allows.
+ *
+ * A preference can never exceed a policy, so:
+ *
+ *  - `autosave={false}` turns recovery autosave OFF and takes the toggle away
+ *    (`toggleAvailable: false`). A user cannot switch on what the application
+ *    forbade, and a switch that silently does nothing is worse than no switch.
+ *  - `autosave={true}`, or the prop omitted entirely, PERMITS autosave. The
+ *    user's toggle then decides, and it defaults to on.
+ *
+ * The prop is therefore only load-bearing when it is `false`. That is
+ * deliberate: crash recovery that is off by default is crash recovery nobody
+ * has, and the shared options schema already declares `save.autoSave: true` as
+ * the user default, so any other prop default would contradict it. Vue, Svelte
+ * and Vanilla previously defaulted to `false` and React and Angular to `true`;
+ * `true` is the answer, and the three that defaulted off now write recovery
+ * snapshots for hosts that never opted in. Pass `autosave={false}` to opt out.
+ *
+ * Two further gates are not negotiable by anyone, because without them there is
+ * nothing to write or nowhere to write it: editing must be possible at all, and
+ * a `filePath` must be set to key the IndexedDB record.
+ *
+ * ## Cadence follows the same rule
+ *
+ * An explicit `autosaveIntervalMs` prop is a policy and is honoured as given.
+ * Otherwise the cadence is the user's own File > Options > Save > "Save
+ * AutoRecover information every N minutes" (default two minutes), which React
+ * and Angular already respected and the other three ignored.
+ *
+ * ## What the two engine shapes must agree on
+ *
+ * React and Angular POLL on a fixed interval; Vue, Svelte and Vanilla DEBOUNCE
+ * on the edit. Both are legitimate, but a plain debounce has a failure mode a
+ * poll does not: a user who keeps editing keeps re-arming the timer, so it can
+ * defer a snapshot forever, and at the two-minute cadence that is an entire
+ * session of lost work. {@link nextAutosaveDelayMs} caps the debounce so both
+ * shapes make the same promise:
+ *
+ *   **a snapshot lands no later than one interval after the first unsaved edit,
+ *   and no more often than once per interval.**
+ *
+ * @module render/autosave-policy
+ */
+/**
+ * Why autosave is not running. `autosave_toggle_off` and `no_file_path` are the
+ * codes the title bar has always understood; the other two are new and fall
+ * back to the generic message in bindings that do not map them.
+ */
+export type AutosaveDisabledReason = 'autosave_host_off' | 'autosave_toggle_off' | 'no_file_path' | 'read_only';
+export interface AutosaveActivationInput {
+    /**
+     * The host's `autosave` prop. `undefined` means the host said nothing, which
+     * is treated as "permitted" (see the module docstring).
+     */
+    readonly hostAutosave?: boolean | undefined;
+    /** The user preference: title-bar AutoSave toggle / Options > Save > AutoSave. */
+    readonly userEnabled: boolean;
+    /** Whether editing is possible at all. A read-only viewer has nothing to recover. */
+    readonly canEdit: boolean;
+    /** IndexedDB key for the snapshot. Without one there is nowhere to write. */
+    readonly filePath: string | undefined;
+}
+export interface AutosaveActivation {
+    /** Whether recovery snapshots should actually be written. */
+    readonly active: boolean;
+    /**
+     * Whether the user's AutoSave toggle can change anything. False only when
+     * the host passed `autosave={false}`; the toggle must then render off and
+     * inert rather than pretending to work.
+     */
+    readonly toggleAvailable: boolean;
+    /** Why it is inactive, for the title bar. `undefined` when active. */
+    readonly reason?: AutosaveDisabledReason;
+}
+/**
+ * Resolve the host policy and the user preference into one answer.
+ *
+ * Reason precedence is "most fundamental first": a host veto outranks the
+ * toggle, which outranks a missing file path, which outranks read-only, so the
+ * title bar names the thing the user would have to change first.
+ */
+export declare function resolveAutosaveActivation(input: AutosaveActivationInput): AutosaveActivation;
+/** i18n key for a disabled reason, for bindings that render the title-bar hint. */
+export declare function autosaveDisabledReasonKey(reason: AutosaveDisabledReason | undefined): string;
+/** The cadence every binding falls back to: the shared AutoRecover default. */
+export declare const AUTOSAVE_DEFAULT_INTERVAL_MS: number;
+export interface AutosaveIntervalInput {
+    /** The host's `autosaveIntervalMs` prop, if it passed one. */
+    readonly hostIntervalMs?: number | undefined;
+    /**
+     * File > Options > Save > "Save AutoRecover information every N minutes",
+     * already converted to seconds (see `resolveAutosaveIntervalSeconds`).
+     */
+    readonly optionsIntervalSeconds?: number | undefined;
+}
+/**
+ * The interval to use, in milliseconds: the host's explicit prop, else the
+ * user's AutoRecover cadence, else the shared default.
+ */
+export declare function resolveAutosaveIntervalMs(input: AutosaveIntervalInput): number;
+export interface AutosaveDelayInput {
+    /** The resolved interval. */
+    readonly intervalMs: number;
+    /**
+     * When the OLDEST still-unsaved edit happened (epoch ms), or null when the
+     * document is clean. Reset to null after each successful snapshot.
+     */
+    readonly firstDirtyAt: number | null;
+    /** Now, in epoch ms. */
+    readonly now: number;
+}
+/**
+ * How long a debouncing engine may wait before writing the next snapshot.
+ *
+ * The full interval when nothing is outstanding, otherwise whatever is left of
+ * the first unsaved edit's interval, never negative. Continuous editing
+ * therefore still produces a snapshot every interval instead of none at all.
+ */
+export declare function nextAutosaveDelayMs(input: AutosaveDelayInput): number;
+//# sourceMappingURL=autosave-policy.d.ts.map

package/dist/pptx/render/autosave-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autosave-policy.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/autosave-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAQH;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAC/B,mBAAmB,GACnB,qBAAqB,GACrB,cAAc,GACd,WAAW,CAAC;AAEf,MAAM,WAAW,uBAAuB;IACvC;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5C,kFAAkF;IAClF,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,qFAAqF;IACrF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,MAAM,WAAW,kBAAkB;IAClC,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,sEAAsE;IACtE,QAAQ,CAAC,MAAM,CAAC,EAAE,sBAAsB,CAAC;CACzC;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,uBAAuB,GAAG,kBAAkB,CAc5F;AAED,mFAAmF;AACnF,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,GAAG,SAAS,GAAG,MAAM,CAa5F;AAMD,+EAA+E;AAC/E,eAAO,MAAM,4BAA4B,QAA2C,CAAC;AASrF,MAAM,WAAW,qBAAqB;IACrC,8DAA8D;IAC9D,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C;;;OAGG;IACH,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACrD;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,CAU9E;AAMD,MAAM,WAAW,kBAAkB;IAClC,6BAA6B;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,wBAAwB;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAOrE"}

package/dist/pptx/render/autosave-recovery-acknowledgement.d.ts

@@ -0,0 +1,13 @@
+/** The exact snapshot this tab has already loaded for `filePath`, if any. */
+export declare function getAcknowledgedAutosaveRecoveryTimestamp(filePath: string): number | undefined;
+/** Remember that this tab has loaded this exact snapshot without deleting it. */
+export declare function acknowledgeAutosaveRecovery(record: {
+    key: string;
+    timestamp: number;
+}): void;
+/** Undo an acknowledgement when loading that exact snapshot failed. */
+export declare function clearAutosaveRecoveryAcknowledgement(record: {
+    key: string;
+    timestamp: number;
+}): void;
+//# sourceMappingURL=autosave-recovery-acknowledgement.d.ts.map

package/dist/pptx/render/autosave-recovery-acknowledgement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autosave-recovery-acknowledgement.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/autosave-recovery-acknowledgement.ts"],"names":[],"mappings":"AA6BA,6EAA6E;AAC7E,wBAAgB,wCAAwC,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE7F;AAED,iFAAiF;AACjF,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAiB5F;AAED,uEAAuE;AACvE,wBAAgB,oCAAoC,CAAC,MAAM,EAAE;IAC5D,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;CAClB,GAAG,IAAI,CAqBP"}

package/dist/pptx/render/autosave-recovery.d.ts

@@ -0,0 +1,140 @@
+/**
+ * @fileoverview "Is there a recoverable snapshot for this deck, and what should
+ * the prompt say?"
+ *
+ * Every binding writes crash-recovery snapshots into the shared IndexedDB store
+ * (`./autosave-store`). Until now only React ever looked for one again, and
+ * even it merely popped the Version History panel open, which never says the
+ * word "recover". In the other four the data was there and nothing surfaced it,
+ * so the feature was invisible: the user closed a crashed tab, reopened the
+ * deck, and silently got the pre-crash version back.
+ *
+ * The decision lives here as one pure function so all five ask the same
+ * questions in the same order, and each binding does nothing but render the
+ * descriptor as its own dialog.
+ *
+ * @module render/autosave-recovery
+ */
+import type { AutosaveRecord } from './autosave-store.js';
+/** Snapshots older than this are not offered: the session they belong to is gone. */
+export declare const AUTOSAVE_RECOVERY_WINDOW_MS: number;
+export interface AutosaveRecoveryProbeInput {
+    /** This load has already been probed (the check is once per loaded deck). */
+    readonly alreadyChecked: boolean;
+    /** The IndexedDB key. Nothing to look up without one. */
+    readonly filePath: string | undefined;
+    /** True while the load pipeline is running. */
+    readonly loading: boolean;
+    /** A load error; a deck that failed to open cannot be compared to a snapshot. */
+    readonly error: string | null | undefined;
+    /** Slides currently rendered. Zero means nothing opened. */
+    readonly slideCount: number;
+    /**
+     * Whether recovery autosave is permitted at all (see
+     * `resolveAutosaveActivation`). A host that switched autosave off is not
+     * offered snapshots a previous configuration left behind.
+     */
+    readonly autosaveAllowed: boolean;
+}
+/** True when it is worth going to IndexedDB for a snapshot. */
+export declare function shouldProbeAutosaveRecovery(input: AutosaveRecoveryProbeInput): boolean;
+/** Everything a binding needs to render the recovery dialog, and nothing else. */
+export interface AutosaveRecoveryPrompt {
+    /** IndexedDB key the snapshot is stored under (the deck's file path/name). */
+    readonly filePath: string;
+    /** When the snapshot was written (epoch ms). */
+    readonly timestamp: number;
+    /** Snapshot size in bytes. */
+    readonly size: number;
+    /** Whole minutes since it was written, floored at 0. */
+    readonly ageMinutes: number;
+    readonly titleKey: string;
+    readonly messageKey: string;
+    /** `size` is pre-formatted here because byte units are not translated. */
+    readonly messageParams: {
+        readonly file: string;
+        readonly size: string;
+    };
+    /** Relative age, reusing the existing autosave age keys. */
+    readonly ageKey: string;
+    readonly ageParams: {
+        readonly count: number;
+    };
+    readonly restoreKey: string;
+    readonly discardKey: string;
+}
+export interface AutosaveRecoveryPromptInput {
+    /** The stored snapshot, or undefined when there is none. */
+    readonly record: {
+        key: string;
+        timestamp: number;
+        size: number;
+    } | undefined;
+    /** Public document name for UI copy; the record key remains storage-only. */
+    readonly displayName?: string;
+    /** Now, epoch ms. */
+    readonly now: number;
+    /** Exact snapshot this tab has already loaded for this document. */
+    readonly acknowledgedTimestamp?: number;
+}
+/** Format a snapshot size without translating it: "812 KB", "1.2 MB". */
+export declare function formatSnapshotSize(bytes: number): string;
+/**
+ * The prompt to show, or null when there is nothing worth offering.
+ *
+ * Rejects, in order: no record, an empty record, and one older than the
+ * recovery window. A valid record remains recoverable until explicit discard.
+ */
+export declare function autosaveRecoveryPrompt(input: AutosaveRecoveryPromptInput): AutosaveRecoveryPrompt | null;
+export interface AutosaveRecoveryVisibilityInput {
+    /** The descriptor the probe produced, if any. */
+    readonly prompt: AutosaveRecoveryPrompt | null | undefined;
+    /** Whether a slide show is running. */
+    readonly presenting: boolean;
+}
+/**
+ * Whether the recovery prompt may be mounted right now.
+ *
+ * A running slide show has no editor chrome: every editor region must leave the
+ * layout, the focus order AND the accessibility tree, and an overlay that merely
+ * looks absent does not qualify. This prompt is editor chrome by that
+ * definition, and it is also modal, so leaving it mounted puts a full-area
+ * backdrop over the show that swallows action-button clicks. That was measured,
+ * not theorised: `<div data-pptx-autosave-recovery> intercepts pointer events`
+ * is what the click log said.
+ *
+ * The offer is DEFERRED, not dropped. The probe result is kept, so the prompt
+ * appears the moment the show ends. Interrupting someone's presentation with a
+ * modal about crash recovery is a worse outcome than answering it a few minutes
+ * later, and the snapshot is not going anywhere.
+ *
+ * Note the deliberate non-fix: making the overlay pointer-transparent instead.
+ * A modal that does not take the pointer is a lie (its own buttons stop being
+ * clickable), and it would still sit in the accessibility tree during the show.
+ */
+export declare function shouldShowAutosaveRecoveryPrompt(input: AutosaveRecoveryVisibilityInput): boolean;
+export interface AutosaveRecoveryOffer {
+    readonly prompt: AutosaveRecoveryPrompt;
+    readonly record: AutosaveRecord;
+}
+/**
+ * Look up the snapshot for `filePath` and decide whether to offer it.
+ *
+ * Never throws: a blocked or missing IndexedDB is "nothing to recover".
+ */
+export declare function probeAutosaveRecovery(filePath: string, now?: number, displayName?: string): Promise<AutosaveRecoveryOffer | null>;
+/**
+ * The user accepted: hand back the bytes for the binding to load. The snapshot
+ * remains recoverable until the user explicitly discards it.
+ */
+export declare function acceptAutosaveRecovery(record: AutosaveRecord): Uint8Array;
+/**
+ * The user declined: drop the snapshot. Deliberately destructive, because
+ * "Discard" that leaves the file behind would ask again in the next tab, and
+ * the editor's own autosave writes a fresh one the moment they edit anything.
+ */
+export declare function discardAutosaveRecovery(record: {
+    key: string;
+    timestamp: number;
+}): Promise<void>;
+//# sourceMappingURL=autosave-recovery.d.ts.map