ooxml-ui 0.30.0 → 0.31.0

package/dist/pptx/render/wheel-intent.d.ts

@@ -0,0 +1,90 @@
+/**
+ * `wheel-intent`: what a mouse-wheel / trackpad gesture MEANS, on PowerPoint's
+ * terms.
+ *
+ * PowerPoint's desktop behaviour, which this reproduces:
+ *  - Normal (editing) view: a plain wheel scrolls the view, and once there is
+ *    nothing left to scroll it steps to the next / previous slide. Ctrl+wheel
+ *    zooms.
+ *  - Slide Show: every wheel notch navigates - down advances, up goes back.
+ *  - The thumbnail rail scrolls independently, which is native CSS overflow and
+ *    needs no handler at all.
+ *
+ * Pure arithmetic over `deltaY` / `deltaMode` / `ctrlKey`, so it lives here
+ * rather than five times over: the exact shape `presentation-keymap` already
+ * uses for keyboard input.
+ *
+ * @module render/wheel-intent
+ */
+/** What a wheel event should cause. */
+export type WheelIntent = 
+/** Zoom by `deltaScale` (positive zooms in). */
+{
+    readonly intent: 'zoom';
+    readonly deltaScale: number;
+} | {
+    readonly intent: 'next-slide';
+} | {
+    readonly intent: 'previous-slide';
+}
+/** Let the browser scroll normally. */
+ | {
+    readonly intent: 'scroll';
+}
+/** Swallow it: charge accumulated toward a step that has not landed yet. */
+ | {
+    readonly intent: 'none';
+};
+/** The fields of a `WheelEvent` this module reads. */
+export interface WheelInput {
+    readonly deltaY: number;
+    /** 0 = pixel, 1 = line, 2 = page. Absent is treated as pixel. */
+    readonly deltaMode?: number;
+    readonly ctrlKey?: boolean;
+    /** macOS pinch-zoom arrives as Meta on some browsers. */
+    readonly metaKey?: boolean;
+}
+/**
+ * Carries partial scroll charge between events so one trackpad flick is one
+ * slide step rather than twenty. Create per viewport with
+ * {@link createWheelStepBuffer}.
+ */
+export interface WheelStepBuffer {
+    accumulated: number;
+}
+/** A fresh, empty step buffer. */
+export declare function createWheelStepBuffer(): WheelStepBuffer;
+/**
+ * A wheel event's travel in PIXELS, whatever unit it was reported in.
+ *
+ * Reading `deltaY` raw is why Ctrl+wheel zoom felt broken on Firefox: it
+ * reports `deltaMode: 1` with ~3 lines per notch, so a notch moved zoom by
+ * 0.003 instead of ~0.1.
+ *
+ * @param input The wheel event fields.
+ * @returns Signed travel in pixels.
+ */
+export declare function normalizeWheelDelta({ deltaY, deltaMode }: WheelInput): number;
+/**
+ * Map a wheel event in the EDITING view.
+ *
+ * @param input The wheel event fields.
+ * @param buffer Per-viewport step buffer.
+ * @param canScrollFurther Whether the viewport still has scroll travel left in
+ *   the gesture's direction. Derive this from the SCALED stage height, not
+ *   `scrollHeight - clientHeight`: the stage is CSS-transformed, transforms do
+ *   not affect layout, so the untransformed box leaves hundreds of px of
+ *   phantom scroll range that would otherwise have to be wheeled through before
+ *   the slide would step.
+ * @returns The intent to act on.
+ */
+export declare function mapEditingWheel(input: WheelInput, buffer: WheelStepBuffer, canScrollFurther: boolean): WheelIntent;
+/**
+ * Map a wheel event during a SLIDE SHOW, where every notch navigates.
+ *
+ * @param input The wheel event fields.
+ * @param buffer Per-viewport step buffer.
+ * @returns The intent to act on.
+ */
+export declare function mapPresentationWheel(input: WheelInput, buffer: WheelStepBuffer): WheelIntent;
+//# sourceMappingURL=wheel-intent.d.ts.map

package/dist/pptx/render/wheel-intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wheel-intent.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/wheel-intent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,uCAAuC;AACvC,MAAM,MAAM,WAAW;AACtB,gDAAgD;AAC9C;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GACxD;IAAE,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;CAAE,GACjC;IAAE,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAA;CAAE;AACvC,uCAAuC;GACrC;IAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAA;CAAE;AAC/B,4EAA4E;GAC1E;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/B,sDAAsD;AACtD,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,iEAAiE;IACjE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,yDAAyD;IACzD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC/B,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,kCAAkC;AAClC,wBAAgB,qBAAqB,IAAI,eAAe,CAEvD;AAYD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,MAAM,EAAE,SAAa,EAAE,EAAE,UAAU,GAAG,MAAM,CAQjF;AAwBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,eAAe,EACvB,gBAAgB,EAAE,OAAO,GACvB,WAAW,CAWb;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,eAAe,GAAG,WAAW,CAE5F"}

