ooxml-ui 0.30.1 → 0.31.0

package/dist/pptx/render/shape-adjustment.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Shape-adjustment handles: PowerPoint's yellow `a:avLst` diamonds. Pure,
+ * framework-agnostic math shared by all five bindings.
+ *
+ * Owns the adjustment scalar constants and the handle/drag descriptor types so
+ * each binding consumes one copy rather than re-declaring them.
+ *
+ * A preset has ONE handle per adjustable parameter and many presets have
+ * several (`callout3` has eight), so the entry point is
+ * {@link getShapeAdjustmentHandleDescriptors}, returning an array. Placement and
+ * drag scale are measured off the preset geometry by
+ * `shape-adjustment-handles`; this module is the element-level policy around
+ * it (lock check, element type, custom geometry) plus the round-rect helpers
+ * the renderers use for `border-radius`.
+ */
+import type { PptxElement, PptxElementWithShapeStyle } from 'ooxml-core/pptx';
+import type { AdjustmentAxisSolver } from './shape-adjustment-model.js';
+export declare const SHAPE_ADJUSTMENT_MIN = 0;
+export declare const SHAPE_ADJUSTMENT_MAX = 50000;
+export declare const DEFAULT_ROUND_RECT_ADJUSTMENT = 16667;
+/** Descriptor for one draggable adjustment handle (the amber diamond). */
+export interface ShapeAdjustmentHandleDescriptor {
+    /** The `a:avLst` guide name this handle writes (`adj`, `adj1`, ...). */
+    key: string;
+    /** Handle x offset in element-local px (origin = element top-left). */
+    left: number;
+    /** Handle y offset in element-local px. */
+    top: number;
+    /**
+     * Current adjustment value in GUIDE units, not a 0-1 fraction. Most presets
+     * range 0..50000 or 0..100000 and the angular ones run to 21,600,000.
+     */
+    value: number;
+    cursor: string;
+    /**
+     * How this handle's drag resolves, measured off the preset geometry: one
+     * entry per `a:avLst` guide it drives (callouts drive two). Absent only for
+     * a caller that built a descriptor by hand.
+     */
+    solvers?: AdjustmentAxisSolver[];
+}
+/** Live drag state captured when an adjustment gesture starts. */
+export interface ShapeAdjustmentDragState {
+    elementId: string;
+    key: string;
+    shapeType: string;
+    startClientX: number;
+    startClientY: number;
+    startAdjustment: number;
+    startWidth: number;
+    startHeight: number;
+    moved: boolean;
+    /** Copied from the descriptor the gesture started on. */
+    solvers?: AdjustmentAxisSolver[];
+    /**
+     * The element's whole `a:avLst` map at gesture start.
+     *
+     * A binding writes `shapeAdjustments` as one object, so a drag that sent
+     * only the guide it changed would DELETE every other authored adjustment on
+     * a multi-adjust preset (a `quadArrow` would lose two of its three the first
+     * time one was touched).
+     */
+    startAdjustments?: Record<string, number>;
+}
+export declare function clampShapeAdjustmentValue(value: number): number;
+export declare function getRoundRectAdjustmentValue(element: PptxElementWithShapeStyle): number;
+export declare function getRoundRectRadiusPx(element: PptxElementWithShapeStyle): number;
+/**
+ * Every adjustment handle `element` offers, in `a:avLst`/`a:ahLst`
+ * declaration order.
+ *
+ * A `a:custGeom` shape with its own `a:ahXY`/`a:ahPolar` gets its handles from
+ * {@link deriveCustomGeometryAdjustmentHandles} (evaluated off its OWN
+ * `a:gdLst`, not the preset table, which would describe geometry nobody
+ * paints for a freeform shape); a preset shape gets them from
+ * `derivePresetAdjustmentHandles`. Empty when neither applies, or when the
+ * element's `a:spLocks/@noAdjustHandles` forbids the affordance. The lock
+ * check lives HERE rather than at each binding's overlay, so a locked shape
+ * hides its amber diamonds in all five without five separate guards.
+ */
+export declare function getShapeAdjustmentHandleDescriptors(element: PptxElement): ShapeAdjustmentHandleDescriptor[];
+/**
+ * The FIRST adjustment handle for `element`, or `null`.
+ *
+ * Kept for callers that only ever showed one diamond; new view code should
+ * render {@link getShapeAdjustmentHandleDescriptors} so a preset with several
+ * adjustable parameters offers all of them.
+ */
+export declare function getShapeAdjustmentHandleDescriptor(element: PptxElement): ShapeAdjustmentHandleDescriptor | null;
+/**
+ * New adjustment value for a pointer delta (element px) from the gesture start.
+ *
+ * `deltaY` matters for every handle that does not travel horizontally (the
+ * vertical arm of a `quadArrow`, a callout's leader line, the swing of a `pie`
+ * wedge); it defaults to 0 so a caller that only tracks horizontal travel keeps
+ * working.
+ */
+export declare function getDraggedShapeAdjustmentValue(state: ShapeAdjustmentDragState, deltaX: number, deltaY?: number): number;
+/**
+ * The whole `shapeAdjustments` map to write for a drag delta (element px).
+ *
+ * This is what a binding should write, not a single value: a callout handle
+ * drives two guides at once (so resolving only
+ * {@link getDraggedShapeAdjustmentValue} would move its leader line
+ * horizontally and never vertically), and the result carries the element's
+ * other adjustments forward so writing it cannot drop them.
+ */
+export declare function getDraggedShapeAdjustments(state: ShapeAdjustmentDragState, deltaX: number, deltaY?: number): Record<string, number>;
+/**
+ * Capture the drag state for an adjustment gesture starting on `descriptor`.
+ *
+ * Shared so no binding has to remember to copy the solver across (and so none
+ * repeats the `shapeType` lower-casing that used to be needed).
+ */
+export declare function beginShapeAdjustment(element: PptxElement, descriptor: ShapeAdjustmentHandleDescriptor, clientX: number, clientY: number): ShapeAdjustmentDragState;
+//# sourceMappingURL=shape-adjustment.d.ts.map

