ooxml-ui 0.30.0 → 0.31.0

package/dist/pptx/render/stroke-outline.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Stroked SVG OUTLINES: gradient/pattern lines (`a:ln/a:gradFill`,
+ * `a:ln/a:pattFill`), stroke-only ("open") preset geometry, and centred
+ * (`a:ln/@algn="ctr"`) solid lines.
+ *
+ * Every binding paints a shape's outline as a CSS `border`, which can only take
+ * a single flat colour, can only outline a BOX, and - because `box-sizing:
+ * border-box` puts the whole border INSIDE the element's declared box - can only
+ * express `a:ln/@algn="in"`. That breaks three ways:
+ *
+ *  - A gradient outline was rendered with the parser's averaged `strokeColor`
+ *    (two-tone came out flat, fade-to-transparent came out opaque), and a
+ *    patterned outline with the pattern's foreground alone, so the hatching
+ *    disappeared entirely.
+ *  - An open preset (`<a:prstGeom prst="line"/>`, the connector family, `arc`,
+ *    …) has no region to fill and no box to outline, so a CSS border drew a
+ *    RECTANGLE where PowerPoint draws a line or an arc. See
+ *    `./stroke-only-preset`.
+ *  - `@algn="ctr"` is PowerPoint's DEFAULT (an omitted `@algn` means `ctr`, not
+ *    `in`): the line straddles the shape's path, half outside the box and half
+ *    over the fill. A `border-box` CSS border cannot straddle anything - it can
+ *    only sit flush with the box edge - so every bordered shape at the default
+ *    alignment rendered `strokeWidth / 2` too small on each edge. An SVG
+ *    `<path>` stroke is centred on the path by definition, so routing the
+ *    default-aligned case through this same overlay is the fix; `@algn="in"`
+ *    keeps the cheap `border-box` CSS border, which is already exactly right.
+ *
+ * CSS has no way to fix any of these in place - `border-image` ignores
+ * `border-radius` and cannot follow a `clip-path`, and no CSS property centres a
+ * border on the box edge - so the outline is instead stroked as a real SVG path
+ * laid over the element, using the shape's own resolved geometry. This module
+ * turns an element into everything a binding needs for that overlay; the
+ * bindings supply only the ~10 lines of view layer.
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { SvgGradientDef, SvgPatternDef } from './svg-gradient-paint.js';
+/** The paint server an outline is stroked with: a gradient or a pattern. */
+export type StrokeOutlinePaint = SvgGradientDef | SvgPatternDef;
+/**
+ * One parallel stroke of a compound (`a:ln/@cmpd`) line: its width, and its
+ * perpendicular offset from the centre line in element px. A single line is one
+ * strand at offset `0`.
+ */
+export interface StrokeOutlineStrand {
+    strokeWidth: number;
+    offset: number;
+}
+/** Everything needed to stroke one shape's outline as an SVG overlay. */
+export interface StrokeOutline {
+    /** Path data in the element's own pixel space (viewBox `0 0 width height`). */
+    d: string;
+    /**
+     * Paint server to define in `<defs>`, or `undefined` when the outline is
+     * stroked with a flat colour (an open preset with an ordinary solid line).
+     */
+    paint: StrokeOutlinePaint | undefined;
+    /** Ready-to-use SVG `stroke` value: `url(#…)` for a paint server, else a colour. */
+    stroke: string;
+    strokeWidth: number;
+    /** Parallel strands to emit; one entry unless the line is compound. */
+    strands: readonly StrokeOutlineStrand[];
+    /** SVG `stroke-dasharray`, or `undefined` for a solid line. */
+    dashArray: string | undefined;
+    lineCap: 'butt' | 'round' | 'square';
+    lineJoin: 'round' | 'bevel' | 'miter';
+}
+/** Narrowing helper for bindings, whose templates cannot narrow a union inline. */
+export declare function isPatternPaint(paint: StrokeOutlinePaint | undefined): paint is SvgPatternDef;
+/**
+ * Convert a CSS `clip-path` value into path data in element pixel space.
+ *
+ * `getResolvedShapeClipPath` already returns `path('…')` for every preset the
+ * ECMA evaluator covers (including `ellipse`, which the bindings otherwise paint
+ * with `border-radius`), so that is the common case. `polygon()` from the static
+ * table is converted point by point; anything else - `inset()`, or no clip at
+ * all - falls back to the element's rectangle.
+ */
+export declare function outlinePathData(clipPath: string | undefined, width: number, height: number): string | undefined;
+/** Whether a preset's pointer is part of the authored outline and may extend outside its body box. */
+export declare function isWedgeCalloutPresetShape(shapeType?: string): boolean;
+export interface PresetShapeVectorGeometry {
+    d: string;
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    viewWidth: number;
+    viewHeight: number;
+}
+/** Resolve a preset outline into SVG path data plus any authored out-of-box bounds. */
+export declare function getPresetShapeVectorGeometry(shapeType: string | undefined, width: number, height: number, adjustments?: Record<string, number>): PresetShapeVectorGeometry | undefined;
+/**
+ * Resolve the SVG overlay that paints an element's outline, or `undefined` when
+ * the binding's CSS border is correct and cheaper (a closed shape whose line is
+ * explicitly inset, `a:ln/@algn="in"`).
+ *
+ * Three things need the overlay: a gradient/pattern line, which a CSS border
+ * cannot express; a stroke-only preset, which has no box to put a border on;
+ * and a centred (`ctr`, the default) solid line, which a `border-box` CSS
+ * border cannot straddle. The last two are painted with a flat colour, so
+ * `paint` is `undefined` there and `stroke` carries the colour instead.
+ */
+export declare function buildStrokeOutline(element: PptxElement): StrokeOutline | undefined;
+/**
+ * The `viewBox` a binding must give the outline overlay: the element's PAINTED
+ * box, i.e. its authored extent (see shared `getContainerStyle` /
+ * `paintedElementSize`), floored at zero.
+ *
+ * Matching the viewBox to the painted box rather than to some other extent
+ * keeps the user-space mapping 1:1 under `preserveAspectRatio="none"`: the
+ * overlay `<svg>` is displayed at exactly the wrapper's own CSS width/height
+ * (100%/100%), so its `viewBox` must equal the same box the wrapper itself
+ * uses or the outline would be non-uniformly scaled. This used to be the
+ * INTERACTIVE-only padded box (see `elementHitTargetStyle`); painting the
+ * outline at that padded size in read-only rendering stretched a hairline
+ * rule's border across a much taller box than it was authored at (issue #285).
+ *
+ * Returns `undefined` for a box under 1px on either side. A zero side would
+ * hide the `<svg>`, and the 1px minimum size the bindings give it would stretch
+ * a sub-pixel one. The path is then drawn in the wrapper's own pixels.
+ */
+export declare function strokeOutlineViewBox(element: PptxElement): string | undefined;
+/**
+ * Whether a binding should suppress its CSS border for this element because the
+ * stroke overlay is painting the outline instead. Keeping both would draw the
+ * averaged solid (or the pattern's bare foreground) underneath a gradient line,
+ * and would box a stroke-only preset inside the rectangle it does not have.
+ */
+export declare function suppressesCssBorder(element: PptxElement): boolean;
+//# sourceMappingURL=stroke-outline.d.ts.map

