ooxml-ui 0.30.0 → 0.31.0

package/dist/pptx/chunk-ZJFN5POF.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+var pptx = require('ooxml-core/pptx');
+
+// src/pptx/render/image-file-insertion.ts
+var isPositiveFinite = (value) => Number.isFinite(value) && value > 0;
+function createImageElementFromFile(file, canvasSize, signal) {
+  const { width: canvasWidth, height: canvasHeight } = canvasSize;
+  if (!file.type.startsWith("image/") || file.size === 0 || !isPositiveFinite(canvasWidth) || !isPositiveFinite(canvasHeight) || signal?.aborted || typeof FileReader === "undefined" || typeof Image === "undefined") {
+    return Promise.resolve(null);
+  }
+  return new Promise((resolve) => {
+    let reader;
+    let image;
+    let settled = false;
+    const finish = (element) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      signal?.removeEventListener("abort", abort);
+      if (reader) {
+        reader.onload = reader.onerror = reader.onabort = null;
+        if (reader.readyState === 1) {
+          reader.abort();
+        }
+      }
+      if (image) {
+        image.onload = image.onerror = null;
+        image.removeAttribute("src");
+      }
+      resolve(element);
+    };
+    const abort = () => finish(null);
+    try {
+      reader = new FileReader();
+      reader.onerror = reader.onabort = abort;
+      reader.onload = () => {
+        const dataUrl = reader?.result;
+        if (typeof dataUrl !== "string" || !dataUrl.startsWith("data:image/")) {
+          finish(null);
+          return;
+        }
+        try {
+          image = new Image();
+          image.onerror = abort;
+          image.onload = () => {
+            const naturalWidth = image.naturalWidth;
+            const naturalHeight = image.naturalHeight;
+            if (!isPositiveFinite(naturalWidth) || !isPositiveFinite(naturalHeight)) {
+              finish(null);
+              return;
+            }
+            const scale = Math.min(1, canvasWidth / naturalWidth, canvasHeight / naturalHeight);
+            const width = naturalWidth * scale;
+            const height = naturalHeight * scale;
+            if (!isPositiveFinite(width) || !isPositiveFinite(height)) {
+              finish(null);
+              return;
+            }
+            finish(
+              pptx.createImageElement(dataUrl, {
+                x: (canvasWidth - width) / 2,
+                y: (canvasHeight - height) / 2,
+                width,
+                height
+              })
+            );
+          };
+          image.src = dataUrl;
+        } catch {
+          finish(null);
+        }
+      };
+      signal?.addEventListener("abort", abort, { once: true });
+      reader.readAsDataURL(file);
+    } catch {
+      finish(null);
+    }
+  });
+}
+
+exports.createImageElementFromFile = createImageElementFromFile;

package/dist/pptx/constants.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Scalar viewer defaults shared by the UI bindings.
+ *
+ * Subset of the React package's `constants/scalar.ts` that the Vue and Angular
+ * viewers also need. Additional constant groups (toolbar presets, shape styles,
+ * transitions, etc.) remain per-binding until those features are ported.
+ */
+/** Default slide canvas width in pixels when the file declares none. */
+export declare const DEFAULT_CANVAS_WIDTH = 1280;
+/** Default slide canvas height in pixels when the file declares none. */
+export declare const DEFAULT_CANVAS_HEIGHT = 720;
+/** Fallback text colour. */
+export declare const DEFAULT_TEXT_COLOR = "#111827";
+/** Fallback shape fill colour. */
+export declare const DEFAULT_FILL_COLOR = "#3b82f6";
+/** Fallback shape stroke colour. */
+export declare const DEFAULT_STROKE_COLOR = "#1f2937";
+/** Colour PowerPoint paints hyperlinked text in when the theme declares none. */
+export declare const HYPERLINK_COLOR = "#0563C1";
+/**
+ * Font stack declared on a text body that authors no typeface.
+ *
+ * Declaring one is not cosmetic: with no `font-family` on the body, a run that
+ * inherits (a bullet marker, an unstyled run) picks up the HOST PAGE's font,
+ * so the same deck measured different advances in each binding's demo chrome.
+ */
+export declare const DEFAULT_FONT_FAMILY = "\"Segoe UI\", \"Helvetica Neue\", Arial, sans-serif";
+/** Font size in px for a text body that authors none (PowerPoint's 18pt body). */
+export declare const DEFAULT_TEXT_FONT_SIZE = 24;
+/**
+ * OOXML default body text insets in px (`a:bodyPr` lIns/rIns = 91440 EMU,
+ * tIns/bIns = 45720 EMU, divided by EMU_PER_PIXEL).
+ */
+export declare const DEFAULT_BODY_INSET_LR_PX: number;
+/** See {@link DEFAULT_BODY_INSET_LR_PX}. */
+export declare const DEFAULT_BODY_INSET_TB_PX: number;
+//# sourceMappingURL=constants.d.ts.map

