ooxml-ui 0.30.0 → 0.31.0

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

@@ -0,0 +1,198 @@
+/**
+ * Element CSS-style builders shared by the React, Vue, and Angular bindings.
+ *
+ * Holds the framework-agnostic, binding-identical portions of each binding's
+ * element-style layer: the absolute container style (position / size / flip +
+ * rotation transform / opacity / z-index / hidden) and the displayable
+ * image-source resolution. Returns a neutral CSS map keyed in camelCase (both
+ * Vue `CSSProperties` and Angular `[ngStyle]` accept camelCase keys), which
+ * each binding casts to its framework's style type.
+ *
+ * The fill/stroke/geometry and text-block builders are intentionally NOT shared
+ * here: the Vue and Angular implementations diverge (Vue resolves fills via the
+ * shared structured fill/effect/3D builders and applies body insets; Angular
+ * uses inline gradient/pattern/duotone builders and a different geometry
+ * cascade), so each binding keeps its own to avoid changing render output.
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { CssStyleMap } from './element-style-transform.js';
+/** Map a number to a CSS pixel string. */
+export declare function px(n: number): string;
+/**
+ * The box an element is PAINTED in: its authored extent, unmodified (floored
+ * at zero to guard against a negative/NaN size reaching CSS).
+ *
+ * This used to pad the box out to {@link MIN_ELEMENT_SIZE} in either axis, so
+ * that a degenerate shape - a horizontal rule authored as
+ * `<a:prstGeom prst="line"/>` with `cy="1"` EMU is the canonical one, whose box
+ * rounds to a fraction of a pixel - stayed hoverable, clickable and draggable.
+ * That padding was applied unconditionally, including in read-only rendering,
+ * where nothing is hoverable or draggable at all: a solid-filled rect (or any
+ * shape whose fill paints as the wrapper's `background-color`) got PADDED
+ * FILL, so a 1-2px authored rule rendered as a 12-15px solid bar (issue #285).
+ *
+ * The padding survives, but only as a separate, interaction-only affordance:
+ * see {@link elementHitTargetStyle}, which a binding renders as an extra
+ * transparent overlay ONLY while the element is interactive/editable, and
+ * which never changes this function's return value or the visible paint.
+ */
+export declare function paintedElementSize(el: PptxElement): {
+    width: number;
+    height: number;
+};
+/**
+ * A transparent hit-target overlay for an element whose authored extent is
+ * smaller than {@link MIN_ELEMENT_SIZE} in either axis, centred over the
+ * element's (possibly sub-pixel) painted box. `undefined` when the authored
+ * box already meets the minimum in both axes, which is the overwhelmingly
+ * common case.
+ *
+ * A binding renders this as an extra sibling INSIDE the element's own
+ * wrapper, absolutely positioned (so it can extend past the wrapper's own,
+ * now-authored-size, bounds) and ONLY while the element is interactive/
+ * editable: a click or drag landing on this transparent overlay bubbles to
+ * the same ancestor handlers the (tiny) wrapper itself would receive a click
+ * on, exactly reproducing the old always-padded box's grabbability without
+ * ever enlarging the painted fill/stroke a read-only render shows (issue
+ * #285). Never render this outside an interactive/editable surface: a
+ * read-only viewer has nothing for it to make grabbable.
+ */
+export declare function elementHitTargetStyle(el: PptxElement): CssStyleMap | undefined;
+/**
+ * Whether a binding should render {@link elementHitTargetStyle}'s overlay at
+ * all, for ANY element type (shape/text, image, chart, table, media, ole,
+ * model3d, smartArt, equation, zoom, contentPart, ink, group, connector).
+ *
+ * The single source of truth for the interaction gate every binding's
+ * per-type renderer must apply: interactive/editable AND not on the live
+ * presentation stage. Centralising this (rather than each binding repeating
+ * `interactive && !presenting` at each of its ~11 call sites) is what keeps a
+ * future gate change (or a binding's copy of it) from drifting per element
+ * type (issue #285 follow-up).
+ */
+export declare function shouldRenderHitTarget(interactive: boolean, presenting: boolean): boolean;
+/**
+ * The CSS height for an element's absolute container box.
+ *
+ * Every element type except a table renders at its authored (painted)
+ * height. PowerPoint always sizes a `graphicFrame` holding a table to the
+ * actual sum of its row heights: `a:tr/@h` is a MINIMUM, not a fixed height,
+ * and a row whose cell text needs more room than that grows the row (and so
+ * the whole table) taller than it. The authored `a:ext/@cy` PowerPoint writes
+ * back is a cache of that computed sum as of the last save, not a hard clip,
+ * so treating it as a fixed CSS height clips off however many trailing rows
+ * no longer fit once THIS renderer's fonts (or simply more text than the
+ * deck's last save had) need more vertical room than that cached value.
+ * `minHeight` keeps a table from visually collapsing when its rows sum to
+ * less than the authored extent (rounding, or a stale extent the other way).
+ */
+export declare function elementContainerHeightStyle(el: PptxElement, paintedHeightPx: number): CssStyleMap;
+/**
+ * Absolute container style: position, size, rotation, flip, opacity, z-index.
+ * Mirrors the essentials of the React `getContainerStyle`.
+ */
+export declare function getContainerStyle(el: PptxElement, zIndex: number): CssStyleMap;
+/**
+ * Resolve a displayable image source for picture/image/media poster frames.
+ *
+ * The SVG variant is preferred over the raster one, which is not merely a
+ * quality choice: `<a:blip>` can carry an `asvg:svgBlip` extension whose
+ * `r:embed` is the ONLY relationship on the blip, so there is no raster
+ * fallback at all. A resolver that looks solely at `imageData` renders those
+ * pictures as an empty box, and real decks use exactly that shape for icon
+ * artwork. PowerPoint paints the SVG when both are present, so preferring it
+ * is also the higher-fidelity answer when a raster fallback does exist.
+ */
+export declare function getImageSrc(el: PptxElement, mediaDataUrls: Map<string, string>): string | undefined;
+/**
+ * `overflow` for a picture's container box.
+ *
+ * Pictures clip, because {@link getImageFitStyle} renders a crop by
+ * deliberately painting the cropped-away part outside the frame. The one
+ * exception is a blur with `@grow`, whose halo is MEANT to bleed past the
+ * element box (see `getComputedEffectStyle().overflowVisible`); clipping there
+ * would trade one visible defect for another. Mirrors React's container rule.
+ */
+export declare function getImageOverflow(el: PptxElement): 'hidden' | 'visible';
+/**
+ * How a picture's `<img>` should fill its frame, including the `<a:srcRect>`
+ * source crop.
+ *
+ * CSS `object-fit` cannot express an OOXML source crop: `contain` and `cover`
+ * pick a region of the FRAME, whereas `srcRect` picks a region of the SOURCE
+ * bitmap which PowerPoint then stretches to fill the frame. The crop is
+ * therefore rendered by scaling the image by the reciprocal of the surviving
+ * region and translating the cropped-away part out of the (overflow-hidden)
+ * frame. Skipping it does not merely mis-scale the picture, it shows the wrong
+ * part of it: a deck that crops one wide composite image into several different
+ * insets otherwise renders the same photo in every one of them.
+ *
+ * Callers must give the containing element `overflow: hidden`, since the
+ * cropped branch deliberately paints outside the frame.
+ *
+ * Absent a crop, `<a:stretch><a:fillRect/></a:stretch>` (the default fill
+ * mode) maps the ENTIRE source bitmap onto the destination rect, distorting
+ * its aspect ratio if the frame's doesn't match. That is CSS `fill`, not
+ * `cover`: `cover` crops to preserve aspect, which PowerPoint's own picture
+ * placeholder never does on a plain (non-cropped) blip fill.
+ *
+ * @returns A neutral CSS map to spread onto the `<img>`; never `undefined`, so
+ *          the uncropped case still pins the shared `fill` fit that every
+ *          binding must agree on.
+ */
+export declare function getImageFitStyle(el: PptxElement): CssStyleMap;
+/** The eight `a:srcRect` / `a:fillRect` inset fractions that place a picture. */
+export interface ImageFitInsets {
+    cropLeft: number;
+    cropTop: number;
+    cropRight: number;
+    cropBottom: number;
+    fillRectLeft: number;
+    fillRectTop: number;
+    fillRectRight: number;
+    fillRectBottom: number;
+}
+/**
+ * The `<img>` `transform` for ARBITRARY inset fractions, always padded to the
+ * full `translate/scale translate/scale` list.
+ *
+ * The Morph engine interpolates a pair's insets SAMPLE BY SAMPLE (the crop and
+ * the frame must compensate each other or the image visibly zooms, see
+ * `morph-image-crop`), so it needs the mapping for values between two
+ * elements', not just for whole elements.
+ */
+export declare function fitTransformsFromInsets(insets: ImageFitInsets): {
+    placement: string;
+    crop: string;
+};
+/**
+ * The `<img>` `transform` that renders a picture's fill-rect placement and
+ * source crop, as one string.
+ *
+ * This is the value {@link getImageFitStyle} puts on the element; it is exposed
+ * separately so the Morph engine can animate BETWEEN two pictures' crops
+ * without re-deriving the maths (issue #148: PowerPoint's "Scale Height" /
+ * "Scale Width" is an `a:srcRect` crop, so a slide pair that differs only in
+ * scale has identical frames and morphed as a hard cut).
+ *
+ * @param el - The picture element.
+ * @param padToIdentity - When true, ALWAYS emits both the placement and the
+ *   crop `translate`/`scale` pair, substituting an identity pair where the
+ *   element has none. Two pictures then produce the same transform function
+ *   list, which is what lets CSS interpolate them function-by-function instead
+ *   of decomposing to a matrix (and lets an uncropped end of a pair sit at a
+ *   true identity, so the element lands exactly on its static style).
+ * @returns The transform value; `''` only when there is nothing to apply and
+ *   `padToIdentity` is false.
+ */
+export declare function buildImageFitTransform(el: PptxElement, padToIdentity?: boolean): string;
+/**
+ * `el` re-expressed in its own container's frame: at the origin, unrotated,
+ * unflipped and fully opaque. For rendering an element's content INSIDE a
+ * wrapper that already carries its {@link getContainerStyle} (position,
+ * rotation, flips, opacity), such as the 2D fallback slotted into a
+ * `<pptx-three-view>` or an invisible hit-test copy, so none of those apply
+ * twice. Memoised per element object, so a re-render keeps the same identity.
+ */
+export declare function elementInLocalFrame(el: PptxElement): PptxElement;
+//# sourceMappingURL=element-style.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"element-style.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/element-style.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAG7D,0CAA0C;AAC1C,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEpC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,WAAW,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAKrF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAc9E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAExF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,GAAG,WAAW,CAKjG;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAuC9E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAC1B,EAAE,EAAE,WAAW,EACf,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,MAAM,GAAG,SAAS,CAepB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,WAAW,GAAG,QAAQ,GAAG,SAAS,CAOtE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,WAAW,GAAG,WAAW,CAgC7D;AAyBD,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,cAAc,GAAG;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACb,CAoDA;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,WAAW,EAAE,aAAa,UAAQ,GAAG,MAAM,CAMrF;AAcD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,WAAW,GAAG,WAAW,CAgBhE"}