package/dist/pptx/render/stroke-outline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke-outline.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/stroke-outline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,EAAE,WAAW,EAAc,MAAM,iBAAiB,CAAC;AAe/D,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAS1E,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAAG,cAAc,GAAG,aAAa,CAAC;AAEhE;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CACf;AAED,yEAAyE;AACzE,MAAM,WAAW,aAAa;IAC7B,+EAA+E;IAC/E,CAAC,EAAE,MAAM,CAAC;IACV;;;OAGG;IACH,KAAK,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACtC,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACxC,+DAA+D;IAC/D,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IACrC,QAAQ,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;CACtC;AAED,mFAAmF;AACnF,wBAAgB,cAAc,CAAC,KAAK,EAAE,kBAAkB,GAAG,SAAS,GAAG,KAAK,IAAI,aAAa,CAE5F;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACZ,MAAM,GAAG,SAAS,CAiCpB;AAQD,sGAAsG;AACtG,wBAAgB,yBAAyB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAErE;AAED,MAAM,WAAW,yBAAyB;IACzC,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACnB;AAqBD,uFAAuF;AACvF,wBAAgB,4BAA4B,CAC3C,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,yBAAyB,GAAG,SAAS,CAkCvC;AAuDD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,aAAa,GAAG,SAAS,CA+ClF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAO7E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAEjE"}

