ooxml-ui 0.30.0 → 0.31.0

package/dist/pptx/render/bullet-toggle.d.ts

@@ -0,0 +1,3 @@
+export { DEFAULT_BULLET_CHAR, DEFAULT_AUTONUM_TYPE, bulletInfoForKind, isBulletMarkerSegment, paragraphBulletKind, withoutListType, toggleParagraphBullet, splitBulletParagraphs, resolveBulletSegments, paragraphsBulletKind, elementBulletKind, setElementBullets, toggleElementBullets, } from 'ooxml-core/pptx/editor/render/bullet-toggle';
+export type { ParagraphBulletKind, ElementBulletKind, BulletParagraphRange, ElementBulletPatch, BulletParagraph, } from 'ooxml-core/pptx/editor/render/bullet-toggle';
+//# sourceMappingURL=bullet-toggle.d.ts.map

package/dist/pptx/render/bullet-toggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bullet-toggle.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/bullet-toggle.ts"],"names":[],"mappings":"AACA,OAAO,EACN,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,GACpB,MAAM,6CAA6C,CAAC;AACrD,YAAY,EACX,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,GACf,MAAM,6CAA6C,CAAC"}

package/dist/pptx/render/canvas-context-menu-commands.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The right-click menu for the empty slide canvas (no element under the
+ * cursor), as distinct from {@link ./context-menu-commands}'s per-element menu.
+ *
+ * Right-clicking empty canvas used to do nothing at all in every binding: React
+ * and Vue both bailed out early (`getElementIdFromEvent` returns `null`, so the
+ * handler just returns) rather than opening a menu, and the other three never
+ * wired a handler for it either. PowerPoint offers Paste, Layout, Reset,
+ * Format Background and view toggles (Grid and Guides, Ruler) from this menu;
+ * this module is the one list every binding renders instead of five omissions.
+ *
+ * @module render/canvas-context-menu-commands
+ */
+/** Every command the empty-canvas context menu can offer, in no particular order. */
+export type CanvasContextMenuCommandId = 'paste' | 'layout' | 'reset-slide' | 'format-background' | 'grid-and-guides' | 'ruler';
+/** One rendered entry: a command, plus how it is presented. */
+export interface CanvasContextMenuEntry {
+    id: CanvasContextMenuCommandId;
+    /** i18n key; the binding translates it with its own translator. */
+    labelKey: string;
+    /** Draw a rule above this entry (it opens a new group of commands). */
+    separatorBefore?: boolean;
+    /** Offered but not usable right now (greyed out, still announced). */
+    disabled?: boolean;
+    /**
+     * This entry is a checkbox-style toggle (Grid and Guides, Ruler) currently
+     * in this state, rather than a one-shot command.
+     */
+    checked?: boolean;
+}
+/** What the empty-canvas menu is being opened over. */
+export interface CanvasContextMenuContext {
+    /**
+     * Whether there is anything to paste. Omit when the binding does not track
+     * it: Paste is then offered enabled, matching the element menu's default.
+     */
+    hasClipboard?: boolean;
+    /** Whether the grid is currently shown, for the "Grid and Guides" checkbox. */
+    showGrid?: boolean;
+    /** Whether the ruler is currently shown, for the "Ruler" checkbox. */
+    showRulers?: boolean;
+}
+/** The i18n key for a command, so a binding never spells one out itself. */
+export declare function canvasContextMenuLabelKey(id: CanvasContextMenuCommandId): string;
+/**
+ * The empty-canvas menu for `context`, in order, separators included:
+ * Paste; Layout, Reset Slide; Format Background; Grid and Guides, Ruler.
+ */
+export declare function buildCanvasContextMenuEntries(context?: CanvasContextMenuContext): CanvasContextMenuEntry[];
+//# sourceMappingURL=canvas-context-menu-commands.d.ts.map

package/dist/pptx/render/canvas-context-menu-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-context-menu-commands.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/canvas-context-menu-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,qFAAqF;AACrF,MAAM,MAAM,0BAA0B,GACnC,OAAO,GACP,QAAQ,GACR,aAAa,GACb,mBAAmB,GACnB,iBAAiB,GACjB,OAAO,CAAC;AAEX,+DAA+D;AAC/D,MAAM,WAAW,sBAAsB;IACtC,EAAE,EAAE,0BAA0B,CAAC;IAC/B,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAC;IACjB,uEAAuE;IACvE,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,uDAAuD;AACvD,MAAM,WAAW,wBAAwB;IACxC;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,sEAAsE;IACtE,UAAU,CAAC,EAAE,OAAO,CAAC;CACrB;AAWD,4EAA4E;AAC5E,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,0BAA0B,GAAG,MAAM,CAEhF;AASD;;;GAGG;AACH,wBAAgB,6BAA6B,CAC5C,OAAO,GAAE,wBAA6B,GACpC,sBAAsB,EAAE,CAU1B"}

