ooxml-ui 0.30.0 → 0.31.0

package/dist/pptx/render/text-autofit-shrink.d.ts

@@ -0,0 +1,90 @@
+/**
+ * `a:normAutofit` ("Shrink text on overflow") editor-time recompute.
+ *
+ * ECMA-376 21.1.2.1.1 (`CT_TextNormalAutofit`) stores `fontScale` and
+ * `lnSpcReduction` as PowerPoint's OWN pre-computed shrink-to-fit values, not
+ * a formula the renderer evaluates: `text-style-helpers.ts`'s
+ * `computeAutoFitTextStyle` applies whatever percentage is on disk verbatim.
+ * That is correct for a deck nobody has edited since PowerPoint last saved it,
+ * but the moment a user types into a `normAutofit` box in this editor, the
+ * stored percentage is stale: PowerPoint recomputes it continuously as you
+ * type (and grows it back toward 100% as you delete). Contrast with
+ * `a:spAutoFit`, which resizes the SHAPE instead and already gets live
+ * remeasurement via `shape-autofit-resize.ts`; this module is `normAutofit`'s
+ * equivalent for the font-shrink side.
+ *
+ * Two pieces, split the same way `shape-autofit-resize.ts` splits its own:
+ * - {@link computeNormAutofitShrink}: the pure decision (this module). Takes
+ *   plain numbers and a measurement CALLBACK rather than touching the DOM
+ *   itself, so it is unit-testable with a fake measurer and identical across
+ *   all five bindings.
+ * - `measureNormAutofitStepHeightPx` (`text-autofit-shrink-measure.ts`): the
+ *   one DOM-touching implementation of that callback, shared for the same
+ *   reason `measureAutoFitContentHeightPx` is.
+ *
+ * PowerPoint's own shrink staircase (fontScale / lnSpcReduction pairs) is not
+ * a formula either: it is a fixed table PowerPoint steps through, trying each
+ * one in order until the text fits. The values below are the commonly
+ * documented reverse-engineered table (the same one the audit that opened
+ * this gap cites: "PowerPoint steps roughly 100/92/84/76/...% with
+ * lnSpcReduction kicking in after a few steps"). A COM probe was attempted
+ * (see the implementation report) but proved inconclusive: `Presentation.
+ * SaveAs` from an unrendered automation window never triggers PowerPoint's
+ * layout pass, so the serialized `fontScale`/`lnSpcReduction` stayed absent
+ * even for grossly overflowing text; reading `TextRange.Font.Size` from a
+ * visible, selected shape DID shrink as text grew, but the read-back point
+ * sizes did not resolve to clean percentages of any single base size,  so
+ * they were not trustworthy as ground truth either. This table is therefore
+ * the audit's documented value, not a freshly COM-verified one.
+ */
+import type { TextStyle } from 'ooxml-core/pptx';
+/** One (fontScale, lnSpcReduction) rung of PowerPoint's shrink staircase. */
+export interface NormAutofitStep {
+    /** Fraction 0..1: matches {@link TextStyle.autoFitFontScale}'s convention (1 = 100%, unscaled). */
+    fontScale: number;
+    /** Fraction 0..1: matches {@link TextStyle.autoFitLineSpacingReduction}'s convention. */
+    lnSpcReduction: number;
+}
+/**
+ * PowerPoint's `a:normAutofit` shrink staircase, largest (unscaled) first.
+ *
+ * `fontScale` steps down in roughly-8-point increments to a 25% floor;
+ * `lnSpcReduction` stays 0 for the first few steps, then holds at 10%, then
+ * 20% for the remainder. {@link computeNormAutofitShrink} always searches from
+ * the top, which is also what makes the "grow back on deletion" requirement
+ * fall out for free: a shorter document just finds a fit at an earlier rung.
+ */
+export declare const NORM_AUTOFIT_STEPS: readonly NormAutofitStep[];
+/** Input to {@link computeNormAutofitShrink}. */
+export interface NormAutofitShrinkInput {
+    /** `a:bodyPr` autofit mode; only `'normal'` (`a:normAutofit`) shrinks the text. */
+    autoFitMode: TextStyle['autoFitMode'] | undefined;
+    /** The element's currently stored `autoFitFontScale`, or `undefined` for unscaled (1). */
+    currentFontScale: number | undefined;
+    /** The element's currently stored `autoFitLineSpacingReduction`, or `undefined` for none (0). */
+    currentLnSpcReduction: number | undefined;
+    /**
+     * Measures the rendered content height (px, the shape's whole box including
+     * insets, the same convention `measuredContentHeightPx` uses in
+     * `shape-autofit-resize.ts`) if the body were painted at `step`. Returning
+     * `0` (or any non-positive number) for every step means "no usable
+     * measurement", and the function returns `'unchanged'` without picking a
+     * rung.
+     */
+    measureAtStep: (step: NormAutofitStep) => number;
+    /** The shape's fixed box height (px). `normAutofit` never resizes the shape itself. */
+    boxHeightPx: number;
+}
+/** The resolved shrink state, or `'unchanged'` when nothing needs to be written back. */
+export type NormAutofitShrinkResult = NormAutofitStep | 'unchanged';
+/**
+ * Decide the `normAutofit` `fontScale`/`lnSpcReduction` pair that makes the
+ * current text fit `boxHeightPx`, re-deriving from scratch (always searching
+ * from 100%) so a user who deletes text grows the scale back exactly as
+ * PowerPoint does.
+ *
+ * Pure: takes plain numbers and a measurement callback, so it is trivially
+ * the same across all five bindings and unit-testable without a DOM.
+ */
+export declare function computeNormAutofitShrink(input: NormAutofitShrinkInput): NormAutofitShrinkResult;
+//# sourceMappingURL=text-autofit-shrink.d.ts.map