package/dist/pptx/render/zoom-return-navigation.d.ts

@@ -0,0 +1,107 @@
+/**
+ * `pslz:zmPr`/`psezm:zmPr`/`psuz:zmPr`'s `@returnToParent` and
+ * `@transitionDur` (MS-PPTX `CT_ZoomObjectProperties`): what a Slide Zoom /
+ * Section Zoom / Summary Zoom tile does to slide-show PLAYBACK, not just what
+ * core parses and round-trips.
+ *
+ * `returnToParent`: once the show advances past the LAST slide of the
+ * zoom's target (a single slide for a Slide Zoom, or the whole contiguous
+ * section for a Section Zoom / Summary Zoom tile), a forward "next slide"
+ * step jumps back to the slide the zoom was clicked FROM instead of
+ * continuing linearly through the deck. This module tracks that pending
+ * "excursion" as a plain value so every binding's own navigation hook stores
+ * it in whatever reactive primitive it already uses (a ref, a signal, a
+ * store field) and asks {@link resolveForwardSlideWithZoomReturn} what the
+ * next slide is on every forward step.
+ *
+ * `transitionDur`: the zoom's own transition length, independent of
+ * whatever `<p:transition>` the destination slide is authored with.
+ * PowerPoint plays a `zoom` transition (see `slide-transition-css.ts`) for a
+ * live Zoom link; {@link buildZoomTransitionOverride} produces the synthetic
+ * `PptxSlideTransition` a binding's transition executor should play INSTEAD
+ * of the destination's own, only for the duration of the click/return, so
+ * this is additive and reversible: the destination slide's own transition
+ * still plays normally on any later, non-zoom visit.
+ *
+ * @module render/zoom-return-navigation
+ */
+import type { PptxSlide, PptxSlideTransition, SummaryZoomTarget, ZoomPptxElement } from 'ooxml-core/pptx';
+/**
+ * The navigation-relevant fields of a Zoom click target, independent of
+ * `zoomType`.
+ *
+ * `returnToParent` is already resolved to its EFFECTIVE value here (not the
+ * raw, possibly-`undefined` `ZoomPptxElement`/`SummaryZoomTarget` field):
+ * `CT_ZoomObjectProperties/@returnToParent` (MS-PPTX) is `<xsd:attribute
+ * name="returnToParent" type="xsd:boolean" use="optional" default="true"/>`,
+ * so an ABSENT attribute means true, not false. Core deliberately stores
+ * `undefined` rather than fabricating `true` (so a round-trip never invents
+ * an attribute the source never had), which makes `Boolean(x)` the wrong way
+ * to read it; the two `resolve*NavigationTarget` functions below are the only
+ * place that distinction should be made.
+ */
+export interface ZoomNavigationTarget {
+    targetSlideIndex: number;
+    targetSectionId?: string;
+    returnToParent: boolean;
+    transitionDurationMs?: number;
+}
+/**
+ * Resolve the click target for a Slide Zoom or Section Zoom element (NOT a
+ * Summary Zoom, whose tiles each carry their own values; see
+ * {@link resolveSummaryZoomTileNavigationTarget}).
+ */
+export declare function resolveZoomNavigationTarget(element: ZoomPptxElement): ZoomNavigationTarget | undefined;
+/** Resolve the click target for one Summary Zoom tile (its own `zmPr`, not the container's mirrored copy). */
+export declare function resolveSummaryZoomTileNavigationTarget(tile: SummaryZoomTarget | undefined): ZoomNavigationTarget | undefined;
+/**
+ * The last slide index (inclusive) of the zoom's target range: for a Section
+ * Zoom / Summary Zoom tile, the last slide of the contiguous run of slides
+ * sharing `targetSectionId` starting at `targetSlideIndex` (sections are
+ * always contiguous); for a plain Slide Zoom (no section), just the target
+ * slide itself.
+ */
+export declare function resolveZoomExcursionEndIndex(target: Pick<ZoomNavigationTarget, 'targetSlideIndex' | 'targetSectionId'>, slides: readonly Pick<PptxSlide, 'sectionId'>[]): number;
+/** A pending "return to the zoom's origin slide" excursion, tracked by the binding across forward-advance steps. */
+export interface ZoomExcursion {
+    /** The slide to jump back to once `endSlideIndex` is passed (the slide the zoom was clicked from). */
+    returnSlideIndex: number;
+    /** The last slide index of the zoom's target range; see {@link resolveZoomExcursionEndIndex}. */
+    endSlideIndex: number;
+    /** The zoom's own `transitionDur`, applied to the jump INTO the target and to the return jump. */
+    transitionDurationMs?: number;
+}
+/**
+ * Begin tracking a zoom excursion for a click on `target`, or `undefined`
+ * when the target's `returnToParent` is not set (a plain, one-way jump).
+ */
+export declare function beginZoomExcursion(target: ZoomNavigationTarget, returnSlideIndex: number, slides: readonly Pick<PptxSlide, 'sectionId'>[]): ZoomExcursion | undefined;
+/** The outcome of a forward "advance" step, honoring a pending zoom excursion. */
+export interface ZoomReturnStep {
+    /** The slide to advance to (unchanged from `naturalNextIndex` unless the excursion just closed). */
+    nextSlideIndex: number | undefined;
+    /** The excursion to keep tracking (`undefined` once it has been consumed). */
+    excursion: ZoomExcursion | undefined;
+    /** Whether this step was the automatic "return to zoom" jump. */
+    returnedToZoom: boolean;
+}
+/**
+ * Decide the next slide for a forward advance step, given a pending zoom
+ * excursion. When the show is currently sitting on the excursion's last
+ * slide, the step returns to the zoom's origin slide (and clears the
+ * excursion) instead of `naturalNextIndex`. Otherwise the excursion is left
+ * untouched and `naturalNextIndex` is used as-is. Backward steps should not
+ * call this (PowerPoint's return jump is forward-only); a caller stepping
+ * backward keeps its excursion by simply not calling this helper.
+ */
+export declare function resolveForwardSlideWithZoomReturn(currentSlideIndex: number, naturalNextIndex: number | undefined, excursion: ZoomExcursion | undefined): ZoomReturnStep;
+/**
+ * A synthetic `zoom`-type transition carrying the zoom's own `transitionDur`,
+ * for a binding's transition executor to play INSTEAD of the destination
+ * slide's own authored `<p:transition>` when navigating a Zoom click or its
+ * automatic return. `undefined` when the zoom omitted `@transitionDur`
+ * (per the field's doc comment, that means "use the destination slide's own
+ * transition", so the caller should fall through to its normal resolution).
+ */
+export declare function buildZoomTransitionOverride(transitionDurationMs: number | undefined): PptxSlideTransition | undefined;
+//# sourceMappingURL=zoom-return-navigation.d.ts.map