package/dist/pptx/render/element-update-batch.d.ts

@@ -0,0 +1,38 @@
+import type { PptxElement, PptxSlide } from 'ooxml-core/pptx';
+import type { ViewerMode } from '../types.js';
+/** A shallow property patch for a top-level element on an ordinary slide. */
+export interface ElementUpdate {
+    slideId: string;
+    elementId: string;
+    patch: Partial<PptxElement>;
+}
+export interface ElementUpdateOptions {
+    /** Optional description for the undo entry. */
+    label?: string;
+}
+export interface ElementUpdateTarget {
+    canEdit: boolean;
+    mode: ViewerMode;
+    loaded: boolean;
+    editTemplateMode: boolean;
+}
+/** Check the editing context before any pending text or document state is touched. */
+export declare function assertElementUpdateTarget(target: ElementUpdateTarget): void;
+/** Detach caller-owned patches before a binding waits for its render to settle. */
+export declare function cloneElementUpdates(updates: readonly ElementUpdate[]): ElementUpdate[];
+/**
+ * Prepare the entire batch without mutating the document. Duplicate targets
+ * apply in input order. Return null for an empty batch or no net change.
+ * Nested properties follow updateElement's shallow replacement semantics.
+ */
+export declare function prepareElementUpdateBatch(slides: readonly PptxSlide[], updates: readonly ElementUpdate[]): PptxSlide[] | null;
+export interface ElementUpdateHost {
+    getTarget(): ElementUpdateTarget;
+    hasActivePointerInteraction(): boolean;
+    getSlides(): readonly PptxSlide[];
+    commitPendingText(): void;
+    commitSlides(slides: PptxSlide[], label?: string): void;
+}
+/** Synchronous commit adapter for bindings with explicit pre-edit history. */
+export declare function commitElementUpdateBatch(updates: readonly ElementUpdate[], options: ElementUpdateOptions | undefined, host: ElementUpdateHost): void;
+//# sourceMappingURL=element-update-batch.d.ts.map