package/dist/pptx/render/text-autofit-shrink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-autofit-shrink.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-autofit-shrink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,6EAA6E;AAC7E,MAAM,WAAW,eAAe;IAC/B,mGAAmG;IACnG,SAAS,EAAE,MAAM,CAAC;IAClB,yFAAyF;IACzF,cAAc,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,eAAe,EAgBxD,CAAC;AAKF,iDAAiD;AACjD,MAAM,WAAW,sBAAsB;IACtC,mFAAmF;IACnF,WAAW,EAAE,SAAS,CAAC,aAAa,CAAC,GAAG,SAAS,CAAC;IAClD,0FAA0F;IAC1F,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,iGAAiG;IACjG,qBAAqB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C;;;;;;;OAOG;IACH,aAAa,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,MAAM,CAAC;IACjD,uFAAuF;IACvF,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,yFAAyF;AACzF,MAAM,MAAM,uBAAuB,GAAG,eAAe,GAAG,WAAW,CAAC;AAEpE;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,sBAAsB,GAAG,uBAAuB,CAoC/F"}

package/dist/pptx/render/text-block-style.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The single text-BODY (block) style builder every binding renders text with.
+ *
+ * Why this exists: React's `getTextStyleForElement` and the four near-identical
+ * `getTextBlockStyle` copies in the Vue / Angular / Svelte / Vanilla bindings
+ * had drifted apart, and the drift was invisible to a screenshot-level parity
+ * test. The copies never read `a:normAutofit` (a title authored
+ * `fontScale="70000"` painted 43% too large in four of five bindings) and never
+ * read `a:bodyPr/@wrap="none"` (a no-wrap line wrapped to three lines), plus
+ * they omitted the default font declaration, the italic padding nudge and the
+ * body margin/indent pair. One builder, five callers, no drift.
+ *
+ * The result is a neutral CSS record (camelCase keys, plain values), never a
+ * framework's `CSSProperties`, so each binding casts or maps it into its own
+ * style binding. Lengths are emitted as bare numbers by default (React's
+ * convention, and what its unit tests assert); bindings whose style binding
+ * does not add units pass `pxLengths: true`.
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+/** A neutral CSS record: camelCase property names, plain CSS values. */
+export type TextBlockStyle = Record<string, string | number>;
+/** Knobs the five bindings differ on; everything else is identical for all. */
+export interface TextBlockStyleOptions {
+    /**
+     * Colour used when the element authors none. React threads its
+     * theme-resolved default here; the other bindings pass their own constant.
+     */
+    fallbackColor?: string;
+    /**
+     * Emit the body BOX as well as its typography: size, `white-space` /
+     * `word-break`, and everything `buildTextBodyLayoutStyle` decides (columns,
+     * the `a:bodyPr/@anchor` justification, `@anchorCtr`, `tab-size`, kinsoku),
+     * plus the `@rot` transform. React composes the same shared decisions onto a
+     * separate layer in `getTextLayoutStyle`; the other four fold them into this
+     * one style.
+     */
+    bodyLayout?: boolean;
+    /**
+     * Emit lengths as `"12px"` strings rather than the bare `12` React's JSX
+     * style prop unit-suffixes for us. Vue / Angular / Svelte / Vanilla style
+     * bindings all assign the value verbatim, so a bare number is dropped.
+     */
+    pxLengths?: boolean;
+}
+/**
+ * Build the CSS for one element's text body.
+ *
+ * Covers colour (including the hyperlink override), alignment and direction,
+ * the font declaration, decorations, line height, body insets, the
+ * element-level margin/indent fallback, vertical writing modes,
+ * `wrap="none"`, and the `a:normAutofit` / `spAutoFit` font scale.
+ *
+ * Returns just `{ color }` for an element with no text properties, so a caller
+ * can spread the result unconditionally.
+ */
+export declare function buildTextBlockStyle(element: PptxElement, options?: TextBlockStyleOptions): TextBlockStyle;
+//# sourceMappingURL=text-block-style.d.ts.map