package/dist/pptx/render/shape-adjustment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-adjustment.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/shape-adjustment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAM9E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAIrE,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,eAAO,MAAM,oBAAoB,QAAQ,CAAC;AAC1C,eAAO,MAAM,6BAA6B,QAAQ,CAAC;AAEnD,0EAA0E;AAC1E,MAAM,WAAW,+BAA+B;IAC/C,wEAAwE;IACxE,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,OAAO,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACjC;AAED,kEAAkE;AAClE,MAAM,WAAW,wBAAwB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,yDAAyD;IACzD,OAAO,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACjC;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,yBAAyB,GAAG,MAAM,CAMtF;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,yBAAyB,GAAG,MAAM,CAK/E;AA4BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mCAAmC,CAClD,OAAO,EAAE,WAAW,GAClB,+BAA+B,EAAE,CAqBnC;AAED;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CACjD,OAAO,EAAE,WAAW,GAClB,+BAA+B,GAAG,IAAI,CAExC;AAED;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC7C,KAAK,EAAE,wBAAwB,EAC/B,MAAM,EAAE,MAAM,EACd,MAAM,SAAI,GACR,MAAM,CAkBR;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACzC,KAAK,EAAE,wBAAwB,EAC/B,MAAM,EAAE,MAAM,EACd,MAAM,SAAI,GACR,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWxB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE,+BAA+B,EAC3C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACb,wBAAwB,CAe1B"}