package/dist/pptx/render/element-update-batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-update-batch.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/element-update-batch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,6EAA6E;AAC7E,MAAM,WAAW,aAAa;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;CAC5B;AAED,MAAM,WAAW,oBAAoB;IACpC,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;CAC1B;AAED,sFAAsF;AACtF,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAI3E;AAED,mFAAmF;AACnF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,aAAa,EAAE,CAKtF;AAkCD;;;;GAIG;AACH,wBAAgB,yBAAyB,CACxC,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,OAAO,EAAE,SAAS,aAAa,EAAE,GAC/B,SAAS,EAAE,GAAG,IAAI,CAiDpB;AAED,MAAM,WAAW,iBAAiB;IACjC,SAAS,IAAI,mBAAmB,CAAC;IACjC,2BAA2B,IAAI,OAAO,CAAC;IACvC,SAAS,IAAI,SAAS,SAAS,EAAE,CAAC;IAClC,iBAAiB,IAAI,IAAI,CAAC;IAC1B,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxD;AAED,8EAA8E;AAC9E,wBAAgB,wBAAwB,CACvC,OAAO,EAAE,SAAS,aAAa,EAAE,EACjC,OAAO,EAAE,oBAAoB,GAAG,SAAS,EACzC,IAAI,EAAE,iBAAiB,GACrB,IAAI,CAgBN"}