package/dist/pptx/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/pptx/constants.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,wEAAwE;AACxE,eAAO,MAAM,oBAAoB,OAAO,CAAC;AACzC,yEAAyE;AACzE,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,4BAA4B;AAC5B,eAAO,MAAM,kBAAkB,YAAY,CAAC;AAC5C,kCAAkC;AAClC,eAAO,MAAM,kBAAkB,YAAY,CAAC;AAC5C,oCAAoC;AACpC,eAAO,MAAM,oBAAoB,YAAY,CAAC;AAC9C,iFAAiF;AACjF,eAAO,MAAM,eAAe,YAAY,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,wDAAoD,CAAC;AACrF,kFAAkF;AAClF,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC;;;GAGG;AACH,eAAO,MAAM,wBAAwB,QAAe,CAAC;AACrD,4CAA4C;AAC5C,eAAO,MAAM,wBAAwB,QAAe,CAAC"}

package/dist/pptx/dom/activex-controls-overlay.d.ts

@@ -0,0 +1,13 @@
+import type { PptxActiveXControl } from 'ooxml-core/pptx';
+import type { CanvasSize } from '../index.js';
+/**
+ * ActiveX controls (`p:controls > p:control`) cannot run inside a viewer.
+ * Draw each one's static fallback picture when core resolved one, otherwise
+ * a labelled placeholder badge, so the slide shows where the control lives
+ * instead of a blank gap (React-only before this; the other bindings drew
+ * nothing). Split out of `slide-stage.ts` to keep it inside the file-size
+ * budget; see {@link getActiveXControlOverlayView} for the shared geometry
+ * decision this maps onto DOM.
+ */
+export declare function buildActiveXControlsOverlay(doc: Document, controls: readonly PptxActiveXControl[], canvasSize: CanvasSize): HTMLElement;
+//# sourceMappingURL=activex-controls-overlay.d.ts.map

package/dist/pptx/dom/activex-controls-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activex-controls-overlay.d.ts","sourceRoot":"","sources":["../../../src/pptx/dom/activex-controls-overlay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAK3C;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAC1C,GAAG,EAAE,QAAQ,EACb,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,UAAU,EAAE,UAAU,GACpB,WAAW,CA8Bb"}

package/dist/pptx/dom/comment-markers.d.ts

@@ -0,0 +1,19 @@
+import type { PptxComment } from 'ooxml-core/pptx';
+import type { CanvasSize } from '../index.js';
+import type { Translator } from '../i18n/translator.js';
+/**
+ * Append the numbered comment marker dots to a slide stage (Vanilla port of
+ * React's `canvas/CommentMarkersOverlay.tsx` / Vue's
+ * `CommentMarkersOverlay.vue`). The descriptors (position clamped to the
+ * slide or a 4-column grid fallback, 1-based numbering, and the
+ * `"<author>: <text>"` tooltip) come from the shared `buildCommentMarkers`,
+ * so the dots match every other binding.
+ *
+ * The overlay lives INSIDE the stage (the `aria-roledescription="slide"`
+ * region, the framework-neutral e2e hook), authored in raw slide coordinates
+ * so the stage's CSS scale applies exactly once. The stage is rebuilt on
+ * every store change, so the dots track the comment model with no
+ * subscription of their own.
+ */
+export declare function appendCommentMarkers(doc: Document, stage: HTMLElement, comments: readonly PptxComment[], canvasSize: CanvasSize, t: Translator, onMarkerClick?: (commentId: string) => void): void;
+//# sourceMappingURL=comment-markers.d.ts.map

package/dist/pptx/dom/comment-markers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment-markers.d.ts","sourceRoot":"","sources":["../../../src/pptx/dom/comment-markers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAG3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CACnC,GAAG,EAAE,QAAQ,EACb,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,UAAU,EAAE,UAAU,EACtB,CAAC,EAAE,UAAU,EACb,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,GACzC,IAAI,CAgDN"}

package/dist/pptx/dom/dom.d.ts