package/dist/pptx/render/shape-autofit-resize.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Editor-time resize for `a:spAutoFit` ("Resize shape to fit text").
+ *
+ * ECMA-376 gives autofit two, mutually exclusive jobs: `a:normAutofit`
+ * shrinks the TEXT to fit the shape (`fontScale` / `lnSpcReduction`, see
+ * `computeAutoFitTextStyle` in `text-style-helpers.ts`); `a:spAutoFit` grows
+ * or shrinks the SHAPE to fit the text, never the font. `computeAutoFitTextStyle`
+ * deliberately applies no font override for `spAutoFit` because an authored
+ * deck's `a:ext` is already the box PowerPoint sized to fit - but that
+ * assumption only holds for a shape nobody has touched since. The moment a
+ * user types into a `spAutoFit` box in this editor, something has to keep it
+ * true by resizing the box itself; this module is that something.
+ *
+ * Three pieces:
+ * - {@link measureAutoFitContentHeightPx}: the one DOM-touching step, shared
+ *   because it needs no framework, only the DOM API. It clones the live
+ *   contentEditable node into an off-screen, `height: auto` copy at the
+ *   shape's current width, so the reported height is the text's natural
+ *   extent rather than the box's own (possibly stale) height. A plain
+ *   `el.scrollHeight` read cannot tell "text now fits in less space" apart
+ *   from "box unchanged": with the box's own height still imposed via CSS
+ *   (flex vertical anchoring, `height: 100%`), `scrollHeight` on a
+ *   shorter-than-before body still reports the box's old height, so autofit
+ *   would only ever grow, never shrink.
+ * - {@link computeAutoFitShapeHeightPx}: the pure decision the measured number
+ *   feeds into.
+ * - {@link resolveInlineEditAutoFitHeight}: the two composed into the one call
+ *   every binding's inline-text-editor commit handler makes. Each handler
+ *   queries its own still-mounted `[data-inline-editor]` DOM node (the exact
+ *   query is left to the binding since the timing of "still mounted" differs
+ *   slightly framework to framework) and passes it in here along with the
+ *   element's text style and current height; the result is written onto the
+ *   element's `height` (model px, the same unit `PptxElement.width/height`
+ *   already use) via the binding's normal update path - which is also what
+ *   makes the resize survive to disk: core's save pipeline serializes
+ *   `height` to `a:ext/@cy` exactly as it does for a drag-resize.
+ */
+import type { TextStyle } from 'ooxml-core/pptx';
+/** Input for {@link computeAutoFitShapeHeightPx}. */
+export interface AutoFitShapeResizeInput {
+    /** `a:bodyPr` autofit mode; only `'shrink'` (`a:spAutoFit`) resizes the shape. */
+    autoFitMode: TextStyle['autoFitMode'] | undefined;
+    /**
+     * The text body's natural content height in px, insets included (from
+     * {@link measureAutoFitContentHeightPx}).
+     */
+    measuredContentHeightPx: number;
+    /** The shape's current height in px (`element.height`, model units). */
+    currentHeightPx: number;
+}
+/**
+ * Below this, PowerPoint's "Resize shape to fit text" never shrinks a box
+ * further: a completely empty spAutoFit text box still reserves room for one
+ * line plus its insets. Reusing the shared drag-resize floor keeps this
+ * consistent with every other resize path rather than inventing a second
+ * minimum.
+ */
+export declare const AUTOFIT_MIN_SHAPE_HEIGHT_PX = 12;
+/**
+ * Decide the new shape height for a `spAutoFit` text box after an edit, or
+ * `undefined` when no resize is needed (autofit isn't `'shrink'`, there is no
+ * usable measurement, or the required height did not meaningfully change).
+ *
+ * Pure: takes plain numbers, so it is trivially the same across all five
+ * bindings and unit-testable without a DOM.
+ */
+export declare function computeAutoFitShapeHeightPx(input: AutoFitShapeResizeInput): number | undefined;
+/**
+ * Measure `el`'s natural content height in px at a fixed width, independent
+ * of whatever height the live element currently has imposed on it (flex
+ * vertical anchoring, an explicit `height: 100%`, etc.).
+ *
+ * Clones `el` (so the exact rendered runs/bullets/columns are measured, not
+ * an approximation), pins the clone off-screen at `widthPx` with
+ * `height: auto`, reads `scrollHeight`, then discards the clone. Safe to call
+ * from any binding's commit handler; it never touches the live, still-focused
+ * editor node.
+ *
+ * `el` may be a plain `<textarea>` (Angular's editor) instead of a
+ * contentEditable div: `cloneNode` copies a textarea's default value (its
+ * original `value` attribute), not the live `.value` the user has been typing
+ * into, so a textarea's current value is copied onto the clone explicitly.
+ *
+ * Returns `0` outside a DOM environment (SSR / non-browser test) so a caller
+ * can treat that as "no measurement available" without special-casing it.
+ */
+export declare function measureAutoFitContentHeightPx(el: HTMLElement, widthPx: number): number;
+/**
+ * The one call every binding's inline-text-editor commit handler makes:
+ * measure `editorEl` (when present) and decide the shape's new height.
+ *
+ * `editorEl` is `null` when the binding could not find its still-mounted
+ * editor node (or never had one, e.g. committing with nothing selected); this
+ * returns `undefined` in that case without measuring, exactly as it does when
+ * the measurement or the mode says no resize is needed.
+ */
+export declare function resolveInlineEditAutoFitHeight(textStyle: TextStyle | undefined, currentHeightPx: number, editorEl: HTMLElement | null): number | undefined;
+//# sourceMappingURL=shape-autofit-resize.d.ts.map

package/dist/pptx/render/shape-autofit-resize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-autofit-resize.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/shape-autofit-resize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,qDAAqD;AACrD,MAAM,WAAW,uBAAuB;IACvC,kFAAkF;IAClF,WAAW,EAAE,SAAS,CAAC,aAAa,CAAC,GAAG,SAAS,CAAC;IAClD;;;OAGG;IACH,uBAAuB,EAAE,MAAM,CAAC;IAChC,wEAAwE;IACxE,eAAe,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,KAAmB,CAAC;AAS5D;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,uBAAuB,GAAG,MAAM,GAAG,SAAS,CAY9F;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,6BAA6B,CAAC,EAAE,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CA2BtF;AAED;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAC7C,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,WAAW,GAAG,IAAI,GAC1B,MAAM,GAAG,SAAS,CAUpB"}

package/dist/pptx/render/shape-geometry-cascade.d.ts