package/dist/pptx/render/canvas-element-node.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Find the editing canvas's DOM node for a slide element.
+ *
+ * Every binding marks a rendered element with `data-element-id`, but Angular,
+ * Svelte and Vanilla leave that marker on the slides-pane thumbnails too, and
+ * the thumbnail rail sits AHEAD of the main canvas in their DOM. A bare
+ * `document.querySelector('[data-element-id="..."]')` therefore returned the
+ * thumbnail's copy: the ribbon's animation Preview played on a 150px
+ * thumbnail, and the Paste Options toolbar anchored itself to one. The main
+ * canvas is the `[data-pptx-viewport]` subtree in all five bindings, so that
+ * copy wins; anywhere else is only a fallback for hosts without one.
+ *
+ * @module render/canvas-element-node
+ */
+/**
+ * The main-canvas node for `elementId`, else (unless `canvasOnly`) the first
+ * node anywhere, else null. Pass `canvasOnly` when a thumbnail copy would be
+ * actively wrong, e.g. anchoring on-canvas chrome to a node that has not
+ * rendered on the canvas yet.
+ */
+export declare function findCanvasElementNode(root: ParentNode, elementId: string, options?: {
+    canvasOnly?: boolean;
+}): HTMLElement | null;
+//# sourceMappingURL=canvas-element-node.d.ts.map

package/dist/pptx/render/canvas-element-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-element-node.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/canvas-element-node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAUH;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACpC,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAO,GACpC,WAAW,GAAG,IAAI,CAOpB"}

package/dist/pptx/render/canvas-size-probe.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Detects the host browser's actual maximum canvas dimension so large raster
+ * exports can be tiled (see `export-tile-plan`) instead of silently
+ * producing a blank or truncated image.
+ *
+ * Browsers do not expose their canvas size cap directly, and exceeding it is
+ * not guaranteed to throw: some implementations clamp the canvas to a
+ * smaller backing size and quietly return blank pixels for anything drawn
+ * past it. The only reliable way to find the real cap is to draw a marker
+ * pixel near a candidate edge and read it back.
+ *
+ * Re-exported (cached) from `../export/canvas-size-probe.ts` for callers in
+ * that directory; this is the implementation.
+ */
+/** A minimal canvas-like surface, duck-typed so tests can inject a fake. */
+export interface ProbeCanvas {
+    width: number;
+    height: number;
+    getContext(id: '2d'): ProbeCanvasContext | null;
+}
+/** The subset of `CanvasRenderingContext2D` the probe needs. */
+export interface ProbeCanvasContext {
+    fillStyle: string | CanvasGradient | CanvasPattern;
+    fillRect(x: number, y: number, w: number, h: number): void;
+    getImageData(x: number, y: number, w: number, h: number): {
+        data: ArrayLike<number>;
+    };
+}
+/** Injectable canvas factory, defaults to `document.createElement('canvas')`. */
+export type CanvasFactory = (width: number, height: number) => ProbeCanvas;
+/**
+ * Candidate maximum dimensions to probe, largest first, drawn from documented
+ * real-world caps: Chromium (~65,535 in theory but practically tested up to
+ * 16,384 reliably), older WebKit (~4,096-8,192), Firefox (~11,180, the
+ * largest square whose area fits a 32-bit index).
+ */
+export declare const CANVAS_DIMENSION_CANDIDATES: readonly number[];
+/**
+ * Probe candidate dimensions (largest first) and return the largest one the
+ * browser actually honours. Falls back to the smallest candidate if every
+ * probe fails outright (e.g. no 2D context available at all, such as in a
+ * DOM-less test environment), so callers always get a usable, conservative
+ * number rather than `undefined`.
+ *
+ * @param factory - Canvas constructor, injectable for testing. Defaults to
+ *                   `document.createElement('canvas')`.
+ */
+export declare function probeMaxCanvasDimension(factory?: CanvasFactory): number;
+/**
+ * Cached wrapper around {@link probeMaxCanvasDimension}: the cap is a
+ * property of the browser/GPU, not of any particular export, so probing once
+ * per session (a handful of tiny canvas allocations) is enough. Exported
+ * separately so tests can reset the cache between runs.
+ */
+export declare function getMaxCanvasDimension(factory?: CanvasFactory): number;
+/** Test-only: clear the memoised probe result. */
+export declare function _resetCanvasDimensionCache(): void;
+//# sourceMappingURL=canvas-size-probe.d.ts.map

package/dist/pptx/render/canvas-size-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-size-probe.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/canvas-size-probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,4EAA4E;AAC5E,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,EAAE,IAAI,GAAG,kBAAkB,GAAG,IAAI,CAAC;CAChD;AAED,gEAAgE;AAChE,MAAM,WAAW,kBAAkB;IAMlC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,aAAa,CAAC;IACnD,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3D,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;KAAE,CAAC;CACtF;AAED,iFAAiF;AACjF,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,WAAW,CAAC;AAE3E;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,EAAE,SAAS,MAAM,EAExD,CAAC;AA0BF;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACtC,OAAO,GAAE,aAKR,GACC,MAAM,CAWR;AAID;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAKrE;AAED,kDAAkD;AAClD,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD"}

package/dist/pptx/render/chart-3d-bar-mesh.d.ts