package/dist/pptx/render/zoom-return-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoom-return-navigation.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/zoom-return-navigation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EACX,SAAS,EACT,mBAAmB,EACnB,iBAAiB,EACjB,eAAe,EACf,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAoB;IACpC,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,OAAO,CAAC;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAC1C,OAAO,EAAE,eAAe,GACtB,oBAAoB,GAAG,SAAS,CAUlC;AAED,8GAA8G;AAC9G,wBAAgB,sCAAsC,CACrD,IAAI,EAAE,iBAAiB,GAAG,SAAS,GACjC,oBAAoB,GAAG,SAAS,CAUlC;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC3C,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,kBAAkB,GAAG,iBAAiB,CAAC,EAC1E,MAAM,EAAE,SAAS,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,EAAE,GAC7C,MAAM,CAYR;AAED,oHAAoH;AACpH,MAAM,WAAW,aAAa;IAC7B,sGAAsG;IACtG,gBAAgB,EAAE,MAAM,CAAC;IACzB,iGAAiG;IACjG,aAAa,EAAE,MAAM,CAAC;IACtB,kGAAkG;IAClG,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,oBAAoB,EAC5B,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,SAAS,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,EAAE,GAC7C,aAAa,GAAG,SAAS,CAS3B;AAED,kFAAkF;AAClF,MAAM,WAAW,cAAc;IAC9B,oGAAoG;IACpG,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,8EAA8E;IAC9E,SAAS,EAAE,aAAa,GAAG,SAAS,CAAC;IACrC,iEAAiE;IACjE,cAAc,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,CAChD,iBAAiB,EAAE,MAAM,EACzB,gBAAgB,EAAE,MAAM,GAAG,SAAS,EACpC,SAAS,EAAE,aAAa,GAAG,SAAS,GAClC,cAAc,CAShB;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAC1C,oBAAoB,EAAE,MAAM,GAAG,SAAS,GACtC,mBAAmB,GAAG,SAAS,CAKjC"}

package/dist/pptx/render/zoom-step.d.ts