@@ -0,0 +1,19 @@
+import type { CssStyleMap } from '../index.js';
+/**
+ * Apply a shared `CssStyleMap` to an element. The shared builders emit a mix
+ * of camelCase (`backgroundColor`) and kebab-case (`background-color`) keys;
+ * both are normalised to `style.setProperty` calls.
+ */
+export declare function applyStyleMap(el: HTMLElement | SVGElement, style: CssStyleMap): void;
+/** Create an element with an optional class and style map. */
+export declare function createEl<K extends keyof HTMLElementTagNameMap>(doc: Document, tag: K, className?: string, style?: CssStyleMap): HTMLElementTagNameMap[K];
+/** Create a namespaced SVG element with optional attributes. */
+export declare function createSvgEl<K extends keyof SVGElementTagNameMap>(doc: Document, tag: K, attrs?: Record<string, string | number | undefined>): SVGElementTagNameMap[K];
+/** Set attributes on an SVG element, skipping undefined values. */
+export declare function setSvgAttrs(el: SVGElement, attrs: Record<string, string | number | undefined>): void;
+/**
+ * Compose two transform strings (either may be empty/undefined). Used to merge
+ * the container's rotation/flip transform with style-layer transforms (3D).
+ */
+export declare function composeTransforms(first: string | number | undefined, second: string | number | undefined): string | undefined;
+//# sourceMappingURL=dom.d.ts.map

package/dist/pptx/dom/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../../src/pptx/dom/dom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAa5C;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,WAAW,GAAG,UAAU,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAQpF;AAED,8DAA8D;AAC9D,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,qBAAqB,EAC7D,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,CAAC,EACN,SAAS,CAAC,EAAE,MAAM,EAClB,KAAK,CAAC,EAAE,WAAW,GACjB,qBAAqB,CAAC,CAAC,CAAC,CAS1B;AAID,gEAAgE;AAChE,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,oBAAoB,EAC/D,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,CAAC,EACN,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,GACjD,oBAAoB,CAAC,CAAC,CAAC,CAMzB;AAED,mEAAmE;AACnE,wBAAgB,WAAW,CAC1B,EAAE,EAAE,UAAU,EACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,GAChD,IAAI,CAMN;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAChC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAClC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GACjC,MAAM,GAAG,SAAS,CAOpB"}

package/dist/pptx/dom/element-styles.d.ts

@@ -0,0 +1,26 @@
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { CssStyleMap } from '../index.js';
+/**
+ * Fill / stroke / effects / 3D / corner geometry for shape-like elements.
+ * Returns an empty map when the element carries no shape styling. Mirrors the
+ * Vue binding's `getShapeFillStrokeStyle` cascade.
+ */
+export declare function getShapeFillStrokeStyle(el: PptxElement, animatesFill?: boolean, animatesStroke?: boolean): CssStyleMap;
+/**
+ * Text block style (flex column, body insets, font, alignment, writing mode).
+ *
+ * A thin adapter over the shared {@link buildTextBlockStyle}, which React
+ * renders from too. This used to be a hand-ported copy of React's builder, and
+ * the copy had silently lost `a:normAutofit` (a shrink-to-fit title painted 43%
+ * too large), `a:bodyPr/@wrap="none"` (a no-wrap line wrapped to three), the
+ * default font declaration, the italic padding nudge and the body
+ * margin/indent pair. `pxLengths` is required because these maps are written
+ * straight onto `element.style`, where a bare number is not a length.
+ *
+ * Also folds in the text body's 3D scene (`a:bodyPr/a:scene3d` -> CSS
+ * `perspective` + `rotate` transform), mirroring React/Vue/Angular's
+ * `ElementBody`. The scene transform is COMPOSED with any existing text-block
+ * transform rather than clobbering it; a no-op for the common no-scene3d case.
+ */
+export declare function getTextBlockStyle(el: PptxElement): CssStyleMap;
+//# sourceMappingURL=element-styles.d.ts.map

package/dist/pptx/dom/element-styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-styles.d.ts","sourceRoot":"","sources":["../../../src/pptx/dom/element-styles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAmB,WAAW,EAAE,MAAM,UAAU,CAAC;AAkF7D;;;;GAIG;AACH,wBAAgB,uBAAuB,CACtC,EAAE,EAAE,WAAW,EAIf,YAAY,CAAC,EAAE,OAAO,EACtB,cAAc,CAAC,EAAE,OAAO,GACtB,WAAW,CA0Ib;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,WAAW,GAAG,WAAW,CAmB9D"}

package/dist/pptx/dom/elements/chart-editable.d.ts