@@ -0,0 +1,38 @@
+/**
+ * WebGL geometry for a right-angle-axes `bar3D` chart
+ * (`chart-3d-oblique-layout.ts`): one box mesh per bar and the wall/floor
+ * gridlines, in the oblique scene's frame (`chart-3d-view-scene.ts`).
+ *
+ * Scene frame: X/Y in chart px centred on the chart (Y up), Z = minus the
+ * layout's world depth, so the scene camera's shear moves only what recedes.
+ * A layout point `(x, y, z)` sits at scene
+ * `(origin.x + x - W/2, H/2 - origin.y + y, -z)`, which the camera projects to
+ * exactly the chart px `obliqueToScreen` returns.
+ *
+ * Box faces are flat `MeshBasicMaterial`s (PowerPoint shades box faces flat
+ * in chart space, not by lighting) from `chart-3d-shading.ts`'s measured
+ * multipliers. Gridlines are drawn in the scene rather than the SVG overlay
+ * because bars must hide the back-wall lines behind them.
+ *
+ * @module chart-3d-bar-mesh
+ */
+import type * as THREE from 'three';
+import type { ObliqueBar, ObliqueChartLayout } from './chart-3d-oblique-layout.js';
+type ThreeModule = typeof THREE;
+export interface Chart3DBarMeshResult {
+    group: THREE.Group;
+    /** One mesh per bar, same order as `layout.bars`; carries `{ seriesIndex, categoryIndex }` in `userData`. */
+    meshes: THREE.Mesh[];
+    dispose: () => void;
+}
+/** Scene position of a layout world point. */
+export declare function obliqueToScene(layout: ObliqueChartLayout, svgWidth: number, svgHeight: number, p: readonly [number, number, number]): [number, number, number];
+/**
+ * Place (and for a `c:shape` bar, reshape and reshade) a bar's mesh at a
+ * bar's current world box. Used at build time and for the drag preview.
+ */
+export declare function placeObliqueBarMesh(three: ThreeModule, mesh: THREE.Mesh, layout: ObliqueChartLayout, svgWidth: number, svgHeight: number, bar: ObliqueBar): void;
+/** Build the bar boxes and gridlines of an oblique layout into a new group. */
+export declare function buildChart3DBarMeshes(three: ThreeModule, layout: ObliqueChartLayout, svgWidth: number, svgHeight: number): Chart3DBarMeshResult;
+export {};
+//# sourceMappingURL=chart-3d-bar-mesh.d.ts.map

package/dist/pptx/render/chart-3d-bar-mesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-3d-bar-mesh.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/chart-3d-bar-mesh.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAShF,KAAK,WAAW,GAAG,OAAO,KAAK,CAAC;AAKhC,MAAM,WAAW,oBAAoB;IACpC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;IACnB,6GAA6G;IAC7G,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,IAAI,CAAC;CACpB;AAED,8CAA8C;AAC9C,wBAAgB,cAAc,CAC7B,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAClC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAE1B;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,KAAK,CAAC,IAAI,EAChB,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,UAAU,GACb,IAAI,CAqBN;AAED,+EAA+E;AAC/E,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GACf,oBAAoB,CAuDtB"}

package/dist/pptx/render/chart-3d-chrome-overlay.d.ts

@@ -0,0 +1,31 @@
+import type { ChartViewModel, LegendEntry } from './chart-view-model-types.js';
+/** A 3D scene's own axis labels, in chart px. */
+export interface Chart3DBoxLabel {
+    text: string;
+    x: number;
+    y: number;
+    anchor: 'start' | 'middle' | 'end';
+    fontSize: number;
+    /** Defaults to `central` (text centred on `y`). */
+    baseline?: 'central' | 'hanging';
+}
+/**
+ * Chrome for a scene that draws its own plot box (the oblique and perspective
+ * layouts): its labels replace the flat axes, and the title and legend move
+ * to where PowerPoint puts them on a 3D chart.
+ */
+export interface Chart3DBoxChrome {
+    labels: ReadonlyArray<Chart3DBoxLabel>;
+    /** List the legend bottom-up (a clustered horizontal bar chart does). */
+    reverseLegend: boolean;
+    /** Legend entries replacing the flat chart's (a surface lists its value bands). */
+    legend?: LegendEntry[];
+}
+/**
+ * Render a `ChartViewModel`'s chrome (everything except data marks) to an
+ * `<svg>` sized to `vm.svgWidth` x `vm.svgHeight`, matching the WebGL
+ * scene's own world-unit convention (1 world unit = 1 authored chart px) so
+ * an element positioned from the same view-model's rects lines up exactly.
+ */
+export declare function renderChart3DChromeOverlaySvg(doc: Document, source: ChartViewModel, box?: Chart3DBoxChrome): SVGSVGElement;
+//# sourceMappingURL=chart-3d-chrome-overlay.d.ts.map

package/dist/pptx/render/chart-3d-chrome-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-3d-chrome-overlay.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/chart-3d-chrome-overlay.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE5E,iDAAiD;AACjD,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;CACjC;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAChC,MAAM,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IACvC,yEAAyE;IACzE,aAAa,EAAE,OAAO,CAAC;IACvB,mFAAmF;IACnF,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;CACvB;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC5C,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,cAAc,EACtB,GAAG,CAAC,EAAE,gBAAgB,GACpB,aAAa,CA0Ff"}

package/dist/pptx/render/chart-3d-depth.d.ts