package/dist/pptx/render/stroke-paint.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Should this shape/picture outline be painted at all?
+ *
+ * OOXML allows a width-only line, e.g. `<a:ln w="12700"><a:miter .../></a:ln>`,
+ * with no fill child and no `<p:style>/<a:lnRef>` reference. That leaves the
+ * line FILL unspecified, and PowerPoint paints no outline for it (verified
+ * against a PowerPoint render of the real-world media deck, whose photos all
+ * carry exactly that markup: the pictures are frameless). Core parses it as
+ * `strokeWidth > 0` with `strokeColor`/`strokeFillMode` both `undefined`, so a
+ * renderer must treat the missing colour as "no line", never substitute a
+ * default stroke colour: React did, and painted a dark 1px frame around every
+ * such picture that no other binding (and not PowerPoint) draws.
+ *
+ * When a line has any fill source (an explicit `a:solidFill`, an averaged
+ * gradient/pattern colour, or a colour resolved from the theme's `lnStyleLst`
+ * via `a:lnRef`), core writes `strokeColor` (and `strokeFillMode`), and the
+ * outline paints as before.
+ */
+export declare function hasStrokePaint(style: {
+    strokeWidth?: number;
+    strokeColor?: string;
+    strokeFillMode?: string;
+} | undefined): boolean;
+/**
+ * The stroke width a renderer should paint: the parsed width when the line has
+ * a fill source, `0` when it is a width-only (fill-less) line. Bindings that
+ * gate their CSS border on `strokeWidth > 0` can substitute this directly.
+ */
+export declare function paintedStrokeWidth(style: {
+    strokeWidth?: number;
+    strokeColor?: string;
+    strokeFillMode?: string;
+} | undefined): number;
+//# sourceMappingURL=stroke-paint.d.ts.map

package/dist/pptx/render/stroke-paint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke-paint.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/stroke-paint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC7B,KAAK,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,GACxF,OAAO,CAKT;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,GACxF,MAAM,CAER"}