@@ -0,0 +1,29 @@
+import type { PptxChartData, PptxElement } from 'ooxml-core/pptx';
+import type { ElementRenderContext } from '../types.js';
+/**
+ * chart-editable: direct on-canvas chart editing for the vanilla binding, the
+ * counterpart of `smartart-editable.ts` and the port of Vue's
+ * `useChartCanvasInteraction`.
+ *
+ * The drag state machine, the hit-target stylesheet and the selected-mark
+ * highlight all live in `pptx-viewer-shared/render/chart-canvas-drag`; this
+ * module is only the DOM listener plumbing, so a change to the drag maths
+ * reaches all five bindings at once.
+ *
+ * Press a bar / dot / slice to select it, drag it vertically to change its
+ * value (live local preview, committed ONCE on release so one drag is one undo
+ * step), Escape cancels. The projector always emits the `data-chart-*`
+ * attributes but they stay pointer-transparent until the container carries
+ * `pptx-chart-interactive`, which is what keeps thumbnails and the show stage
+ * inert.
+ *
+ * A press also reports the part through `context.onChartPartSelect`, which
+ * the app stores and threads back down as `context.chartPartSelection`. That
+ * round trip is what lets the chart inspector (`chart-data-grid.ts` /
+ * `chart-point-index.ts`) ring-highlight and scroll to the matching row, the
+ * vanilla counterpart of Vue's `chart-part-selection` provide/inject bridge.
+ */
+export declare function attachChartEditing(container: HTMLElement, element: PptxElement, context: ElementRenderContext, 
+/** Re-project the chart into `container` from the given (preview) data. */
+repaint: (chartData: PptxChartData) => void): void;
+//# sourceMappingURL=chart-editable.d.ts.map

package/dist/pptx/dom/elements/chart-editable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-editable.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/chart-editable.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAoB,aAAa,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAmBpF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CACjC,SAAS,EAAE,WAAW,EACtB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,oBAAoB;AAC7B,2EAA2E;AAC3E,OAAO,EAAE,CAAC,SAAS,EAAE,aAAa,KAAK,IAAI,GACzC,IAAI,CAiON"}

package/dist/pptx/dom/elements/chart-svg.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Vanilla projector for the framework-agnostic chart view-model engine.
+ *
+ * The pure-DOM renderer now lives in `pptx-viewer-shared`
+ * (`render/chart-view-model-dom.ts`) so the 3D chart scene can draw the same
+ * SVG chrome; this module keeps the binding's historical import path.
+ */
+export { renderChartViewModelSvg } from '../../index.js';
+//# sourceMappingURL=chart-svg.d.ts.map

package/dist/pptx/dom/elements/chart-svg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-svg.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/chart-svg.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC"}

package/dist/pptx/dom/elements/chart-title-editor.d.ts

@@ -0,0 +1,3 @@
+/** Open a chart-title input; Enter/blur commit and Escape cancels. */
+export declare function createChartTitleEditor(container: HTMLElement, onCommit: (value: string) => void): (initialValue: string) => void;
+//# sourceMappingURL=chart-title-editor.d.ts.map

package/dist/pptx/dom/elements/chart-title-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-title-editor.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/chart-title-editor.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,wBAAgB,sBAAsB,CACrC,SAAS,EAAE,WAAW,EACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAC/B,CAAC,YAAY,EAAE,MAAM,KAAK,IAAI,CA2ChC"}

package/dist/pptx/dom/elements/chart.d.ts

@@ -0,0 +1,40 @@
+import type { PptxChartData } from 'ooxml-core/pptx';
+import type { ElementRenderer } from '../types.js';
+/**
+ * Renderer for `chart` elements: the flat SVG below, upgraded to the shared
+ * `<pptx-three-view>` 3D scene when the host opted this raw `c:chartType`
+ * into 3D (`PptxViewerOptions.barChart3D` / `lineChart3D` / `areaChart3D` /
+ * `pieChart3D` / `surfaceChart3D`; `resolveChartThreeViewSpec` decides). The
+ * SVG becomes the element's slotted fallback, and a 3D mark's click/drag
+ * feeds the SAME `onChartPartSelect` / `onChartPointChange` path as a 2D one.
+ */
+export declare const renderChartElement: ElementRenderer;
+/**
+ * The flat SVG chart renderer: an inline SVG built from the shared
+ * `buildChartViewModel` engine (`pptx-viewer-shared`), projected to DOM by
+ * `renderChartViewModelSvg`. Covers every kind the shared engine builds:
+ *
+ *   - bar / column (clustered, stacked, percentStacked), line / line3D,
+ *     area / area3D, scatter, bubble, pie / doughnut / pie3D / ofPie, radar,
+ *     including secondary / log / display-unit value axes plus trendline /
+ *     error-bar / axis-title / data-table overlays
+ *   - combo, stock, surface, treemap, waterfall, regionMap, funnel, sunburst,
+ *     histogram, boxWhisker (sibling shared modules)
+ *
+ * Unsupported chart types and charts without series data render a labelled
+ * placeholder box, mirroring Vue's `ChartRenderer.vue` fallback.
+ *
+ * Series colours resolve exactly like the Vue binding: an explicit parsed
+ * `chartData.colorPalette` wins, otherwise the style-id-aware palette
+ * (`getChartStylePalette`), threaded into the shared engine as `colorPalette`.
+ *
+ * Exported so the 3D path above can build it as the scene's fallback.
+ */
+export declare const renderChartSvgElement: ElementRenderer;
+/**
+ * Resolve the colour palette for a chart, mirroring Vue's `resolveVuePalette`:
+ * an explicit parsed `colorPalette` wins, otherwise the style-id palette
+ * (which itself falls back to the default chart palette).
+ */
+export declare function resolveChartPalette(chartData: PptxChartData): string[];
+//# sourceMappingURL=chart.d.ts.map