@@ -0,0 +1,45 @@
+/**
+ * chart-3d-depth.ts: pseudo-3D depth treatment for the flat chart engine.
+ *
+ * The shared chart engine projects `bar3D` / `pie3D` / `line3D` / `area3D` with
+ * their 2D geometry (folded onto `bar` / `pie` / `line` / `area`). This module
+ * layers a lightweight oblique-projection depth pass on top of that flat output,
+ * driven by the chart's `c:view3D` parameters (`rotX`, `rotY`, `depthPercent`),
+ * so a 3D chart reads as 3D instead of collapsing to a flat plot.
+ *
+ * The pass is deliberately additive: it inserts shaded "extrusion" primitives
+ * BEHIND the existing flat marks (top + side faces for bars, a downward thickness
+ * band for pie slices, an offset ribbon for line/area). It never mutates the
+ * front-face geometry, so interactivity (`part` refs, value-drag) is unchanged.
+ *
+ * @module chart-3d-depth
+ */
+import type { PptxChartView3D } from 'ooxml-core/pptx';
+import type { Chart3DSurfaces } from './chart-3d-surfaces.js';
+import type { BarFacePictureContext } from './chart-bar3d-face-picture.js';
+import type { ChartViewModel } from './chart-view-model.js';
+export type { BarFacePictureContext } from './chart-bar3d-face-picture.js';
+/** Oblique depth offset vector (px) derived from the chart's view3D. */
+export interface DepthVector {
+    dx: number;
+    dy: number;
+    magnitude: number;
+}
+/**
+ * Resolve the oblique depth vector from `c:view3D`. `rotY` drives the horizontal
+ * skew, `rotX` the vertical skew, `depthPercent` the magnitude. Absent values
+ * fall back to PowerPoint-like defaults so an untagged 3D chart still gets depth.
+ */
+export declare function computeDepthVector(view3D: PptxChartView3D | undefined): DepthVector;
+/** Translate a generated pie-slice path (`M`/`L`/`A`/`Z` grammar) by (dx, dy). */
+export declare function translateSlicePath(d: string, dx: number, dy: number): string;
+/**
+ * Apply a pseudo-3D depth pass to a flat view-model for a 3D chart type. Returns
+ * a new view-model whose `primitives` are prefixed with shaded extrusion faces;
+ * non-3D types (or unsupported kinds) return the input unchanged.
+ */
+export declare function applyChart3DDepth(vm: ChartViewModel, chartType: string, view3D: PptxChartView3D | undefined, surfaces?: Chart3DSurfaces, grouping?: 'clustered' | 'stacked' | 'percentStacked', pieCenter?: {
+    cx: number;
+    cy: number;
+}, picture?: BarFacePictureContext): ChartViewModel;
+//# sourceMappingURL=chart-3d-depth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chart-3d-depth.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/chart-3d-depth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAKxE,OAAO,KAAK,EAEX,cAAc,EAMd,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAExE,wEAAwE;AACxE,MAAM,WAAW,WAAW;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CAClB;AAOD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,GAAG,WAAW,CAYnF;AAsCD,kFAAkF;AAClF,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CA+B5E;AA2DD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAChC,EAAE,EAAE,cAAc,EAClB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,eAAe,GAAG,SAAS,EACnC,QAAQ,CAAC,EAAE,eAAe,EAC1B,QAAQ,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,gBAAgB,EACrD,SAAS,CAAC,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EACtC,OAAO,CAAC,EAAE,qBAAqB,GAC7B,cAAc,CAiEhB"}

package/dist/pptx/render/chart-3d-hover-tooltip.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `chart-3d-hover-tooltip`: the identical raycast-pointer-to-native-tooltip
+ * wiring every interactive three.js chart scene (bar3D, line3D, area3D,
+ * pie3D, surface3D) used to define for itself: convert a pointer position to
+ * NDC, raycast it against the scene's marks, and set the canvas element's own
+ * `title` attribute so the browser shows the same native tooltip every other
+ * chart kind's SVG `<title>` mark already gets. Extracted so the five
+ * near-identical copies become one; each scene supplies only its own
+ * mesh list and hit -> tooltip-text mapping (`bar-chart-3d-hit-test.ts` and
+ * its per-kind siblings).
+ *
+ * @module chart-3d-hover-tooltip
+ */
+import type * as THREE from 'three';
+type ThreeModule = typeof THREE;
+/** Options wiring one scene's meshes/camera into the shared hover-tooltip raycaster. */
+export interface Chart3DHoverTooltipOptions {
+    three: ThreeModule;
+    canvas: HTMLCanvasElement;
+    camera: THREE.Camera;
+    /** Meshes to raycast against (a single-element array for a scene with one shared mesh, e.g. surface3D). */
+    meshes: ReadonlyArray<THREE.Object3D>;
+    /** Build the tooltip text for a raycast hit (or `undefined`, when there is none). */
+    buildTooltip: (intersection: THREE.Intersection | undefined) => string | undefined;
+}
+/** Handle returned by {@link attachChart3DHoverTooltip}. */
+export interface Chart3DHoverTooltipHandle {
+    dispose: () => void;
+}
+/** Attach the shared raycast-hover-tooltip wiring to one scene's canvas. */
+export declare function attachChart3DHoverTooltip(options: Chart3DHoverTooltipOptions): Chart3DHoverTooltipHandle;
+export {};
+//# sourceMappingURL=chart-3d-hover-tooltip.d.ts.map