package/dist/pptx/render/element-visibility.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The single rule that decides whether a slide element reaches the canvas.
+ *
+ * PowerPoint's Selection Pane eye toggle writes `p:cNvPr/@hidden="1"` on the
+ * shape. A hidden shape is still an object on the slide (it keeps its place in
+ * the z-order, stays listed and selectable in the Selection Pane, and survives
+ * a save), but PowerPoint draws nothing for it: not on the editing canvas, not
+ * in a slide show, not in print or export.
+ *
+ * Every binding routes its element renderer through {@link isElementHidden} so
+ * one rule governs all five, rather than five copies drifting apart. The
+ * bindings skip the element entirely instead of painting it with
+ * `visibility: hidden`, because "not drawn" is the behaviour being modelled:
+ * skipping guarantees the element cannot be hit-tested, cannot take focus,
+ * cannot reach the accessibility tree, is never rasterised by the html2canvas
+ * export path, and does not keep a `<video>` playing or a WebGL scene running
+ * behind an invisible box. Nothing that must keep working depends on the DOM
+ * node: the Selection Pane lists and selects from the slide model, not from the
+ * rendered tree.
+ *
+ * `pptx-viewer-shared`'s `getContainerStyle` additionally emits `display: none`
+ * for a hidden element. That is deliberate belt-and-braces for any surface that
+ * paints an element without going through a binding's element-renderer entry
+ * point; it is not the primary mechanism.
+ *
+ * @module render/element-visibility
+ */
+/** The subset of an element this module needs; keeps the helpers usable on partials. */
+interface HideableElement {
+    hidden?: boolean;
+}
+/**
+ * Whether the Selection Pane has hidden this element.
+ *
+ * @param element - Any slide element (or a partial carrying `hidden`).
+ * @returns `true` when the element must not be drawn.
+ */
+export declare function isElementHidden(element: HideableElement | null | undefined): boolean;
+/**
+ * Whether a renderer should draw this element. The inverse of
+ * {@link isElementHidden}, spelled out so call sites read as intent
+ * (`if (!isElementRendered(el)) return null`) rather than as a negated flag.
+ *
+ * @param element - Any slide element (or a partial carrying `hidden`).
+ * @returns `true` when the element should reach the canvas.
+ */
+export declare function isElementRendered(element: HideableElement | null | undefined): boolean;
+/**
+ * Drop hidden elements from a list, for the consumers that need a filtered
+ * array rather than a per-element guard (reading order, export data, and any
+ * loop that cannot early-return).
+ *
+ * Returns the input array unchanged (same reference) when nothing is hidden, so
+ * the common case allocates nothing and reference-equality memoisation in the
+ * bindings is not defeated on every render.
+ *
+ * @param elements - The elements to filter.
+ * @returns The visible elements, in their original order.
+ */
+export declare function filterRenderedElements<T extends HideableElement>(elements: readonly T[]): readonly T[];
+export {};
+//# sourceMappingURL=element-visibility.d.ts.map

