ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/slide-transition-wipe-keyframes.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Wipe mask keyframes for the slide-transition overlay.
+ *
+ * PowerPoint feathers the wipe edge with a WIDE, smooth gradient - the fade
+ * zone spans roughly a slide width in real renders, not a narrow band. The
+ * incoming layer is masked with a 3x-oversized gradient (fade zone = one slide
+ * width) whose position sweeps it across the slide; the band fully exits both
+ * edges, so the start is fully hidden and the end fully opaque. The old
+ * clip-path inset reveal had a hard edge no feather could be applied to.
+ *
+ * Extracted from `slide-transition-keyframes` to keep that module at its
+ * original size; `SLIDE_TRANSITION_KEYFRAMES` concatenates this block.
+ *
+ * @module render/slide-transition-wipe-keyframes
+ */
+/**
+ * The four directional wipe reveals (`pptx-tr-wipe-from-*`), as a stylesheet
+ * fragment.
+ */
+export declare const WIPE_MASK_KEYFRAMES = "\n/* \u2500\u2500 Wipe (soft mask reveal) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */\n/* PowerPoint feathers the wipe edge with a WIDE, smooth gradient - the fade\n * zone spans roughly a slide width in real renders, not a narrow band. The\n * incoming layer is masked with a 3x-oversized gradient (fade zone = one slide\n * width) whose position sweeps it across the slide; the band fully exits both\n * edges, so the start is fully hidden and the end fully opaque. */\n@keyframes pptx-tr-wipe-from-left {\n\tfrom {\n\t\t-webkit-mask-image: linear-gradient(to right, #000 33.3%, transparent 66.7%);\n\t\t-webkit-mask-size: 300% 100%;\n\t\t-webkit-mask-repeat: no-repeat;\n\t\t-webkit-mask-position: 100% 0;\n\t\tmask-image: linear-gradient(to right, #000 33.3%, transparent 66.7%);\n\t\tmask-size: 300% 100%;\n\t\tmask-repeat: no-repeat;\n\t\tmask-position: 100% 0;\n\t}\n\tto {\n\t\t-webkit-mask-image: linear-gradient(to right, #000 33.3%, transparent 66.7%);\n\t\t-webkit-mask-size: 300% 100%;\n\t\t-webkit-mask-repeat: no-repeat;\n\t\t-webkit-mask-position: 0% 0;\n\t\tmask-image: linear-gradient(to right, #000 33.3%, transparent 66.7%);\n\t\tmask-size: 300% 100%;\n\t\tmask-repeat: no-repeat;\n\t\tmask-position: 0% 0;\n\t}\n}\n@keyframes pptx-tr-wipe-from-right {\n\tfrom {\n\t\t-webkit-mask-image: linear-gradient(to left, #000 33.3%, transparent 66.7%);\n\t\t-webkit-mask-size: 300% 100%;\n\t\t-webkit-mask-repeat: no-repeat;\n\t\t-webkit-mask-position: 0% 0;\n\t\tmask-image: linear-gradient(to left, #000 33.3%, transparent 66.7%);\n\t\tmask-size: 300% 100%;\n\t\tmask-repeat: no-repeat;\n\t\tmask-position: 0% 0;\n\t}\n\tto {\n\t\t-webkit-mask-image: linear-gradient(to left, #000 33.3%, transparent 66.7%);\n\t\t-webkit-mask-size: 300% 100%;\n\t\t-webkit-mask-repeat: no-repeat;\n\t\t-webkit-mask-position: 100% 0;\n\t\tmask-image: linear-gradient(to left, #000 33.3%, transparent 66.7%);\n\t\tmask-size: 300% 100%;\n\t\tmask-repeat: no-repeat;\n\t\tmask-position: 100% 0;\n\t}\n}\n@keyframes pptx-tr-wipe-from-top {\n\tfrom {\n\t\t-webkit-mask-image: linear-gradient(to bottom, #000 33.3%, transparent 66.7%);\n\t\t-webkit-mask-size: 100% 300%;\n\t\t-webkit-mask-repeat: no-repeat;\n\t\t-webkit-mask-position: 0 100%;\n\t\tmask-image: linear-gradient(to bottom, #000 33.3%, transparent 66.7%);\n\t\tmask-size: 100% 300%;\n\t\tmask-repeat: no-repeat;\n\t\tmask-position: 0 100%;\n\t}\n\tto {\n\t\t-webkit-mask-image: linear-gradient(to bottom, #000 33.3%, transparent 66.7%);\n\t\t-webkit-mask-size: 100% 300%;\n\t\t-webkit-mask-repeat: no-repeat;\n\t\t-webkit-mask-position: 0 0%;\n\t\tmask-image: linear-gradient(to bottom, #000 33.3%, transparent 66.7%);\n\t\tmask-size: 100% 300%;\n\t\tmask-repeat: no-repeat;\n\t\tmask-position: 0 0%;\n\t}\n}\n@keyframes pptx-tr-wipe-from-bottom {\n\tfrom {\n\t\t-webkit-mask-image: linear-gradient(to top, #000 33.3%, transparent 66.7%);\n\t\t-webkit-mask-size: 100% 300%;\n\t\t-webkit-mask-repeat: no-repeat;\n\t\t-webkit-mask-position: 0 0%;\n\t\tmask-image: linear-gradient(to top, #000 33.3%, transparent 66.7%);\n\t\tmask-size: 100% 300%;\n\t\tmask-repeat: no-repeat;\n\t\tmask-position: 0 0%;\n\t}\n\tto {\n\t\t-webkit-mask-image: linear-gradient(to top, #000 33.3%, transparent 66.7%);\n\t\t-webkit-mask-size: 100% 300%;\n\t\t-webkit-mask-repeat: no-repeat;\n\t\t-webkit-mask-position: 0 100%;\n\t\tmask-image: linear-gradient(to top, #000 33.3%, transparent 66.7%);\n\t\tmask-size: 100% 300%;\n\t\tmask-repeat: no-repeat;\n\t\tmask-position: 0 100%;\n\t}\n}\n";
+//# sourceMappingURL=slide-transition-wipe-keyframes.d.ts.map