package/dist/pptx/render/chart-3d-hover-tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-3d-hover-tooltip.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/chart-3d-hover-tooltip.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,KAAK,WAAW,GAAG,OAAO,KAAK,CAAC;AAEhC,wFAAwF;AACxF,MAAM,WAAW,0BAA0B;IAC1C,KAAK,EAAE,WAAW,CAAC;IACnB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC;IACrB,2GAA2G;IAC3G,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACtC,qFAAqF;IACrF,YAAY,EAAE,CAAC,YAAY,EAAE,KAAK,CAAC,YAAY,GAAG,SAAS,KAAK,MAAM,GAAG,SAAS,CAAC;CACnF;AAED,4DAA4D;AAC5D,MAAM,WAAW,yBAAyB;IACzC,OAAO,EAAE,MAAM,IAAI,CAAC;CACpB;AAED,4EAA4E;AAC5E,wBAAgB,yBAAyB,CACxC,OAAO,EAAE,0BAA0B,GACjC,yBAAyB,CAsC3B"}

package/dist/pptx/render/chart-3d-interaction.d.ts

@@ -0,0 +1,79 @@
+/**
+ * `chart-3d-interaction`: framework-neutral, three.js-free maths for
+ * click-to-select and drag-to-value on the opt-in true-3D chart scenes
+ * (bar3D / line3D / area3D / pie3D / surface3D).
+ *
+ * The 3D scenes already raycast pointer moves against their meshes for hover
+ * tooltips (`bar-chart-3d-hit-test.ts`, `cartesian-chart-3d-hit-test.ts`,
+ * `pie-chart-3d-hit-test.ts`, `surface-chart-3d-hit-test.ts`). This module
+ * turns that SAME raycast hit into the identical {@link ChartPartRef} the 2D
+ * chart-interaction model (`chart-interaction.ts`, `chart-canvas-drag.ts`)
+ * already uses, so a 3D mark selection drives the same inspector panel a 2D
+ * mark does.
+ *
+ * Drag-to-value has no single fixed screen axis to divide a pointer delta by
+ * (unlike the 2D SVG, which is always dragged along its own vertical pixel
+ * axis): the scene's camera can be orbited to any angle, so "up" on screen is
+ * not fixed. Instead the scene (which owns the camera) projects two points
+ * already known to sit on the mark's OWN value axis, at two distinct data
+ * values, to screen space, and this module turns that screen-space
+ * calibration plus a pointer delta into a value delta. Kept free of any
+ * `three` import so it is unit-testable with plain numbers.
+ *
+ * @module chart-3d-interaction
+ */
+import type { ChartPartRef } from './chart-view-model.js';
+/**
+ * Minimum pointer travel (px) before a mark press becomes a value drag,
+ * mirroring {@link CHART_DRAG_THRESHOLD_PX} (`chart-canvas-drag.ts`): without
+ * a threshold, every click on a mark would commit a (tiny) value change, so a
+ * user could never select a mark without editing it.
+ */
+export declare const CHART_3D_DRAG_THRESHOLD_PX = 3;
+/** Emissive colour + intensity applied to a selected mark's material. */
+export declare const CHART_3D_SELECTED_EMISSIVE = "#3b82f6";
+export declare const CHART_3D_SELECTED_EMISSIVE_INTENSITY = 0.55;
+/** The (series, point) a 3D raycast hit landed on. Every hit-test module's `*Hit` shape already carries this, just under kind-specific field names. */
+export interface Chart3DMarkHit {
+    seriesIndex: number;
+    pointIndex: number;
+}
+/**
+ * Map a 3D raycast hit (or none) to the same selection descriptor the 2D
+ * chart-interaction model uses.
+ */
+export declare function chart3DHitToPartRef(hit: Chart3DMarkHit | null | undefined): ChartPartRef | null;
+/** Whether a mesh's own (series, point) reference is the currently-selected part. */
+export declare function chart3DMarkMatchesPart(mark: Chart3DMarkHit, part: ChartPartRef | null | undefined): boolean;
+/** A 2D point in CSS pixels (screen space). */
+export interface ScreenPoint2D {
+    x: number;
+    y: number;
+}
+/** Screen-space calibration of a mark's value axis, valid only until the camera next moves. */
+export interface Chart3DValueAxisCalibration {
+    /** Screen-space unit vector pointing in the direction of increasing value. */
+    directionScreen: ScreenPoint2D;
+    /** Screen pixels of travel, along {@link directionScreen}, per +1 data value unit. */
+    pixelsPerUnit: number;
+}
+/**
+ * Calibrate a value axis from two already-projected screen points known to
+ * correspond to two distinct data values on the same mark (e.g. its
+ * value-zero base and its current top). Returns `null` when the two values
+ * coincide or the two screen points are (near) coincident (camera looking
+ * straight down the axis), since no calibration is possible.
+ *
+ * Order-independent: swapping `(screenAtValue0, value0)` with
+ * `(screenAtValue1, value1)` yields the same {@link chart3DPointerDeltaToValueDelta}
+ * result, since the direction vector and `pixelsPerUnit` sign flip together.
+ */
+export declare function calibrateChart3DValueAxis(screenAtValue0: ScreenPoint2D, value0: number, screenAtValue1: ScreenPoint2D, value1: number): Chart3DValueAxisCalibration | null;
+/**
+ * Convert a screen-space pointer delta (current position minus drag-start
+ * position, in CSS px) into a value delta, using a calibration taken at drag
+ * start. Add the result to the mark's value at drag start to get the live
+ * (or committed) dragged value.
+ */
+export declare function chart3DPointerDeltaToValueDelta(calibration: Chart3DValueAxisCalibration, pointerDeltaScreen: ScreenPoint2D): number;
+//# sourceMappingURL=chart-3d-interaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chart-3d-interaction.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/chart-3d-interaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C,yEAAyE;AACzE,eAAO,MAAM,0BAA0B,YAAY,CAAC;AACpD,eAAO,MAAM,oCAAoC,OAAO,CAAC;AAEzD,uJAAuJ;AACvJ,MAAM,WAAW,cAAc;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,GAAG,IAAI,CAK/F;AAED,qFAAqF;AACrF,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,GACnC,OAAO,CAQT;AAED,+CAA+C;AAC/C,MAAM,WAAW,aAAa;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,+FAA+F;AAC/F,MAAM,WAAW,2BAA2B;IAC3C,8EAA8E;IAC9E,eAAe,EAAE,aAAa,CAAC;IAC/B,sFAAsF;IACtF,aAAa,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACxC,cAAc,EAAE,aAAa,EAC7B,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,aAAa,EAC7B,MAAM,EAAE,MAAM,GACZ,2BAA2B,GAAG,IAAI,CAYpC;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC9C,WAAW,EAAE,2BAA2B,EACxC,kBAAkB,EAAE,aAAa,GAC/B,MAAM,CAKR"}