package/dist/pptx/render/element-visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-visibility.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/element-visibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,wFAAwF;AACxF,UAAU,eAAe;IACxB,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAEpF;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAEtF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,eAAe,EAC/D,QAAQ,EAAE,SAAS,CAAC,EAAE,GACpB,SAAS,CAAC,EAAE,CAEd"}

package/dist/pptx/render/element.d.ts

@@ -0,0 +1,2 @@
+export { isTemplateElement, isTemplateElementId, isEditableTextElement, getElementLabel, formatCommentTimestamp, getCommentMarkerPosition, getConnectionSitePosition, } from 'ooxml-core/pptx/editor/render/element';
+//# sourceMappingURL=element.d.ts.map

package/dist/pptx/render/element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/element.ts"],"names":[],"mappings":"AACA,OAAO,EACN,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,eAAe,EACf,sBAAsB,EACtB,wBAAwB,EACxB,yBAAyB,GACzB,MAAM,uCAAuC,CAAC"}

package/dist/pptx/render/embedded-fonts.d.ts

@@ -0,0 +1,108 @@
+/**
+ * embedded-fonts.ts: Pure (no DOM-injection) helpers for the embedded-font
+ * subsystem, shared across the React, Vue, and Angular bindings.
+ *
+ * All DOM side effects (injecting the managed `<style>` element, minting /
+ * revoking object URLs) stay in each binding; everything here is pure. The
+ * managed `<style>` element id is binding-specific and stays in each binding.
+ *
+ * The core load pipeline (`PptxHandlerRuntimeEmbeddedFonts`) already
+ * de-obfuscates the OOXML XOR layer and produces a ready-to-use `dataUrl` for
+ * each style variant, so one {@link PptxEmbeddedFont} corresponds to a single
+ * style variant (regular / bold / italic / boldItalic), distinguished by its
+ * `bold` and `italic` flags. As a defence-in-depth fallback, an entry without a
+ * usable `dataUrl` but carrying obfuscated `originalPartBytes` + `fontGuid`
+ * (or clear-text `rawFontData`) is de-obfuscated here and minted into a `Blob`
+ * object URL by the binding.
+ */
+import type { PptxEmbeddedFont } from 'ooxml-core/pptx';
+/**
+ * Resolve an embedded-font entry to its raw (clear-text) font bytes,
+ * independent of how the caller will use them (CSS `@font-face` injection via
+ * {@link resolveFontVariant}, or glyph-outline parsing via
+ * `text-warp-outline-font-cache.ts`). Tries, in order: decoding the core
+ * loader's own `dataUrl` (the common case), the preserved `rawFontData`, and
+ * de-obfuscating `originalPartBytes` with `fontGuid`. Returns `undefined` when
+ * none of these yield usable bytes.
+ */
+export declare function resolveEmbeddedFontClearBytes(font: PptxEmbeddedFont): Uint8Array | undefined;
+/**
+ * True when `url` is safe to interpolate into `src: url("…")`.
+ *
+ * Accepts `blob:` URLs (minted by the binding from de-obfuscated bytes) and
+ * base64 `data:font/…` URLs produced by the core loader; everything else is
+ * rejected to prevent CSS-injection / exfiltration via a hostile PPTX.
+ */
+export declare function isInjectableUrl(url: string): boolean;
+/** Map a resolved CSS font format to the MIME type for a minted `Blob`. */
+export declare function fontMimeForFormat(format: string): string;
+/**
+ * Normalise an entry's declared format to one of the allowed `format()` hints,
+ * falling back to `truetype`.
+ */
+export declare function normalizeFontFormat(format: string | undefined): string;
+/** A single resolved variant ready to be emitted as a `@font-face` rule. */
+export interface ResolvedFontVariant {
+    name: string;
+    url: string;
+    format: string;
+    weight: string;
+    style: string;
+    /** Object URL minted for this variant (must be revoked on cleanup). */
+    objectUrl?: string;
+}
+/**
+ * A font supplied by the host application. The package never ships fonts:
+ * applications provide a licensed URL, data URL, or blob URL for their users.
+ */
+export interface ViewerFontSource {
+    family: string;
+    src: string;
+    format?: 'truetype' | 'opentype' | 'woff' | 'woff2';
+    weight?: string | number;
+    style?: 'normal' | 'italic';
+}
+/**
+ * Factory the (impure) object-URL minting is delegated to, so the resolution
+ * logic stays pure and testable. The binding supplies a real implementation
+ * backed by `Blob` + `URL.createObjectURL`; tests can stub it. Returning
+ * `null` signals object URLs are unsupported in the current runtime.
+ */
+export type ObjectUrlFactory = (bytes: Uint8Array, mime: string) => string | null;
+/**
+ * Resolve a single embedded-font entry to an injectable variant.
+ *
+ * Prefers the de-obfuscated `dataUrl` produced by the core loader. Falls back
+ * to de-obfuscating `originalPartBytes` with `fontGuid` (or using clear-text
+ * `rawFontData` directly) and minting an object URL via `mintObjectUrl` when no
+ * usable data URL is present. Returns `null` when the entry cannot be safely
+ * rendered.
+ *
+ * Pure aside from the injected `mintObjectUrl` callback (which the binding owns).
+ */
+export declare function resolveFontVariant(font: PptxEmbeddedFont, mintObjectUrl: ObjectUrlFactory): ResolvedFontVariant | null;
+/** Build the `@font-face` rule text for one resolved variant. */
+export declare function buildFontFaceRule(variant: ResolvedFontVariant): string;
+/** Build a safe `@font-face` stylesheet for host-provided font sources. */
+export declare function buildUserFontFaceStyles(fonts: readonly ViewerFontSource[] | undefined): string;
+/** The product of resolving an embedded-font list: CSS, families, live URLs. */
+export interface EmbeddedFontStyles {
+    /** The generated `@font-face` stylesheet text. */
+    fontFaceCss: string;
+    /**
+     * Distinct CSS `font-family` strings for the embedded families, each with
+     * substitution fallbacks resolved (e.g. `'"Calibri", "Carlito", …'`).
+     */
+    fontFamilies: string[];
+    /** Object URLs minted while resolving (the caller must revoke these). */
+    objectUrls: string[];
+}
+/**
+ * Resolve a list of embedded fonts into the injectable `@font-face` stylesheet,
+ * the distinct substitution-resolved family strings, and any object URLs minted
+ * along the way (so the caller can track them for revocation).
+ *
+ * Pure aside from the injected `mintObjectUrl` callback.
+ */
+export declare function buildEmbeddedFontStyles(fonts: readonly PptxEmbeddedFont[] | null | undefined, mintObjectUrl: ObjectUrlFactory): EmbeddedFontStyles;
+//# sourceMappingURL=embedded-fonts.d.ts.map