@@ -0,0 +1,37 @@
+/**
+ * One zoom step, for every binding's zoom controls.
+ *
+ * The status-bar and ribbon +/- buttons are the same control in all five
+ * bindings, but each binding owned its own step: React, Vue and Angular added
+ * 0.1 to the scale while Vanilla and Svelte multiplied it by 1.25, so the same
+ * click zoomed 10% in three apps and 25% in the other two. Nothing tied the
+ * five numbers together, which is why they diverged silently.
+ *
+ * React's additive step is the reference (100% means fit-to-viewport there, so
+ * the readout reads 100/110/120% and lands on round numbers). These helpers
+ * are the single definition of it; a binding that needs percentages rather
+ * than a scale factor uses the `*Percent` pair, which is the same arithmetic.
+ *
+ * @module render/zoom-step
+ */
+/** Scale added or removed by one press of zoom in / zoom out. */
+export declare const ZOOM_STEP = 0.1;
+/** Smallest user zoom the controls will step down to (20%). */
+export declare const MIN_ZOOM_SCALE = 0.2;
+/** Largest user zoom the controls will step up to (500%). */
+export declare const MAX_ZOOM_SCALE = 5;
+/** Clamp a user zoom scale into {@link MIN_ZOOM_SCALE}..{@link MAX_ZOOM_SCALE}. */
+export declare function clampZoomScale(scale: number): number;
+/** The scale one zoom-in press moves to, clamped. */
+export declare function zoomInScale(scale: number): number;
+/** The scale one zoom-out press moves to, clamped. */
+export declare function zoomOutScale(scale: number): number;
+/** Smallest zoom percentage the controls will step down to. */
+export declare const ZOOM_MIN_PERCENT: number;
+/** Largest zoom percentage the controls will step up to. */
+export declare const ZOOM_MAX_PERCENT: number;
+/** The percentage one zoom-in press moves to, clamped. */
+export declare function zoomInPercent(percent: number): number;
+/** The percentage one zoom-out press moves to, clamped. */
+export declare function zoomOutPercent(percent: number): number;
+//# sourceMappingURL=zoom-step.d.ts.map

package/dist/pptx/render/zoom-step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoom-step.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/zoom-step.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,iEAAiE;AACjE,eAAO,MAAM,SAAS,MAAM,CAAC;AAE7B,+DAA+D;AAC/D,eAAO,MAAM,cAAc,MAAM,CAAC;AAElC,6DAA6D;AAC7D,eAAO,MAAM,cAAc,IAAI,CAAC;AAYhC,mFAAmF;AACnF,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKpD;AAED,qDAAqD;AACrD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,sDAAsD;AACtD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,+DAA+D;AAC/D,eAAO,MAAM,gBAAgB,QAAuB,CAAC;AAErD,4DAA4D;AAC5D,eAAO,MAAM,gBAAgB,QAAuB,CAAC;AAErD,0DAA0D;AAC1D,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEtD"}

package/dist/pptx/smartart-3d/connector-object.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The connector poly-lines of a SmartArt 3D model (cycle arcs, timeline axis and arrowheads,
+ * bending-process arrows, hierarchy elbows), for `view-scene.ts`.
+ *
+ * `SmartArt3DModel.connectors` was built from the layout's connector paths but never drawn, so
+ * every family that joins its nodes with lines rendered as disconnected shapes in 3D.
+ *
+ * Must not import `three` at runtime (it takes the module as a parameter).
+ *
+ * @module smartart-3d/connector-object
+ */
+import type * as THREE from 'three';
+import type { SmartArt3DConnector } from '../render/smartart-3d-types.js';
+import type { ThreeModule } from '../three-view/types.js';
+import type { Disposable } from './flat-mesh-object.js';
+/**
+ * One `Line` per connector with at least two points. They sit on the base plane under the nodes,
+ * as PowerPoint draws its connectors, so a node's face covers a line that runs behind it.
+ */
+export declare function buildConnectorLines(three: ThreeModule, connectors: readonly SmartArt3DConnector[], disposables: Disposable[]): THREE.Line[];
+//# sourceMappingURL=connector-object.d.ts.map

package/dist/pptx/smartart-3d/connector-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-object.d.ts","sourceRoot":"","sources":["../../../src/pptx/smartart-3d/connector-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAKrD;;;GAGG;AACH,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,SAAS,mBAAmB,EAAE,EAC1C,WAAW,EAAE,UAAU,EAAE,GACvB,KAAK,CAAC,IAAI,EAAE,CAad"}

package/dist/pptx/smartart-3d/flat-mesh-object.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Build the three.js `Object3D` for one flat `SmartArt3DMesh` (fill + stroke
+ * outline + text label), for `view-scene.ts`.
+ *
+ * @module smartart-3d/flat-mesh-object
+ */
+import type * as THREE from 'three';
+import type { SmartArt3DMesh } from '../render/smartart-3d-types.js';
+import type { ThreeModule } from '../three-view/types.js';
+/** Anything the scene must call `.dispose()` on when unmounted. */
+export interface Disposable {
+    dispose: () => void;
+}
+/** The built pieces for one mesh: the group to add to the scene, plus disposables. */
+export interface MeshObject {
+    group: THREE.Group;
+    disposables: Disposable[];
+}
+/** Build the stroke outline (and hole outlines) as line loops. */
+export declare function buildStrokeLines(three: ThreeModule, mesh: SmartArt3DMesh, disposables: Disposable[]): THREE.LineLoop[];
+/** Build the text label plane, or `null` when the mesh has no text. */
+export declare function buildTextPlane(three: ThreeModule, mesh: SmartArt3DMesh, group: THREE.Group, disposables: Disposable[]): void;
+/** Build the complete `Object3D` for one flat mesh. */
+export declare function buildFlatMeshObject(three: ThreeModule, mesh: SmartArt3DMesh): MeshObject;
+//# sourceMappingURL=flat-mesh-object.d.ts.map