package/dist/pptx/render/chart-3d-mark-interaction.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Pointer interaction shared by the 3D chart scenes (`chart-3d-view-scene.ts`):
+ * hover tooltip, click-to-select and drag-to-value on WebGL marks.
+ *
+ * A scene describes its marks through a {@link Chart3DMarkAdapter} (which data
+ * point a ray hit, its value, how a drag previews, how a selection is drawn);
+ * everything about pointer handling lives here once. As in the 2D chart, the
+ * scene only claims a press while the chart is armed for editing
+ * (`isChartInteractionArmed`), and a drag commits one value on release.
+ *
+ * Picking casts its own ray from the camera's inverse projection instead of
+ * `Raycaster.setFromCamera`: the oblique camera carries a hand-inserted
+ * shear and the perspective camera an off-centre projection, neither of which
+ * `setFromCamera` models. Unprojecting the near and far NDC points through the
+ * full inverse projection is exact for both.
+ *
+ * @module chart-3d-mark-interaction
+ */
+import type { PptxChartData } from 'ooxml-core/pptx';
+import type * as THREE from 'three';
+import type { ThreeViewContext } from '../three-view/types.js';
+import type { ChartPartRef } from './chart-view-model.js';
+/** A data point, as the chart's series / category indices. */
+export interface Chart3DPoint {
+    seriesIndex: number;
+    pointIndex: number;
+}
+/** A live value drag on one mark. */
+export interface Chart3DMarkDrag {
+    /**
+     * Preview the value for a pointer delta in chart px (`dx` right, `dy`
+     * down), `at` being the pointer's chart px position; returns the value.
+     */
+    preview: (dx: number, dy: number, at: {
+        x: number;
+        y: number;
+    }) => number;
+}
+export interface Chart3DMarkAdapter {
+    /** The objects rays are cast against. */
+    targets: ReadonlyArray<THREE.Object3D>;
+    /** The data point under a hit, or `null` for none. */
+    pointAt: (hit: THREE.Intersection) => Chart3DPoint | null;
+    /** A data point's authored value, or `undefined` when it has none. */
+    valueOf: (point: Chart3DPoint) => number | undefined;
+    /** Start a value drag on a point, or `null` when it is not draggable. */
+    beginDrag: (point: Chart3DPoint) => Chart3DMarkDrag | null;
+    /** Draw (or clear) the selection. */
+    highlight: (point: Chart3DPoint | null) => void;
+    dispose?: () => void;
+}
+export interface Chart3DMarkInteractionOptions {
+    ctx: ThreeViewContext;
+    camera: THREE.Camera;
+    /** Root refreshed before picking (world matrices only update on render otherwise). */
+    scene: THREE.Object3D;
+    /** Chart px height of the view (client px convert to chart px through it). */
+    svgHeight: number;
+    chartData: PptxChartData;
+    categoryLabels: ReadonlyArray<string>;
+    seriesNames: ReadonlyArray<string>;
+    adapter: Chart3DMarkAdapter;
+}
+export interface Chart3DMarkInteraction {
+    setInteractive: (on: boolean) => void;
+    setSelectedPart: (part: ChartPartRef | null) => void;
+    dispose: () => void;
+}
+/** Attach hover/select/drag to a 3D chart scene's marks. */
+export declare function attachChart3DMarkInteraction(options: Chart3DMarkInteractionOptions): Chart3DMarkInteraction;
+//# sourceMappingURL=chart-3d-mark-interaction.d.ts.map