package/dist/pptx/render/embedded-fonts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedded-fonts.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/embedded-fonts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAoDxD;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,gBAAgB,GAAG,UAAU,GAAG,SAAS,CAc5F;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAQpD;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAItE;AAED,4EAA4E;AAC5E,MAAM,WAAW,mBAAmB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC;IACpD,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CAC5B;AAED;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;AAElF;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,gBAAgB,EACtB,aAAa,EAAE,gBAAgB,GAC7B,mBAAmB,GAAG,IAAI,CA8B5B;AAED,iEAAiE;AACjE,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAUtE;AAED,2EAA2E;AAC3E,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAAG,SAAS,GAAG,MAAM,CAkB9F;AAED,gFAAgF;AAChF,MAAM,WAAW,kBAAkB;IAClC,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,yEAAyE;IACzE,UAAU,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACtC,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAAG,IAAI,GAAG,SAAS,EACrD,aAAa,EAAE,gBAAgB,GAC7B,kBAAkB,CA2BpB"}

package/dist/pptx/render/equation-compile.d.ts

@@ -0,0 +1,59 @@
+/**
+ * `equation-compile` - the LaTeX -> OMML -> sanitised MathML pipeline that backs
+ * every binding's Insert > Equation dialog.
+ *
+ * The three steps it chains already lived in shared
+ * ({@link ./latex-to-omml}, {@link ./omml-to-mathml}, {@link ./mathml-sanitize}),
+ * but each of the five bindings hand-rolled the glue that joins them, and the
+ * copies had drifted: one skipped sanitisation entirely and one carried its own
+ * fail-open DOMPurify wrapper. Chaining them here means the security posture and
+ * the failure behaviour are decided once.
+ *
+ * WHY every failure collapses to an empty result instead of throwing: the editor
+ * recompiles on every keystroke, so most intermediate strings are invalid LaTeX
+ * (`\fra`, `\frac{`, ...). Returning `{ mathml: '', omml: {} }` is what lets the
+ * dialog fall back to its "preview will appear here" placeholder and keep the
+ * Insert button disabled while the user is mid-expression, with no error path.
+ *
+ * WHY the MathML is sanitised here rather than at each injection site: the
+ * markup is fed to `dangerouslySetInnerHTML` / `v-html` / `{@html}` / raw
+ * `innerHTML`, and OMML can arrive from an untrusted deck (edit mode seeds the
+ * textarea from an existing equation). Sanitising at the source means a binding
+ * cannot forget. {@link sanitizeMathMl} fails closed (empty) outside a DOM.
+ *
+ * @module render/equation-compile
+ */
+/**
+ * A compiled equation: sanitised MathML for the live preview, plus the OMML tree
+ * for the insert payload (what core stores as `TextSegment.equationXml`).
+ */
+export interface CompiledEquation {
+    /** Sanitised MathML markup, or `''` when the source does not compile. */
+    mathml: string;
+    /** OMML object (`{ "m:oMathPara": { "m:oMath": … } }`), or `{}` on failure. */
+    omml: Record<string, unknown>;
+}
+/**
+ * Compile a LaTeX source string into `{ mathml, omml }`.
+ *
+ * Never throws: empty, whitespace-only and unparseable input all yield the empty
+ * result, so callers can gate their preview on `Object.keys(omml).length > 0`.
+ */
+export declare function compileLatexEquation(source: string): CompiledEquation;
+/**
+ * Convert a LaTeX string straight to sanitised MathML; `''` on empty input or
+ * any failure. The preview-only half of {@link compileLatexEquation}, used by
+ * the template tiles which never need the OMML.
+ */
+export declare function latexToMathMl(source: string): string;
+/**
+ * Compile the shared {@link EQUATION_TEMPLATES} catalogue to MathML, index for
+ * index, for the dialog's starter-formula tiles.
+ *
+ * Deliberately NOT memoised: `sanitizeMathMl` fails closed without a DOM, so a
+ * cached result computed during SSR / module evaluation would freeze an array of
+ * empty strings into a page that later hydrates in a real browser. Bindings that
+ * want it computed once do so at their own component scope.
+ */
+export declare function compileEquationTemplateMathMl(): string[];
+//# sourceMappingURL=equation-compile.d.ts.map