package/dist/pptx/dom/elements/chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/chart.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAcrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAWhD;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,eAchC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,qBAAqB,EAAE,eA+EnC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,aAAa,GAAG,MAAM,EAAE,CAKtE"}

package/dist/pptx/dom/elements/connector.d.ts

@@ -0,0 +1,13 @@
+import type { ElementRenderer } from '../types.js';
+/**
+ * Renderer for `connector` elements: straight, bent, and curved connectors as
+ * an inline SVG spanning the element's bounding box, with stroke
+ * colour/width/dash, start/end arrowheads, and compound (double/triple) line
+ * support, text labels, and line-level shadow/glow effects. Vanilla port of
+ * Vue's `ConnectorRenderer.vue` and React's connector effects path.
+ *
+ * Flip is baked into the geometry (not a CSS transform) so arrowheads point
+ * the right way; only rotation goes on the wrapper transform.
+ */
+export declare const renderConnectorElement: ElementRenderer;
+//# sourceMappingURL=connector.d.ts.map

package/dist/pptx/dom/elements/connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/connector.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAwB,eAAe,EAAE,MAAM,UAAU,CAAC;AAGtE;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAsKpC,CAAC"}

package/dist/pptx/dom/elements/contentpart.d.ts

@@ -0,0 +1,25 @@
+import type { ElementRenderer } from '../types.js';
+/**
+ * Renderer for `contentPart` elements (embedded XML drawing parts wrapped in
+ * `mc:AlternateContent`), vanilla port of React's `renderContentPart` in
+ * `InkGroupRenderers.tsx` (viewer subset):
+ *
+ * - Ink strokes (`inkStrokes`) render as inline SVG `<path>`s inside the
+ *   element's bounding box, with per-stroke colour / width / opacity.
+ * - Pressure-sensitive variable-width strokes render when a stroke carries
+ *   varying per-point `pressures`: each sampled point becomes a `<circle>`
+ *   whose radius follows the interpolated width (shared
+ *   `generatePressureCircles` maths, same config as React).
+ * - Tilt-aware calligraphic nib strokes render when a stroke carries
+ *   `tiltAngles` (decoded from the source InkML's `OTx`/`OTy` or `AZIMUTH`
+ *   channel): each sampled point becomes an `<ellipse>` widened perpendicular
+ *   to the pen's lean direction (shared `generateNibMarks` maths), taking
+ *   priority over plain pressure circles.
+ * - No strokes: a typed fallback box labelled "Content Part", matching the
+ *   other bindings' fallback (Vue has no dedicated contentPart renderer and
+ *   falls through to its fallback label too).
+ * - Presentation mode progressively replays constant-width paths using the
+ *   shared dash-offset timing model.
+ */
+export declare const renderContentPartElement: ElementRenderer;
+//# sourceMappingURL=contentpart.d.ts.map

package/dist/pptx/dom/elements/contentpart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentpart.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/contentpart.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,wBAAwB,EAAE,eA6CtC,CAAC"}

package/dist/pptx/dom/elements/equation.d.ts

@@ -0,0 +1,12 @@
+import { hasTextProperties } from 'ooxml-core/pptx';
+import type { ElementRenderContext } from '../types.js';
+/**
+ * Render a PURE equation box (OMML and nothing else) as browser-native MathML,
+ * centred in the shape.
+ *
+ * A body that MIXES prose with an inline `m:oMath` returns null and falls
+ * through to the ordinary paragraph path, where shared emits the equation as a
+ * run in its authored position. Coming here dropped every word around it.
+ */
+export declare function renderEquations(element: Parameters<typeof hasTextProperties>[0], context: ElementRenderContext): HTMLElement | null;
+//# sourceMappingURL=equation.d.ts.map