package/dist/pptx/render/chart-3d-mark-interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-3d-mark-interaction.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/chart-3d-mark-interaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAI5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,8DAA8D;AAC9D,MAAM,WAAW,YAAY;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,qCAAqC;AACrC,MAAM,WAAW,eAAe;IAC/B;;;OAGG;IACH,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM,CAAC;CAC1E;AAED,MAAM,WAAW,kBAAkB;IAClC,yCAAyC;IACzC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACvC,sDAAsD;IACtD,OAAO,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,YAAY,KAAK,YAAY,GAAG,IAAI,CAAC;IAC1D,sEAAsE;IACtE,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,MAAM,GAAG,SAAS,CAAC;IACrD,yEAAyE;IACzE,SAAS,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,eAAe,GAAG,IAAI,CAAC;IAC3D,qCAAqC;IACrC,SAAS,EAAE,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,KAAK,IAAI,CAAC;IAChD,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,MAAM,WAAW,6BAA6B;IAC7C,GAAG,EAAE,gBAAgB,CAAC;IACtB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC;IACrB,sFAAsF;IACtF,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC;IACtB,8EAA8E;IAC9E,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,aAAa,CAAC;IACzB,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC,OAAO,EAAE,kBAAkB,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACtC,cAAc,EAAE,CAAC,EAAE,EAAE,OAAO,KAAK,IAAI,CAAC;IACtC,eAAe,EAAE,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,KAAK,IAAI,CAAC;IACrD,OAAO,EAAE,MAAM,IAAI,CAAC;CACpB;AAkBD,4DAA4D;AAC5D,wBAAgB,4BAA4B,CAC3C,OAAO,EAAE,6BAA6B,GACpC,sBAAsB,CAgJxB"}

package/dist/pptx/render/chart-3d-mesh-highlight.d.ts

@@ -0,0 +1,22 @@
+import type { Chart3DMarkHit } from './chart-3d-interaction.js';
+import type { ChartPartRef } from './chart-view-model.js';
+/** The subset of a `THREE.MeshPhongMaterial`/`MeshStandardMaterial` this needs. */
+export interface HighlightableMaterial {
+    emissive: {
+        set: (color: string) => void;
+    };
+    emissiveIntensity: number;
+}
+/** One mesh's material(s): a single material, or a per-face array (a multi-material mesh). */
+export type HighlightableMaterialRef = HighlightableMaterial | readonly HighlightableMaterial[];
+/**
+ * Apply (or clear) the selected-mark emissive highlight across a scene's
+ * mark meshes. `entries` pairs each mesh's own (series, point) reference with
+ * its material (or, for a multi-material mesh, every material in its
+ * per-face array); every entry not matching `part` is reset to no highlight.
+ */
+export declare function applyChart3DMeshHighlight(entries: ReadonlyArray<{
+    mark: Chart3DMarkHit;
+    material: HighlightableMaterialRef;
+}>, part: ChartPartRef | null): void;
+//# sourceMappingURL=chart-3d-mesh-highlight.d.ts.map

package/dist/pptx/render/chart-3d-mesh-highlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-3d-mesh-highlight.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/chart-3d-mesh-highlight.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,mFAAmF;AACnF,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE;QAAE,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;IAC3C,iBAAiB,EAAE,MAAM,CAAC;CAC1B;AAED,8FAA8F;AAC9F,MAAM,MAAM,wBAAwB,GAAG,qBAAqB,GAAG,SAAS,qBAAqB,EAAE,CAAC;AAIhG;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACxC,OAAO,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,wBAAwB,CAAA;CAAE,CAAC,EACpF,IAAI,EAAE,YAAY,GAAG,IAAI,GACvB,IAAI,CASN"}

package/dist/pptx/render/chart-3d-oblique-bars.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Bars, gridlines and value-label text for the right-angle-axes 3D bar chart
+ * (`chart-3d-oblique-layout.ts`), in the layout's world space.
+ *
+ * @module chart-3d-oblique-bars
+ */
+import type { PptxBar3DShape, PptxChartData } from 'ooxml-core/pptx';
+import type { ObliqueBar, ObliqueChartLayout, ObliqueGridline, ObliqueTaper } from './chart-3d-oblique-layout.js';
+import type { ChartViewModel } from './chart-view-model-types.js';
+type Grouping = ObliqueChartLayout['grouping'];
+/** Value-axis label text (`percentStacked` axes read as whole percents). */
+export declare function formatValueLabel(chartData: PptxChartData, grouping: Grouping, v: number): string;
+/**
+ * A shaped bar's taper between world positions `lo` and `hi` along a value
+ * axis `extent` long. A cone or pyramid comes to a point at its value end
+ * (the far end from the baseline, so a negative bar points down); the
+ * `...ToMax` shapes are slices of one solid whose apex sits at the axis end.
+ */
+export declare function obliqueBarTaper(shape: PptxBar3DShape, lo: number, hi: number, extent: number, value: number): ObliqueTaper;
+export declare function buildBars(chartData: PptxChartData, vm: ChartViewModel, layout: ObliqueChartLayout, dims: {
+    nCat: number;
+    slots: number;
+    rows: number;
+    gapWidth: number;
+    gapDepth: number;
+}): ObliqueBar[];
+export declare function buildGridlines(layout: ObliqueChartLayout): ObliqueGridline[];
+export {};
+//# sourceMappingURL=chart-3d-oblique-bars.d.ts.map

package/dist/pptx/render/chart-3d-oblique-bars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-3d-oblique-bars.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/chart-3d-oblique-bars.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErE,OAAO,KAAK,EACX,UAAU,EACV,kBAAkB,EAClB,eAAe,EACf,YAAY,EACZ,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,KAAK,QAAQ,GAAG,kBAAkB,CAAC,UAAU,CAAC,CAAC;AAE/C,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAQhG;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,cAAc,EACrB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACX,YAAY,CAad;AAOD,wBAAgB,SAAS,CACxB,SAAS,EAAE,aAAa,EACxB,EAAE,EAAE,cAAc,EAClB,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACrF,UAAU,EAAE,CAsDd;AAUD,wBAAgB,cAAc,CAAC,MAAM,EAAE,kBAAkB,GAAG,eAAe,EAAE,CAa5E"}