package/dist/pptx/render/equation-compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equation-compile.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/equation-compile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAQH;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;IACf,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9B;AAYD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAYrE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,IAAI,MAAM,EAAE,CAExD"}

package/dist/pptx/render/equation-templates.d.ts

@@ -0,0 +1,20 @@
+/**
+ * equation-templates: the shared catalogue of pre-built equation templates
+ * shown in every binding's equation editor dialog (React's
+ * `EquationEditorDialog` is the reference implementation). Each entry pairs a
+ * LaTeX source with an i18n key (plus an English fallback label) so the
+ * gallery tiles render identically across React, Vue, Angular, Svelte, and
+ * Vanilla.
+ */
+/** Describes a pre-built equation template shown in the template gallery. */
+export interface EquationTemplate {
+    /** Human-readable label (English fallback). */
+    label: string;
+    /** LaTeX source for the template equation. */
+    latex: string;
+    /** i18n translation key for the template name. */
+    i18nKey: string;
+}
+/** Pre-defined equation templates covering common mathematical formulas. */
+export declare const EQUATION_TEMPLATES: readonly EquationTemplate[];
+//# sourceMappingURL=equation-templates.d.ts.map

package/dist/pptx/render/equation-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equation-templates.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/equation-templates.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,6EAA6E;AAC7E,MAAM,WAAW,gBAAgB;IAChC,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,EAAE,SAAS,gBAAgB,EA6DzD,CAAC"}