@@ -0,0 +1,72 @@
+/**
+ * `shape-geometry-cascade`: the single source of truth for HOW a shape's
+ * geometry is painted.
+ *
+ * Every binding resolves fill, stroke, effects and 3D through shared modules
+ * already, then ends with the same ~40-line decision tree: connector ->
+ * stroke-only preset -> roundRect -> ellipse -> clip-path -> line -> cylinder.
+ * That tail was hand-ported five times, and the copies drifted:
+ *
+ *  - Angular compared `shapeType` RAW (`=== 'ellipse' || === 'circle'`) instead
+ *    of normalising it, so `oval` - a preset offered in the shape picker - and
+ *    any capitalised spelling missed the ellipse branch entirely.
+ *  - Angular had no connector, line or cylinder branch at all, so a cylinder
+ *    fell through to a clip-path instead of its `48% / 12%` radius.
+ *  - Two fidelity fixes in one day (ellipse pill radius, identity-rect clip)
+ *    each had to be applied four and five times respectively.
+ *
+ * This module returns a framework-neutral DECISION; each binding only maps that
+ * decision onto its own style-object shape (`React.CSSProperties`, a kebab-case
+ * record, etc). Adding a branch here reaches all five bindings at once.
+ *
+ * @module render/shape-geometry-cascade
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+/**
+ * What the geometry cascade decided to do with a shape's box.
+ *
+ * `bare` and `strokeOnly` both mean "paint no box"; they differ only in that a
+ * stroke-only preset must also drop any background IMAGE, because its fill was
+ * resolved before the cascade ran.
+ */
+export type ShapeGeometryDecision = 
+/** Connector: the SVG renderer paints it; the box itself is empty. */
+{
+    readonly kind: 'bare';
+}
+/** Open preset (line, arc, connector family): outline is stroked as SVG. */
+ | {
+    readonly kind: 'strokeOnly';
+}
+/** roundRect / ellipse / cylinder: a CSS `border-radius` approximation. */
+ | {
+    readonly kind: 'borderRadius';
+    readonly radius: string;
+}
+/** Any other preset with real geometry: a CSS `clip-path`. */
+ | {
+    readonly kind: 'clipPath';
+    readonly clipPath: string;
+}
+/** A `line` preset the evaluator could not open: draw its top edge only. */
+ | {
+    readonly kind: 'lineEdge';
+    readonly strokeWidth: number;
+}
+/** Plain rectangle (or nothing to do): leave the box alone. */
+ | {
+    readonly kind: 'none';
+};
+/**
+ * Resolve a shape element's geometry to a neutral painting decision.
+ *
+ * Order is load-bearing and matches PowerPoint's own precedence: connectors and
+ * open presets never get a box, the two cheap radius approximations win over a
+ * clip-path, and `line`/`cylinder` are consulted only once the evaluator has
+ * declined to produce geometry.
+ *
+ * @param element The shape-like element to resolve.
+ * @returns The decision a binding should apply to its style object.
+ */
+export declare function resolveShapeGeometry(element: PptxElement): ShapeGeometryDecision;
+//# sourceMappingURL=shape-geometry-cascade.d.ts.map

package/dist/pptx/render/shape-geometry-cascade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-geometry-cascade.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/shape-geometry-cascade.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAMnD;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB;AAChC,sEAAsE;AACpE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAC3B,4EAA4E;GAC1E;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;CAAE;AACjC,2EAA2E;GACzE;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AAC5D,8DAA8D;GAC5D;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE;AAC1D,4EAA4E;GAC1E;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAAE;AAC7D,+DAA+D;GAC7D;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAQ7B;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,WAAW,GAAG,qBAAqB,CA4ChF"}