package/dist/pptx/smartart-3d/flat-mesh-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat-mesh-object.d.ts","sourceRoot":"","sources":["../../../src/pptx/smartart-3d/flat-mesh-object.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGvD,mEAAmE;AACnE,MAAM,WAAW,UAAU;IAC1B,OAAO,EAAE,MAAM,IAAI,CAAC;CACpB;AAED,sFAAsF;AACtF,MAAM,WAAW,UAAU;IAC1B,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;IACnB,WAAW,EAAE,UAAU,EAAE,CAAC;CAC1B;AAkCD,kEAAkE;AAClE,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,cAAc,EACpB,WAAW,EAAE,UAAU,EAAE,GACvB,KAAK,CAAC,QAAQ,EAAE,CAclB;AAED,uEAAuE;AACvE,wBAAgB,cAAc,CAC7B,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,WAAW,EAAE,UAAU,EAAE,GACvB,IAAI,CA0BN;AAED,uDAAuD;AACvD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,cAAc,GAAG,UAAU,CAgBxF"}

package/dist/pptx/smartart-3d/lit-mesh-object.d.ts

@@ -0,0 +1,12 @@
+import type { SmartArt3DLightModel } from '../render/smartart-3d-lighting.js';
+import type { SmartArt3DMesh, Vec3 } from '../render/smartart-3d-types.js';
+import type { ThreeModule } from '../three-view/types.js';
+import type { MeshObject } from './flat-mesh-object.js';
+/**
+ * Build the complete `Object3D` for one lit mesh (in diagram space; a scene
+ * camera's rotation is applied by the caller's parent group).
+ *
+ * @param eye - a perspective scene camera's position in diagram space.
+ */
+export declare function buildLitMeshObject(three: ThreeModule, mesh: SmartArt3DMesh, light: SmartArt3DLightModel, eye?: Vec3): MeshObject;
+//# sourceMappingURL=lit-mesh-object.d.ts.map

package/dist/pptx/smartart-3d/lit-mesh-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lit-mesh-object.d.ts","sourceRoot":"","sources":["../../../src/pptx/smartart-3d/lit-mesh-object.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAW3E,OAAO,KAAK,EAAU,cAAc,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAC;AAGhF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAc,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAgJjE;;;;;GAKG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,oBAAoB,EAC3B,GAAG,CAAC,EAAE,IAAI,GACR,UAAU,CAkEZ"}

package/dist/pptx/smartart-3d/lit-text-object.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The label of a lit SmartArt 3D mesh (bevel / scene quick styles): the same
+ * canvas-texture plane the flat path draws, tinted by the light rig, and
+ * stacked into a solid when the quick style extrudes the text itself
+ * (`render/smartart-3d-text-extrusion.ts`).
+ *
+ * Must not import `three` at runtime (it takes the module as a parameter).
+ *
+ * @module smartart-3d/lit-text-object
+ */
+import type * as THREE from 'three';
+import type { SmartArt3DLightModel } from '../render/smartart-3d-lighting.js';
+import type { SmartArt3DMesh } from '../render/smartart-3d-types.js';
+import type { ThreeModule } from '../three-view/types.js';
+import type { Disposable } from './flat-mesh-object.js';
+/** Add the lit label (flat or extruded) of `mesh` to `group`. */
+export declare function buildLitTextObject(three: ThreeModule, mesh: SmartArt3DMesh, group: THREE.Group, light: SmartArt3DLightModel, disposables: Disposable[]): void;
+//# sourceMappingURL=lit-text-object.d.ts.map

package/dist/pptx/smartart-3d/lit-text-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lit-text-object.d.ts","sourceRoot":"","sources":["../../../src/pptx/smartart-3d/lit-text-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAE3E,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,6BAA6B,CAAC;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAoCrD,iEAAiE;AACjE,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,KAAK,EAAE,oBAAoB,EAC3B,WAAW,EAAE,UAAU,EAAE,GACvB,IAAI,CAsBN"}

package/dist/pptx/smartart-3d/text-block-layout.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pure sizing of a SmartArt 3D label canvas (no `three`, no DOM), so it can be tested directly.
+ *
+ * A label's canvas used to be exactly the shape's text box, so text wider than the box (a long
+ * word, a font substitution that is wider than the authored one), descenders, italic overhang and
+ * lines spread past the box height were cut off at the canvas edge, and swapping to a shape with a
+ * smaller text box clipped more. The canvas now grows symmetrically around the block centre to
+ * hold the measured text, and the plane is enlarged by the same amount, so the glyphs do not move.
+ *
+ * @module smartart-3d/text-block-layout
+ */
+import type { SmartArt3DTextBlock } from '../render/smartart-3d-types.js';
+/** Largest canvas side requested; GPUs guarantee at least 4096 for 2D textures. */
+export declare const MAX_TEXTURE_SIDE = 4096;
+/** Canvas pixels per world unit: dense enough for the device, never beyond the texture cap. */
+export declare function textureScale(devicePixelRatio: number): number;
+/** The sized label canvas: world-space plane size and the pixel size to draw it at. */
+export interface TextBlockLayout {
+    worldWidth: number;
+    worldHeight: number;
+    scale: number;
+    pixelWidth: number;
+    pixelHeight: number;
+}
+/**
+ * Size the canvas for `block`. `measure(text)` is the line's width in world units at the block's
+ * font. The plane is never smaller than the block's text box.
+ */
+export declare function layoutTextBlock(block: SmartArt3DTextBlock, measure: (text: string) => number, devicePixelRatio: number): TextBlockLayout;
+//# sourceMappingURL=text-block-layout.d.ts.map