package/dist/pptx/render/export-clone.d.ts

@@ -0,0 +1,9 @@
+/** Explicit editor-only DOM is omitted by both raster export strategies. */
+export declare function isExportIgnoredElement(element: Element): boolean;
+/**
+ * Prepare a detached capture clone, never the live slide. Inline selection
+ * decoration can share the authored element's node, so renderers record its
+ * original paint instead of asking export to guess which shadows are editor UI.
+ */
+export declare function prepareExportClone(root: HTMLElement): void;
+//# sourceMappingURL=export-clone.d.ts.map

package/dist/pptx/render/export-clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-clone.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/export-clone.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAY1D"}

package/dist/pptx/render/export-progress.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Framework-agnostic export-progress maths shared by the React, Vue, and Angular
+ * bindings. A long export (multi-slide PDF/GIF/video) iterates per slide; this
+ * module maps a `(current, total)` slide cursor onto the 0-100 percentage the
+ * progress modal renders, and builds the matching "slide N of M" status label.
+ *
+ * Keeping the mapping here means every binding shows identical progress
+ * behaviour (the same phase split, the same final 95/100 reserved tail) without
+ * re-deriving the arithmetic in each export handler.
+ */
+/** Reserved tail percentages for the post-capture assembly/save phase. */
+export declare const EXPORT_ASSEMBLING_PERCENT = 95;
+export declare const EXPORT_DONE_PERCENT = 100;
+/** Clamp an arbitrary number into the inclusive `[0, 100]` integer range. */
+export declare function clampPercent(value: number): number;
+/**
+ * Map a per-slide cursor onto a percentage that fills a band `[0, span]`.
+ *
+ * @param current - Zero-based index of the slide about to be processed.
+ * @param total   - Total slide count (guarded against zero).
+ * @param span    - Upper bound of the band to fill (default 90, leaving a tail
+ *                  for the assembly/save phase). Pass 45 for a two-phase export
+ *                  (capture then record), then offset the record phase by 45.
+ */
+export declare function slideProgressPercent(current: number, total: number, span?: number): number;
+/**
+ * Map the recording phase of a two-phase (capture + record) export onto the
+ * upper half of the bar: capture fills `[0, 45]`, recording fills `[45, 90]`.
+ */
+export declare function recordProgressPercent(current: number, total: number): number;
+/**
+ * Build a localisable "{verb} slide N of M" status label. `current` is
+ * zero-based (matching the export loop cursor); the label shows the 1-based
+ * slide number.
+ */
+export declare function slideStatusLabel(verb: string, current: number, total: number): string;
+/** The cooperative-cancellation error every export loop throws on abort. */
+export declare function exportAbortError(): DOMException;
+/** True when an error is the `AbortError` produced by {@link exportAbortError}. */
+export declare function isExportAbortError(err: unknown): boolean;
+//# sourceMappingURL=export-progress.d.ts.map

package/dist/pptx/render/export-progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-progress.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/export-progress.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,0EAA0E;AAC1E,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAC5C,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKlD;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,MAAW,GAAG,MAAM,CAK9F;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAK5E;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAErF;AAED,4EAA4E;AAC5E,wBAAgB,gBAAgB,IAAI,YAAY,CAE/C;AAED,mFAAmF;AACnF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAExD"}