package/dist/pptx/dom/elements/equation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equation.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/equation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAMpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAErD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC9B,OAAO,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC,CAAC,EAChD,OAAO,EAAE,oBAAoB,GAC3B,WAAW,GAAG,IAAI,CAyCpB"}

package/dist/pptx/dom/elements/extrusion-overlay.d.ts

@@ -0,0 +1,4 @@
+import type { PptxElement } from 'ooxml-core/pptx';
+/** Build CSS 3D side faces for a shape carrying `a:sp3d` extrusion depth. */
+export declare function renderExtrusionOverlay(doc: Document, element: PptxElement): HTMLElement | null;
+//# sourceMappingURL=extrusion-overlay.d.ts.map

package/dist/pptx/dom/elements/extrusion-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extrusion-overlay.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/extrusion-overlay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAMnD,6EAA6E;AAC7E,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,GAAG,WAAW,GAAG,IAAI,CAwC9F"}

package/dist/pptx/dom/elements/group.d.ts

@@ -0,0 +1,9 @@
+import type { ElementRenderer } from '../types.js';
+/**
+ * Renderer for `group` elements: an absolutely positioned container that
+ * recurses into `children` through the registry (so custom renderers apply
+ * inside groups too). Children painted with `a:grpFill` inherit the fill of the
+ * nearest enclosing group that has one.
+ */
+export declare const renderGroupElement: ElementRenderer;
+//# sourceMappingURL=group.d.ts.map

package/dist/pptx/dom/elements/group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/group.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAmFhD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,eAqChC,CAAC"}

package/dist/pptx/dom/elements/image.d.ts

@@ -0,0 +1,8 @@
+import type { ElementRenderer } from '../types.js';
+/**
+ * Renderer for `image` / `picture` elements: an absolutely positioned box with
+ * an `<img>` under the shared fill/crop fit, the shared computed CSS filter, and
+ * any SVG `<filter>` defs required by duotone / artistic image effects.
+ */
+export declare const renderImageElement: ElementRenderer;
+//# sourceMappingURL=image.d.ts.map

package/dist/pptx/dom/elements/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/image.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGhD;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,eAiJhC,CAAC"}

package/dist/pptx/dom/elements/index.d.ts

@@ -0,0 +1,29 @@
+import type { ElementRendererRegistry } from '../types.js';
+export { renderChartElement, renderChartSvgElement } from './chart.js';
+export { renderConnectorElement } from './connector.js';
+export { renderGroupElement } from './group.js';
+export { renderImageElement } from './image.js';
+export { renderInkElement } from './ink.js';
+export { buildStrokeSvg } from './ink-stroke-svg.js';
+export { renderMediaElement } from './media.js';
+export { renderOleElement } from './ole.js';
+export { renderPlaceholderElement } from './placeholder.js';
+export { registerRichMediaRenderers } from './register-rich-media.js';
+export { registerExtraRenderers } from './register-extras.js';
+export { registerTableChartRenderers } from './register-table-chart.js';
+export { renderSmartArtElement, renderSmartArtSvg } from './smartart.js';
+export { renderSmartArt3DElement } from './smartart-3d.js';
+export { renderTableElement } from './table.js';
+export { collectThreeViews, withReusableThreeViews } from './three-view-reuse.js';
+export { renderTextBlock } from './text-block.js';
+export { renderTextShapeElement } from './text-shape.js';
+/**
+ * The registry the viewer uses by default.
+ *
+ * Dedicated renderers: `text`, `shape`, `image`, `picture`, `group`,
+ * `connector`, `table`, `chart`, `smartArt`, `media`, `ink`, `ole`,
+ * `contentPart`, `zoom`, and `model3d`. Only unknown extension elements fall
+ * through to the typed placeholder fallback.
+ */
+export declare function createDefaultRegistry(): ElementRendererRegistry;
+//# sourceMappingURL=index.d.ts.map

package/dist/pptx/dom/elements/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAUxD,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAKzC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AACzC,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAEtD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,IAAI,uBAAuB,CAa/D"}

package/dist/pptx/dom/elements/ink-stroke-svg.d.ts

@@ -0,0 +1,10 @@
+import type { InkStrokeAnimationStyle, InkStrokeView } from '../../index.js';
+/**
+ * Build one already-decided stroke's SVG node: tilt-driven nib ellipses, then
+ * pressure circles, then a plain constant-width path (the same priority order
+ * `InkStrokeView` documents). Shared by `ink.ts` (Draw-tab `InkPptxElement`)
+ * and `contentpart.ts` (loaded `p:contentPart`), which used to each hand-roll
+ * this exact branch.
+ */
+export declare function buildStrokeSvg(doc: Document, view: InkStrokeView, replay: InkStrokeAnimationStyle | undefined): SVGElement;
+//# sourceMappingURL=ink-stroke-svg.d.ts.map