package/dist/pptx/smartart-3d/text-block-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-block-layout.d.ts","sourceRoot":"","sources":["../../../src/pptx/smartart-3d/text-block-layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE,mFAAmF;AACnF,eAAO,MAAM,gBAAgB,OAAO,CAAC;AASrC,+FAA+F;AAC/F,wBAAgB,YAAY,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED,uFAAuF;AACvF,MAAM,WAAW,eAAe;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,mBAAmB,EAC1B,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EACjC,gBAAgB,EAAE,MAAM,GACtB,eAAe,CAuBjB"}

package/dist/pptx/smartart-3d/text-block-texture.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Canvas texture for a `SmartArt3DTextBlock`, for the `<pptx-three-view>`
+ * SmartArt scene (`view-scene.ts`).
+ *
+ * Unlike the legacy `smartart-3d/text-texture.ts` (which imports `three`
+ * statically and re-wraps text itself), this draws the ALREADY wrapped/
+ * positioned lines a `SmartArt3DTextBlock` carries (built from the same 2D
+ * projection the SVG renderer uses), and takes the runtime `three` module as
+ * a parameter so it stays out of the tsup-bundled `dist/index.mjs` (see the
+ * "no runtime `three` import" rule in `three-view/types.ts`).
+ *
+ * @module smartart-3d/text-block-texture
+ */
+import type * as THREE from 'three';
+import type { SmartArt3DTextBlock } from '../render/smartart-3d-types.js';
+import type { ThreeModule } from '../three-view/types.js';
+/** A built label texture plus the world-space plane size it should fill. */
+export interface TextBlockTexture {
+    texture: THREE.CanvasTexture;
+    worldWidth: number;
+    worldHeight: number;
+}
+/** Build a canvas texture rendering `block`'s pre-wrapped lines, or `null` off-DOM. */
+export declare function buildTextBlockTexture(three: ThreeModule, block: SmartArt3DTextBlock): TextBlockTexture | null;
+//# sourceMappingURL=text-block-texture.d.ts.map

package/dist/pptx/smartart-3d/text-block-texture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-block-texture.d.ts","sourceRoot":"","sources":["../../../src/pptx/smartart-3d/text-block-texture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAMvD,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAChC,OAAO,EAAE,KAAK,CAAC,aAAa,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,uFAAuF;AACvF,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,mBAAmB,GACxB,gBAAgB,GAAG,IAAI,CAkEzB"}

package/dist/pptx/smartart-3d/view-camera.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Cameras for the `<pptx-three-view>` SmartArt scene: the face-on
+ * orthographic framing every quick style starts from, and the whole-diagram
+ * camera of a scene quick style (`SmartArt3DModel.camera`).
+ *
+ * Both frame the diagram's own bounds (letterboxed to the view's aspect) so
+ * the z = 0 plane keeps the 2D layout's scale; a scene camera then turns the
+ * diagram about its centre (see `render/smartart-3d-scene-camera.ts`) and, for
+ * a perspective preset, looks at it from `distance` layout px away with a
+ * field of view that still frames that plane at the same scale.
+ *
+ * Must not import `three` at runtime.
+ *
+ * @module smartart-3d/view-camera
+ */
+import type * as THREE from 'three';
+import type { SmartArt3DBounds, SmartArt3DCamera } from '../render/smartart-3d-types.js';
+import type { ThreeModule, ThreeViewSize } from '../three-view/types.js';
+/** The camera for a model, framed for `size`. */
+export declare function buildSmartArtViewCamera(three: ThreeModule, bounds: SmartArt3DBounds, sceneCamera: SmartArt3DCamera | undefined, size: ThreeViewSize): THREE.OrthographicCamera | THREE.PerspectiveCamera;
+/** Re-frame a camera from {@link buildSmartArtViewCamera} for a new view size. */
+export declare function fitSmartArtViewCamera(camera: THREE.OrthographicCamera | THREE.PerspectiveCamera, bounds: SmartArt3DBounds, size: ThreeViewSize): void;
+//# sourceMappingURL=view-camera.d.ts.map