package/dist/pptx/render/chart-3d-oblique-drag.d.ts

@@ -0,0 +1,19 @@
+import type { ObliqueBar, ObliqueChartLayout } from './chart-3d-oblique-layout.js';
+/** Whether a bar in this layout can be value-dragged. */
+export declare function isObliqueBarDraggable(layout: Pick<ObliqueChartLayout, 'grouping'>): boolean;
+/**
+ * The value after dragging by a pointer delta, in chart px (`dx` right,
+ * `dy` down).
+ */
+export declare function obliqueDragValue(layout: Pick<ObliqueChartLayout, 'horizontal' | 'range' | 'valueScale'>, startValue: number, dx: number, dy: number): number;
+/**
+ * A bar's extent along the value axis after a drag to `value` (the baseline
+ * end stays put), clipped to the axis, in the layout's world units.
+ */
+export declare function obliqueDraggedExtent(layout: Pick<ObliqueChartLayout, 'range' | 'valueScale'>, value: number): {
+    from: number;
+    length: number;
+};
+/** `bar` with its value-axis extent (and taper) replaced: a live drag preview. */
+export declare function obliqueBarAtValue(layout: Pick<ObliqueChartLayout, 'horizontal' | 'range' | 'valueScale'>, bar: ObliqueBar, value: number): ObliqueBar;
+//# sourceMappingURL=chart-3d-oblique-drag.d.ts.map

package/dist/pptx/render/chart-3d-oblique-drag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-3d-oblique-drag.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/chart-3d-oblique-drag.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAGhF,yDAAyD;AACzD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,GAAG,OAAO,CAE3F;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,YAAY,GAAG,OAAO,GAAG,YAAY,CAAC,EACvE,UAAU,EAAE,MAAM,EAClB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACR,MAAM,CAKR;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,OAAO,GAAG,YAAY,CAAC,EACxD,KAAK,EAAE,MAAM,GACX;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAOlC;AAED,kFAAkF;AAClF,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,YAAY,GAAG,OAAO,GAAG,YAAY,CAAC,EACvE,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,MAAM,GACX,UAAU,CAOZ"}

package/dist/pptx/render/chart-3d-oblique-interaction.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Pointer interaction for the oblique `bar3D` scene (`chart-3d-view-scene.ts`):
+ * the {@link Chart3DMarkAdapter} for its boxes, on the shared hover/select/
+ * drag handling of `chart-3d-mark-interaction.ts`.
+ *
+ * Bars come from the right-angle-axes layout (`chart-3d-oblique-layout.ts`);
+ * a value drag moves along that layout's value axis with its own scale
+ * (`chart-3d-oblique-drag.ts`), vertically for columns and horizontally for
+ * a `c:barDir="bar"` chart. As in the 2D chart, stacked segments select but
+ * never drag.
+ *
+ * @module chart-3d-oblique-interaction
+ */
+import type { PptxChartData } from 'ooxml-core/pptx';
+import type * as THREE from 'three';
+import type { ThreeViewContext } from '../three-view/types.js';
+import type { Chart3DMarkInteraction } from './chart-3d-mark-interaction.js';
+import type { ObliqueChartLayout } from './chart-3d-oblique-layout.js';
+export interface ObliqueBarInteractionOptions {
+    ctx: ThreeViewContext;
+    camera: THREE.Camera;
+    meshes: ReadonlyArray<THREE.Mesh>;
+    layout: ObliqueChartLayout;
+    /** Chart px size of the view-box the scene frame is centred on. */
+    svgWidth: number;
+    svgHeight: number;
+    chartData: PptxChartData;
+    categoryLabels: ReadonlyArray<string>;
+    seriesNames: ReadonlyArray<string>;
+    /** Scene the selection outline is added to. */
+    scene: THREE.Object3D;
+}
+export type ObliqueBarInteraction = Chart3DMarkInteraction;
+/** Attach hover/select/drag to an oblique bar scene's boxes. */
+export declare function attachObliqueBarInteraction(options: ObliqueBarInteractionOptions): ObliqueBarInteraction;
+//# sourceMappingURL=chart-3d-oblique-interaction.d.ts.map

package/dist/pptx/render/chart-3d-oblique-interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-3d-oblique-interaction.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/chart-3d-oblique-interaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAG5D,OAAO,KAAK,EAAE,sBAAsB,EAAgB,MAAM,6BAA6B,CAAC;AAMxF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAKpE,MAAM,WAAW,4BAA4B;IAC5C,GAAG,EAAE,gBAAgB,CAAC;IACtB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC;IACrB,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAClC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,aAAa,CAAC;IACzB,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC,+CAA+C;IAC/C,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC;CACtB;AAED,MAAM,MAAM,qBAAqB,GAAG,sBAAsB,CAAC;AAE3D,gEAAgE;AAChE,wBAAgB,2BAA2B,CAC1C,OAAO,EAAE,4BAA4B,GACnC,qBAAqB,CA+EvB"}