package/dist/pptx/render/slide-transition-wipe-keyframes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slide-transition-wipe-keyframes.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/slide-transition-wipe-keyframes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB,uqHA+F/B,CAAC"}

package/dist/pptx/render/smart-art-preset-data.d.ts

@@ -0,0 +1,20 @@
+/**
+ * smart-art-preset-data.ts: builds the in-memory SmartArt data model for an
+ * insert-gallery preset. Single source of truth shared by every binding's
+ * insert handler and its dialog preview, so the gallery preview always shows
+ * exactly the diagram that insertion produces.
+ */
+import type { PptxSmartArtData, PptxSmartArtNode, SmartArtLayout } from 'ooxml-core/pptx';
+/** Produces the node id for the preset item at `index`. */
+export type SmartArtPresetNodeIdFactory = (index: number) => string;
+/**
+ * Build the node tree a preset inserts: one node per default item, with
+ * hierarchy layouts parenting every later node under the first (root) node.
+ */
+export declare function buildSmartArtPresetNodes(layout: SmartArtLayout, defaultItems: string[], idFor?: SmartArtPresetNodeIdFactory): PptxSmartArtNode[];
+/**
+ * Build the complete `PptxSmartArtData` for a preset, using the same default
+ * colour scheme and style intensity the insert handlers apply.
+ */
+export declare function buildSmartArtPresetData(layout: SmartArtLayout, defaultItems: string[], idFor?: SmartArtPresetNodeIdFactory): PptxSmartArtData;
+//# sourceMappingURL=smart-art-preset-data.d.ts.map

package/dist/pptx/render/smart-art-preset-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-art-preset-data.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smart-art-preset-data.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE1F,2DAA2D;AAC3D,MAAM,MAAM,2BAA2B,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAIpE;;;GAGG;AACH,wBAAgB,wBAAwB,CACvC,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,MAAM,EAAE,EACtB,KAAK,GAAE,2BAA8C,GACnD,gBAAgB,EAAE,CASpB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACtC,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,MAAM,EAAE,EACtB,KAAK,CAAC,EAAE,2BAA2B,GACjC,gBAAgB,CAOlB"}

package/dist/pptx/render/smart-art-presets.d.ts

@@ -0,0 +1,31 @@
+/**
+ * smart-art-presets.ts: the SmartArt insert-gallery catalogue, shared across
+ * bindings. Pure data + types; consumed by each binding's insert dialog and
+ * preview thumbnails. Each preset names a core {@link SmartArtLayout}, the
+ * sidebar category it lives under, a label, and the default node texts inserted
+ * when the user picks it without editing.
+ */
+import type { SmartArtLayout } from 'ooxml-core/pptx';
+/** The five categories surfaced in the dialog's left sidebar. */
+export type SmartArtCategory = 'list' | 'process' | 'cycle' | 'hierarchy' | 'relationship';
+/** A single entry in the SmartArt insert gallery. */
+export interface SmartArtPreset {
+    /** Core layout kind this preset inserts. */
+    layout: SmartArtLayout;
+    /** Display label (English fallback). */
+    label: string;
+    /** Translation key resolving to the label. */
+    labelKey: string;
+    /** Sidebar category. */
+    category: SmartArtCategory;
+    /** Default node texts to seed the new SmartArt with. */
+    defaultItems: string[];
+}
+export declare const PRESETS: SmartArtPreset[];
+/** Sidebar tabs, in display order. */
+export declare const CATEGORIES: Array<{
+    id: SmartArtCategory;
+    label: string;
+    labelKey: string;
+}>;
+//# sourceMappingURL=smart-art-presets.d.ts.map

package/dist/pptx/render/smart-art-presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-art-presets.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smart-art-presets.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,iEAAiE;AACjE,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,GAAG,cAAc,CAAC;AAE3F,qDAAqD;AACrD,MAAM,WAAW,cAAc;IAC9B,4CAA4C;IAC5C,MAAM,EAAE,cAAc,CAAC;IACvB,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,wBAAwB;IACxB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,wDAAwD;IACxD,YAAY,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,eAAO,MAAM,OAAO,EAAE,cAAc,EAgQnC,CAAC;AAEF,sCAAsC;AACtC,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,gBAAgB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAMvF,CAAC"}

