ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/smartart-3d-ring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-ring.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-ring.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAOlD,qFAAqF;AACrF,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAiB7D;AAED,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAQ9D;AAED,4DAA4D;AAC5D,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAG7D;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAQjE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAoB9E;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,SAAS,SAAK,GACZ,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiBzB"}

package/dist/pptx/render/smartart-3d-scene-camera.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Whole-diagram camera for the SmartArt scene quick styles
+ * (framework-agnostic, pure).
+ *
+ * Rotation convention (degrees): a diagram point `P` is turned by
+ * `R = Rz(rev) . Rx(lat) . Ry(-lon)` about the diagram centre, then projected
+ * along -z. Its orthographic front-face projection is exactly the
+ * COM-validated `a:camera/a:rot` model in `visual-3d-camera-parametric.ts`
+ * (`x = X cos lon`, `y = Y cos lat - X sin lat sin lon`, then a `rev` roll),
+ * so an explicit `a:rot` is used as authored.
+ *
+ * Presets without `a:rot` take their pose from {@link SCENE_CAMERA_PRESETS}:
+ * the COM-measured unit-square homographies of `visual-3d-camera-homography`
+ * fitted to this pinhole model (rotation + camera distance, in multiples of
+ * the measured 2in square's side). The distance is absolute: the SmartArt
+ * scene-style exports show a whole diagram under `perspectiveLeft` with far
+ * stronger foreshortening than a 2in shape, so it is converted to layout px
+ * ({@link MEASURED_SQUARE_PX}) rather than scaled to the diagram. A preset
+ * missing from the table falls back to the legacy `CAMERA_PRESET_MAP` angles.
+ * `@fov` is not modelled.
+ *
+ * @module render/smartart-3d-scene-camera
+ */
+import type { Pptx3DScene } from 'ooxml-core/pptx';
+import type { SmartArt3DCamera } from './smartart-3d-solid-types.js';
+import type { Vec3 } from './smartart-3d-types.js';
+/** A fitted preset pose; `distance` absent means a parallel projection. */
+interface ScenePresetPose {
+    lat: number;
+    lon: number;
+    rev: number;
+    distance?: number;
+}
+/** Side of the COM measurement square the preset distances are in: 2in at 96 px/in. */
+export declare const MEASURED_SQUARE_PX = 192;
+/**
+ * Presets the SmartArt scene quick styles use (plus their mirror images),
+ * fitted from `CAMERA_HOMOGRAPHY_MAP`.
+ */
+export declare const SCENE_CAMERA_PRESETS: Record<string, ScenePresetPose>;
+/**
+ * The diagram camera for a quick style's `dgm:scene3d`, or `undefined` when
+ * it leaves the diagram face-on (no scene, or an `orthographicFront` camera
+ * with no rotation), where the flat framing already matches PowerPoint.
+ */
+export declare function resolveSmartArt3DCamera(scene: Pptx3DScene | undefined): SmartArt3DCamera | undefined;
+/**
+ * The camera's rotation as a row-major 3x3 matrix (`R = Rz(rev) . Rx(lat) .
+ * Ry(-lon)`).
+ */
+export declare function smartArt3DCameraMatrix(camera: SmartArt3DCamera): number[];
+/**
+ * The camera position in diagram space (before the rotation), for per-point
+ * view directions: `R^T . (0, 0, distance)`. `undefined` for a parallel
+ * projection.
+ */
+export declare function smartArt3DEyeInDiagram(camera: SmartArt3DCamera): Vec3 | undefined;
+export {};
+//# sourceMappingURL=smartart-3d-scene-camera.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-scene-camera.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-scene-camera.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAGhD,2EAA2E;AAC3E,UAAU,eAAe;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAKD,uFAAuF;AACvF,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAEtC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAWhE,CAAC;AAkCF;;;;GAIG;AACH,wBAAgB,uBAAuB,CACtC,KAAK,EAAE,WAAW,GAAG,SAAS,GAC5B,gBAAgB,GAAG,SAAS,CA0B9B;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAsBzE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,CAOjF"}

package/dist/pptx/render/smartart-3d-solid-geometry.d.ts

@@ -0,0 +1,33 @@
+import type { SmartArt3DSolid } from './smartart-3d-solid-types.js';
+import type { Point2 } from './smartart-3d-types.js';
+/** A triangle list: 9 floats (3 xyz vertices) per triangle, normals alike. */
+export interface SolidTriangles {
+    positions: number[];
+    normals: number[];
+}
+/** A planar cap to triangulate (outer ring + holes) at depth `z`. */
+export interface SolidCap {
+    ring: Point2[];
+    holes: Point2[][];
+    z: number;
+    /** +1: faces the viewer (front), -1: faces away (back). */
+    facing: 1 | -1;
+}
+/** Everything the three.js layer needs to build one solid. */
+export interface SmartArt3DSolidGeometry {
+    /** Bevel bands, painted with the shape's fill. */
+    body: SolidTriangles;
+    /** Extrusion walls, painted with the extrusion colour. */
+    sides: SolidTriangles;
+    frontCap: SolidCap;
+    /** Back cap (extrusion colour), when the solid has any depth. */
+    backCap?: SolidCap;
+    /** Contour rims (front and back annuli, contour colour). */
+    contourCaps: SolidCap[];
+}
+/**
+ * Build the geometry for one solid from its mesh-local outline (and holes,
+ * which are cut from the caps but not bevelled).
+ */
+export declare function buildSmartArt3DSolidGeometry(outline: readonly Point2[], holes: readonly Point2[][], solid: SmartArt3DSolid): SmartArt3DSolidGeometry;
+//# sourceMappingURL=smartart-3d-solid-geometry.d.ts.map

package/dist/pptx/render/smartart-3d-solid-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-solid-geometry.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-solid-geometry.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAmB,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAClF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,8EAA8E;AAC9E,MAAM,WAAW,cAAc;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,qEAAqE;AACrE,MAAM,WAAW,QAAQ;IACxB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,2DAA2D;IAC3D,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CACf;AAED,8DAA8D;AAC9D,MAAM,WAAW,uBAAuB;IACvC,kDAAkD;IAClD,IAAI,EAAE,cAAc,CAAC;IACrB,0DAA0D;IAC1D,KAAK,EAAE,cAAc,CAAC;IACtB,QAAQ,EAAE,QAAQ,CAAC;IACnB,iEAAiE;IACjE,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,4DAA4D;IAC5D,WAAW,EAAE,QAAQ,EAAE,CAAC;CACxB;AA8FD;;;GAGG;AACH,wBAAgB,4BAA4B,CAC3C,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,EAC1B,KAAK,EAAE,eAAe,GACpB,uBAAuB,CAoCzB"}

package/dist/pptx/render/smartart-3d-solid-types.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Pure model types for the lit (bevel / scene quick style) SmartArt 3D path.
+ *
+ * Split out of `smartart-3d-types.ts` to keep both under the repo's LOC
+ * budget. Every length is in layout pixels (the drawing's own EMU / 9525),
+ * every angle in degrees, and every point in the mesh-local, y-up space the
+ * mesh's `outline` uses.
+ *
+ * @module render/smartart-3d-solid-types
+ */
+/** A point in mesh-local 2D space (y-up). */
+interface SolidPoint2 {
+    x: number;
+    y: number;
+}
+/** One `a:bevelT` / `a:bevelB`, in layout pixels. */
+export interface SmartArt3DBevel {
+    /** Inset of the bevel from the outline (`@w`). */
+    width: number;
+    /** Relief of the bevel (`@h`). */
+    height: number;
+    /** `@prst` profile token (`circle` when absent, per ECMA-376). */
+    profile: string;
+}
+/** A shape's resolved `a:sp3d`, in layout pixels. */
+export interface SmartArt3DSolid {
+    bevelTop?: SmartArt3DBevel;
+    bevelBottom?: SmartArt3DBevel;
+    /** Extrusion depth behind the front face (`@extrusionH`). */
+    extrusion: number;
+    /** Side-wall colour (`a:extrusionClr`), `#rrggbb`; the fill colour when absent. */
+    extrusionColor?: string;
+    /** Contour rim width around the whole solid (`@contourW`). */
+    contourWidth: number;
+    /** Contour colour (`a:contourClr`), `#rrggbb`. */
+    contourColor?: string;
+    /** `@prstMaterial` token. */
+    material: string;
+}
+/** One gradient stop, `offset` in 0..1. */
+export interface SmartArt3DGradientStop {
+    offset: number;
+    color: string;
+}
+/**
+ * A shape's gradient fill, in mesh-local space: linear from `from` to `to`,
+ * or radial around `from` with the distance to `to` as its radius.
+ */
+export interface SmartArt3DGradient {
+    kind: 'linear' | 'radial';
+    from: SolidPoint2;
+    to: SolidPoint2;
+    stops: SmartArt3DGradientStop[];
+}
+/** The light rig (`a:lightRig`) a lit SmartArt scene is shaded with. */
+export interface SmartArt3DLighting {
+    /** `@rig` token, e.g. `threePt`, `flat`, `morning`. */
+    rig: string;
+    /** `@dir` token, e.g. `t`, `tl`. */
+    direction: string;
+    /** Rig revolution about the view axis (`a:rot/@rev`), degrees. */
+    revDeg: number;
+}
+/**
+ * The whole-diagram camera of a scene quick style (`dgm:styleDef/dgm:scene3d`).
+ *
+ * The diagram is rotated about its own centre by `latDeg` (about x), `lonDeg`
+ * (about y) and `revDeg` (roll about the view axis), then projected either in
+ * parallel or through a pinhole placed `distance` layout px away, and
+ * finally scaled by `zoom`.
+ */
+export interface SmartArt3DCamera {
+    projection: 'orthographic' | 'perspective';
+    latDeg: number;
+    lonDeg: number;
+    revDeg: number;
+    /**
+     * Camera distance from the diagram centre in layout px (`perspective`
+     * only). Absolute, like PowerPoint's: a larger diagram shows stronger
+     * perspective under the same preset.
+     */
+    distance: number;
+    /** `a:camera/@zoom` as a fraction (1 = 100%). */
+    zoom: number;
+}
+export {};
+//# sourceMappingURL=smartart-3d-solid-types.d.ts.map

package/dist/pptx/render/smartart-3d-solid-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-solid-types.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-solid-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,6CAA6C;AAC7C,UAAU,WAAW;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,qDAAqD;AACrD,MAAM,WAAW,eAAe;IAC/B,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,qDAAqD;AACrD,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,8DAA8D;IAC9D,YAAY,EAAE,MAAM,CAAC;IACrB,kDAAkD;IAClD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6BAA6B;IAC7B,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,2CAA2C;AAC3C,MAAM,WAAW,sBAAsB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAClC,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC1B,IAAI,EAAE,WAAW,CAAC;IAClB,EAAE,EAAE,WAAW,CAAC;IAChB,KAAK,EAAE,sBAAsB,EAAE,CAAC;CAChC;AAED,wEAAwE;AACxE,MAAM,WAAW,kBAAkB;IAClC,uDAAuD;IACvD,GAAG,EAAE,MAAM,CAAC;IACZ,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAChC,UAAU,EAAE,cAAc,GAAG,aAAa,CAAC;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;CACb"}

package/dist/pptx/render/smartart-3d-solid.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolve a SmartArt cached shape's `a:sp3d` into the pixel-space
+ * {@link SmartArt3DSolid} the lit 3D scene builds (framework-agnostic, pure).
+ *
+ * @module render/smartart-3d-solid
+ */
+import type { Pptx3DShape } from 'ooxml-core/pptx';
+import type { SmartArt3DSolid } from './smartart-3d-solid-types.js';
+/**
+ * The lit solid for one shape, or `undefined` when its `a:sp3d` changes
+ * nothing (the shape then renders as a flat face).
+ *
+ * @param halfExtent - half of the shape's smaller side, in layout px (bounds
+ *   the bevel width).
+ */
+export declare function resolveSmartArt3DSolid(shape3d: Pptx3DShape | undefined, halfExtent: number): SmartArt3DSolid | undefined;
+//# sourceMappingURL=smartart-3d-solid.d.ts.map

package/dist/pptx/render/smartart-3d-solid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-solid.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-solid.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAmB,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAiClF;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACrC,OAAO,EAAE,WAAW,GAAG,SAAS,EAChC,UAAU,EAAE,MAAM,GAChB,eAAe,GAAG,SAAS,CA0B7B"}

package/dist/pptx/render/smartart-3d-spatial.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Three.js SmartArt renderer - spatial (phase 2) layout transforms.
+ *
+ * Post-processes the flat extruded {@link SmartArt3DModel} (every node at z = 0,
+ * facing +z) into a genuine 3D arrangement per layout family, reusing all of the
+ * phase-1 styling, text, and footprint work:
+ *
+ * - `cycle` / `radial`  -> a horizontal carousel ring (nodes on a ring in the XZ
+ *   plane, each rotated to face radially outward).
+ * - `hierarchy`         -> a layered tree that recedes into -Z by depth, so
+ *   levels read as receding planes when the camera tilts/orbits.
+ *
+ * Families without a spatial form are returned unchanged (flat extruded), so the
+ * transform degrades gracefully. Pure; no `three` import.
+ */
+import type { SmartArt3DModel } from './smartart-3d-types.js';
+/**
+ * Apply the spatial arrangement for the model's layout family. Returns the model
+ * unchanged when the family has no spatial form.
+ */
+export declare function applySpatialLayout(model: SmartArt3DModel): SmartArt3DModel;
+//# sourceMappingURL=smartart-3d-spatial.d.ts.map

package/dist/pptx/render/smartart-3d-spatial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-spatial.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-spatial.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAGX,eAAe,EAEf,MAAM,qBAAqB,CAAC;AA8D7B;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,eAAe,GAAG,eAAe,CAU1E"}

package/dist/pptx/render/smartart-3d-style-path.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Which 3D pipeline a SmartArt quick style needs, decided from the cached
+ * drawing alone (framework-agnostic, pure).
+ *
+ * PowerPoint caches three shapes of quick style in `ppt/diagrams/drawing*.xml`:
+ *
+ * - **flat** (Simple Fill .. Intense Effect): no `a:sp3d` on any shape.
+ * - **bevel** (Polished, Inset, Cartoon, Powder): every shape carries its own
+ *   `a:scene3d` (always `orthographicFront`) plus an `a:sp3d` bevel, so the
+ *   2D layout stays undistorted and only the edges are lit.
+ * - **scene** (Brick, Flat, Metallic, Sunset, Bird's Eye Scene): shapes carry
+ *   only `a:sp3d`; the one camera for the whole diagram lives in the quick
+ *   style part (`dgm:styleDef/dgm:scene3d`).
+ *
+ * Working rule: any shape with `scene3d` -> bevel; else any shape with a
+ * non-empty `shape3d` -> scene; else flat.
+ *
+ * @module render/smartart-3d-style-path
+ */
+import type { Pptx3DShape, PptxSmartArtDrawingShape } from 'ooxml-core/pptx';
+import type { SmartArt3DStyleCategory } from './smartart-3d-types.js';
+/** Whether an `a:sp3d` carries anything that changes the rendered solid. */
+export declare function hasSmartArtShape3D(shape3d: Pptx3DShape | undefined): boolean;
+/** Decide the 3D pipeline for a SmartArt's cached drawing shapes. */
+export declare function resolveSmartArt3DStylePath(shapes: readonly Pick<PptxSmartArtDrawingShape, 'scene3d' | 'shape3d'>[]): SmartArt3DStyleCategory;
+//# sourceMappingURL=smartart-3d-style-path.d.ts.map

package/dist/pptx/render/smartart-3d-style-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-style-path.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-style-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAE7E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAEnE,4EAA4E;AAC5E,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAa5E;AAED,qEAAqE;AACrE,wBAAgB,0BAA0B,CACzC,MAAM,EAAE,SAAS,IAAI,CAAC,wBAAwB,EAAE,SAAS,GAAG,SAAS,CAAC,EAAE,GACtE,uBAAuB,CAQzB"}

package/dist/pptx/render/smartart-3d-text-extrusion.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Extruded SmartArt labels (framework-agnostic, pure).
+ *
+ * A quick style can extrude the label text itself off the shape face
+ * (`a:bodyPr/a:sp3d`, e.g. Bird's Eye Scene: `extrusionH="28000"`). The
+ * scene has glyph bitmaps, not glyph outlines, so it builds the letters'
+ * solid from stacked copies of the label: side layers every
+ * {@link TEXT_LAYER_STEP} px from the face up to the extrusion depth, drawn in
+ * the shaded side colour, then the front copy on top at the full depth.
+ * Under the diagram's camera the stack reads as the letters' walls.
+ *
+ * @module render/smartart-3d-text-extrusion
+ */
+import type { SmartArt3DTextBlock } from './smartart-3d-types.js';
+/** Depth between two side layers, layout px (fine enough to read as a wall). */
+export declare const TEXT_LAYER_STEP = 0.4;
+/**
+ * sRGB factor on the side colour. Read off the Bird's Eye Scene export
+ * (`gt/sa-014.webp`): white letters show walls around (164, 172, 175) under
+ * a front face reading (245, 248, 249).
+ */
+export declare const TEXT_SIDE_SHADE = 0.69;
+/** Stacked planes for one label. */
+export interface SmartArt3DTextLayers {
+    /** z of each side layer, back to front (world units, absolute). */
+    sideZ: number[];
+    /** z of the front copy. */
+    frontZ: number;
+    /** Side colour, `#rrggbb`. */
+    sideColor: string;
+}
+/**
+ * The stacked layers for an extruded label, or `undefined` when the label is
+ * flat (no `extrusion`).
+ */
+export declare function smartArt3DTextLayers(block: SmartArt3DTextBlock): SmartArt3DTextLayers | undefined;
+//# sourceMappingURL=smartart-3d-text-extrusion.d.ts.map

package/dist/pptx/render/smartart-3d-text-extrusion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-text-extrusion.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-text-extrusion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,gFAAgF;AAChF,eAAO,MAAM,eAAe,MAAM,CAAC;AAKnC;;;;GAIG;AACH,eAAO,MAAM,eAAe,OAAO,CAAC;AAEpC,oCAAoC;AACpC,MAAM,WAAW,oBAAoB;IACpC,mEAAmE;IACnE,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,2BAA2B;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;CAClB;AAeD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,mBAAmB,GAAG,oBAAoB,GAAG,SAAS,CAejG"}

package/dist/pptx/render/smartart-3d-translucency.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Translucent lit SmartArt solids (framework-agnostic, pure).
+ *
+ * Basic Venn caches its circles as `accent1` at `a:alpha 50000`, and every
+ * bevel / scene quick style keeps that alpha on the solid. PowerPoint blends
+ * each solid ONCE: a face-on circle of Polished, Brick or Sunset reads exactly
+ * the 50% blend of the flat style (`#89afc0` over white, `gt/sa-076.webp`),
+ * and an overlap reads two layers (75%). Painting every surface of the solid
+ * translucently (front cap, back cap and bevel bands all stacked) read 75% on
+ * a single circle, so the three.js layer culls the surfaces facing away from
+ * the camera; {@link orientSmartArt3DTriangles} makes each triangle's winding
+ * agree with its shading normal so that culling is by the normal the lighting
+ * already uses.
+ *
+ * `clear` (`a:sp3d/@prstMaterial`, Venn's Cartoon and Metallic Scene) is a
+ * glass: a face-on surface keeps a fifth of its fill's alpha (the Cartoon
+ * export reads a 50% circle as a 10% blend, `#e8eef2`, and its overlap as the
+ * 19% of two such layers), while a surface tilted away from the view grows
+ * denser, up to past the fill's own alpha at the silhouette (the Cartoon
+ * bevel band reads a 59-66% blend next to the outline).
+ * {@link smartArt3DSurfaceAlpha} is that curve.
+ *
+ * @module render/smartart-3d-translucency
+ */
+import type { SmartArt3DLightModel } from './smartart-3d-lighting.js';
+import type { SolidTriangles } from './smartart-3d-solid-geometry.js';
+import type { SmartArt3DMesh, Vec3 } from './smartart-3d-types.js';
+/** Whether a material paints its fill as a see-through glass. */
+export declare function isSmartArt3DGlassMaterial(material: string | undefined): boolean;
+/**
+ * The alpha to paint a surface at.
+ *
+ * @param opacity - the fill's own alpha (1 for an opaque fill).
+ * @param facing - cosine between the surface normal and the view direction
+ *   (1 face-on, 0 edge-on).
+ */
+export declare function smartArt3DSurfaceAlpha(material: string | undefined, opacity: number, facing: number): number;
+/**
+ * Per-vertex alphas for a triangle list, from each vertex normal against the
+ * view (the direction to `eye` under a perspective camera, else `+z`).
+ */
+export declare function smartArt3DVertexAlphas(positions: readonly number[], normals: readonly number[], material: string | undefined, opacity: number, eye?: Vec3): Float32Array;
+/**
+ * Flip every triangle whose winding disagrees with its (averaged) shading
+ * normal, in place, so counter-clockwise winding means "faces along the
+ * normal" and back-face culling hides exactly the surfaces facing away.
+ */
+export declare function orientSmartArt3DTriangles(triangles: SolidTriangles): void;
+/** Whether a lit mesh is see-through (a fill alpha below 1 or a glass material). */
+export declare function isSmartArt3DTranslucentMesh(mesh: SmartArt3DMesh): boolean;
+/**
+ * The light model a glass surface is painted with: its fill, unlit (only the
+ * rig's face tint stays). The Cartoon export's bevel band is the plain fill
+ * made denser toward the silhouette (`#456c7a` at the rim over white, the
+ * fill at full alpha), with none of the brightening an opaque bevel band
+ * gets from the key light; the alpha ramp alone draws it.
+ */
+export declare function smartArt3DGlassLightModel(model: SmartArt3DLightModel): SmartArt3DLightModel;
+//# sourceMappingURL=smartart-3d-translucency.d.ts.map

package/dist/pptx/render/smartart-3d-translucency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-translucency.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-translucency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAShE,iEAAiE;AACjE,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAE/E;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACrC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,GACZ,MAAM,CAOR;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACrC,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,IAAI,GACR,YAAY,CAed;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI,CAyBzE;AAED,oFAAoF;AACpF,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAEzE;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,oBAAoB,GAAG,oBAAoB,CAE3F"}

package/dist/pptx/render/smartart-3d-types.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Three.js SmartArt renderer - pure model types (phase 1: extruded layouts).
+ *
+ * These describe a framework-agnostic, three.js-agnostic 3D scene derived from
+ * the 2D {@link SmartArtLayoutResult}. The pure model is built by
+ * `buildSmartArt3DModel` (no `three` import, fully testable) and consumed by the
+ * vanilla-three scene builder under `pptx-viewer-shared/smartart-3d`, which is
+ * shared verbatim by the React, Vue, and Angular bindings.
+ *
+ * Coordinate convention: world space is y-up, centred on the origin, with the
+ * front face of every extruded block facing +z. Layout (SVG) space is y-down
+ * with the origin at the top-left; the model builder performs the flip.
+ */
+import type { SmartArt3DCamera, SmartArt3DGradient, SmartArt3DLighting, SmartArt3DSolid } from './smartart-3d-solid-types.js';
+export type * from './smartart-3d-solid-types.js';
+/** A point in the world's XZ-agnostic 2D outline space (y-up). */
+export interface Point2 {
+    x: number;
+    y: number;
+}
+/** A world-space position (y-up). */
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * A single extruded shape (one SmartArt node) in the 3D scene.
+ *
+ * The {@link outline} is a closed polygon centred on the mesh's own origin
+ * (y-up); the scene builder extrudes it by {@link depth} along +z and positions
+ * the result at {@link position}.
+ */
+export interface SmartArt3DMesh {
+    id: string;
+    /** Closed 2D outline to extrude, centred on the mesh origin (y-up). */
+    outline: Point2[];
+    /**
+     * Additional closed loops cut out of {@link outline} as holes (e.g. a
+     * compound custom-geometry shape), in the same mesh-local space. Empty for
+     * the common single-loop case.
+     */
+    holes?: Point2[][];
+    /** Hint that the outline approximates a circle (drives tessellation). */
+    rounded: boolean;
+    /** Extrusion depth along +z, in layout pixels. */
+    depth: number;
+    /** Bevel size; 0 disables bevelling. */
+    bevel: number;
+    /**
+     * True when this mesh should render as a flat, unlit, zero-depth face
+     * (`ShapeGeometry`) rather than an extruded/bevelled solid
+     * (`ExtrudeGeometry`), matching a PowerPoint flat SmartArt quick style.
+     */
+    flat?: boolean;
+    /** Fill colour, `#rrggbb`. Ignored (nothing painted) when {@link fillNone}. */
+    fill: string;
+    /**
+     * The source shape declared `a:noFill`: paint nothing, but the mesh may
+     * still carry a {@link textBlock} (SmartArt commonly stacks an unfilled
+     * label shape over a painted one).
+     */
+    fillNone?: boolean;
+    /** Resolved data-URI/URL of a picture fill, when the source shape has one (not yet textured). */
+    imageUrl?: string;
+    /** Edge/stroke colour, `#rrggbb`. */
+    stroke: string;
+    /** Stroke width in layout pixels (0 = no visible edge line). */
+    strokeWidth: number;
+    /** Mesh opacity, 0..1. */
+    opacity: number;
+    /** World-space centre of the mesh (y-up, z = 0 base plane). */
+    position: Vec3;
+    /**
+     * Euler rotation (radians, XYZ order) applied to the mesh. `{0,0,0}` for the
+     * extruded (phase 1) layout and the flat drawing-shape model (rotation is
+     * baked into {@link outline} there); spatial layouts (e.g. the cycle
+     * carousel) rotate blocks to face along the arrangement.
+     */
+    rotation: Vec3;
+    /** Text label drawn on the front (+z) face (single string; legacy consumers). */
+    text: string;
+    /**
+     * Pre-laid-out multi-line text matching the 2D SVG projection. Preferred
+     * over {@link text} when present.
+     */
+    textBlock?: SmartArt3DTextBlock;
+    /** Text colour, `#rrggbb`. */
+    textColor: string;
+    /** Font size in layout pixels. */
+    fontSize: number;
+    /** Half-width of the footprint (for sizing the text plane). */
+    halfWidth: number;
+    /** Half-height of the footprint. */
+    halfHeight: number;
+    /**
+     * Lit solid (bevel / extrusion / contour) from the cached shape's `a:sp3d`,
+     * for the `'bevel'` and `'scene'` style categories. Absent: a flat face.
+     */
+    solid?: SmartArt3DSolid;
+    /** Gradient fill to paint instead of {@link fill}, when the shape has one. */
+    gradient?: SmartArt3DGradient;
+}
+/**
+ * A multi-line text label, pre-laid-out to match the 2D SVG projection
+ * (`centeredSvgTextLines`), for the renderer to draw onto a texture/plane
+ * rather than re-wrapping text itself.
+ */
+export interface SmartArt3DTextBlock {
+    /** One entry per line; `dy` is the line's offset from the block centre (y-up, layout px). */
+    lines: Array<{
+        text: string;
+        dy: number;
+    }>;
+    /** World-space centre of the text block. */
+    x: number;
+    y: number;
+    z: number;
+    /** Available width/height for the block, in layout pixels. */
+    maxWidth: number;
+    maxHeight: number;
+    /** Text colour, `#rrggbb`. */
+    color: string;
+    /** Font size in layout pixels. */
+    fontSize: number;
+    fontFamily?: string;
+    fontWeight?: number;
+    fontStyle?: 'normal' | 'italic';
+    /**
+     * The label's own extrusion (`a:bodyPr/a:sp3d`, e.g. Bird's Eye Scene),
+     * in layout px toward the viewer: the letters stand this far off the
+     * shape face, and their sides are drawn in {@link extrusionColor} (the
+     * text colour when absent).
+     */
+    extrusion?: number;
+    extrusionColor?: string;
+}
+/** A connector poly-line drawn between meshes on the base plane. */
+export interface SmartArt3DConnector {
+    id: string;
+    /** World-space points (y-up). */
+    points: Vec3[];
+    /** Line colour, `#rrggbb`. */
+    color: string;
+    /** Line width in layout pixels. */
+    width: number;
+}
+/** Camera-framing bounds of the whole model, in layout pixels. */
+export interface SmartArt3DBounds {
+    width: number;
+    height: number;
+}
+/** The layout family the model was built from (drives the spatial transform). */
+export type SmartArt3DFamily = 'list' | 'process' | 'cycle' | 'hierarchy' | 'matrix' | 'radial' | 'pyramid' | 'venn' | 'funnel' | 'target';
+/**
+ * Which PowerPoint quick-style family this model was built for, so the scene
+ * builder can pick the right camera/shading/geometry pipeline: `'flat'`
+ * (unlit, zero-depth, orthographic matching the 2D viewBox), `'bevel'`
+ * (per-shape `orthographicFront` camera + lit `a:sp3d` bevel/material), or
+ * `'scene'` (one whole-diagram camera from the quick style, lit extruded
+ * solids). See `resolveSmartArt3DStylePath`. Undefined for the legacy
+ * layout-engine model (`buildSmartArt3DModel`), which predates this
+ * distinction.
+ */
+export type SmartArt3DStyleCategory = 'flat' | 'bevel' | 'scene';
+/** The complete pure 3D model for one SmartArt element. */
+export interface SmartArt3DModel {
+    meshes: SmartArt3DMesh[];
+    connectors: SmartArt3DConnector[];
+    bounds: SmartArt3DBounds;
+    /** Layout family, used to choose a spatial arrangement. */
+    family?: SmartArt3DFamily;
+    /** Optional background chrome colour, `#rrggbb`. */
+    background?: string;
+    /** See {@link SmartArt3DStyleCategory}. */
+    styleCategory?: SmartArt3DStyleCategory;
+    /** Whole-diagram camera (`'scene'` only). */
+    camera?: SmartArt3DCamera;
+    /** Light rig the lit solids are shaded with (`'bevel'` / `'scene'`). */
+    lighting?: SmartArt3DLighting;
+}
+/** Tunables for {@link buildSmartArt3DModel}. */
+export interface SmartArt3DModelOptions {
+    /**
+     * Extrusion depth as a fraction of each node's smaller footprint dimension.
+     * Ignored when {@link depth} is set. Default `0.35`.
+     */
+    depthRatio?: number;
+    /** Fixed extrusion depth in layout pixels; overrides {@link depthRatio}. */
+    depth?: number;
+    /** Bevel size as a fraction of the extrusion depth. Default `0.2`. */
+    bevelRatio?: number;
+    /** Background chrome colour, `#rrggbb`. */
+    background?: string;
+    /**
+     * Arrange nodes in genuine 3D space per layout family (cycle -> carousel
+     * ring, hierarchy -> layered tree, pyramid -> stacked tiers) instead of the
+     * flat extruded layout. Families without a spatial form keep the flat
+     * layout. Default `false` (phase 1 extruded behaviour).
+     */
+    spatial?: boolean;
+    /**
+     * `PptxSmartArtNode.id`s carrying `dgm:prSet/@coherent3DOff="1"` (a per-node
+     * opt-out of PowerPoint's "no two identical" bevel variation a 3-D SmartArt
+     * quick style applies). A mesh whose `RenderedNode.nodeId` is in this set
+     * always gets the plain, un-varied bevel; every other mesh gets a small,
+     * deterministic (hash-of-id) bevel variation so identical shapes do not
+     * render pixel-identical, matching PowerPoint's "coherent 3-D" behaviour.
+     * Absent/empty set: no variation at all (pre-existing behaviour).
+     */
+    coherent3DOffNodeIds?: ReadonlySet<string>;
+}
+//# sourceMappingURL=smartart-3d-types.d.ts.map

package/dist/pptx/render/smartart-3d-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-types.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EACX,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,MAAM,2BAA2B,CAAC;AAEnC,mBAAmB,2BAA2B,CAAC;AAE/C,kEAAkE;AAClE,MAAM,WAAW,MAAM;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,qCAAqC;AACrC,MAAM,WAAW,IAAI;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,uEAAuE;IACvE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,yEAAyE;IACzE,OAAO,EAAE,OAAO,CAAC;IACjB,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iGAAiG;IACjG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,QAAQ,EAAE,IAAI,CAAC;IACf;;;;;OAKG;IACH,QAAQ,EAAE,IAAI,CAAC;IACf,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IACnC,6FAA6F;IAC7F,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3C,4CAA4C;IAC5C,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAChC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,oEAAoE;AACpE,MAAM,WAAW,mBAAmB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,iCAAiC;IACjC,MAAM,EAAE,IAAI,EAAE,CAAC;IACf,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;CACd;AAED,kEAAkE;AAClE,MAAM,WAAW,gBAAgB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,iFAAiF;AACjF,MAAM,MAAM,gBAAgB,GACzB,MAAM,GACN,SAAS,GACT,OAAO,GACP,WAAW,GACX,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,MAAM,GACN,QAAQ,GACR,QAAQ,CAAC;AAEZ;;;;;;;;;GASG;AACH,MAAM,MAAM,uBAAuB,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAEjE,2DAA2D;AAC3D,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,MAAM,EAAE,gBAAgB,CAAC;IACzB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,oDAAoD;IACpD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,aAAa,CAAC,EAAE,uBAAuB,CAAC;IACxC,6CAA6C;IAC7C,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,wEAAwE;IACxE,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC9B;AAED,iDAAiD;AACjD,MAAM,WAAW,sBAAsB;IACtC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;;OAQG;IACH,oBAAoB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC3C"}

package/dist/pptx/render/smartart-3d-vertex-shading.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Per-vertex colour factors for a lit SmartArt 3D solid (framework-agnostic,
+ * pure).
+ *
+ * The three.js layer paints a solid with `MeshBasicMaterial` (base colour or
+ * gradient map) times a per-vertex colour. This module computes that vertex
+ * colour so the displayed (sRGB) result is `base * mul + add` from
+ * `shadeSmartArt3DNormal`, with the division done in linear space because
+ * three multiplies linear values.
+ *
+ * @module render/smartart-3d-vertex-shading
+ */
+import type { SmartArt3DLightModel } from './smartart-3d-lighting.js';
+import type { Point2, Vec3 } from './smartart-3d-types.js';
+/** An sRGB colour, channels 0..1. */
+export type Rgb = [number, number, number];
+/** sRGB channel (0..1) -> linear. */
+export declare function srgbToLinear(c: number): number;
+/** `#rrggbb` -> sRGB channels 0..1 (black when unparsable). */
+export declare function hexToRgb(hex: string): Rgb;
+/**
+ * Vertex colours (3 floats per vertex, linear factors) for a triangle list.
+ *
+ * @param positions - mesh-local xyz per vertex.
+ * @param normals - mesh-local unit normals per vertex.
+ * @param baseAt - the sRGB base colour painted at a mesh-local point.
+ * @param eye - camera position in mesh-local space, for a perspective scene
+ *   camera; omitted for a parallel view.
+ *
+ * The light is fixed to the diagram, not the camera: a scene camera turning
+ * the diagram does not relight its faces (the scene-style exports keep every
+ * face at the same colour however far it is turned).
+ */
+export declare function shadeSmartArt3DVertices(positions: readonly number[], normals: readonly number[], baseAt: (p: Point2) => Rgb, model: SmartArt3DLightModel, eye?: Vec3): Float32Array;
+//# sourceMappingURL=smartart-3d-vertex-shading.d.ts.map

package/dist/pptx/render/smartart-3d-vertex-shading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-vertex-shading.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-vertex-shading.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEnE,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAExD,qCAAqC;AACrC,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE3C,qCAAqC;AACrC,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,+DAA+D;AAC/D,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAOzC;AAUD;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACtC,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,GAAG,EAC1B,KAAK,EAAE,oBAAoB,EAC3B,GAAG,CAAC,EAAE,IAAI,GACR,YAAY,CAoBd"}