package/dist/pptx/render/stroke-style.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The CSS a shape's OUTLINE (`a:ln`) is painted with, as one neutral decision.
+ *
+ * Every binding ended up writing its own two-line version of this
+ * (`border: <width> <dash> <colour>`), and each of those copies dropped a
+ * different part of `a:ln`:
+ *
+ *  - `@cmpd` (double / thickThin / thinThick / tri) reached only React and
+ *    Angular, because only they passed the compound type to
+ *    {@link getCssBorderDashStyle}. Vue, Svelte and Vanilla painted every
+ *    compound outline as one solid line.
+ *  - `a:miter/@lim` reached only React, which wrote `stroke-miterlimit` on the
+ *    shape container. That property is an INHERITED SVG presentation property,
+ *    so writing it on the container is what makes both the freeform `<path>` and
+ *    the stroke overlay honour it - no per-overlay wiring needed.
+ *  - `strokeOpacity` was applied by React and dropped by Svelte.
+ *
+ * So the outline is resolved here once and each binding only maps the result
+ * onto its own style object. One thing deliberately stays OUT: suppressing the
+ * border for an element the binding paints as an SVG `<path>` of its own
+ * (React's freeform `renderVectorShape`) is a view-layer fact, not a property of
+ * the OOXML, so it stays in the binding.
+ *
+ * @module render/stroke-style
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { CssBorderStyle } from './element-style-transform.js';
+/** SVG `stroke-linejoin` values, as `a:ln/a:round|a:bevel|a:miter` map onto them. */
+export type SvgStrokeLineJoin = 'miter' | 'round' | 'bevel';
+/** SVG `stroke-linecap` values, as `a:ln/@cap` maps onto them. */
+export type SvgStrokeLineCap = 'butt' | 'round' | 'square';
+/** The resolved CSS outline of a shape. See {@link getComputedStrokeStyle}. */
+export interface ComputedStrokeStyle {
+    /**
+     * `border-width` in px. `0` means "paint no CSS border": either the shape has
+     * no painted line at all, or the stroke overlay
+     * ({@link suppressesCssBorder}) is painting the outline instead.
+     *
+     * A compound line keeps the full authored width, which `border-style: double`
+     * then divides between its strands and the gap.
+     */
+    readonly borderWidth: number;
+    /** `border-style`, or `undefined` when nothing is painted. */
+    readonly borderStyle: CssBorderStyle | undefined;
+    /** `border-color` (already carrying `strokeOpacity`), or `undefined`. */
+    readonly borderColor: string | undefined;
+    /**
+     * The three above as a `border` shorthand, for bindings that write one
+     * property. `undefined` when nothing is painted.
+     */
+    readonly border: string | undefined;
+    /** `stroke-linejoin` (inherited into descendant SVG), from `a:ln`'s join. */
+    readonly strokeLinejoin: SvgStrokeLineJoin | undefined;
+    /** `stroke-linecap` (inherited into descendant SVG), from `a:ln/@cap`. */
+    readonly strokeLinecap: SvgStrokeLineCap | undefined;
+    /**
+     * `stroke-miterlimit` from `a:miter/@lim`, as a plain ratio. Inherited, so
+     * writing it on the shape container reaches the freeform path AND the stroke
+     * overlay without either of them restating it.
+     */
+    readonly strokeMiterlimit: number | undefined;
+}
+/**
+ * Resolve the CSS outline of a shape-like element.
+ *
+ * @param element - The element whose `a:ln` is being painted.
+ * @returns A neutral descriptor; `borderWidth === 0` when no CSS border applies.
+ */
+export declare function getComputedStrokeStyle(element: PptxElement): ComputedStrokeStyle;
+//# sourceMappingURL=stroke-style.d.ts.map

package/dist/pptx/render/stroke-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke-style.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/stroke-style.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAc,MAAM,iBAAiB,CAAC;AAI/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAMhE,qFAAqF;AACrF,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAC5D,kEAAkE;AAClE,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE3D,+EAA+E;AAC/E,MAAM,WAAW,mBAAmB;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,8DAA8D;IAC9D,QAAQ,CAAC,WAAW,EAAE,cAAc,GAAG,SAAS,CAAC;IACjD,yEAAyE;IACzE,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,6EAA6E;IAC7E,QAAQ,CAAC,cAAc,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACvD,0EAA0E;IAC1E,QAAQ,CAAC,aAAa,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACrD;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9C;AA2DD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,GAAG,mBAAmB,CAyChF"}

package/dist/pptx/render/subpath-fill-overlay.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Per-sub-path FILL overlay: the shared mechanism behind two structurally
+ * identical bugs.
+ *
+ * Both custom geometry (`a:custGeom`) and preset geometry (`a:prstGeom`) can
+ * carry several sub-paths, each with its own `@fill` mode
+ * (`norm`/`lighten`/`lightenLess`/`darken`/`darkenLess`/`none`) and `@stroke`
+ * flag. Every binding paints a shape as ONE box: a single CSS
+ * `background-color` clipped to a single merged `clip-path` built by
+ * concatenating every sub-path's `d` together (`getResolvedShapeClipPath`,
+ * `buildCustomGeometryClipPath`). That merge is lossy two ways:
+ *
+ *  - It discards each sub-path's own `@fill`, so a preset's shading/bevel
+ *    sub-paths (`lighten`/`darken`, e.g. every `actionButton*`, curved arrows,
+ *    `bevel`, `foldedCorner`) paint as flat instead of shaded, and a `fill="none"`
+ *    sub-path (`smileyFace`'s eyes/mouth) paints FILLED instead of as an open
+ *    stroke - because `clip-path` auto-closes every sub-path.
+ *  - It cannot vary the fill AT ALL across sub-paths, so it is architecturally
+ *    incapable of the above regardless of which colour is chosen.
+ *
+ * The fix is the same for both: paint the affected element as layered SVG
+ * `<path>`s, each carrying its own resolved fill, instead of one CSS box. This
+ * module decides WHICH elements need that (an element needs it only when at
+ * least one sub-path's mode is not `norm`/unset, or it opts out of its stroke)
+ * and builds the paints via the shared `./vector-subpath-paint`; a binding's
+ * `ShapeEffectOverlay` renders the result as an `<svg>` sibling to the shape
+ * box (mirroring `buildStrokeOutline`), and `getComputedFillStyle`
+ * ({@link suppressesCssFill}) drops the CSS background so the flat colour does
+ * not show underneath.
+ *
+ * Restricted to a solid (or absent) fill: a gradient/pattern/image fill keeps
+ * the existing single merged clip-path box, since neither geometry kind's
+ * sub-paths can carry an independent paint SERVER (only a solid, mode-shifted
+ * colour), and the common case for both bug classes - shading/bevel highlights,
+ * `smileyFace`'s eyes - is a solid theme colour.
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { SubpathPaint } from './vector-subpath-paint.js';
+/** Everything a binding needs to paint an element's per-sub-path fill overlay. */
+export interface SubpathFillOverlay {
+    /** One paint per sub-path, in authoring order. */
+    readonly paints: readonly SubpathPaint[];
+    /** `viewBox` width, in the same coordinate space as every `paints[].d`. */
+    readonly viewBoxWidth: number;
+    /** `viewBox` height, in the same coordinate space as every `paints[].d`. */
+    readonly viewBoxHeight: number;
+}
+/**
+ * Whether a binding must drop its CSS `background-color` / `background-image`
+ * for this element because {@link buildSubpathFillOverlay} is painting the
+ * fill instead. Mirrors `suppressesCssBorder`'s role for the stroke overlay;
+ * consumed by shared `getComputedFillStyle`.
+ */
+export declare function suppressesCssFill(element: PptxElement): boolean;
+/**
+ * Build the per-sub-path fill overlay for an element, or `undefined` when a
+ * single merged fill/clip-path is correct (the ordinary case).
+ */
+export declare function buildSubpathFillOverlay(element: PptxElement): SubpathFillOverlay | undefined;
+//# sourceMappingURL=subpath-fill-overlay.d.ts.map

package/dist/pptx/render/subpath-fill-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subpath-fill-overlay.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/subpath-fill-overlay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,KAAK,EAIX,WAAW,EACX,MAAM,iBAAiB,CAAC;AASzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAqB3D,kFAAkF;AAClF,MAAM,WAAW,kBAAkB;IAClC,kDAAkD;IAClD,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;IACzC,2EAA2E;IAC3E,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAC/B;AAoHD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAE/D;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,WAAW,GAAG,kBAAkB,GAAG,SAAS,CAiB5F"}

package/dist/pptx/render/subtitle-settings.d.ts

@@ -0,0 +1,22 @@
+import type { ViewerOptions, ViewerOptionsStore } from './options/index.js';
+export declare const SUBTITLE_LANGUAGES: readonly ['auto', 'en-US', 'en-GB', 'fr-FR', 'de-DE', 'es-ES', 'pt-BR', 'it-IT', 'ja-JP', 'ko-KR', 'zh-CN'];
+export interface SubtitleSettings {
+    spokenLanguage: string;
+}
+/** Render familiar language names while keeping browser recognition codes in state. */
+export declare function subtitleLanguageLabel(language: string): string;
+export interface SubtitleSettingsLabels {
+    title: string;
+    language: string;
+    browserLanguage: string;
+    description: string;
+    apply: string;
+    cancel: string;
+}
+/** Browser recognition settings, independent of caption visibility and deck metadata. */
+export declare function normalizeSubtitleSettings(settings?: Partial<SubtitleSettings>): SubtitleSettings;
+export declare function subtitleSettingsFromOptions(options?: ViewerOptions): SubtitleSettings;
+export declare function updateSubtitleSettings(store: Pick<ViewerOptionsStore, 'setValue'>, settings: SubtitleSettings): void;
+export declare function subtitleRecognitionLanguage(settings: SubtitleSettings, browserLanguage?: string): string;
+export declare function subtitleSettingsLabels(t: (key: string) => string): SubtitleSettingsLabels;
+//# sourceMappingURL=subtitle-settings.d.ts.map

package/dist/pptx/render/subtitle-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtitle-settings.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/subtitle-settings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAEnE,eAAO,MAAM,kBAAkB,YAC9B,MAAM,EACN,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,CACE,CAAC;AACX,MAAM,WAAW,gBAAgB;IAChC,cAAc,EAAE,MAAM,CAAC;CACvB;AAED,uFAAuF;AACvF,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAM9D;AACD,MAAM,WAAW,sBAAsB;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,yFAAyF;AACzF,wBAAgB,yBAAyB,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,gBAAgB,CAOhG;AACD,wBAAgB,2BAA2B,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,gBAAgB,CAErF;AACD,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,EAC3C,QAAQ,EAAE,gBAAgB,GACxB,IAAI,CAMN;AACD,wBAAgB,2BAA2B,CAC1C,QAAQ,EAAE,gBAAgB,EAC1B,eAAe,SAAU,GACvB,MAAM,CAER;AACD,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,sBAAsB,CASzF"}

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

@@ -0,0 +1,51 @@
+/**
+ * summary-zoom.ts: the framework-neutral tile model for an Office 2016 Summary
+ * Zoom container, consumed by all five bindings.
+ *
+ * Every caption this module produces reaches the DOM (as a tile subtitle or an
+ * `aria-label`), so it takes the binding's translator rather than hard-coding
+ * English. The parameter is optional purely so existing callers keep
+ * compiling; a viewer that omits it renders a French deck's zoom tiles in
+ * English.
+ *
+ * @module render/summary-zoom
+ */
+import type { ZoomPptxElement } from 'ooxml-core/pptx';
+/** Resolves a `pptx.*` key, interpolating `{{...}}` params when given. */
+export type SummaryZoomTranslate = (key: string, params?: Record<string, string>) => string;
+export interface SummaryZoomTargetInfo {
+    slideNumber?: number;
+    sectionName?: string;
+    backgroundColor?: string;
+}
+export type SummaryZoomTargetLookup = (targetSlideIndex: number) => SummaryZoomTargetInfo | undefined;
+export interface SummaryZoomTileView {
+    key: string;
+    sectionId: string;
+    targetSlideIndex: number;
+    label: string;
+    slideLabel: string;
+    imageSrc?: string;
+    backgroundColor: string;
+    style: Record<string, string>;
+    ariaLabel: string;
+    /** This tile's own `zmPr/@returnToParent`; see {@link ZoomPptxElement.returnToParent}. */
+    returnToParent: boolean;
+    /** This tile's own `zmPr/@transitionDur` in milliseconds; see {@link ZoomPptxElement.transitionDurationMs}. */
+    transitionDurationMs?: number;
+}
+export interface SummaryZoomView {
+    layout: 'grid' | 'fixed';
+    containerStyle: Record<string, string>;
+    tiles: SummaryZoomTileView[];
+    ariaLabel: string;
+}
+/**
+ * Build the ordered, framework-neutral tile model for a Summary Zoom container.
+ *
+ * @param translate - The binding's translator; omit for English.
+ */
+export declare function buildSummaryZoomView(element: ZoomPptxElement, lookup?: SummaryZoomTargetLookup, translate?: SummaryZoomTranslate): SummaryZoomView | undefined;
+/** Resolve a tile activation to its slide target without relying on DOM state. */
+export declare function resolveSummaryZoomNavigation(view: SummaryZoomView | undefined, tileIndex: number): number | undefined;
+//# sourceMappingURL=summary-zoom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"summary-zoom.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/summary-zoom.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,0EAA0E;AAC1E,MAAM,MAAM,oBAAoB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;AAE5F,MAAM,WAAW,qBAAqB;IACrC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,uBAAuB,GAAG,CACrC,gBAAgB,EAAE,MAAM,KACpB,qBAAqB,GAAG,SAAS,CAAC;AAEvC,MAAM,WAAW,mBAAmB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,0FAA0F;IAC1F,cAAc,EAAE,OAAO,CAAC;IACxB,+GAA+G;IAC/G,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,eAAe,EACxB,MAAM,CAAC,EAAE,uBAAuB,EAChC,SAAS,CAAC,EAAE,oBAAoB,GAC9B,eAAe,GAAG,SAAS,CAsD7B;AAED,kFAAkF;AAClF,wBAAgB,4BAA4B,CAC3C,IAAI,EAAE,eAAe,GAAG,SAAS,EACjC,SAAS,EAAE,MAAM,GACf,MAAM,GAAG,SAAS,CAKpB"}

package/dist/pptx/render/surface-chart-3d-geom.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Pure surface-chart 3D geometry helpers (framework- and three-agnostic).
+ *
+ * The hosted surface scene ({@link createSurfaceChart3DScene}) feeds these
+ * the `three` module `<pptx-three-view>` loaded, so the library stays an
+ * optional import while the grid maths (plane subdivision -> height/colour displacement,
+ * world-space label anchors) lives here as small, separately testable units.
+ */
+import type * as THREE from 'three';
+/** The subset of the `three` module surface the geometry builder uses. */
+type ThreeModule = typeof THREE;
+/** Maximum height displacement (world units) for a normalised value of 1. */
+export declare const MAX_HEIGHT = 1.5;
+/** Grid world extent (width along cols, depth along rows). */
+export interface GridExtent {
+    gridWidth: number;
+    gridDepth: number;
+}
+/** Compute the world-space width/depth of the data grid. */
+export declare function computeGridExtent(cols: number, rows: number): GridExtent;
+/** A label to overlay over the canvas, with its world-space anchor point. */
+export interface SurfaceLabel {
+    /** Stable key for DOM reconciliation. */
+    key: string;
+    /** Display text. */
+    text: string;
+    /** World-space anchor [x, y, z] projected to screen each frame. */
+    anchor: readonly [number, number, number];
+    /** Logical axis the label belongs to (for styling). */
+    axis: 'category' | 'series' | 'value';
+}
+/**
+ * Build the surface mesh + wireframe geometries from the normalised height and
+ * colour maps. The plane is subdivided to match the data grid, rotated into the
+ * XZ plane, then each vertex is displaced in Y by its height and tinted by its
+ * colour. Returns disposable geometries the caller adds to the scene.
+ */
+export declare function buildSurfaceGeometry(three: ThreeModule, cols: number, rows: number, heightMap: Float32Array, colorMap: Float32Array): {
+    geometry: THREE.BufferGeometry;
+    wireGeometry: THREE.BufferGeometry;
+};
+/**
+ * World-space position of one surface-grid vertex `(row, col)`, matching the
+ * EXACT vertex layout {@link buildSurfaceGeometry}'s rotated
+ * `THREE.PlaneGeometry` produces (row -> depth segment / world Z, col ->
+ * width segment / world X, height -> world Y). A caller placing a selection
+ * marker or calibrating a value drag against a specific data point needs this
+ * to land on the SAME point the rendered mesh does, rather than re-deriving
+ * (and risking drifting from) the plane-geometry math.
+ */
+export declare function surfaceVertexWorldPosition(cols: number, rows: number, row: number, col: number, heightMap: Float32Array): readonly [number, number, number];
+/**
+ * Build the axis labels (category along the front edge, series along the right
+ * edge, plus a single "Value" Y-axis label) as world-anchored {@link
+ * SurfaceLabel}s. Category/series labels are thinned to at most `maxCat`/`maxSer`
+ * entries to avoid clutter, mirroring the prior drei `Html` layout.
+ */
+export declare function buildSurfaceLabels(cols: number, rows: number, categoryLabels: ReadonlyArray<string>, seriesNames: ReadonlyArray<string>, maxCat?: number, maxSer?: number): SurfaceLabel[];
+/** The `c:view3D` fields the camera placement cares about. */
+export interface SurfaceCameraView3D {
+    /** X-axis rotation in degrees (-90...90); PowerPoint's "elevation". */
+    rotX?: number;
+    /** Y-axis rotation in degrees (0...360); PowerPoint's "rotation". */
+    rotY?: number;
+}
+/**
+ * Camera placement that frames the whole grid.
+ *
+ * When `view3D` carries an authored `rotX` and/or `rotY`, the camera is
+ * placed on a sphere around the target at the corresponding elevation/azimuth
+ * (missing fields fall back to PowerPoint-like defaults, matching the 2D
+ * engine's oblique-depth defaults so both presentations agree on an untagged
+ * angle). When `view3D` is absent entirely (no `c:view3D` was authored), the
+ * original fixed isometric-like offset is used unchanged, so charts nobody
+ * has touched keep their exact prior framing.
+ *
+ * `rotX` (elevation) is clamped to (-90, 90) exclusive so the camera never
+ * sits exactly on the vertical axis, which is a degenerate case for
+ * `lookAt`/OrbitControls (an ill-defined up vector).
+ */
+export declare function computeCameraPlacement(cols: number, rows: number, view3D?: SurfaceCameraView3D): {
+    position: readonly [number, number, number];
+    target: readonly [number, number, number];
+};
+export {};
+//# sourceMappingURL=surface-chart-3d-geom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"surface-chart-3d-geom.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/surface-chart-3d-geom.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,0EAA0E;AAC1E,KAAK,WAAW,GAAG,OAAO,KAAK,CAAC;AAIhC,6EAA6E;AAC7E,eAAO,MAAM,UAAU,MAAM,CAAC;AAE9B,8DAA8D;AAC9D,MAAM,WAAW,UAAU;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,4DAA4D;AAC5D,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAKxE;AAED,6EAA6E;AAC7E,MAAM,WAAW,YAAY;IAC5B,yCAAyC;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,uDAAuD;IACvD,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,OAAO,CAAC;CACtC;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,YAAY,EACvB,QAAQ,EAAE,YAAY,GACpB;IAAE,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAC;IAAC,YAAY,EAAE,KAAK,CAAC,cAAc,CAAA;CAAE,CAoCxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACzC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,YAAY,GACrB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAOnC;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,EACrC,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,EAClC,MAAM,SAAI,EACV,MAAM,SAAI,GACR,YAAY,EAAE,CAkChB;AAED,8DAA8D;AAC9D,MAAM,WAAW,mBAAmB;IACnC,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAsBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,mBAAmB,GAC1B;IAAE,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CA2B5F"}

package/dist/pptx/render/surface-chart-3d-walls.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Floor/side-wall/back-wall backdrop planes for an interactive 3D chart scene.
+ *
+ * `c:floor`, `c:sideWall`, and `c:backWall` are parsed onto `PptxChartData`
+ * but, before this module, only the flat SVG isometric renderer painted
+ * them; a WebGL scene showed a fixed grey `GridHelper` regardless of what
+ * was authored. Each authored surface becomes one semi-transparent plane
+ * mesh so the interactive view agrees with the SVG one. A surface with no
+ * authored fill colour gets no plane, so an untouched chart's WebGL scene is
+ * unchanged.
+ *
+ * Shared by every interactive chart scene that has a category/series grid to
+ * wall in: the surface chart ({@link ./surface-chart-3d-scene.ts}) and the
+ * cartesian bar3D scene ({@link ./bar-chart-3d-scene.ts}), and (pending
+ * follow-up) line3D/area3D. Each caller passes its OWN grid extent (a
+ * cartesian chart's depth axis is scaled by `c:view3D/@depthPercent`, unlike
+ * the surface chart's 1:1 row spacing), so this module never recomputes an
+ * extent that could disagree with the caller's own mesh layout.
+ *
+ * @module surface-chart-3d-walls
+ */
+import type * as THREE from 'three';
+import type { GridExtent } from './surface-chart-3d-geom.js';
+type ThreeModule = typeof THREE;
+/** `c:floor`/`c:sideWall`/`c:backWall` fill colours (`#RRGGBB`), when authored. */
+export interface SurfaceWallColors {
+    floor?: string;
+    sideWall?: string;
+    backWall?: string;
+}
+/** Disposable handle to the wall/floor meshes mounted into the scene. */
+export interface SurfaceWallMeshes {
+    meshes: THREE.Mesh[];
+    dispose: () => void;
+}
+/**
+ * Build plane meshes for each authored surface colour. The floor lies flat
+ * under the grid (z=0); the back wall stands at the grid's far depth edge;
+ * the side wall stands at the grid's far width edge, matching the 2D
+ * isometric renderer's back-wall/side-wall corner convention.
+ *
+ * `extent` defaults to the surface chart's own `computeGridExtent(cols, rows)`
+ * (1:1 grid-step spacing) when omitted, so existing callers are unaffected.
+ * A cartesian scene whose depth axis is NOT 1:1 with its row count (bar3D's
+ * `c:view3D/@depthPercent` scaling) passes its own precomputed extent instead
+ * of letting this module recompute a mismatched one.
+ */
+export declare function buildSurfaceWallMeshes(three: ThreeModule, cols: number, rows: number, wallHeight: number, colors: SurfaceWallColors, extent?: GridExtent): SurfaceWallMeshes;
+export {};
+//# sourceMappingURL=surface-chart-3d-walls.d.ts.map

package/dist/pptx/render/surface-chart-3d-walls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-chart-3d-walls.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/surface-chart-3d-walls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAGpC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D,KAAK,WAAW,GAAG,OAAO,KAAK,CAAC;AAEhC,mFAAmF;AACnF,MAAM,WAAW,iBAAiB;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IACjC,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,IAAI,CAAC;CACpB;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,iBAAiB,EACzB,MAAM,CAAC,EAAE,UAAU,GACjB,iBAAiB,CAyDnB"}