package/dist/pptx/render/text-block-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-block-style.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-block-style.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAe,MAAM,iBAAiB,CAAC;AA8BhE,wEAAwE;AACxE,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;AAE7D,+EAA+E;AAC/E,MAAM,WAAW,qBAAqB;IACrC;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAgCD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAClC,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,qBAA0B,GACjC,cAAc,CAoNhB"}

package/dist/pptx/render/text-body-layout.d.ts

@@ -0,0 +1,159 @@
+/**
+ * `text-body-layout`: the `a:bodyPr` LAYOUT decisions, for all five bindings.
+ *
+ * `buildTextBlockStyle` owns the text body's typography (colour, font, line
+ * height, insets). This module owns the box it is laid out in: how many columns
+ * it has (`@numCol` / `@spcCol`), how tab characters advance (`a:tabLst` /
+ * `@defTabSz`), where the text sits vertically (`@anchor`) and horizontally
+ * (`@anchorCtr`), the CJK break rules (`@eaLnBrk` / `@latinLnBrk` /
+ * `@hangingPunct`), and whether an overflowing body clips (`@vertOverflow` /
+ * `@horzOverflow`).
+ *
+ * Why it exists: every one of those reached React ONLY. React composed them in
+ * its private `getTextLayoutStyle`, while Vue / Angular / Svelte / Vanilla went
+ * through `buildTextBlockStyle`, which had no branch for any of them. A
+ * two-column body rendered as one column in four of five bindings, tabbed text
+ * fell back to the browser's 8-character default in four, and `anchorCtr` and
+ * `vertOverflow` were honoured by nobody at all - Vanilla even shipped a
+ * "Column Spacing" inspector control whose value its renderer never read.
+ *
+ * The function returns a neutral CSS record; `buildTextBlockStyle` folds it in
+ * for the four bindings that ask for `bodyLayout`, and React's
+ * `getTextLayoutStyle` is a thin wrapper over it. One implementation, five
+ * bindings.
+ *
+ * @module render/text-body-layout
+ */
+import type { PptxElement, TextStyle } from 'ooxml-core/pptx';
+/** A neutral CSS record: camelCase property names, plain CSS values. */
+export type TextBodyLayoutStyle = Record<string, string | number>;
+/**
+ * Resolved column layout for a text body.
+ *
+ * `count` is 1 for the overwhelmingly common single-column body, in which case
+ * `gap` is `undefined` and a caller emits no multi-column CSS at all.
+ */
+export interface TextBodyColumns {
+    /** `a:bodyPr/@numCol`, clamped to the schema's 1..16 range. */
+    count: number;
+    /**
+     * `a:bodyPr/@spcCol` as a CSS length, or `undefined` for a single column.
+     *
+     * The schema default is 0 (`ST_PositiveCoordinate32`, "Specifies the space
+     * between text columns... Default 0"), and 0 is what we emit for an omitted
+     * attribute. React used to invent a `0.75em` gap here, which is neither the
+     * authored value nor the spec default.
+     */
+    gap?: string;
+}
+/**
+ * Resolve `a:bodyPr/@numCol` + `@spcCol` into a column count and CSS gap.
+ *
+ * @param textStyle The element's resolved text style, or `undefined`.
+ * @returns The column decision; `count` is 1 when the body is single-column.
+ */
+export declare function resolveTextBodyColumns(textStyle: TextStyle | undefined): TextBodyColumns;
+/**
+ * Compute a CSS `tab-size` from parsed tab stops.
+ *
+ * CSS can only express ONE uniform advance, so a body with several stops is
+ * approximated by the average distance between consecutive stops (a single stop
+ * is used verbatim). When no stop is authored, `a:pPr/@defTabSz` (already in px)
+ * supplies the interval, which is the value PowerPoint actually advances by; the
+ * browser default of 8 characters is never right for a deck.
+ *
+ * Per-stop ALIGNMENT (`@algn="ctr"|"r"|"dec"`) and leader glyphs cannot be
+ * expressed as `tab-size`; those need a measured inline layout, which
+ * `text-tab-layout` / `text-tab-run-build` provide via `ParagraphRun.tabLines`
+ * for a run whose text actually contains a tab.
+ *
+ * @param tabStops    Parsed `a:tabLst` entries (positions in px).
+ * @param defaultTabSize `a:pPr/@defTabSz` in px.
+ * @returns A CSS `tab-size` value, or `undefined` when nothing is authored.
+ */
+export declare function computeTabSize(tabStops: TextStyle['tabStops'], defaultTabSize?: number): string | undefined;
+/**
+ * `a:bodyPr/@vertOverflow` / `@horzOverflow` as a CSS overflow decision.
+ *
+ * The spec's `clip` and `ellipsis` both mean "do not let the text escape the
+ * shape"; `overflow` (and an omitted attribute) mean it may spill, which is what
+ * PowerPoint does by default and what every binding already did.
+ *
+ * Both axes are clipped together even when only one is authored, because CSS
+ * forbids the mixed state: setting one axis to `hidden` while the other stays
+ * `visible` computes the visible one to `auto`, which paints a scrollbar inside
+ * the shape. Clipping the other axis as well is the lesser deviation, and only
+ * reachable on a body that authored a clip in the first place.
+ *
+ * @returns `'hidden'` when the body must clip, otherwise `undefined`.
+ */
+export declare function resolveTextOverflowClip(textStyle: TextStyle | undefined): 'hidden' | undefined;
+/**
+ * Build the CSS for one element's text-body BOX (as opposed to its typography).
+ *
+ * Emits, in this order so a later rule can override an earlier one:
+ *
+ *  1. the column box (`display: block` + `column-count` + `column-gap` +
+ *     `column-fill: auto` + `align-content` for `@anchor` + `direction` for
+ *     `@rtlCol`) when `@numCol > 1`, otherwise the flex column with the
+ *     `@anchor` justification;
+ *  2. `align-items: center` for `@anchorCtr="1"`;
+ *  3. `tab-size`;
+ *  4. the kinsoku rules, last, because `@latinLnBrk` legitimately overrides the
+ *     default `word-break`.
+ *
+ * `@vertOverflow` is deliberately NOT here: it has to beat the `wrap="none"` and
+ * linked-text-box overflow rules `buildTextBlockStyle` applies afterwards, so it
+ * is folded in there (see {@link resolveTextOverflowClip}).
+ *
+ * @param element The element whose text body is being laid out.
+ * @returns A neutral CSS record, empty for an element with no text properties.
+ *          Every length is already a unit-suffixed string, so no `pxLengths`
+ *          conversion applies to it.
+ */
+export declare function buildTextBodyLayoutStyle(element: PptxElement): TextBodyLayoutStyle;
+/**
+ * `a:bodyPr/@rot` (and `@upright`) as a CSS `transform` value.
+ *
+ * `@rot` rotates the text body inside an otherwise unrotated shape
+ * (PowerPoint's "Text Options > Text Box > custom angle"). Core stores it in
+ * degrees, clockwise positive, which is also CSS's sense, so the mapping is
+ * direct.
+ *
+ * `@upright` keeps the text screen-upright when the SHAPE itself carries its
+ * own rotation (`element.rotation`, from `xfrm/@rot`): PowerPoint counter-
+ * rotates the text body by exactly the shape's own angle so the glyphs stay
+ * level while the shape's outline still turns. Both angles land on the same
+ * transform (the text body nested inside the already-rotated shape), so they
+ * compose into one `rotate()` rather than two separate declarations.
+ *
+ * Returns `undefined` when neither angle is authored, so a caller can compose
+ * this with its own transforms without emitting a no-op `rotate(0deg)`.
+ *
+ * @param element The element whose text body may be rotated and/or upright.
+ * @returns e.g. `'rotate(45deg)'`, or `undefined`.
+ */
+export declare function getTextBodyRotationTransform(element: PptxElement): string | undefined;
+/**
+ * `a:bodyPr/@vertOverflow="ellipsis"` as a CSS multi-line clamp.
+ *
+ * `resolveTextOverflowClip` treats `ellipsis` the same as `clip` (both just
+ * hide the overflow), which is honest about a plain single-line
+ * `text-overflow: ellipsis` not applying to the multi-line, wrapped text a
+ * PowerPoint text body actually renders. `-webkit-line-clamp` (now supported
+ * by every major engine, including Firefox, despite the prefix) is the one
+ * CSS mechanism that truncates WRAPPED text with a trailing "…" glyph, but it
+ * needs a line COUNT, not a pixel height, so this estimates one from the
+ * body's own content box and resolved line height.
+ *
+ * @param textStyle      The element's resolved text style.
+ * @param contentHeightPx The text body's content-box height in px (the
+ *                        element's own height minus its insets). A
+ *                        non-positive value (an unset or too-small box)
+ *                        clamps to one line rather than emitting no clamp.
+ * @param lineHeightPx    The resolved single-line height in px.
+ * @returns The clamp CSS, or `{}` when `@vertOverflow` is not `ellipsis` or
+ *          `lineHeightPx` is unusable (so the caller's plain clip still wins).
+ */
+export declare function resolveVertOverflowEllipsisStyle(textStyle: TextStyle | undefined, contentHeightPx: number, lineHeightPx: number): TextBodyLayoutStyle;
+//# sourceMappingURL=text-body-layout.d.ts.map