package/dist/pptx/render/smartart-3d-bevel-profile.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `a:bevelT/@prst` cross-sections for the lit SmartArt 3D solids
+ * (framework-agnostic, pure).
+ *
+ * A profile is a polyline from the shape's outline (`s = 0`, `t = 0`) to the
+ * inner edge of the bevel (`s = 1`, `t = 1`): `s` is the inset as a fraction
+ * of the bevel width, `t` the height as a fraction of the bevel height. The
+ * shapes follow the ECMA-376 20.1.10.9 preset silhouettes, tuned against the
+ * PowerPoint exports of the SmartArt bevel quick styles
+ * (`e2e/fixtures/three-d-parity/gt`): `circle` (Polished) is a quarter round,
+ * `relaxedInset` (Inset) dips into a groove before rising to the face, which
+ * is what paints its dark outer line and bright inner ridge.
+ *
+ * @module render/smartart-3d-bevel-profile
+ */
+/** One sample of a bevel cross-section. */
+export interface BevelProfilePoint {
+    /** Inset from the outline, as a fraction of the bevel width (0..1). */
+    s: number;
+    /** Height above the bevel's base, as a fraction of the bevel height. */
+    t: number;
+}
+/**
+ * The cross-section for a bevel preset token; unknown tokens fall back to
+ * `circle` (the ECMA-376 default for an `a:bevelT` without `@prst`).
+ */
+export declare function getSmartArtBevelProfile(profile: string | undefined): BevelProfilePoint[];
+//# sourceMappingURL=smartart-3d-bevel-profile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-bevel-profile.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-bevel-profile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,2CAA2C;AAC3C,MAAM,WAAW,iBAAiB;IACjC,uEAAuE;IACvE,CAAC,EAAE,MAAM,CAAC;IACV,wEAAwE;IACxE,CAAC,EAAE,MAAM,CAAC;CACV;AAsED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,iBAAiB,EAAE,CAGxF"}

