ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/visual-effects.d.ts

@@ -0,0 +1,341 @@
+/**
+ * Visual effects composable  -  pure CSS computation for OOXML shape/image effects.
+ *
+ * Mirrors the React `pptx-viewer` effect layer (shape-visual-style.ts +
+ * color-core.ts + effect-dag-filters.ts) without any React/Vue runtime
+ * dependency. Everything here is a pure function so it can be unit-tested
+ * without mounting a component, then wired into `element-style.ts` /
+ * `ElementRenderer.vue` by the integrator.
+ *
+ * It covers, for shapes/connectors/images:
+ *  - **Outer shadow**       → CSS `box-shadow`
+ *  - **Inner shadow**       → CSS `inset` `box-shadow`
+ *  - **Multi-layer shadow** → comma-joined `box-shadow` (from `shadows[]`)
+ *  - **Outer glow**         → CSS `filter: drop-shadow(...)` (simple path) and
+ *                             optional layered `box-shadow` (high-fidelity path)
+ *  - **Soft edges / blur**  → CSS `filter: blur(...)`
+ *  - **Reflection**         → a mirrored sibling's wrapper style (`reflection.ts`)
+ *  - **Effect DAG**         → CSS `filter` (grayscale/biLevel/lum/hsl/tint…),
+ *                             `opacity`, `mix-blend-mode`, + optional duotone
+ *                             `<filter>` SVG markup (high-fidelity path)
+ *
+ * Units/precedence match the React implementation: spatial values are already
+ * in px on `ShapeStyle` (pre-converted from EMU by core), angles are degrees,
+ * alpha is 0–1. The EMU constants are re-exported from core for callers that
+ * need to convert raw values themselves.
+ *
+ * @module viewer/composables/visual-effects
+ */
+import type { PptxElement, ShapeStyle } from 'ooxml-core/pptx';
+import type { ReflectionWrapperStyle } from './reflection.js';
+/**
+ * Escape a string for safe inclusion in an SVG/XML attribute value. Applied
+ * to element-derived ids before they're interpolated into hand-built
+ * `<filter>` markup (some bindings inject that markup via `innerHTML`/
+ * `v-html`, so an unescaped id from a crafted OOXML shape id could otherwise
+ * break out of the attribute).
+ *
+ * This is the ONE escaper for every string-concatenated SVG in `render/`.
+ * `chart-sparkline`, `svg-gradient-paint` and `image-tiling` all build markup
+ * that lands in `innerHTML`, and each grew its own private copy of exactly
+ * this function; the copies are the failure mode, because a hardening applied
+ * to one of four escapers protects a quarter of the surface.
+ *
+ * `String(value)` is deliberate rather than decorative: these builders are
+ * fed descriptors assembled from parsed OOXML, so a field typed `string` can
+ * still arrive `undefined` from a malformed deck. Coercing yields an inert
+ * `"undefined"` in the attribute instead of throwing partway through building
+ * a markup string, which is what one of the private copies already did and
+ * what the consolidated version must keep doing.
+ */
+export declare function escapeSvgAttr(value: string): string;
+/**
+ * Geometry context enabling the `a:outerShdw/@rotWithShape=false` correction
+ * in {@link getOuterShadowCss}: the element's own rotation, so the shadow
+ * angle can be counter-rotated to stay fixed in page space. Mirrors
+ * {@link GradientRenderContext} in `fill-style.ts`, which applies the same
+ * correction to `a:gradFill/@rotWithShape`.
+ */
+export interface ShadowRenderContext {
+    /** Element rotation in degrees (`PptxElementBase.rotation`). */
+    rotation?: number;
+}
+/**
+ * Build a CSS `box-shadow` value from the single outer-shadow properties on a
+ * {@link ShapeStyle}. Supports both angle/distance and direct x/y offset modes.
+ * Returns `undefined` when no shadow colour is defined.
+ *
+ * When `style.shadowRotateWithShape` is explicitly `false` (`a:outerShdw
+ * /@rotWithShape="0"`) and `context.rotation` is supplied, the shadow angle is
+ * counter-rotated by the element's own rotation so the shadow stays fixed in
+ * page space instead of spinning with the (CSS-transformed) shape - the same
+ * correction {@link adjustLinearGradientAngle} in `fill-style.ts` applies to
+ * `a:gradFill/@rotWithShape`. The default (`true`/unset) needs no correction:
+ * a `box-shadow` already rotates for free with the element's own `transform`.
+ */
+export declare function getOuterShadowCss(style: ShapeStyle | undefined, context?: ShadowRenderContext): string | undefined;
+/**
+ * Build pixel-composited outer shadows for images, text and groups.
+ *
+ * `box-shadow` follows the rectangular element box; PowerPoint shadows the
+ * already-composited pixels. CSS `drop-shadow()` has those semantics.
+ */
+export declare function getCompositeOuterShadowFilterCss(style: ShapeStyle | undefined, context?: ShadowRenderContext): string | undefined;
+/**
+ * Build a CSS `inset` `box-shadow` value from the inner-shadow properties on a
+ * {@link ShapeStyle}. Returns `undefined` when no inner-shadow colour is set.
+ */
+export declare function getInnerShadowCss(style: ShapeStyle | undefined): string | undefined;
+/**
+ * Build a comma-joined CSS `box-shadow` string for all layers in the `shadows`
+ * array (PowerPoint compound outer shadows). Returns `undefined` when empty.
+ */
+export declare function getMultiLayerShadowCss(style: ShapeStyle | undefined): string | undefined;
+/**
+ * Build a high-fidelity layered `box-shadow` for a glow effect (3 concentric
+ * shadows at increasing radius / decreasing opacity). This supplements the
+ * filter-based glow from {@link getEffectFilterCss}. Returns `undefined` when
+ * no glow is configured.
+ */
+export declare function getGlowBoxShadowCss(color: string | undefined, radius: number | undefined, opacity: number | undefined): string | undefined;
+/**
+ * Combine outer-shadow, multi-layer shadow, inner-shadow and (optionally) the
+ * layered glow into a single CSS `box-shadow` value, with the same precedence
+ * as the React `getShapeVisualStyle`:
+ *   multi-layer (if any) **else** single outer-shadow, then inner-shadow,
+ *   then layered glow.
+ *
+ * @returns A `box-shadow` value string, or `undefined` if nothing applies.
+ */
+export declare function getBoxShadowCss(style: ShapeStyle | undefined, options?: {
+    includeGlow?: boolean;
+}, context?: ShadowRenderContext): string | undefined;
+/** Alias of {@link getOuterShadowCss} (React `buildShadowCssFromShapeStyle`). */
+export declare const buildShadowCssFromShapeStyle: typeof getOuterShadowCss;
+/** Alias of {@link getInnerShadowCss} (React `buildInnerShadowCssFromShapeStyle`). */
+export declare const buildInnerShadowCssFromShapeStyle: typeof getInnerShadowCss;
+/** Alias of {@link getMultiLayerShadowCss} (React `buildMultiLayerShadowCss`). */
+export declare const buildMultiLayerShadowCss: typeof getMultiLayerShadowCss;
+/** Alias of {@link getGlowBoxShadowCss} (React `buildGlowBoxShadow`). */
+export declare const buildGlowBoxShadow: typeof getGlowBoxShadowCss;
+/** Resolved parameters for a line-level (`a:ln`) outer shadow. */
+export interface LineShadowParams {
+    offsetX: number;
+    offsetY: number;
+    blur: number;
+    color: string;
+    opacity: number;
+}
+/**
+ * Resolve the line-level shadow (`a:ln/a:effectLst/a:outerShdw`) parameters from
+ * a {@link ShapeStyle}, applying PowerPoint's defaults for any missing values.
+ * Returns `undefined` when no line shadow colour is defined, so callers can gate
+ * on it. Feeds both the CSS box-shadow ({@link getLineShadowCss}) and the SVG
+ * `feDropShadow` used to shadow connector strokes.
+ */
+export declare function getLineShadowParams(style: ShapeStyle | undefined): LineShadowParams | undefined;
+/**
+ * Build a CSS `box-shadow` value for a line-level shadow. Returns `undefined`
+ * when no line shadow is defined. Mirrors React's `buildLineShadowCss`.
+ */
+export declare function getLineShadowCss(style: ShapeStyle | undefined): string | undefined;
+/**
+ * Build a CSS `filter` value for a line-level glow (`a:ln/a:effectLst/a:glow`).
+ * Returns `undefined` when no line glow is defined. Mirrors React's
+ * `buildLineGlowFilter`.
+ */
+export declare function getLineGlowFilterCss(style: ShapeStyle | undefined): string | undefined;
+/** Alias of {@link getLineShadowCss} (React `buildLineShadowCss`). */
+export declare const buildLineShadowCss: typeof getLineShadowCss;
+/** Alias of {@link getLineGlowFilterCss} (React `buildLineGlowFilter`). */
+export declare const buildLineGlowFilter: typeof getLineGlowFilterCss;
+/**
+ * Map effect-DAG properties on a {@link ShapeStyle} to CSS `filter` functions.
+ * Ported verbatim from the React `getEffectDagCssFilter`. Returns `undefined`
+ * when no DAG filters apply.
+ *
+ * @param style     - The shape style carrying the `dag*` fields.
+ * @param elementId - Element ID, used only for the duotone `url(#…)` reference.
+ */
+export declare function getEffectDagCssFilter(style: ShapeStyle | undefined, elementId?: string): string | undefined;
+/**
+ * Legacy alias of {@link getEffectDagCssFilter}, preserved for the React
+ * `effect-dag-filters` shim.
+ */
+export declare const getEffectDagFilter: typeof getEffectDagCssFilter;
+/**
+ * Whether a {@link ShapeStyle} carries any active effect-DAG property. Useful
+ * for short-circuiting rendering logic when no DAG effects apply.
+ */
+export declare function hasEffectDagProperties(style: ShapeStyle | undefined): boolean;
+/**
+ * Build the CSS `filter` value for the "simple" effect path of a shape/image
+ * {@link ShapeStyle}: outer glow (`drop-shadow`), soft edges (`blur`),
+ * standalone blur (`blur`), and effect-DAG adjustments.
+ *
+ * Mirrors the `filterParts` assembly in the React `getShapeVisualStyle`.
+ * Returns `undefined` when no filter applies.
+ *
+ * @param style     - The shape style.
+ * @param elementId - Element ID, forwarded to the DAG duotone reference.
+ */
+export declare function getEffectFilterCss(style: ShapeStyle | undefined, elementId?: string): string | undefined;
+/** Extract CSS `opacity` (0–1) from `dagAlphaModFix`, or `undefined`. */
+export declare function getEffectDagOpacity(style: ShapeStyle | undefined): number | undefined;
+/** Map `dagFillOverlayBlend` to a CSS `mix-blend-mode`, or `undefined`. */
+export declare function getEffectDagBlendMode(blend: ShapeStyle['dagFillOverlayBlend']): string | undefined;
+/**
+ * A fill-overlay tint layer: the overlay {@link https://developer.mozilla.org/en-US/docs/Web/CSS/color colour}
+ * (an `rgba()` string carrying the overlay's alpha) plus the `mix-blend-mode`
+ * used to composite it over the element. Unlike the whole-element
+ * {@link getEffectDagBlendMode} proxy, this describes a *separate* coloured
+ * layer the integrator should paint on top of the element (e.g. an absolutely
+ * positioned pseudo-element / child), so the tint colour is actually rendered.
+ */
+export interface FillOverlayCss {
+    /** Overlay colour as an `rgba()`/hex string (already includes opacity). */
+    color: string;
+    /** `mix-blend-mode` for the overlay layer (`normal` for the `over` blend). */
+    blendMode: string;
+}
+/**
+ * Resolve the DAG fill-overlay tint layer from a {@link ShapeStyle}. Returns
+ * `undefined` when no overlay colour was parsed. The `over` blend maps to
+ * `normal` (an opaque tint), the others to their `mix-blend-mode` equivalents.
+ */
+export declare function getEffectDagFillOverlay(style: ShapeStyle | undefined): FillOverlayCss | undefined;
+/**
+ * Resolve a DIRECT `a:effectLst/a:fillOverlay` (D1-G3: CT_EffectList
+ * §20.1.8.24 lists it as a legal sibling of shadow/glow/blur, not only inside
+ * `a:effectDag`) into the same {@link FillOverlayCss} shape as
+ * {@link getEffectDagFillOverlay}, so both render through one integrator path.
+ * Kept in separate `shapeFillOverlay*` fields (see `ShapeStyle`) since the two
+ * forms come from different XML locations and could theoretically both be
+ * present.
+ */
+export declare function getShapeFillOverlay(style: ShapeStyle | undefined): FillOverlayCss | undefined;
+/** Stable SVG filter id for a DAG duotone effect on a given element. */
+export declare function getDuotoneFilterId(elementId: string): string;
+/**
+ * A high-fidelity SVG `<filter>` definition: the filter `id`, a `filter:
+ * url(#id)` reference for callers, and the `<filter>` markup to inject into a
+ * `<defs>` (or a standalone hidden `<svg>`). Optional/secondary to the CSS
+ * path.
+ */
+export interface SvgFilterDefinition {
+    /** The `<filter>` element id. */
+    id: string;
+    /** A ready-to-use `filter: url(#id)` CSS reference. */
+    cssReference: string;
+    /** The `<filter>…</filter>` markup (no wrapping `<svg>`/`<defs>`). */
+    filterMarkup: string;
+}
+/**
+ * Build the duotone `<filter>` markup (BT.709 grayscale → linear ramp between
+ * two colours) for the high-fidelity DAG path. Returns `undefined` when the
+ * style has no `dagDuotone`.
+ *
+ * Inject `filterMarkup` once into an SVG `<defs>` and apply `cssReference` as
+ * the element's `filter` (or append it to {@link getEffectFilterCss}'s result).
+ */
+export declare function getDuotoneSvgFilter(style: ShapeStyle | undefined, elementId: string): SvgFilterDefinition | undefined;
+/** Stable SVG filter id for a soft-edge feather on a given element. */
+export declare function getSoftEdgeFilterId(elementId: string): string;
+/**
+ * Build the soft-edge `<filter>` markup that feathers only the shape's alpha
+ * edge, leaving the interior fill/text sharp. It erodes `SourceAlpha` inward
+ * (matching PowerPoint's own soft-edge distance, see
+ * {@link SOFT_EDGE_ERODE_FACTOR}), blurs that eroded alpha, and composites
+ * the original `SourceGraphic` back *into* the result (`operator="in"`), so
+ * the boundary fades from transparent (at the authored edge) to opaque
+ * (further inward) while interior pixels keep full opacity and no blur.
+ *
+ * Inject `filterMarkup` once into an SVG `<defs>` (or a hidden `<svg>`) and
+ * apply `cssReference` (already emitted by {@link getEffectFilterCss} when an
+ * element id is supplied). Returns `undefined` when no soft edge is configured.
+ */
+export declare function getSoftEdgeSvgFilter(style: ShapeStyle | undefined, elementId: string): SvgFilterDefinition | undefined;
+/**
+ * Build a self-contained, hidden `<svg>` wrapper containing a duotone
+ * `<filter>` (BT.709 grayscale → linear two-colour ramp), suitable for direct
+ * injection into the DOM in non-React contexts (tests, SSR, string templates).
+ *
+ * Unlike {@link getDuotoneSvgFilter} (which returns just the `<filter>` markup),
+ * this wraps the filter in `<svg width="0" height="0" …>` so the returned
+ * string can be inserted as-is. Mirrors React's `getDuotoneSvgFilterMarkup`.
+ *
+ * @param filterId - The `<filter>` element id.
+ * @param color1   - Shadow colour (hex).
+ * @param color2   - Highlight colour (hex).
+ */
+export declare function getDuotoneSvgFilterMarkup(filterId: string, color1: string, color2: string): string;
+/**
+ * The full set of CSS effect properties for a shape/image element, ready to be
+ * spread onto a Vue `CSSProperties`-style object by the integrator. Every field
+ * is optional and omitted when the corresponding effect is absent.
+ */
+export interface ComputedEffectStyle {
+    /** Combined outer/inner/multi-layer/glow `box-shadow`. */
+    boxShadow?: string;
+    /** Combined glow/soft-edge/blur/DAG `filter`. */
+    filter?: string;
+    /**
+     * Reflection wrapper style (see `reflection.ts`'s `getReflectionWrapperStyle`)
+     * for a mirrored sibling node the integrator renders just below the
+     * element, painted with the SAME resolved fill/image content. Cross-browser
+     * (unlike the `-webkit-box-reflect` this replaced), and expresses
+     * `@sx`/`@sy`/`@kx`/`@ky`/`@rot`/`@fadeDir`/`@algn`.
+     */
+    reflection?: ReflectionWrapperStyle;
+    /** Overall `opacity` from `dagAlphaModFix`. */
+    opacity?: number;
+    /**
+     * `mix-blend-mode` from `dagFillOverlayBlend`. Only emitted for the legacy
+     * blend-only case (no overlay colour parsed); when {@link fillOverlay} is
+     * present the blend rides on that overlay layer instead.
+     */
+    mixBlendMode?: string;
+    /**
+     * DAG fill-overlay tint layer (colour + blend mode). The integrator should
+     * paint this as a separate blended layer over the element (an absolutely
+     * positioned pseudo-element / child), rather than blending the whole element.
+     */
+    fillOverlay?: FillOverlayCss;
+    /**
+     * `true` when a blur effect has `@grow` set: the element must render with
+     * `overflow: visible` (and ideally grown bounds) so the blur halo is not
+     * clipped at the element box.
+     */
+    overflowVisible?: boolean;
+}
+/**
+ * Compute every CSS effect property for an element in one call. The element is
+ * used to read `shapeStyle`, the element id (for DAG filter refs), and the
+ * height (for reflection fade length). Image effects (`imageEffects`) are NOT
+ * handled here  -  see {@link hasImageEffects} and the React `image-effects` /
+ * `shape-visual-effects` modules (deferred, see return notes).
+ *
+ * @returns A {@link ComputedEffectStyle}; all-undefined when no effects apply.
+ */
+/**
+ * The `ShapeStyle` {@link getComputedEffectStyle} reads effects from: a shape
+ * / image / text / connector's own `shapeStyle`, or a group's
+ * `groupEffectStyle` (the SAME `p:grpSpPr` extraction, kept for shadow / glow
+ * / soft-edge / reflection even when the group has no fill of its own - see
+ * that field's doc on `GroupPptxElement`).
+ *
+ * Exported so a binding's soft-edge `<filter>` injection - which needs the
+ * raw `ShapeStyle` to call {@link getSoftEdgeSvgFilter}, not just the
+ * aggregated `ComputedEffectStyle` - can find the exact same style
+ * `getComputedEffectStyle` used, for a group as much as for a shape. Every
+ * binding had its own copy of the `hasShapeProperties(...) ? el.shapeStyle :
+ * undefined` ternary and none of them accounted for a group, which is why a
+ * group's own `a:softEdge` filter reference resolved to nothing.
+ */
+export declare function getEffectStyleSource(element: PptxElement): ShapeStyle | undefined;
+export declare function getComputedEffectStyle(element: PptxElement, options?: {
+    includeGlowBoxShadow?: boolean;
+}): ComputedEffectStyle;
+/** Whether an element carries any (recolour/artistic) image effects. */
+export declare function hasImageEffects(element: PptxElement): boolean;
+//# sourceMappingURL=visual-effects.d.ts.map