package/dist/pptx/render/text-body-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-body-layout.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-body-layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAoC9D,wEAAwE;AACxE,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;AAKlE;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC/B,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,GAAG,eAAe,CAWxF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC7B,QAAQ,EAAE,SAAS,CAAC,UAAU,CAAC,EAC/B,cAAc,CAAC,EAAE,MAAM,GACrB,MAAM,GAAG,SAAS,CA2BpB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAI9F;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,GAAG,mBAAmB,CAsElF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAkBrF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gCAAgC,CAC/C,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,MAAM,GAClB,mBAAmB,CAkBrB"}

package/dist/pptx/render/text-body-rect.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `text-body-rect`: the geometry's TEXT RECTANGLE (`a:rect`), as body padding.
+ *
+ * Every preset geometry, and every `a:custGeom`, may declare an `a:rect`: the
+ * inscribed rectangle PowerPoint lays text out in. A chevron's text sits between
+ * its two arrow points, a `homePlate`'s stops short of its nose, an action
+ * button's is inset from its bevel. The core evaluator has always computed it
+ * (`evaluatePresetShape(...).textRect`) and `a:custGeom`'s has always been
+ * parsed (`customGeometryTextRect`), but NOTHING read either one: a grep for
+ * `.textRect` across all five bindings found only unrelated
+ * `getBoundingClientRect` locals. Text in a chevron, callout, arrow or wedge was
+ * therefore laid out against the full bounding box and spilled over the
+ * geometry, in every binding equally.
+ *
+ * This module turns the evaluator's output into a framework-neutral padding
+ * quadruple that `buildTextBlockStyle` adds to the `a:bodyPr` insets (which, per
+ * the spec, apply INSIDE the text rectangle, so the two add). That single seam
+ * reaches react, vue, angular, svelte and vanilla at once.
+ *
+ * It applies the rectangle only for the presets PowerPoint itself has confirmed
+ * (see {@link VERIFIED_TEXT_RECT_PRESETS}): the table's `rect` entries had never
+ * been read by anything, and measuring PowerPoint showed most of them are wrong.
+ *
+ * @module render/text-body-rect
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+/** Extra padding, in px, contributed by the geometry's text rectangle. */
+export interface TextBodyRectPadding {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+/**
+ * Resolve the padding an element's geometry text rectangle contributes.
+ *
+ * Returns zeroes (never `undefined`) so a caller can add the four values
+ * unconditionally. Zeroes are returned for a plain rectangle, for a shape with
+ * no geometry, and for any rectangle the guards above reject.
+ *
+ * @param element The element whose text body is being laid out.
+ * @returns Extra px padding on each edge, from the geometry's `a:rect`.
+ */
+export declare function resolveTextBodyRectPadding(element: PptxElement): TextBodyRectPadding;
+//# sourceMappingURL=text-body-rect.d.ts.map

package/dist/pptx/render/text-body-rect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-body-rect.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-body-rect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAKnD,0EAA0E;AAC1E,MAAM,WAAW,mBAAmB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AA6HD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,WAAW,GAAG,mBAAmB,CAkCpF"}

package/dist/pptx/render/text-build-spans.d.ts

@@ -0,0 +1,78 @@
+/**
+ * `text-build-spans` - framework-agnostic spec for rendering a staged text
+ * build (by paragraph / word / letter).
+ *
+ * `expandTextBuildAnimations` splits one animation into per-paragraph,
+ * per-word or per-character sub-animations keyed `<elementId>::p0` /
+ * `::w0-3` / `::c0-7`. Something then has to split the RENDERED text the same
+ * way and attach each sub-animation to its own span, or the build has no
+ * visible effect and the whole box fades as one.
+ *
+ * React did that inline in JSX, which left the other four bindings with no
+ * by-letter animation at all. This module returns the split as plain data so
+ * every binding can render it with its own primitives - the same shape as
+ * `notesSegmentsToSpans`.
+ *
+ * @module render/text-build-spans
+ */
+import type { ElementAnimationState } from './animation-timeline-types.js';
+/** A styled run of text, as the bindings' paragraph models already hold it. */
+export interface TextBuildRun<TStyle> {
+    text: string;
+    style?: TStyle;
+}
+/** One rendered piece of a staged text build. */
+export interface TextBuildSpan<TStyle = unknown> {
+    /**
+     * The sub-animation id (`<elementId>::c0-3`), or `undefined` for the
+     * whitespace between words, which is emitted verbatim and never animated.
+     */
+    animId?: string;
+    /** The text this span renders. */
+    text: string;
+    /** True when the sub-animation says the piece is not visible yet. */
+    hidden: boolean;
+    /** The CSS `animation` shorthand to apply, when one is running. */
+    cssAnimation?: string;
+    /**
+     * The style of the run this piece came from, passed straight through. A
+     * build splits the text but must not flatten its formatting: without this a
+     * bold or coloured run turns plain for the duration of the animation.
+     */
+    style?: TStyle;
+}
+/** How a paragraph's text is split for its build. */
+export type TextBuildGranularity = 'paragraph' | 'word' | 'char';
+/** The spec for one paragraph of a staged text build. */
+export interface TextBuildSpec<TStyle = unknown> {
+    granularity: TextBuildGranularity;
+    /** For a paragraph-level build, the single wrapper's id. */
+    animId?: string;
+    hidden?: boolean;
+    cssAnimation?: string;
+    /** For word/char builds, the pieces in render order. */
+    spans?: TextBuildSpan<TStyle>[];
+}
+/**
+ * Resolve how a paragraph should be split, or `undefined` when no staged build
+ * targets it (the overwhelmingly common case - callers render normally then).
+ *
+ * Detection mirrors the ids `expandTextBuildAnimations` emits: a paragraph
+ * build registers `::p<i>`, a word build `::w<i>-0`, a char build `::c<i>-0`.
+ *
+ * @param elementId - The owning element's id.
+ * @param paraIndex - Index of this paragraph within the element's text.
+ * @param runs      - The paragraph's styled runs, in order.
+ * @param states    - Live sub-element animation states for the slide.
+ */
+export declare function buildTextBuildSpec<TStyle>(elementId: string, paraIndex: number, runs: ReadonlyArray<TextBuildRun<TStyle>>, states: ReadonlyMap<string, ElementAnimationState> | undefined): TextBuildSpec<TStyle> | undefined;
+/**
+ * The inline style a {@link TextBuildSpan} (or a paragraph-level spec) needs.
+ * Returned as a plain record so each binding can apply it however it applies
+ * styles; `display: inline` keeps the wrapper from breaking text layout.
+ */
+export declare function textBuildSpanStyle(span: {
+    hidden?: boolean;
+    cssAnimation?: string;
+}): Record<string, string>;
+//# sourceMappingURL=text-build-spans.d.ts.map

package/dist/pptx/render/text-build-spans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-build-spans.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-build-spans.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAExE,+EAA+E;AAC/E,MAAM,WAAW,YAAY,CAAC,MAAM;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,iDAAiD;AACjD,MAAM,WAAW,aAAa,CAAC,MAAM,GAAG,OAAO;IAC9C;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,MAAM,EAAE,OAAO,CAAC;IAChB,mEAAmE;IACnE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,qDAAqD;AACrD,MAAM,MAAM,oBAAoB,GAAG,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AAEjE,yDAAyD;AACzD,MAAM,WAAW,aAAa,CAAC,MAAM,GAAG,OAAO;IAC9C,WAAW,EAAE,oBAAoB,CAAC;IAClC,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wDAAwD;IACxD,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;CAChC;AAkCD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EACxC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,aAAa,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,EACzC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAAG,SAAS,GAC5D,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAyEnC;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACxC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASzB"}

package/dist/pptx/render/text-case-transform.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var chunk52LKIMK3_cjs = require('../chunk-52LKIMK3.cjs');
+
+
+
+Object.defineProperty(exports, "applyCaseTransformToSegments", {
+  enumerable: true,
+  get: function () { return chunk52LKIMK3_cjs.applyCaseTransformToSegments; }
+});
+Object.defineProperty(exports, "transformTextCase", {
+  enumerable: true,
+  get: function () { return chunk52LKIMK3_cjs.transformTextCase; }
+});

package/dist/pptx/render/text-case-transform.d.ts

@@ -0,0 +1,19 @@
+/**
+ * "Change Case" text mutation (PowerPoint's Aa dropdown: Sentence case, lower,
+ * UPPER, Capitalize Each Word, tOGGLE cASE). Unlike `textCaps` (a purely
+ * visual `text-transform`-style render hint), these modes rewrite the actual
+ * characters, matching PowerPoint's own behaviour. Framework-agnostic; no
+ * framework imports.
+ */
+import type { TextSegment } from 'ooxml-core/pptx';
+import type { InlineTextSelection } from './inline-selection-utils.js';
+export type ChangeCaseMode = 'sentence' | 'lower' | 'upper' | 'capitalize' | 'toggle';
+/** Transform a plain-text string per the given Change Case mode. */
+export declare function transformTextCase(text: string, mode: ChangeCaseMode): string;
+/**
+ * Apply a Change Case transform to a set of text segments, either within an
+ * inline-editor selection range (mirrors {@link applyStyleToSelectedSegments})
+ * or, when `selection` is `null`, across every segment's text.
+ */
+export declare function applyCaseTransformToSegments(segments: TextSegment[], selection: InlineTextSelection | null, mode: ChangeCaseMode): TextSegment[];
+//# sourceMappingURL=text-case-transform.d.ts.map

package/dist/pptx/render/text-case-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-case-transform.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-case-transform.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,YAAY,GAAG,QAAQ,CAAC;AAKtF,oEAAoE;AACpE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,CAkC5E;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC3C,QAAQ,EAAE,WAAW,EAAE,EACvB,SAAS,EAAE,mBAAmB,GAAG,IAAI,EACrC,IAAI,EAAE,cAAc,GAClB,WAAW,EAAE,CAmCf"}

package/dist/pptx/render/text-case-transform.mjs

@@ -0,0 +1 @@
+export { applyCaseTransformToSegments, transformTextCase } from '../chunk-APQ3OOAT.mjs';

package/dist/pptx/render/text-decoration.d.ts

@@ -0,0 +1,98 @@
+/**
+ * OOXML underline / strikethrough -> CSS text-decoration resolution, shared by
+ * every binding's text renderer.
+ *
+ * Pure, framework-agnostic: returns a neutral record of CSS text-decoration
+ * properties (literal-union `textDecorationStyle` plus `px` strings). Each
+ * binding casts it into its own style type at the call site.
+ */
+import type { TextStyle } from 'ooxml-core/pptx';
+/** CSS `text-decoration-style` keyword values. */
+export type CssTextDecorationStyle = 'solid' | 'double' | 'dotted' | 'dashed' | 'wavy';
+/**
+ * CSS properties that fully describe the visual appearance of an underline or
+ * strikethrough decoration. Returned by {@link resolveUnderlineDecorationStyle}.
+ */
+export interface UnderlineDecorationCss {
+    textDecorationStyle?: CssTextDecorationStyle;
+    textDecorationThickness?: string;
+    textUnderlineOffset?: string;
+}
+/**
+ * Resolve an OOXML underline / strikethrough style to a set of CSS
+ * text-decoration properties that make all 16 underline types visually
+ * distinct.
+ *
+ * CSS `text-decoration-style` only has 5 variants (solid, double, dotted,
+ * dashed, wavy), so we use `text-decoration-thickness` to differentiate heavy
+ * variants and `text-underline-offset` for additional visual separation where
+ * compound patterns (dotDash, dotDotDash, dashLong) share the same CSS base
+ * style.
+ *
+ * @param isDoubleStrike Whether a double-strikethrough is requested (wins over
+ *                       the underline style).
+ * @param underlineStyle The OOXML underline-style token (e.g. `"sng"`,
+ *                       `"wavyHeavy"`), or `undefined` / `"none"`.
+ */
+export declare function resolveUnderlineDecorationStyle(isDoubleStrike: boolean, underlineStyle?: string): UnderlineDecorationCss | undefined;
+/**
+ * Resolve a run's own `<a:rPr><a:uLn>` (underline line properties: width,
+ * compound type, dash pattern, caps) to the CSS that overrides the plain
+ * `a:u`-style decoration {@link resolveUnderlineDecorationStyle} produces.
+ *
+ * `a:uLn` is a distinct, independent line description from `a:u`'s style
+ * token - a run can author both (`u="sng"` for the underline TYPE plus a
+ * custom-width dashed `uLn` for its STROKE), and the line's own width/dash
+ * take priority over whatever the type token implied, exactly as `a:ln`
+ * overrides a shape outline's default weight. Previously only the line's
+ * colour (`a:uLn/a:solidFill`, via `underlineColor`) was ever rendered; the
+ * width and dash preset parsed into {@link TextStyle.underlineLine} were
+ * captured for round-trip but never reached the screen.
+ *
+ * @param underlineLine The run's parsed `a:uLn`, or `undefined`.
+ * @param hasUnderline  Whether the run actually renders an underline at all
+ *                       (`a:u` present and not `"none"`); a `uLn` on a run
+ *                       with no underline has nothing to decorate.
+ * @returns The thickness/style override, or `undefined` when the run has no
+ *          underline or its `uLn` authors neither a width nor a known dash.
+ */
+export declare function resolveUnderlineLineDecoration(underlineLine: TextStyle['underlineLine'] | undefined, hasUnderline: boolean): UnderlineDecorationCss | undefined;
+/**
+ * Whether a run's underline should be split into per-word pieces with a gap
+ * under the spaces. Always `false`: although `u="words"` is specified as
+ * words-only, PowerPoint 365 draws it continuously, exactly like `sng`
+ * (COM-verified: audit-text slide 12's "words under line" is underlined
+ * across both spaces). The per-word plumbing ({@link splitWordsForUnderline})
+ * stays for callers that opt in explicitly.
+ */
+export declare function splitsUnderlineIntoWords(_style: {
+    underline?: boolean;
+    underlineStyle?: string;
+} | undefined): boolean;
+/** One word-or-whitespace piece of a run's text, for `u="words"` rendering. */
+export interface UnderlineWordPiece {
+    text: string;
+    /** Whether this piece should carry the underline decoration. */
+    underline: boolean;
+}
+/**
+ * Split `text` into alternating word / whitespace pieces so a binding can
+ * render `a:rPr/@u="words"` (D2-G3) as true per-word underlines with a gap
+ * under the spaces between them, by wrapping each `underline: true` piece in
+ * its own `<span>` and leaving whitespace pieces undecorated.
+ *
+ * Wired into the ordinary per-word metric split via `splitStyledRun`
+ * (`text-run-spacing.ts`, which emits the words/gaps as sibling `BuiltRun`s)
+ * and, for the two run shapes that must stay ONE piece, into
+ * `paragraph-run-build.ts` (`BuiltRun.underlineWordPieces`, a ruby run) and
+ * `text-tab-run-build.ts` (`TabbedRunPiece.words`, a tab-separated piece) -
+ * both fall back to {@link resolveUnderlineDecorationStyle}'s `'words'` case
+ * (a single continuous underline) for a binding that does not render the
+ * per-piece field yet.
+ *
+ * @param text Run text to split. Whitespace here means ASCII/Unicode spaces
+ *             and tabs; a run already split into `tabLines` should call this
+ *             per tab-stop segment, not on the raw unsplit text.
+ */
+export declare function splitWordsForUnderline(text: string): UnderlineWordPiece[];
+//# sourceMappingURL=text-decoration.d.ts.map

package/dist/pptx/render/text-decoration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-decoration.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-decoration.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,kDAAkD;AAClD,MAAM,MAAM,sBAAsB,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AA4BvF;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACtC,mBAAmB,CAAC,EAAE,sBAAsB,CAAC;IAC7C,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,+BAA+B,CAC9C,cAAc,EAAE,OAAO,EACvB,cAAc,CAAC,EAAE,MAAM,GACrB,sBAAsB,GAAG,SAAS,CAoGpC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,8BAA8B,CAC7C,aAAa,EAAE,SAAS,CAAC,eAAe,CAAC,GAAG,SAAS,EACrD,YAAY,EAAE,OAAO,GACnB,sBAAsB,GAAG,SAAS,CAgBpC;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACvC,MAAM,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,GAClE,OAAO,CAET;AAED,+EAA+E;AAC/E,MAAM,WAAW,kBAAkB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,SAAS,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAiBzE"}