package/dist/pptx/render/shape-geometry.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Shape geometry helpers  -  Vue port of the React package's
+ * `viewer/utils/resolved-shape-clip-path.ts` cascade.
+ *
+ * All the heavy lifting (the ECMA-376 preset evaluator, the adjustment-aware
+ * table, the cubic-Bezier cloud paths, and the static preset clip-path table)
+ * already lives in `ooxml-core/pptx` and is framework-agnostic, so  -  unlike
+ * the React package, which keeps a local polygon fallback  -  the Vue binding
+ * imports those entry points directly. No `pptx-viewer-shared` extraction is
+ * required here.
+ *
+ * The resolution priority mirrors React exactly:
+ *
+ *   1. **Adjustment-aware**  -  when `shapeAdjustments` exist, consult
+ *      {@link getAdjustmentAwareClipPath} so `pie`, `arc`, `donut`,
+ *      `blockArc`, and wedge callouts respond to their adjustment values.
+ *   2. **Spec-correct preset evaluator**  -  {@link getShapeClipPathFromPreset}
+ *      produces a `path('…')` clip-path for any shape in the preset table.
+ *   3. **Cloud Bezier path**  -  {@link getCloudPathForRendering} for
+ *      `cloud` / `cloudCallout`.
+ *   4. **Static preset table**  -  {@link getShapeClipPath} as the final
+ *      fallback (core's comprehensive `PRESET_SHAPE_CLIP_PATHS`).
+ *
+ * Step 1 deliberately calls the DYNAMIC-only entry point
+ * ({@link getAdjustmentAwareClipPath}) rather than core's
+ * `getAdjustmentAwareShapeClipPath` wrapper. That wrapper falls back to the
+ * static, adjustment-BLIND polygon table whenever a shape is outside its
+ * 14-shape dynamic set, and returning that at step 1 swallowed the whole rest
+ * of the cascade: every preset carrying an authored `a:avLst` adjustment
+ * (parallelogram, trapezoid, teardrop, notchedRightArrow, round2SameRect, the
+ * arrows…) was clipped with its DEFAULT adjustment instead of its own. A
+ * parallelogram authored at `adj="84929"`  -  a thin diagonal band  -  rendered as
+ * the 25000-default polygon covering ~80% of its box and occluded the text
+ * behind it (issue #132).
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+/**
+ * Resolve the best available CSS `clip-path` value for a shape type at a given
+ * pixel size. Implements the priority cascade described in the module
+ * docstring. Returns `undefined` when the shape needs no clipping.
+ *
+ * @param shapeType   The OOXML preset geometry name (case-insensitive).
+ * @param width       Element width in pixels (must be > 0 for path output).
+ * @param height      Element height in pixels (must be > 0 for path output).
+ * @param adjustments Optional `shapeAdjustments` record from the element.
+ */
+export declare function getResolvedShapeClipPathFor(shapeType: string | undefined, width: number, height: number, adjustments?: Record<string, number>): string | undefined;
+/**
+ * Build a CSS `clip-path: path('…')` value from a custom-geometry (`a:custGeom`)
+ * SVG path string, rescaling its path-space coordinates (`pathWidth` x
+ * `pathHeight`) into the element's pixel box.
+ *
+ * CSS `path()` coordinates live in the element's own border-box pixel space
+ * (there is no viewBox), so freeform coordinates authored against the OOXML path
+ * extent must be scaled by `elemW / pathWidth` and `elemH / pathHeight`. Every
+ * binding already clips its shape container's background fill with the resolved
+ * clip-path, so returning one here lets a themed freeform (e.g. the "Balloons"
+ * background) render as its true outline instead of flooding its bounding box.
+ *
+ * Supports the absolute command set produced by the core geometry engine
+ * (M/L/C/Q/Z) plus elliptical arcs (A); unknown commands are passed through
+ * unscaled rather than dropped.
+ */
+export declare function buildCustomGeometryClipPath(pathData: string, pathWidth: number, pathHeight: number, elemWidth: number, elemHeight: number): string | undefined;
+/**
+ * Element-level convenience wrapper. Pulls `shapeType`, `width`, `height`, and
+ * `shapeAdjustments` off a {@link PptxElement} and delegates to
+ * {@link getResolvedShapeClipPathFor}.
+ *
+ * Custom-geometry freeforms (which carry `pathData`/`pathWidth`/`pathHeight`
+ * rather than a preset `shapeType`) take priority: their outline is rescaled
+ * into the element box via {@link buildCustomGeometryClipPath} so the fill clips
+ * to the real shape instead of its bounding rectangle.
+ *
+ * @param element The PPTX element to resolve a clip-path for.
+ * @param width   Optional width override (pixels). Defaults to `element.width`.
+ * @param height  Optional height override (pixels). Defaults to `element.height`.
+ */
+export declare function getResolvedShapeClipPath(element: PptxElement, width?: number, height?: number): string | undefined;
+/**
+ * Whether `element`'s resolved clip-path would be its own bounding rectangle,
+ * i.e. a clip that paints identically but suppresses overflow. Custom-geometry
+ * freeforms are never identity clips: their `pathData` outline is the point.
+ *
+ * @param element The element whose clip-path is being resolved.
+ * @returns `true` when the clip can be skipped so overflow stays visible.
+ */
+export declare function isIdentityRectClip(element: PptxElement): boolean;
+//# sourceMappingURL=shape-geometry.d.ts.map

package/dist/pptx/render/shape-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-geometry.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/shape-geometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAUnD;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CAC1C,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,MAAM,GAAG,SAAS,CAmCpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,2BAA2B,CAC1C,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAuDpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CACvC,OAAO,EAAE,WAAW,EACpB,KAAK,CAAC,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,GACb,MAAM,GAAG,SAAS,CA0BpB;AAgBD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAOhE"}

package/dist/pptx/render/shape-preset-catalog.d.ts

@@ -0,0 +1,35 @@
+/**
+ * shape-preset-catalog.ts: the Insert > Shape picker catalogue shared by every
+ * binding's toolbar/inspector.
+ *
+ * Pure data: each entry carries the preset geometry `type` (OOXML `a:prstGeom`
+ * value the editor can insert), an English fallback `label`, the shared-i18n
+ * `i18nKey`, and a framework-neutral icon descriptor ({@link ShapePresetGlyph}
+ * name + optional utility-class modifier for rotation/skew). Each binding maps
+ * the glyph name onto its own icon component/SVG.
+ *
+ * Order matters: bindings surface the first 12 entries as the quick "top
+ * shapes" row, so new presets should be appended, not inserted.
+ *
+ * @module render/shape-preset-catalog
+ */
+/** Shape preset geometry types offered by the insert picker. */
+export type ShapePresetType = 'rect' | 'roundRect' | 'ellipse' | 'cylinder' | 'rtArrow' | 'leftArrow' | 'upArrow' | 'downArrow' | 'triangle' | 'rtTriangle' | 'diamond' | 'parallelogram' | 'trapezoid' | 'pentagon' | 'hexagon' | 'octagon' | 'chevron' | 'star5' | 'star6' | 'star8' | 'plus' | 'heart' | 'cloud' | 'sun' | 'moon' | 'pie' | 'plaque' | 'teardrop' | 'line' | 'connector';
+/** Framework-neutral glyph names each binding maps to its own icon set. */
+export type ShapePresetGlyph = 'square' | 'circle' | 'database' | 'diamond' | 'minus' | 'moveRight' | 'plus' | 'triangle';
+/** One entry of the Insert > Shape picker catalogue. */
+export interface ShapePresetDef {
+    /** Preset geometry inserted when picked (OOXML `a:prstGeom` value). */
+    type: ShapePresetType;
+    /** English fallback label (render sites may prefer `t(i18nKey)`). */
+    label: string;
+    /** Shared-i18n dictionary key for the label. */
+    i18nKey: string;
+    /** Neutral icon glyph name (see {@link ShapePresetGlyph}). */
+    glyph: ShapePresetGlyph;
+    /** Extra utility classes for the glyph (rotation/skew); `''` when none. */
+    glyphClass: string;
+}
+/** The Insert > Shape picker catalogue (see module docs for ordering rules). */
+export declare const SHAPE_PRESET_DEFS: readonly ShapePresetDef[];
+//# sourceMappingURL=shape-preset-catalog.d.ts.map

package/dist/pptx/render/shape-preset-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-preset-catalog.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/shape-preset-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,gEAAgE;AAChE,MAAM,MAAM,eAAe,GACxB,MAAM,GACN,WAAW,GACX,SAAS,GACT,UAAU,GACV,SAAS,GACT,WAAW,GACX,SAAS,GACT,WAAW,GACX,UAAU,GACV,YAAY,GACZ,SAAS,GACT,eAAe,GACf,WAAW,GACX,UAAU,GACV,SAAS,GACT,SAAS,GACT,SAAS,GACT,OAAO,GACP,OAAO,GACP,OAAO,GACP,MAAM,GACN,OAAO,GACP,OAAO,GACP,KAAK,GACL,MAAM,GACN,KAAK,GACL,QAAQ,GACR,UAAU,GACV,MAAM,GACN,WAAW,CAAC;AAEf,2EAA2E;AAC3E,MAAM,MAAM,gBAAgB,GACzB,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,SAAS,GACT,OAAO,GACP,WAAW,GACX,MAAM,GACN,UAAU,CAAC;AAEd,wDAAwD;AACxD,MAAM,WAAW,cAAc;IAC9B,uEAAuE;IACvE,IAAI,EAAE,eAAe,CAAC;IACtB,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,KAAK,EAAE,gBAAgB,CAAC;IACxB,2EAA2E;IAC3E,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,gFAAgF;AAChF,eAAO,MAAM,iBAAiB,EAAE,SAAS,cAAc,EAmNtD,CAAC"}

package/dist/pptx/render/shape-quick-styles.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Pre-defined shape quick-style presets (inspired by PowerPoint's Shape Styles
+ * gallery). Framework-free pure data, consumed by every binding's Quick Styles
+ * gallery (React / Vue / Angular).
+ */
+import type { PptxElement, ShapeStyle } from 'ooxml-core/pptx';
+/** A named preset shape style used in the Quick Styles gallery. */
+export interface ShapeQuickStyle {
+    name: string;
+    style: Partial<ShapeStyle>;
+}
+/** The CSS a gallery swatch needs to preview a preset without rendering a shape. */
+export interface QuickStyleSwatchCss {
+    background: string;
+    boxShadow?: string;
+    border?: string;
+}
+/**
+ * Derive the swatch CSS for a preset button.
+ *
+ * WHY here and not in each binding's template: the fallback order (gradient
+ * beats flat colour, absent stroke means no border, shadow offsets default to
+ * 2/2/4) is a presentation *rule*, and four hand-written copies of it is how
+ * galleries end up looking different per framework.
+ */
+export declare function quickStyleSwatchCss(quickStyle: ShapeQuickStyle): QuickStyleSwatchCss;
+/** Serialise {@link quickStyleSwatchCss} into an inline `style` attribute value. */
+export declare function quickStyleSwatchStyleAttr(quickStyle: ShapeQuickStyle): string;
+/**
+ * Build the element patch that applies a quick style.
+ *
+ * Merges over the element's existing `shapeStyle` rather than replacing it, so
+ * a preset that sets no shadow leaves an author's shadow alone (matching
+ * PowerPoint, where a quick style is an overlay and not a reset).
+ */
+export declare function shapeQuickStylePatch(el: PptxElement, style: Partial<ShapeStyle>): Partial<PptxElement>;
+export declare const SHAPE_QUICK_STYLES: ShapeQuickStyle[];
+//# sourceMappingURL=shape-quick-styles.d.ts.map

package/dist/pptx/render/shape-quick-styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-quick-styles.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/shape-quick-styles.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG/D,mEAAmE;AACnE,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;CAC3B;AAED,oFAAoF;AACpF,MAAM,WAAW,mBAAmB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,eAAe,GAAG,mBAAmB,CAWpF;AAED,oFAAoF;AACpF,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,eAAe,GAAG,MAAM,CAU7E;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CACnC,EAAE,EAAE,WAAW,EACf,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,GACxB,OAAO,CAAC,WAAW,CAAC,CAGtB;AAED,eAAO,MAAM,kBAAkB,EAAE,eAAe,EA6H/C,CAAC"}

package/dist/pptx/render/share-form.d.ts

@@ -0,0 +1,41 @@
+/**
+ * share-form: framework-free helpers for the Share dialog's start/join form
+ * (field seeding, validity, and CollaborationConfig assembly). Thin sugar over
+ * the neutral session builders in `share-session`, exposing the binding-facing
+ * names the Share dialogs already used. Shared by every binding; each re-exports
+ * these through a thin shim so the SFC/DOM layer stays presentation-only.
+ */
+import type { CollaborationConfig } from '../types.js';
+import { buildJoinCollaborationConfig, canJoinCollaborationSession } from './share-session.js';
+import type { JoinSessionFields } from './share-session.js';
+/** The share form's editable fields. */
+export interface ShareFormFields {
+    roomId: string;
+    userName: string;
+    serverUrl: string;
+}
+/** Optional seed values for the share start form. */
+export interface ShareDefaults {
+    roomId?: string;
+    userName?: string;
+    serverUrl?: string;
+}
+/** Seed the form fields from the (optional) host-supplied defaults. */
+export declare function seedShareFields(defaults?: ShareDefaults): ShareFormFields;
+/**
+ * Whether the form can start a session: room id and display name are required
+ * (after trimming); the server URL may be blank, which selects the serverless
+ * webrtc peer-to-peer transport.
+ */
+export declare function canStartShare(fields: ShareFormFields): boolean;
+/** True when the current server field selects serverless peer-to-peer mode. */
+export declare function isPeerToPeerShare(serverUrl: string): boolean;
+/**
+ * Assemble a {@link CollaborationConfig} from the (trimmed) form fields, or
+ * `null` when the form is incomplete. Peers edit together under the default
+ * `role: 'collaborator'`.
+ */
+export declare function buildShareConfig(fields: ShareFormFields): CollaborationConfig | null;
+export { buildJoinCollaborationConfig as buildJoinConfig, canJoinCollaborationSession as canJoinShare, };
+export type { JoinSessionFields };
+//# sourceMappingURL=share-form.d.ts.map

package/dist/pptx/render/share-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"share-form.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/share-form.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEpD,OAAO,EAEN,4BAA4B,EAC5B,2BAA2B,EAC3B,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,wCAAwC;AACxC,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,qDAAqD;AACrD,MAAM,WAAW,aAAa;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,uEAAuE;AACvE,wBAAgB,eAAe,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,eAAe,CAMzE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAE9D;AAED,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,eAAe,GAAG,mBAAmB,GAAG,IAAI,CAEpF;AAED,OAAO,EACN,4BAA4B,IAAI,eAAe,EAC/C,2BAA2B,IAAI,YAAY,GAC3C,CAAC;AACF,YAAY,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/pptx/render/share-session.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Framework-neutral Share dialog form, invitation-link, and join parsing.
+ * Every UI binding emits the same CollaborationConfig shape from these helpers.
+ */
+import type { CollaborationConfig } from '../types.js';
+export interface ShareSessionDefaults {
+    roomId?: string;
+    userName?: string;
+    serverUrl?: string;
+}
+export interface ShareSessionFields {
+    roomId: string;
+    userName: string;
+    serverUrl: string;
+}
+export interface JoinSessionFields {
+    /** A complete invitation URL or a room ID. */
+    invitation: string;
+    userName: string;
+    /** Used when `invitation` is a room ID rather than a complete URL. */
+    serverUrl: string;
+}
+export declare function seedShareSessionFields(defaults?: ShareSessionDefaults): ShareSessionFields;
+export declare function canCreateCollaborationSession(fields: ShareSessionFields): boolean;
+export declare function buildCreateCollaborationConfig(fields: ShareSessionFields): CollaborationConfig | null;
+/**
+ * Parse an invitation produced by any framework binding. Complete links carry
+ * the standard `room`, `server`, `transport`, and optional `signaling` query
+ * parameters. A bare room ID uses the supplied fallback server.
+ */
+export declare function buildJoinCollaborationConfig(fields: JoinSessionFields): CollaborationConfig | null;
+export declare function canJoinCollaborationSession(fields: JoinSessionFields): boolean;
+export declare function buildCollaborationShareUrl(config: Pick<CollaborationConfig, 'roomId' | 'serverUrl' | 'transport' | 'signaling'>, location?: {
+    origin: string;
+    pathname: string;
+}): string;
+//# sourceMappingURL=share-session.d.ts.map

package/dist/pptx/render/share-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"share-session.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/share-session.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAIpD,MAAM,WAAW,oBAAoB;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IACjC,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,CAAC,EAAE,oBAAoB,GAAG,kBAAkB,CAM1F;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAEjF;AAED,wBAAgB,8BAA8B,CAC7C,MAAM,EAAE,kBAAkB,GACxB,mBAAmB,GAAG,IAAI,CAa5B;AAUD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC3C,MAAM,EAAE,iBAAiB,GACvB,mBAAmB,GAAG,IAAI,CAgC5B;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAE9E;AAED,wBAAgB,0BAA0B,CACzC,MAAM,EAAE,IAAI,CAAC,mBAAmB,EAAE,QAAQ,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC,EACrF,QAAQ,CAAC,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC7C,MAAM,CAeR"}

package/dist/pptx/render/sheet-dismiss.d.ts

@@ -0,0 +1,17 @@
+export interface SheetPointerEventLike {
+    clientY: number;
+    pointerId: number;
+    currentTarget?: {
+        setPointerCapture?(pointerId: number): void;
+        releasePointerCapture?(pointerId: number): void;
+    };
+}
+export interface SheetDismissGesture {
+    pointerDown(event: SheetPointerEventLike): void;
+    pointerMove(event: SheetPointerEventLike): void;
+    pointerUp(event: SheetPointerEventLike): void;
+    cancel(event: SheetPointerEventLike): void;
+}
+/** Framework-neutral downward drag recognizer for mobile bottom sheets. */
+export declare function createSheetDismissGesture(onOffset: (offset: number, dragging: boolean) => void, onDismiss: () => void, threshold?: number): SheetDismissGesture;
+//# sourceMappingURL=sheet-dismiss.d.ts.map

package/dist/pptx/render/sheet-dismiss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sheet-dismiss.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/sheet-dismiss.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE;QACf,iBAAiB,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;QAC5C,qBAAqB,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;KAChD,CAAC;CACF;AAED,MAAM,WAAW,mBAAmB;IACnC,WAAW,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAChD,WAAW,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAChD,SAAS,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC9C,MAAM,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI,CAAC;CAC3C;AAED,2EAA2E;AAC3E,wBAAgB,yBAAyB,CACxC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,KAAK,IAAI,EACrD,SAAS,EAAE,MAAM,IAAI,EACrB,SAAS,SAAM,GACb,mBAAmB,CAkCrB"}

package/dist/pptx/render/slide-background-patch.d.ts

@@ -0,0 +1,3 @@
+export { solidBackgroundPatch, imageBackgroundPatch, clearBackgroundPatch, } from 'ooxml-core/pptx/editor/render/slide-background-patch';
+export type { SlideBackgroundPatch } from 'ooxml-core/pptx/editor/render/slide-background-patch';
+//# sourceMappingURL=slide-background-patch.d.ts.map

package/dist/pptx/render/slide-background-patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slide-background-patch.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/slide-background-patch.ts"],"names":[],"mappings":"AACA,OAAO,EACN,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,GACpB,MAAM,sDAAsD,CAAC;AAC9D,YAAY,EAAE,oBAAoB,EAAE,MAAM,sDAAsD,CAAC"}

package/dist/pptx/render/slide-background.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Slide-background style resolution.
+ *
+ * Maps a `PptxSlide`'s already-resolved background fields to a neutral CSS map
+ * for the slide stage. The core parser resolves the theme/master chain onto the
+ * slide, so here we only translate the resolved fields to CSS. Pure TypeScript
+ * shared by the React, Vue, and Angular bindings (each casts the map to its
+ * framework's CSS type).
+ *
+ * Precedence (highest first): image fill -> gradient -> pattern -> solid colour.
+ */
+import type { PptxSlide } from 'ooxml-core/pptx';
+import type { CssStyleMap } from './element-style-transform.js';
+/** Default slide stage colour when a slide carries no usable background. */
+export declare const DEFAULT_SLIDE_BACKGROUND = "#ffffff";
+/**
+ * The slide's own pixel size, needed only to anchor a `shadeToTitle`
+ * gradient on the title placeholder's bounds (see
+ * `background-shade-to-title.ts`). Optional: a caller that omits it still
+ * gets the plain authored gradient, matching this project's prior behaviour.
+ */
+export interface SlideBackgroundSize {
+    widthPx: number;
+    heightPx: number;
+}
+/**
+ * Build the background portion of the slide stage style from a slide's
+ * resolved background fields. Returns only `background-*` properties so the
+ * caller can spread it into the rest of the stage style.
+ */
+export declare function getSlideBackgroundStyle(slide: PptxSlide | undefined, slideSize?: SlideBackgroundSize): CssStyleMap;
+//# sourceMappingURL=slide-background.d.ts.map

package/dist/pptx/render/slide-background.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slide-background.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/slide-background.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAG7D,4EAA4E;AAC5E,eAAO,MAAM,wBAAwB,YAAY,CAAC;AAElD;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACtC,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,SAAS,CAAC,EAAE,mBAAmB,GAC7B,WAAW,CA+Cb"}