package/dist/pptx/render/visual-effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visual-effects.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/visual-effects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAI/D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAQ3D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMnD;AAiDD;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IACnC,gEAAgE;IAChE,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAChC,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,OAAO,CAAC,EAAE,mBAAmB,GAC3B,MAAM,GAAG,SAAS,CA6DpB;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAC/C,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,OAAO,CAAC,EAAE,mBAAmB,GAC3B,MAAM,GAAG,SAAS,CA6EpB;AAuBD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAyBnF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAmBxF;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,MAAM,GAAG,SAAS,GACzB,MAAM,GAAG,SAAS,CAepB;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,EACvC,OAAO,CAAC,EAAE,mBAAmB,GAC3B,MAAM,GAAG,SAAS,CA6BpB;AAOD,iFAAiF;AACjF,eAAO,MAAM,4BAA4B,0BAAoB,CAAC;AAC9D,sFAAsF;AACtF,eAAO,MAAM,iCAAiC,0BAAoB,CAAC;AACnE,kFAAkF;AAClF,eAAO,MAAM,wBAAwB,+BAAyB,CAAC;AAC/D,yEAAyE;AACzE,eAAO,MAAM,kBAAkB,4BAAsB,CAAC;AAItD,kEAAkE;AAClE,MAAM,WAAW,gBAAgB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,gBAAgB,GAAG,SAAS,CAc/F;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAQlF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAWtF;AAED,sEAAsE;AACtE,eAAO,MAAM,kBAAkB,yBAAmB,CAAC;AACnD,2EAA2E;AAC3E,eAAO,MAAM,mBAAmB,6BAAuB,CAAC;AAIxD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,SAAS,CAAC,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAoDpB;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,8BAAwB,CAAC;AAExD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAmB7E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,SAAS,CAAC,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CA4CpB;AAID,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAKrF;AAED,2EAA2E;AAC3E,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,UAAU,CAAC,qBAAqB,CAAC,GACtC,MAAM,GAAG,SAAS,CAapB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC9B,2EAA2E;IAC3E,KAAK,EAAE,MAAM,CAAC;IACd,8EAA8E;IAC9E,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,cAAc,GAAG,SAAS,CAUjG;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,cAAc,GAAG,SAAS,CAU7F;AAID,wEAAwE;AACxE,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IACnC,iCAAiC;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,uDAAuD;IACvD,YAAY,EAAE,MAAM,CAAC;IACrB,sEAAsE;IACtE,YAAY,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,GACf,mBAAmB,GAAG,SAAS,CA6BjC;AAID,uEAAuE;AACvE,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE7D;AA+BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,GACf,mBAAmB,GAAG,SAAS,CAgBjC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACxC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACZ,MAAM,CA2BR;AAID;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IACnC,0DAA0D;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,sBAAsB,CAAC;IACpC,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,WAAW,CAAC,EAAE,cAAc,CAAC;IAC7B;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,WAAW,GAAG,UAAU,GAAG,SAAS,CAKjF;AAED,wBAAgB,sBAAsB,CACrC,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE;IAAE,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9C,mBAAmB,CAiGrB;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAE7D"}

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