package/dist/pptx/dom/elements/ink-stroke-svg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ink-stroke-svg.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/ink-stroke-svg.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAI1E;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC7B,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,uBAAuB,GAAG,SAAS,GACzC,UAAU,CAoDZ"}

package/dist/pptx/dom/elements/ink.d.ts

@@ -0,0 +1,26 @@
+import type { ElementRenderer } from '../types.js';
+/**
+ * Renderer for `ink` elements, vanilla port of Vue's `InkRenderer.vue`
+ * (viewer subset):
+ *
+ * Freehand ink strokes (`inkPaths`) render as inline SVG `<path>`s inside the
+ * element's bounding box, with per-stroke colour / width / opacity resolved
+ * from the parallel `inkColors` / `inkWidths` / `inkOpacities` arrays.
+ *
+ * Pressure-sensitive variable-width strokes render when the element carries
+ * per-point pressure data (`inkPointPressures`), or a legacy per-point
+ * `inkWidths` array with variation: each sampled point becomes a `<circle>`
+ * whose radius follows the interpolated width (shared
+ * `generatePressureCircles` maths). Tilt-aware calligraphic nib strokes render
+ * when a path carries genuine `inkPointTiltX`/`inkPointTiltY` lean, taking
+ * priority over pressure circles (shared `buildInkGroupStrokes` decision
+ * function, the same one `contentpart.ts` uses for a loaded `p:contentPart`).
+ * Strokes without either degrade to plain constant-width paths.
+ *
+ * Presentation mode progressively replays constant-width paths using the
+ * shared dash-offset timing model. Highlighter strokes use multiply blending.
+ * Pressure circles and nib marks remain static because SVG dash replay only
+ * applies to paths.
+ */
+export declare const renderInkElement: ElementRenderer;
+//# sourceMappingURL=ink.d.ts.map

package/dist/pptx/dom/elements/ink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ink.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/ink.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,gBAAgB,EAAE,eAwC9B,CAAC"}

package/dist/pptx/dom/elements/media-fullscreen-overlay.d.ts

@@ -0,0 +1,11 @@
+import type { MediaPptxElement } from 'ooxml-core/pptx';
+import type { CssStyleMap } from '../../index.js';
+import type { ElementRenderContext } from '../types.js';
+/**
+ * Wires the fullScrn overlay onto a mounted `<video>`/`<audio>`: on `play` it
+ * spreads the shared overlay style over the container and shows the shared
+ * stop button; on `pause`/`ended` it reverts both. Exported for direct
+ * testing.
+ */
+export declare function wireMediaFullscreenOverlay(doc: Document, container: HTMLElement, mediaNode: HTMLMediaElement, element: MediaPptxElement, context: ElementRenderContext, baseStyle: CssStyleMap): void;
+//# sourceMappingURL=media-fullscreen-overlay.d.ts.map

package/dist/pptx/dom/elements/media-fullscreen-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-fullscreen-overlay.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/media-fullscreen-overlay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAMxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAyErD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACzC,GAAG,EAAE,QAAQ,EACb,SAAS,EAAE,WAAW,EACtB,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,oBAAoB,EAC7B,SAAS,EAAE,WAAW,GACpB,IAAI,CAgCN"}

package/dist/pptx/dom/elements/media.d.ts