package/dist/pptx/render/smartart-3d-drawing-model.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Three.js SmartArt renderer - pure model builder for the CACHED DRAWING path.
+ *
+ * Converts a SmartArt element's cached `drawingShapes` (`ppt/diagrams/
+ * drawing*.xml`, the exact geometry PowerPoint itself drew and the 2D SVG
+ * renderer already projects via {@link projectDrawingShapes}) into a
+ * framework/three-agnostic {@link SmartArt3DModel}. This is the PREFERRED
+ * source for the 3D renderer (PowerPoint parity): the layout-engine path in
+ * `smartart-3d-model.ts` is a fallback for elements with no cached drawing.
+ *
+ * FLAT quick styles (Simple Fill, White Outline, Subtle, Moderate, Intense):
+ * every shape is coplanar (z separated only by a tiny per-paint-order epsilon
+ * to avoid z-fighting where SmartArt stacks an unfilled label shape over a
+ * painted one), unlit, and framed by an orthographic camera matching the 2D
+ * SVG viewBox exactly. BEVEL and SCENE quick styles (see
+ * `resolveSmartArt3DStylePath`) keep the same meshes and add a lit solid,
+ * gradient, light rig and (scene only) a whole-diagram camera, via
+ * `smartart-3d-drawing-solid.ts`.
+ *
+ * No `three` import: this module returns plain data: three.js Shape/geometry
+ * construction happens in `smartart-3d/view-scene.ts`, which has `ctx.three`.
+ *
+ * @module render/smartart-3d-drawing-model
+ */
+import type { PptxSmartArtData } from 'ooxml-core/pptx';
+import type { SmartArt3DModel } from './smartart-3d-types.js';
+/**
+ * Build the 3D model directly from a SmartArt element's cached
+ * `drawingShapes`, or `undefined` when it has none (caller falls back to the
+ * layout-engine model).
+ */
+export declare function buildSmartArt3DDrawingModel(data: PptxSmartArtData): SmartArt3DModel | undefined;
+//# sourceMappingURL=smartart-3d-drawing-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-drawing-model.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-drawing-model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAA4B,MAAM,iBAAiB,CAAC;AAKlF,OAAO,KAAK,EAGX,eAAe,EAEf,MAAM,qBAAqB,CAAC;AA4L7B;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,gBAAgB,GAAG,eAAe,GAAG,SAAS,CAgC/F"}

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

@@ -0,0 +1,34 @@
+/**
+ * The lit (bevel / scene quick style) half of the cached-drawing SmartArt 3D
+ * model: per-shape solids and gradients, plus the diagram's light rig and
+ * camera (framework-agnostic, pure).
+ *
+ * `smartart-3d-drawing-model.ts` builds the flat meshes; this module decorates
+ * them when {@link resolveSmartArt3DStylePath} picks `'bevel'` or `'scene'`.
+ *
+ * @module render/smartart-3d-drawing-solid
+ */
+import type { PptxSmartArtData, PptxSmartArtDrawingShape } from 'ooxml-core/pptx';
+import type { SmartArt3DCamera, SmartArt3DGradient, SmartArt3DLighting } from './smartart-3d-solid-types.js';
+import type { Point2, SmartArt3DMesh, SmartArt3DStyleCategory } from './smartart-3d-types.js';
+import type { Rgb } from './smartart-3d-vertex-shading.js';
+import type { RenderedShape } from './smartart-drawing.js';
+/**
+ * The shape's gradient in mesh-local space, or `undefined` for a plain fill.
+ *
+ * @param toLocal - maps a viewBox point (y-down, before the shape's own
+ *   rotation / flip) to mesh-local space (y-up, rotation applied).
+ */
+export declare function buildSmartArt3DGradient(rendered: RenderedShape, toLocal: (p: Point2) => Point2): SmartArt3DGradient | undefined;
+/** Where a mesh-local point falls along a gradient, 0..1. */
+export declare function smartArt3DGradientCoordinate(p: Point2, gradient: SmartArt3DGradient): number;
+/** The sRGB colour a gradient paints at a mesh-local point (stops interpolated in sRGB, as SVG does). */
+export declare function smartArt3DGradientColor(gradient: SmartArt3DGradient, p: Point2): Rgb;
+/** Give a flat mesh its lit solid and gradient, from its cached shape. */
+export declare function decorateSmartArt3DMesh(mesh: SmartArt3DMesh, shape: PptxSmartArtDrawingShape, rendered: RenderedShape, toLocal: (p: Point2) => Point2): void;
+/** The light rig and camera for a lit diagram. */
+export declare function resolveSmartArt3DSceneSetup(data: PptxSmartArtData, category: SmartArt3DStyleCategory): {
+    lighting?: SmartArt3DLighting;
+    camera?: SmartArt3DCamera;
+};
+//# sourceMappingURL=smartart-3d-drawing-solid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-drawing-solid.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-drawing-solid.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAIlF,OAAO,KAAK,EACX,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAC3F,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,8BAA8B,CAAC;AAExD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAUxD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,GAC5B,kBAAkB,GAAG,SAAS,CAuBhC;AAED,6DAA6D;AAC7D,wBAAgB,4BAA4B,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAY5F;AAED,yGAAyG;AACzG,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,kBAAkB,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,CAsBpF;AAED,0EAA0E;AAC1E,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,wBAAwB,EAC/B,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,GAC5B,IAAI,CAoBN;AAED,kDAAkD;AAClD,wBAAgB,2BAA2B,CAC1C,IAAI,EAAE,gBAAgB,EACtB,QAAQ,EAAE,uBAAuB,GAC/B;IAAE,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAAC,MAAM,CAAC,EAAE,gBAAgB,CAAA;CAAE,CAgB9D"}

package/dist/pptx/render/smartart-3d-edit-layer.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The inline-editing layer over a 3D SmartArt view (framework-agnostic).
+ *
+ * `<pptx-three-view>` keeps a SmartArt's 2D SVG only as its fallback, hidden
+ * once the scene is up, so a binding that edits node text on the canvas lays
+ * a second render of the diagram over the scene with its SVG paint hidden:
+ * its `[data-smartart-node-id]` groups still take the double-click and the
+ * textarea it opens is not SVG, so it shows. That layer is an input surface,
+ * not a second copy of the element, so its element markers go.
+ *
+ * @module smartart-3d-edit-layer
+ */
+/** Element markers a second render of a diagram must not repeat. */
+export declare const EDIT_LAYER_MARKER_ATTRS: readonly ['data-element-id', 'data-testid', 'data-pptx-element', 'role', 'aria-label', 'aria-roledescription'];
+/** Remove the element markers from `root` and everything under it, except on its controls. */
+export declare function stripEditLayerMarkers(root: Element): void;
+/**
+ * The `[data-smartart-node-id]` element under viewport point `(x, y)` inside
+ * `root`, by geometry: the smallest node containing the point. Unlike
+ * `document.elementsFromPoint`, this finds nodes that hit-testing skips, such
+ * as a hidden layer's `pointer-events: none` groups.
+ *
+ * A node is tested against its drawn shapes where the host can, so a rotated
+ * diagram resolves the node under the pointer rather than a neighbour whose
+ * bounding box merely overlaps it; otherwise by its bounding box.
+ */
+export declare function smartArtNodeAtPoint(root: ParentNode, x: number, y: number): Element | null;
+/**
+ * Route a 3D edit layer's pointer input to the node under the pointer, found by
+ * geometry (`smartArtNodeAtPoint`) instead of by event target.
+ *
+ * The layer is an invisible copy under a perspective scene, and a node group is
+ * only hit where it paints (often its label alone), so a double-click or hover
+ * on the node's fill missed the group's own handlers. This forwards a
+ * double-click as `dblclick` and a change of hovered node as enter / leave events
+ * (`mouseover`, `mouseenter`, `mouseout`, `mouseleave`) to the group, so each binding's existing editor and fill swatches run unchanged.
+ * Returns a function that removes the listeners.
+ */
+export declare function routeEditLayerPointerToNodes(layer: Element): () => void;
+//# sourceMappingURL=smartart-3d-edit-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-edit-layer.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-edit-layer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,oEAAoE;AACpE,eAAO,MAAM,uBAAuB,YACnC,iBAAiB,EACjB,aAAa,EACb,mBAAmB,EACnB,MAAM,EACN,YAAY,EACZ,sBAAsB,CACb,CAAC;AAQX,8FAA8F;AAC9F,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAWzD;AA2CD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAiB1F;AAKD;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,IAAI,CA8EvE"}

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

@@ -0,0 +1,21 @@
+/**
+ * Build the {@link SmartArt3DModel} for a SmartArt element: the one place
+ * every binding (and `<pptx-three-view>`) turns an element into its 3D scene
+ * input, instead of each binding repeating the layout-resolution steps.
+ *
+ * @module smartart-3d-element
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { SmartArt3DModel } from './smartart-3d-types.js';
+/** Options for {@link buildSmartArt3DSpecForElement}. */
+export interface SmartArt3DElementOptions {
+    /**
+     * Opt into the non-PowerPoint "spatial" arrangements (cycle carousel,
+     * receding hierarchy). Off by default: the default 3D view matches what
+     * PowerPoint draws for the diagram's quick style.
+     */
+    spatial?: boolean;
+}
+/** The 3D model for a SmartArt element, or `null` when it has nothing to draw. */
+export declare function buildSmartArt3DSpecForElement(element: PptxElement, options?: SmartArt3DElementOptions): SmartArt3DModel | null;
+//# sourceMappingURL=smartart-3d-element.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-element.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-element.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAMnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAG3D,yDAAyD;AACzD,MAAM,WAAW,wBAAwB;IACxC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,kFAAkF;AAClF,wBAAgB,6BAA6B,CAC5C,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,wBAA6B,GACpC,eAAe,GAAG,IAAI,CAqCxB"}

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

@@ -0,0 +1,42 @@
+/**
+ * Three.js SmartArt renderer - pure geometry & colour helpers.
+ *
+ * Outline builders (rect, rounded-rect, circle), colour-contrast picking, and
+ * SVG-path/polygon-point parsing used by `buildSmartArt3DModel`. No `three`
+ * import; fully unit-testable.
+ */
+import type { Point2 } from './smartart-3d-types.js';
+/** Parse a `"0 0 W H"` viewBox string into `{ width, height }`. */
+export declare function parseViewBox(viewBox: string): {
+    width: number;
+    height: number;
+};
+/**
+ * Build a (optionally rounded) rectangle outline centred on the origin (y-up).
+ *
+ * @param width  Full footprint width.
+ * @param height Full footprint height.
+ * @param radius Corner radius; 0 yields sharp corners.
+ * @param segments Arc segments per rounded corner.
+ */
+export declare function roundedRectOutline(width: number, height: number, radius: number, segments?: number): Point2[];
+/** Build a circle outline centred on the origin. */
+export declare function circleOutline(radius: number, segments?: number): Point2[];
+/** Parse an SVG polygon `points` string (`"x,y x,y …"`) into points (y-down). */
+export declare function parsePolygonPoints(points: string): Point2[];
+/**
+ * Parse a simple SVG path (`M`/`L`/`H`/`V`, with curve commands reduced to
+ * their end point) into a poly-line of absolute points (y-down). The SmartArt
+ * layout engine only emits straight-segment connector paths, so this covers the
+ * real input without a full path parser.
+ */
+export declare function parsePathPoints(d: string): Point2[];
+/** Axis-aligned bounding box / centroid of a set of points. */
+export declare function boundsOf(points: Point2[]): {
+    cx: number;
+    cy: number;
+    width: number;
+    height: number;
+};
+export { parseHex, contrastTextColor } from './color-contrast.js';
+//# sourceMappingURL=smartart-3d-geom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-geom.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-geom.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,mEAAmE;AACnE,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAQ/E;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,QAAQ,SAAI,GACV,MAAM,EAAE,CA2BV;AAED,oDAAoD;AACpD,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,SAAK,GAAG,MAAM,EAAE,CAOrE;AAED,iFAAiF;AACjF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAW3D;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAgEnD;AAED,+DAA+D;AAC/D,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG;IAC3C,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf,CA4BA;AAKD,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/pptx/render/smartart-3d-layout-source.d.ts

@@ -0,0 +1,32 @@
+/**
+ * SmartArt 3D - which 2D geometry the 3D model is built from.
+ *
+ * The SVG renderers prefer the cached `dsp:` drawing (`smartArtData.drawingShapes`,
+ * PowerPoint's own layout output, with the deck's real theme fills) and only
+ * run the layout engine when a deck carries no cache. The 3D scene used to
+ * ALWAYS run the layout engine, so the same element rendered with different
+ * geometry and different colours the moment the scene was switched on, and a
+ * diagram that had been saved and reopened (which then carries both a cache
+ * and a `layoutDefinition`) could change shape entirely. This module gives
+ * the 3D path the same preference order: cached drawing first, engine second.
+ */
+import type { PptxSmartArtDrawingShape, PptxSmartArtNode, SmartArtStyle } from 'ooxml-core/pptx';
+import type { SmartArtElementLayoutSource } from './smartart-layout.js';
+import type { BoundingBox, SmartArtLayoutResult } from './smartart-layout-types.js';
+/** The subset of `PptxSmartArtData` this module reads. */
+export type SmartArt3DLayoutSource = SmartArtElementLayoutSource & {
+    drawingShapes?: PptxSmartArtDrawingShape[];
+};
+/**
+ * Layout geometry for the 3D model from the cached drawing, in element-box
+ * coordinates (the drawing is fitted `xMidYMid meet`, exactly as the SVG
+ * renderers place it), or `null` when the element carries no cache.
+ */
+export declare function drawingShapesLayoutResult(elementId: string, shapes: PptxSmartArtDrawingShape[] | undefined, box: BoundingBox, palette: string[], style: SmartArtStyle, family: SmartArtLayoutResult['family']): SmartArtLayoutResult | null;
+/**
+ * The geometry the 3D model should be built from: the cached drawing when
+ * the element has one (same source, same colours as the SVG renderers),
+ * otherwise the shared layout engine.
+ */
+export declare function resolveSmartArt3DLayout(smartArtData: SmartArt3DLayoutSource, nodes: PptxSmartArtNode[], box: BoundingBox, palette: string[], style: SmartArtStyle, elementId: string): SmartArtLayoutResult;
+//# sourceMappingURL=smartart-3d-layout-source.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-layout-source.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-layout-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAMjG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAErE,OAAO,KAAK,EAAE,WAAW,EAAgB,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAE/F,0DAA0D;AAC1D,MAAM,MAAM,sBAAsB,GAAG,2BAA2B,GAAG;IAClE,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC3C,CAAC;AAoFF;;;;GAIG;AACH,wBAAgB,yBAAyB,CACxC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,wBAAwB,EAAE,GAAG,SAAS,EAC9C,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,oBAAoB,CAAC,QAAQ,CAAC,GACpC,oBAAoB,GAAG,IAAI,CAwB7B;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACtC,YAAY,EAAE,sBAAsB,EACpC,KAAK,EAAE,gBAAgB,EAAE,EACzB,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,MAAM,GACf,oBAAoB,CAMtB"}

package/dist/pptx/render/smartart-3d-light-rig.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The specular lights of a SmartArt 3D light rig (framework-agnostic, pure).
+ *
+ * PowerPoint's `a:lightRig` presets are several directional lights, not one.
+ * The single-light tables in `visual-3d-bevel-lighting-tables.ts` capture
+ * what a rig does to a BEVEL (the key light's elevation and which edge it
+ * lights); they say nothing about the other lights, which only show where a
+ * specular material meets a changing view direction. A perspective scene
+ * camera is exactly that case: every point of a flat face is seen from a
+ * slightly different angle, so a metal face picks up the broad sweep of a
+ * light the bevel campaign never saw (Metallic Scene: `threePt` + `metal`
+ * under `perspectiveLeft`, bright at the diagram's top-left and fading to the
+ * plain fill at its bottom-right).
+ *
+ * Under a perspective scene camera, each rig listed here replaces the default
+ * highlight (one light above the key light's azimuth) with its own lights. A
+ * parallel view keeps the default: the bevel constants in
+ * `smartart-3d-lighting.ts` were fitted against the bevel quick styles with
+ * that highlight, and the `threePt` light below over-brightens Inset's bevel
+ * bands (every layout's Inset export regressed with it). Azimuths are relative to the key
+ * light's (the snapped `a:lightRig/@dir` turned by the rig's `rev`),
+ * counter-clockwise in diagram space; `intensity` scales the material's own
+ * specular constant and `sharpness` its exponent.
+ *
+ * `threePt`'s highlight light was fitted to the Metallic Scene export
+ * (`e2e/fixtures/three-d-parity/gt/sa-012.webp`): 838 face samples mapped
+ * back onto the diagram plane through the fitted scene camera, Blinn lobe,
+ * mean absolute error 2.3 (0-255) against a fill + white highlight. Adding
+ * the default highlight to the fit gave it a zero weight, so the default is
+ * replaced rather than kept.
+ *
+ * @module render/smartart-3d-light-rig
+ */
+/** One specular light of a rig. */
+export interface SmartArt3DRigLight {
+    /** Azimuth relative to the key light, degrees, counter-clockwise. */
+    azimuthDeg: number;
+    /** Elevation above the diagram plane, degrees. */
+    elevationDeg: number;
+    /** Multiplier on the material's specular constant. */
+    intensity: number;
+    /** Multiplier on the material's specular exponent. */
+    sharpness: number;
+}
+/** Rigs whose specular lights are known (see the module doc). */
+export declare const SMARTART_RIG_SPECULAR_LIGHTS: Record<string, readonly SmartArt3DRigLight[]>;
+/**
+ * The specular lights of a rig: its own under a perspective scene camera,
+ * otherwise (or for a rig not listed) the default single highlight.
+ */
+export declare function smartArt3DRigSpecularLights(rig: string | undefined, perspective: boolean): readonly SmartArt3DRigLight[];
+/** The key (diffuse) light of a rig, relative to the snapped `a:lightRig/@dir`. */
+export interface SmartArt3DRigKeyLight {
+    /** Azimuth relative to the key light's direction, degrees, counter-clockwise. */
+    azimuthDeg: number;
+    /** Elevation above the diagram plane, degrees. */
+    elevationDeg: number;
+}
+/**
+ * Key-light elevations under a scene camera, fitted per rig against the scene
+ * quick styles' exports (whole-slide MAE over all eight layouts of each
+ * style in `e2e/fixtures/three-d-parity/gt/`, sweeping the elevation):
+ * `flat` (Brick Scene, isometric) 4.18 -> 3.94 at 40, `threePt` (Metallic
+ * Scene) 3.89 -> 3.60 at 90, `morning` (Sunset Scene) 3.63 -> 3.53 at 60,
+ * `soft` (Bird's Eye Scene) 3.69 -> 3.12 at 80. Under a parallel view the
+ * grazing default stays: raising it made Polished (`flat`) and Cartoon
+ * (`contrasting`) worse, because the bevel constants were fitted with it.
+ */
+export declare const SMARTART_RIG_SCENE_KEY_LIGHTS: Record<string, SmartArt3DRigKeyLight>;
+/**
+ * A rig's own key light under a scene camera, or `undefined` for the default
+ * (a grazing light from `@dir`, fitted against the bevel quick styles).
+ */
+export declare function smartArt3DRigKeyLight(rig: string | undefined, sceneCamera: boolean): SmartArt3DRigKeyLight | undefined;
+//# sourceMappingURL=smartart-3d-light-rig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-light-rig.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-light-rig.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,mCAAmC;AACnC,MAAM,WAAW,kBAAkB;IAClC,qEAAqE;IACrE,UAAU,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,YAAY,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;CAClB;AASD,iEAAiE;AACjE,eAAO,MAAM,4BAA4B,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,kBAAkB,EAAE,CAEtF,CAAC;AAEF;;;GAGG;AACH,wBAAgB,2BAA2B,CAC1C,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,WAAW,EAAE,OAAO,GAClB,SAAS,kBAAkB,EAAE,CAG/B;AAED,mFAAmF;AACnF,MAAM,WAAW,qBAAqB;IACrC,iFAAiF;IACjF,UAAU,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,YAAY,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAK/E,CAAC;AAEF;;;GAGG;AACH,wBAAgB,qBAAqB,CACpC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,WAAW,EAAE,OAAO,GAClB,qBAAqB,GAAG,SAAS,CAEnC"}

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

@@ -0,0 +1,53 @@
+import type { SmartArt3DLighting } from './smartart-3d-solid-types.js';
+import type { Vec3 } from './smartart-3d-types.js';
+/** The resolved light for one solid: a key light plus a material response. */
+export interface SmartArt3DLightModel {
+    /** Unit vector toward the key (diffuse) light (diagram space: y-up, +z toward the viewer). */
+    light: Vec3;
+    /** The rig's specular lights (see `smartart-3d-light-rig.ts`). */
+    highlights: SmartArt3DHighlight[];
+    /** Share of the diffuse response that does not depend on the normal. */
+    ambient: number;
+    diffuse: number;
+    /**
+     * Linear per-channel factor the rig applies to every surface, including a
+     * face-on one (see {@link RIG_FACE_READING}).
+     */
+    tint: [number, number, number];
+}
+/** One specular light, resolved to diagram space. */
+export interface SmartArt3DHighlight {
+    /** Unit vector toward the light. */
+    direction: Vec3;
+    /** Specular weight (material constant times the rig light's intensity). */
+    weight: number;
+    /** Specular exponent (material exponent times the rig light's sharpness). */
+    exponent: number;
+}
+/** A vertex's shading: display colour = `fill * mul + add` (per channel, 0..1). */
+export interface SmartArt3DShade {
+    mul: number;
+    add: number;
+}
+/**
+ * Resolve the light model for a rig and an `a:sp3d/@prstMaterial`.
+ *
+ * @param perspective - the solid is seen through a perspective scene camera,
+ *   which switches on the rig's own specular lights (see
+ *   `smartart-3d-light-rig.ts`).
+ * @param sceneCamera - the diagram is turned by a quick-style scene camera
+ *   (perspective or not), which switches on the rig's own key light.
+ */
+export declare function resolveSmartArt3DLightModel(lighting: SmartArt3DLighting | undefined, material: string | undefined, perspective?: boolean, sceneCamera?: boolean): SmartArt3DLightModel;
+/**
+ * Shade one unit normal (diagram space).
+ *
+ * @param eye - unit direction from the surface point toward the camera. When
+ *   omitted (a face-on, parallel view) the specular term is measured against a
+ *   face-on surface, so a normal facing the viewer returns exactly
+ *   `{ mul: 1, add: 0 }`. A perspective scene camera passes the real per-point
+ *   direction instead, and its faces pick up the moving highlight a metal
+ *   diagram shows in the Metallic Scene export.
+ */
+export declare function shadeSmartArt3DNormal(normal: Vec3, model: SmartArt3DLightModel, eye?: Vec3): SmartArt3DShade;
+//# sourceMappingURL=smartart-3d-lighting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-lighting.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-lighting.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAIhD,8EAA8E;AAC9E,MAAM,WAAW,oBAAoB;IACpC,8FAA8F;IAC9F,KAAK,EAAE,IAAI,CAAC;IACZ,kEAAkE;IAClE,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED,qDAAqD;AACrD,MAAM,WAAW,mBAAmB;IACnC,oCAAoC;IACpC,SAAS,EAAE,IAAI,CAAC;IAChB,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,mFAAmF;AACnF,MAAM,WAAW,eAAe;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACZ;AAsDD;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAC1C,QAAQ,EAAE,kBAAkB,GAAG,SAAS,EACxC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,WAAW,UAAQ,EACnB,WAAW,UAAc,GACvB,oBAAoB,CAkCtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,IAAI,EACZ,KAAK,EAAE,oBAAoB,EAC3B,GAAG,CAAC,EAAE,IAAI,GACR,eAAe,CAgBjB"}

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

@@ -0,0 +1,26 @@
+/**
+ * Three.js SmartArt renderer - pure model builder.
+ *
+ * Converts the 2D {@link SmartArtLayoutResult} (rect/circle/polygon view-models
+ * produced by `computeSmartArtLayout`) into a framework-agnostic, three-agnostic
+ * {@link SmartArt3DModel} of extruded meshes + connectors. No `three` import.
+ */
+import type { PptxSmartArtNode } from 'ooxml-core/pptx';
+import type { SmartArt3DModel, SmartArt3DModelOptions } from './smartart-3d-types.js';
+import type { SmartArtLayoutResult } from './smartart-layout-types.js';
+/**
+ * Build the pure 3D model for a SmartArt element from its 2D layout result.
+ *
+ * @param layout  Output of `computeSmartArtLayout`.
+ * @param options Depth/bevel/background tunables.
+ */
+export declare function buildSmartArt3DModel(layout: SmartArtLayoutResult, options?: SmartArt3DModelOptions): SmartArt3DModel;
+/**
+ * Collect the ids of nodes (including nested children) that opt out of
+ * PowerPoint's "coherent 3-D" per-node bevel variation via
+ * `dgm:prSet/@coherent3DOff`. Every binding's 3D SmartArt renderer calls this
+ * once from the element's `smartArtData.nodes` and passes the result as
+ * {@link SmartArt3DModelOptions.coherent3DOffNodeIds}.
+ */
+export declare function collectCoherent3DOffNodeIds(nodes: readonly PptxSmartArtNode[]): ReadonlySet<string>;
+//# sourceMappingURL=smartart-3d-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-model.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-model.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAaxD,OAAO,KAAK,EAKX,eAAe,EACf,sBAAsB,EACtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAA8B,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAyIhG;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,oBAAoB,EAC5B,OAAO,GAAE,sBAA2B,GAClC,eAAe,CAkCjB;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAChC,WAAW,CAAC,MAAM,CAAC,CAQrB"}

package/dist/pptx/render/smartart-3d-primitive-outline.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Polygon outlines for the two native SVG primitives the 2D SmartArt
+ * projection draws directly (`RenderedShapeKind` `'rect'` and `'ellipse'`),
+ * for the three.js flat/bevel SmartArt renderer, which needs a concrete
+ * outline rather than an SVG primitive.
+ *
+ * @module render/smartart-3d-primitive-outline
+ */
+import type { Point2 } from './svg-path-flatten.js';
+/**
+ * Outline of an axis-aligned rectangle, optionally with rounded corners, as a
+ * closed polygon (first point repeated at the end, matching
+ * {@link flattenSvgPath}'s convention). `rx` is clamped to at most half the
+ * smaller side.
+ */
+export declare function rectOutline(x: number, y: number, width: number, height: number, rx: number, cornerSegments?: number): Point2[];
+/** Outline of an axis-aligned ellipse as a closed polygon. */
+export declare function ellipseOutline(cx: number, cy: number, rx: number, ry: number, segments?: number): Point2[];
+//# sourceMappingURL=smartart-3d-primitive-outline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-primitive-outline.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-primitive-outline.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,WAAW,CAC1B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,EACV,cAAc,SAAI,GAChB,MAAM,EAAE,CA8BV;AAED,8DAA8D;AAC9D,wBAAgB,cAAc,CAC7B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,QAAQ,SAAK,GACX,MAAM,EAAE,CAOV"}

package/dist/pptx/render/smartart-3d-regenerated-drawing.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The drawing shapes the 3D SmartArt scene uses for a diagram whose cached
+ * drawing was dropped by a STRUCTURAL edit (add / remove / reorder a node).
+ *
+ * Such a diagram has no `drawingShapes` until it is saved, so without this it
+ * fell back to the layout-engine 3D model, which knows nothing of the quick
+ * style's bevel / scene 3D and rendered flat. Core's `relayoutSmartArt`
+ * recomputes the shapes and re-applies the quick style's per-label 3D (the
+ * same shapes the save caches), so the diagram keeps its bevel / scene look
+ * both before and after save.
+ *
+ * @module render/smartart-3d-regenerated-drawing
+ */
+import type { PptxSmartArtData } from 'ooxml-core/pptx';
+/**
+ * `data` with regenerated, 3D-styled `drawingShapes` when its cached drawing
+ * is gone and its quick style carries 3D; otherwise `data` itself (an intact
+ * drawing, or a flat style that keeps the existing layout-engine path).
+ */
+export declare function withRegeneratedSmartArt3DDrawing(data: PptxSmartArtData, size: {
+    width: number;
+    height: number;
+}): PptxSmartArtData;
+//# sourceMappingURL=smartart-3d-regenerated-drawing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-3d-regenerated-drawing.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-3d-regenerated-drawing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAexD;;;;GAIG;AACH,wBAAgB,gCAAgC,CAC/C,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACrC,gBAAgB,CAMlB"}

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

@@ -0,0 +1,35 @@
+/**
+ * Closed-polygon ("ring") helpers for the lit SmartArt 3D solids: clean-up,
+ * orientation, per-edge normals and a mitred inward/outward offset
+ * (framework-agnostic, pure).
+ *
+ * @module render/smartart-3d-ring
+ */
+import type { Point2 } from './smartart-3d-types.js';
+/** Drop repeated consecutive points and the closing duplicate of the first point. */
+export declare function cleanRing(points: readonly Point2[]): Point2[];
+/** Shoelace signed area: positive for a counter-clockwise ring in y-up space. */
+export declare function ringSignedArea(ring: readonly Point2[]): number;
+/** A cleaned, counter-clockwise (y-up) copy of `points`. */
+export declare function toCcwRing(points: readonly Point2[]): Point2[];
+/**
+ * Unit inward normal of every edge `i -> i + 1` of a counter-clockwise ring
+ * (the interior is on the edge's left).
+ */
+export declare function ringEdgeNormals(ring: readonly Point2[]): Point2[];
+/**
+ * Offset a counter-clockwise ring by `distance` along its inward normals
+ * (negative grows it). Each vertex moves along its mitre, clipped at
+ * {@link MITER_LIMIT} times the distance so a sharp spike stays bounded.
+ */
+export declare function offsetRing(ring: readonly Point2[], distance: number): Point2[];
+/**
+ * The in-plane inward direction to shade each edge's two ends with.
+ *
+ * `result[i]` is `[atStart, atEnd]` for edge `i -> i + 1`. Where the ring
+ * turns by less than `smoothDeg` (a curve's tessellation) the two edges share
+ * the averaged normal, so a circle shades smoothly; at a real corner each
+ * edge keeps its own normal, so a rectangle's sides shade flat.
+ */
+export declare function ringShadingNormals(ring: readonly Point2[], smoothDeg?: number): Array<[Point2, Point2]>;
+//# sourceMappingURL=smartart-3d-ring.d.ts.map