package/dist/pptx/smartart-3d/view-camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-camera.d.ts","sourceRoot":"","sources":["../../../src/pptx/smartart-3d/view-camera.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACtF,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAiBtE,iDAAiD;AACjD,wBAAgB,uBAAuB,CACtC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,gBAAgB,GAAG,SAAS,EACzC,IAAI,EAAE,aAAa,GACjB,KAAK,CAAC,kBAAkB,GAAG,KAAK,CAAC,iBAAiB,CAcpD;AAED,kFAAkF;AAClF,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,KAAK,CAAC,kBAAkB,GAAG,KAAK,CAAC,iBAAiB,EAC1D,MAAM,EAAE,gBAAgB,EACxB,IAAI,EAAE,aAAa,GACjB,IAAI,CAaN"}

package/dist/pptx/smartart-3d/view-overflow.d.ts

@@ -0,0 +1,19 @@
+/**
+ * How far a turned SmartArt diagram reaches past its element box, and the
+ * camera framing that draws it there (see `three-view/view-overflow.ts`).
+ *
+ * Must not import `three` at runtime (it takes the module as a parameter).
+ *
+ * @module smartart-3d/view-overflow
+ */
+import type * as THREE from 'three';
+import type { ThreeModule, ThreeViewOverflow, ThreeViewSize } from '../three-view/types.js';
+type ViewCamera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
+/**
+ * Frame `camera` for the element box plus the diagram's overflow, and return
+ * that overflow. `turned` is false for a face-on diagram, which always fits
+ * its box (no overflow is measured).
+ */
+export declare function frameSmartArtOverflow(three: ThreeModule, root: THREE.Object3D, camera: ViewCamera, size: ThreeViewSize, turned: boolean): ThreeViewOverflow;
+export {};
+//# sourceMappingURL=view-overflow.d.ts.map

package/dist/pptx/smartart-3d/view-overflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-overflow.d.ts","sourceRoot":"","sources":["../../../src/pptx/smartart-3d/view-overflow.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAQzF,KAAK,UAAU,GAAG,KAAK,CAAC,kBAAkB,GAAG,KAAK,CAAC,iBAAiB,CAAC;AA0CrE;;;;GAIG;AACH,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,KAAK,CAAC,QAAQ,EACpB,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,OAAO,GACb,iBAAiB,CAkBnB"}