@@ -0,0 +1,37 @@
+import type { MediaPlaybackSource, MediaTrimFadeSource } from '../../index.js';
+import type { ElementRenderer } from '../types.js';
+/**
+ * Renderer for `media` (audio / video) elements, vanilla port of Vue's
+ * `ElementMediaBox.vue`, viewer subset:
+ *
+ * - Playable source resolved exactly like Vue: `mediaData` (data-URL embedded
+ *   by the load pipeline) first, then `mediaPath` looked up in
+ *   `context.mediaDataUrls`.
+ * - Video renders a native `<video controls>` (with the poster frame when one
+ *   is available); audio renders a native `<audio controls>`.
+ * - No playable source: the poster / thumbnail image alone (shared
+ *   `getImageSrc` resolves `posterFrameData` / `posterFramePath`).
+ * - Nothing at all: a graceful typed fallback box labelled "Media".
+ * - Presentation-mode autoplay: when `context.presenting` is true the element
+ *   starts playing right after it is appended to the DOM (matching Vue's
+ *   mounted-watcher via the shared `startMediaAutoplay`), and the native
+ *   transport is suppressed there, as React does (`controls={!isPresentationMode}`).
+ */
+/**
+ * Apply the deck's playback settings and the presentation-mode play/pause state
+ * to a mounted `<video>`/`<audio>`. Since the vanilla renderer rebuilds the
+ * whole stage on every state change (no persistent element to `watch`), this
+ * runs once right after the element is appended: start autoplay when
+ * presenting, otherwise make sure a (rare, already-playing) element is paused.
+ * Exported for direct testing.
+ *
+ * `loop` / `volume` / `playbackRate` come from the shared resolver rather than
+ * being left at their defaults. Dropping `loop` is not cosmetic: a deck that
+ * loops a short background clip (solution-explorer slide 2 loops a 2-second
+ * video) played it once, hit the end and froze on the last frame, which reads
+ * exactly like media that never started. Leaving `volume` alone was worse: a
+ * deck marked `vol="0"` played at full volume.
+ */
+export declare function applyMediaPresentingState(el: HTMLMediaElement, presenting: boolean, playback: MediaPlaybackSource & MediaTrimFadeSource): void;
+export declare const renderMediaElement: ElementRenderer;
+//# sourceMappingURL=media.d.ts.map

package/dist/pptx/dom/elements/media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/media.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAG5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGhD;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACxC,EAAE,EAAE,gBAAgB,EACpB,UAAU,EAAE,OAAO,EACnB,QAAQ,EAAE,mBAAmB,GAAG,mBAAmB,GACjD,IAAI,CAkBN;AAED,eAAO,MAAM,kBAAkB,EAAE,eA4IhC,CAAC"}

package/dist/pptx/dom/elements/model3d.d.ts

@@ -0,0 +1,24 @@
+import type { ElementRenderer } from '../types.js';
+/**
+ * Renderer for `model3d` (embedded GLB/GLTF) elements, vanilla port of Vue's
+ * `Model3DRenderer.vue` / React's `Model3DRenderer.tsx`:
+ *
+ * - Poster image (`posterImage`, then the raster `imageData`) renders by
+ *   default; without one, a labelled "3D Model" placeholder box (cube icon)
+ *   renders instead, exactly like the other bindings.
+ * - When the element carries the model binary (`modelData`), a "view in 3D"
+ *   button mounts the shared framework-free vanilla-three controller
+ *   (`mountModel3D`, which dynamically imports the OPTIONAL `three` peer
+ *   dependency) on demand for interactive rotate/zoom. Vue/React mount the
+ *   scene eagerly via their reactive lifecycles; the stateless vanilla
+ *   renderer mounts on click so `three` is never touched for passive viewing.
+ * - Graceful fallback: when `three` is unavailable or the model fails to load
+ *   (`handle.ok === false`), the poster/placeholder stays and the affordance
+ *   is removed, mirroring Vue's `showPoster` fallback.
+ *
+ * The `modelData` data URL becomes a blob (object) URL via core
+ * `parseDataUrlToBytes` (never hand-rolled base64), revoked once the mount
+ * attempt settles - the same lifecycle as Vue's `useModel3dScene`.
+ */
+export declare const renderModel3dElement: ElementRenderer;
+//# sourceMappingURL=model3d.d.ts.map

package/dist/pptx/dom/elements/model3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model3d.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/model3d.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAwB,eAAe,EAAE,MAAM,UAAU,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,oBAAoB,EAAE,eAsBlC,CAAC"}

package/dist/pptx/dom/elements/ole-icons.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedOleType } from '../../index.js';
+/**
+ * Type-specific OLE placeholder icons, vanilla port of the inline SVG icons in
+ * Vue's `OleRenderer.vue` (Excel grid, Word document, PDF, Visio diagram,
+ * MathType `f(x)`, and a generic linked-objects glyph). The shape data lives
+ * in `pptx-viewer-shared` (`getOleIconShapes`); this module only maps each
+ * {@link OleIconShape} onto its `<rect>`/`<line>`/`<text>` DOM primitive.
+ */
+/** Build the 36x36 placeholder icon `<svg>` for a resolved OLE type. */
+export declare function buildOleIcon(doc: Document, type: ResolvedOleType, color: string): SVGSVGElement;
+//# sourceMappingURL=ole-icons.d.ts.map

package/dist/pptx/dom/elements/ole-icons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ole-icons.d.ts","sourceRoot":"","sources":["../../../../src/pptx/dom/elements/ole-icons.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAKnD;;;;;;GAMG;AAEH,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,CAmB/F"}