package/dist/pptx/smartart-3d/view-scene.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `<pptx-three-view>` scene module for 3D SmartArt.
+ *
+ * Flat quick styles (Simple Fill, White Outline, Subtle, Moderate, Intense):
+ * every mesh is a zero-depth `ShapeGeometry` face, unlit (`MeshBasicMaterial`),
+ * under a fixed orthographic camera framing the diagram's own viewBox
+ * (`model.bounds`) - the same geometry/fills/text the 2D SVG renderer draws,
+ * built by `render/smartart-3d-drawing-model.ts`.
+ *
+ * Bevel and scene quick styles (`model.styleCategory` `'bevel'`/`'scene'`):
+ * each mesh becomes a lit solid (`lit-mesh-object.ts`: bevel bands,
+ * extrusion, contour, per-vertex shading from the model's light rig). A scene
+ * style also turns the whole diagram by its quick-style camera
+ * (`model.camera`, `view-camera.ts`).
+ *
+ * The camera is fixed (no orbit): PowerPoint never turns a SmartArt under the
+ * pointer, and dragging the element to move it must not rotate the diagram.
+ *
+ * Must not import `three` at runtime (use `ctx.three`): this module is
+ * reachable from the main barrel through the scene registry.
+ *
+ * @module smartart-3d/view-scene
+ */
+import type { SmartArt3DModel } from '../render/smartart-3d-types.js';
+import type { ThreeViewContext, ThreeViewScene } from '../three-view/types.js';
+export declare function mountSmartArt3DView(model: SmartArt3DModel, ctx: ThreeViewContext): Promise<ThreeViewScene>;
+//# sourceMappingURL=view-scene.d.ts.map

package/dist/pptx/smartart-3d/view-scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-scene.d.ts","sourceRoot":"","sources":["../../../src/pptx/smartart-3d/view-scene.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAQ5E,wBAAsB,mBAAmB,CACxC,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,gBAAgB,GACnB,OAAO,CAAC,cAAc,CAAC,CAiFzB"}

package/dist/pptx/theme/css-vars.d.ts

@@ -0,0 +1,16 @@
+import type { ViewerTheme } from './types.js';
+/**
+ * Convert a `ViewerTheme` into a flat `Record<string, string>` of CSS
+ * custom properties (including the `--` prefix) ready to be spread onto
+ * a `style` attribute.
+ *
+ * Only properties that differ from the built-in defaults are emitted when
+ * `omitDefaults` is true (the default).
+ */
+export declare function themeToCssVars(theme: ViewerTheme | undefined, omitDefaults?: boolean): Record<string, string>;
+/**
+ * Build the complete set of CSS custom properties with all defaults.
+ * Useful for generating a full fallback stylesheet.
+ */
+export declare function defaultCssVars(): Record<string, string>;
+//# sourceMappingURL=css-vars.d.ts.map

package/dist/pptx/theme/css-vars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css-vars.d.ts","sourceRoot":"","sources":["../../../src/pptx/theme/css-vars.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAqB,MAAM,SAAS,CAAC;AA0C9D;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC7B,KAAK,EAAE,WAAW,GAAG,SAAS,EAC9B,YAAY,UAAQ,GAClB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAwDxB;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYvD"}

package/dist/pptx/theme/defaults.d.ts

@@ -0,0 +1,20 @@
+import type { ViewerTheme, ViewerThemeColors } from './types.js';
+/**
+ * Default dark-theme color values.
+ *
+ * These correspond to the built-in dark UI of the PowerPoint viewer and
+ * use Tailwind's gray palette as the neutral scale with indigo as the
+ * primary accent.
+ */
+export declare const defaultThemeColors: ViewerThemeColors;
+/** Default border-radius. */
+export declare const defaultRadius = "0.5rem";
+/**
+ * Built-in light-theme color values, companion to {@link defaultThemeColors}
+ * (which is itself a dark palette despite the name). Pass `lightTheme` to the
+ * viewer's `theme` prop to opt into a light UI without picking the vermilion brand.
+ */
+export declare const lightThemeColors: ViewerThemeColors;
+/** Light theme, ready for the viewer's `theme` prop. */
+export declare const lightTheme: ViewerTheme;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/pptx/theme/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/pptx/theme/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE,iBA4BhC,CAAC;AAEF,6BAA6B;AAC7B,eAAO,MAAM,aAAa,WAAW,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,iBA4B9B,CAAC;AAEF,wDAAwD;AACxD,eAAO,MAAM,UAAU,EAAE,WAExB,CAAC"}

package/dist/pptx/theme/index.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+var chunk47FYJVMH_cjs = require('../chunk-47FYJVMH.cjs');
+
+
+
+Object.defineProperty(exports, "GALLERY_THEME_PRESETS", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.GALLERY_THEME_PRESETS; }
+});
+Object.defineProperty(exports, "THEME_CATALOG", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.THEME_CATALOG; }
+});
+Object.defineProperty(exports, "activeGalleryThemePreset", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.activeGalleryThemePreset; }
+});
+Object.defineProperty(exports, "defaultCssVars", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.defaultCssVars; }
+});
+Object.defineProperty(exports, "defaultRadius", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.defaultRadius; }
+});
+Object.defineProperty(exports, "defaultThemeColors", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.defaultThemeColors; }
+});
+Object.defineProperty(exports, "lightTheme", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.lightTheme; }
+});
+Object.defineProperty(exports, "lightThemeColors", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.lightThemeColors; }
+});
+Object.defineProperty(exports, "resolveThemeCatalogEntry", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.resolveThemeCatalogEntry; }
+});
+Object.defineProperty(exports, "themeToCssVars", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.themeToCssVars; }
+});
+Object.defineProperty(exports, "vermilionDarkColors", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.vermilionDarkColors; }
+});
+Object.defineProperty(exports, "vermilionDarkTheme", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.vermilionDarkTheme; }
+});
+Object.defineProperty(exports, "vermilionLightColors", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.vermilionLightColors; }
+});
+Object.defineProperty(exports, "vermilionLightTheme", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.vermilionLightTheme; }
+});
+Object.defineProperty(exports, "vermilionRadius", {
+  enumerable: true,
+  get: function () { return chunk47FYJVMH_cjs.vermilionRadius; }
+});

package/dist/pptx/theme/index.d.ts

@@ -0,0 +1,8 @@
+export type { ViewerTheme, ViewerThemeColors } from './types.js';
+export { defaultThemeColors, defaultRadius, lightThemeColors, lightTheme } from './defaults.js';
+export { themeToCssVars, defaultCssVars } from './css-vars.js';
+export { vermilionLightColors, vermilionDarkColors, vermilionLightTheme, vermilionDarkTheme, vermilionRadius, } from './presets.js';
+export { THEME_CATALOG, resolveThemeCatalogEntry } from './theme-catalog.js';
+export type { ThemeCatalogEntry } from './theme-catalog.js';
+export { activeGalleryThemePreset, GALLERY_THEME_PRESETS } from './theme-gallery-presets.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/pptx/theme/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pptx/theme/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7F,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EACN,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,GACf,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAC1E,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/pptx/theme/index.mjs

@@ -0,0 +1 @@
+export { GALLERY_THEME_PRESETS, THEME_CATALOG, activeGalleryThemePreset, defaultCssVars, defaultRadius, defaultThemeColors, lightTheme, lightThemeColors, resolveThemeCatalogEntry, themeToCssVars, vermilionDarkColors, vermilionDarkTheme, vermilionLightColors, vermilionLightTheme, vermilionRadius } from '../chunk-XRWEURSV.mjs';