ooxml-ui 0.30.0 → 0.31.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-list-style-update.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-list-style-update.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAS3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AA4DpE,iFAAiF;AACjF,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,WAAW,EAAE,EACvB,OAAO,EAAE,WAAW,EAAE,GACpB,WAAW,EAAE,CAsBf;AAED,mFAAmF;AACnF,wBAAgB,2BAA2B,CAC1C,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,mBAAmB,GAAG,IAAI,GACnC,mBAAmB,CAUrB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,EAC3B,SAAS,EAAE,mBAAmB,GAAG,IAAI,GACnC;IAAE,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAAC,SAAS,EAAE,mBAAmB,GAAG,IAAI,CAAA;CAAE,CAqDxE"}

package/dist/pptx/render/text-metric-tracking.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Per-run advance-width compensation, so the browser breaks lines where
+ * PowerPoint breaks them.
+ *
+ * PowerPoint lays text out with GDI-compatible (hinted) metrics: every glyph
+ * advance is snapped to a whole device pixel at 576 DPI, i.e. to 1/8 point,
+ * i.e. to 1/6 of a CSS px. The browser uses unrounded fractional advances. The
+ * two therefore disagree by up to 1/12 px per glyph, in EITHER direction, and
+ * the accumulated disagreement over a line is what decides a knife-edge wrap.
+ *
+ * Ground truth (PowerPoint COM `TextRange.BoundWidth` over the issue #131 /
+ * #149 deck): summing `round(advance * 6) / 6` reproduced all 78 advance-exact
+ * measured lines to under 0.001 px, while the browser's own measurement of the
+ * same strings ran anywhere from 1.07% narrow to 0.28% wide.
+ *
+ * That spread is the point. The first attempt at this (issue #131) applied a
+ * flat 0.003em to every run, which is roughly the middle of the range: it
+ * tipped genuinely-late wraps the right way but pushed every string the browser
+ * already measured WIDER than PowerPoint over its column, so short labels that
+ * PowerPoint keeps on one line ("Explore solution", "Secure Data Movement")
+ * started wrapping (issue #149). No single constant can do this job; the
+ * correction has to be derived from the actual characters.
+ *
+ * So: measure the run, compute the width PowerPoint would have measured, and
+ * emit the letter-spacing that closes the gap. Two details decide whether that
+ * works or does damage, and both are documented where they are made -
+ * `advancesOf` (advances come from prefix differences, never from measuring a
+ * character alone) and the clamp in `resolveMetricTrackingPx`.
+ *
+ * Measured end to end in Chromium, rendered span against COM ground truth: mean
+ * error 0.026 px, worst 0.40 px, against 0.53 px / 2.05 px uncompensated. On
+ * shaped scripts the correction moves the text by 0.00% (Arabic, CJK) to 0.08%
+ * (Devanagari), i.e. nothing visible.
+ */
+/** The font a run actually renders with, after substitution and autofit. */
+export interface RunFontSpec {
+    /** Resolved CSS `font-family` list (already PANOSE-substituted). */
+    fontFamily?: string;
+    /** Resolved CSS font size in px (already scaled by `normAutofit`). */
+    fontSizePx?: number;
+    bold?: boolean;
+    italic?: boolean;
+}
+/**
+ * The letter-spacing (in CSS px) that makes `text` render at the width
+ * PowerPoint measured it at. `0` when there is nothing to correct, no DOM to
+ * measure with, or the correction came out implausible.
+ *
+ * The divisor is the character count, not the gap count: every engine adds the
+ * spacing after the final character too, and that trailing gap is part of the
+ * inline box the line breaker sees. Being wrong about that convention would
+ * cost one unit of tracking (~0.04 px), well inside the tolerance here.
+ *
+ * The result is clamped to half a grid step per character, and that bound is
+ * the model's own definition rather than a magic number: snapping an advance to
+ * the grid can move it by at most half a step, so a correction larger than that
+ * is not describing rounding at all. It means the browser and PowerPoint
+ * disagree for some other reason - kerning the run enables and PowerPoint does
+ * not, a font that never loaded - and uniform letter-spacing is the wrong tool
+ * for those. Clamping keeps the correction imperceptible (at most 0.083 px per
+ * glyph) instead of visibly stretching the text to chase a difference it cannot
+ * legitimately close.
+ */
+export declare function resolveMetricTrackingPx(text: string, font: RunFontSpec): number;
+/** A stretch of a run that carries its own tracking. */
+export interface MetricRunPiece {
+    text: string;
+    /** letter-spacing in CSS px that renders `text` at PowerPoint's width. */
+    tracking: number;
+}
+/**
+ * Cut a run at every line-break opportunity so each piece can carry its own
+ * tracking.
+ *
+ * One tracking for a whole run makes the RUN measure exactly, but a line is a
+ * prefix of it, and the rounding error is not spread evenly through the text -
+ * so a line can still come out up to ~0.95 px off, which is enough to move a
+ * break (issue #149, slide 5: "operational" fitted on a line PowerPoint had
+ * already closed). Give every word its own tracking and every whitespace gap
+ * its own, and any line the browser assembles out of whole pieces measures
+ * exactly what PowerPoint measured, because advances simply add up.
+ *
+ * A break INSIDE a piece (mid-word, or between CJK characters, which have no
+ * spaces to cut at) falls back to that piece's average - i.e. to the run-level
+ * behaviour, never worse.
+ *
+ * Returns a single piece when the run has no interior boundary, which keeps the
+ * common case (a short label, a one-word run) at exactly one span.
+ */
+export declare function splitRunForMetrics(text: string, font: RunFontSpec): MetricRunPiece[];
+/**
+ * {@link resolveMetricTrackingPx} as a CSS length, or `undefined` when the run
+ * needs no correction (so callers can leave `letter-spacing` undeclared rather
+ * than emitting a no-op `0px`).
+ */
+export declare function resolveMetricTracking(text: string, font: RunFontSpec): string | undefined;
+/**
+ * The width `text` actually PAINTS at once {@link resolveMetricTrackingPx}'s
+ * correction is applied as `letter-spacing` (browser measurement plus the
+ * tracking added once per character, same formula as {@link splitStyledRun}
+ * in `text-run-spacing.ts`).
+ *
+ * Exported for `text-tab-run-build.ts`: a tabbed piece is positioned by the
+ * leader gap laid out in front of it rather than by absolute CSS, so unlike an
+ * ordinary run its LAYOUT and its PAINT have to agree on one width or the next
+ * tab stop drifts once the correction is actually applied.
+ *
+ * @param naturalWidth The caller's own (unhinted) measurement of `text`, so
+ *   this does not measure the same string on the canvas twice.
+ */
+export declare function resolveTrackedTextWidth(text: string, font: RunFontSpec, naturalWidth: number): number;
+/** Test hook: forget every measurement (also used by the font-load listener). */
+export declare function resetMetricTrackingCache(): void;
+//# sourceMappingURL=text-metric-tracking.d.ts.map

package/dist/pptx/render/text-metric-tracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-metric-tracking.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-metric-tracking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAIH,4EAA4E;AAC5E,MAAM,WAAW,WAAW;IAC3B,oEAAoE;IACpE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAgGD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,CAkC/E;AAED,wDAAwD;AACxD,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAC;CACjB;AAiBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,cAAc,EAAE,CAmBpF;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAGzF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,WAAW,EACjB,YAAY,EAAE,MAAM,GAClB,MAAM,CAMR;AAED,iFAAiF;AACjF,wBAAgB,wBAAwB,IAAI,IAAI,CAG/C"}

package/dist/pptx/render/text-outline-dash.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Dashed text outline (`a:rPr > a:ln > a:prstDash`) as CSS.
+ *
+ * `-webkit-text-stroke` can only paint a solid stroke, so a dashed outline
+ * (COM-verified: `audit-text` slide 13's "DASH OUTLINE" run, which PowerPoint
+ * draws as broken black dashes around a yellow fill) used to render solid.
+ * The stroke is instead made transparent and a repeating diagonal stripe of
+ * the outline colour is painted underneath it, clipped to the glyphs with
+ * `background-clip: text`. Only the stroke band shows the stripes (the fill
+ * is painted over the rest via `-webkit-text-fill-color`), so the outline
+ * reads as a run of dashes whose lengths follow the preset's ECMA-376 dash
+ * pattern in multiples of the line width. The stripes run diagonally, so
+ * horizontal and vertical strokes both break up, which is the closest a
+ * box-level paint can get to dashes that follow each glyph contour.
+ *
+ * Pure and framework-agnostic: returns a neutral CSS record, merged by
+ * `text-run-style.ts` for every binding.
+ *
+ * @module text-outline-dash
+ */
+import type { TextStyle } from 'ooxml-core/pptx';
+/** The CSS a dashed text outline merges onto its run. */
+export interface TextOutlineDashCss {
+    WebkitTextStroke: string;
+    WebkitTextFillColor: string;
+    background: string;
+    backgroundClip: string;
+    WebkitBackgroundClip: string;
+}
+/**
+ * Resolve a run's dashed outline to CSS, or `undefined` when the run has no
+ * outline, a solid/unknown dash, or already owns the `background` for a
+ * gradient, pattern or picture text fill (or a highlight) that the stripes
+ * would clobber; such runs keep the plain solid stroke.
+ *
+ * @param s         The run style.
+ * @param fillColor The colour the run's glyphs are filled with.
+ */
+export declare function resolveTextOutlineDashCss(s: Pick<TextStyle, 'textOutlineWidth' | 'textOutlineColor' | 'textOutlineDash' | 'textFillGradient' | 'textFillPattern' | 'textFillBlipUrl' | 'highlightColor' | 'textFillNone'>, fillColor: string | undefined): TextOutlineDashCss | undefined;
+//# sourceMappingURL=text-outline-dash.d.ts.map

package/dist/pptx/render/text-outline-dash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-outline-dash.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-outline-dash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAkBjD,yDAAyD;AACzD,MAAM,WAAW,kBAAkB;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;CAC7B;AAmBD;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACxC,CAAC,EAAE,IAAI,CACN,SAAS,EACP,kBAAkB,GAClB,kBAAkB,GAClB,iBAAiB,GACjB,kBAAkB,GAClB,iBAAiB,GACjB,iBAAiB,GACjB,gBAAgB,GAChB,cAAc,CAChB,EACD,SAAS,EAAE,MAAM,GAAG,SAAS,GAC3B,kBAAkB,GAAG,SAAS,CAiBhC"}

package/dist/pptx/render/text-overflow-lines.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `a:bodyPr/@vertOverflow="clip"`: PowerPoint clips an overflowing text body
+ * to the last WHOLE line that fits, never half a line (COM-verified,
+ * audit-text slide 2: four lines of the three 18pt paragraphs show, the
+ * fifth is gone entirely). A plain `overflow: hidden` on the body cut the
+ * fifth line through the middle of its glyphs in every binding. The same
+ * holds for `ellipsis`, whose `-webkit-line-clamp` only truncates the
+ * paragraph it lands in: the next paragraph's first line still peeked in.
+ *
+ * CSS cannot clip at a line boundary it does not know, so this estimates the
+ * line count from the body's content box and resolved line height (the same
+ * estimate `resolveVertOverflowEllipsisStyle` uses for its clamp) and clips
+ * the rest with `clip-path`. Only top-anchored bodies are handled: a
+ * centred or bottom-anchored overflowing body spills both ways and its line
+ * grid does not start at the content box edge.
+ *
+ * @module text-overflow-lines
+ */
+import type { TextStyle } from 'ooxml-core/pptx';
+/** The clip CSS for {@link resolveVertOverflowClipLines}. */
+export interface TextOverflowLineClip {
+    clipPath: string;
+}
+/**
+ * @param textStyle       The element's resolved text style.
+ * @param contentHeightPx The content-box height (element height minus insets).
+ * @param paddingBottomPx The body's own bottom inset.
+ * @param lineHeightPx    The resolved single-line height.
+ * @returns The clip, or `undefined` when the body does not clip, is not
+ *          top-anchored, or the inputs are unusable.
+ */
+export declare function resolveVertOverflowClipLines(textStyle: Pick<TextStyle, 'vertOverflow' | 'vAlign'> | undefined, contentHeightPx: number, paddingBottomPx: number, lineHeightPx: number): TextOverflowLineClip | undefined;
+//# sourceMappingURL=text-overflow-lines.d.ts.map

package/dist/pptx/render/text-overflow-lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-overflow-lines.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-overflow-lines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,6DAA6D;AAC7D,MAAM,WAAW,oBAAoB;IACpC,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC3C,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,cAAc,GAAG,QAAQ,CAAC,GAAG,SAAS,EACjE,eAAe,EAAE,MAAM,EACvB,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,MAAM,GAClB,oBAAoB,GAAG,SAAS,CAiBlC"}

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

@@ -0,0 +1,70 @@
+/**
+ * Per-paragraph BiDi direction + text-alignment resolution, shared by every
+ * binding's paragraph renderer.
+ *
+ * Pure, framework-agnostic. `resolveParagraphRtl` / `resolveParagraphAlign`
+ * walk a paragraph's segment entries to find the first explicit
+ * direction/alignment, falling back to the element-level default.
+ * `resolveCssTextAlign` maps an OOXML alignment + RTL flag to a neutral CSS
+ * `text-align` keyword (each binding casts it into its own style type).
+ */
+import type { TextStyle } from 'ooxml-core/pptx';
+/** Minimal paragraph-entry shape the resolvers read (`segment.style`). */
+export interface ParagraphStyleEntry {
+    segment: {
+        style?: Pick<TextStyle, 'rtl' | 'align'>;
+        /**
+         * The paragraph's OWN `a:pPr` (attached to the paragraph's first
+         * segment only, see `PptxHandlerRuntimeShapeParagraphContentParsing`).
+         * `rtl` in particular is a paragraph-level attribute (`a:pPr/@rtl`)
+         * with no per-run carrier: `segment.style.rtl` is only ever set from a
+         * RUN-level `<a:rtl>` override, so a plain `a:pPr@rtl` (the common
+         * case) is invisible unless this field is also consulted.
+         */
+        paragraphProperties?: Pick<TextStyle, 'rtl' | 'align'>;
+    };
+}
+/** CSS `text-align` keyword values produced by {@link resolveCssTextAlign}. */
+export type CssTextAlign = 'left' | 'right' | 'center' | 'justify' | 'start' | 'end';
+/**
+ * Resolve per-paragraph RTL direction from segment styles.
+ *
+ * Returns `true` for RTL, `false` for explicit LTR, or `undefined` when no
+ * segment carries an explicit direction (inherits the element-level default).
+ */
+export declare function resolveParagraphRtl(paraSegments: ReadonlyArray<ParagraphStyleEntry>, elementRtl: boolean | undefined): boolean | undefined;
+/**
+ * Resolve per-paragraph explicit text alignment from segment styles.
+ *
+ * Returns the OOXML alignment value if any segment carries an explicit `align`
+ * property, or `undefined` when none does.
+ */
+export declare function resolveParagraphAlign(paraSegments: ReadonlyArray<ParagraphStyleEntry>, elementAlign: TextStyle['align'] | undefined): TextStyle['align'] | undefined;
+/**
+ * Map an OOXML alignment + RTL direction to a CSS `text-align` value.
+ *
+ * When no explicit alignment is set and the paragraph is RTL, returns
+ * `"right"`. The special OOXML values `justLow` / `dist` / `thaiDist` all map
+ * to CSS `"justify"`. Returns `undefined` for an unset alignment in LTR (the
+ * caller leaves `text-align` to inherit the default).
+ */
+export declare function resolveCssTextAlign(align: TextStyle['align'] | undefined, isRtl: boolean): CssTextAlign | undefined;
+/**
+ * Resolve `text-align-last` for `algn="dist"` (ECMA-376 `ST_TextAlignType`
+ * "distributed"), the one alignment whose OWN last line - and a single-line
+ * paragraph, which IS its own last line - stretches to fill the full width.
+ *
+ * `algn="just"` / `"justLow"` deliberately do NOT stretch their last line
+ * (matching plain CSS `text-align: justify`'s default, which never justifies
+ * a block's last line): COM-verified against `audit-text/pp/s9.png` (`gen.py`
+ * slide 9), where the `just` and `justLow` boxes both leave their final
+ * wrapped line left-aligned while the `dist` box visibly spaces out its
+ * final line's words, and the single-line "Dist one line" / "均等割り付け"
+ * boxes are also stretched edge to edge.
+ *
+ * Only `"dist"` gets this: `"thaiDist"` is Thai's character-distribution
+ * variant of `just` (still leaves the last line alone) and is deliberately
+ * excluded.
+ */
+export declare function resolveTextAlignLast(align: TextStyle['align'] | undefined): 'justify' | undefined;
+//# sourceMappingURL=text-paragraph-style.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-paragraph-style.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-paragraph-style.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,0EAA0E;AAC1E,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE;QACR,KAAK,CAAC,EAAE,IAAI,CAAC,SAAS,EAAE,KAAK,GAAG,OAAO,CAAC,CAAC;QACzC;;;;;;;WAOG;QACH,mBAAmB,CAAC,EAAE,IAAI,CAAC,SAAS,EAAE,KAAK,GAAG,OAAO,CAAC,CAAC;KACvD,CAAC;CACF;AAED,+EAA+E;AAC/E,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,KAAK,CAAC;AAErF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAClC,YAAY,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAChD,UAAU,EAAE,OAAO,GAAG,SAAS,GAC7B,OAAO,GAAG,SAAS,CAqBrB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACpC,YAAY,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAChD,YAAY,EAAE,SAAS,CAAC,OAAO,CAAC,GAAG,SAAS,GAC1C,SAAS,CAAC,OAAO,CAAC,GAAG,SAAS,CAQhC;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,GAAG,SAAS,EACrC,KAAK,EAAE,OAAO,GACZ,YAAY,GAAG,SAAS,CAS1B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAEjG"}

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

@@ -0,0 +1,53 @@
+/**
+ * Build a slide element's rich text into rendered paragraphs of styled runs,
+ * enriched with bullet markers + hanging-indent layout (framework-agnostic).
+ *
+ * THE paragraph builder: all five bindings call this and render the descriptor
+ * it returns. It groups `textSegments` into paragraphs, resolves each
+ * paragraph's bullet glyph / auto-number / font / colour, its marginLeft and
+ * text-indent, its spacing, alignment and line-break rules, and drops the
+ * core-inserted bullet-marker segment from the runs (the marker is rendered
+ * separately so it can pick up bullet font/size/colour). Each binding maps the
+ * returned plain-object styles onto its own style binding.
+ *
+ * It used to be described here as "mirrors React's `renderTextSegments`", which
+ * was the problem rather than the design: React kept a private copy that had
+ * drifted (it split paragraphs on a soft `a:br`, and never indented an
+ * outline-level paragraph that authored no explicit `marL`). That copy is gone;
+ * React's `text-paragraph-render` is now a view layer over this descriptor.
+ */
+import type { PptxElement, TextSegment } from 'ooxml-core/pptx';
+import type { RenderParagraph } from './paragraph-types.js';
+import type { FieldSubstitutionContext } from './text-field-substitution.js';
+/**
+ * Group `element`'s text segments into rendered paragraphs. Paragraph
+ * separators are `isParagraphBreak` segments (post-edit remap) or bare `"\n"`
+ * text segments (the slide-load path); soft line breaks insert a newline within
+ * a paragraph. Bullets are suppressed for paragraphs with no visible text.
+ *
+ * When a `fieldContext` is supplied, any segment carrying a `fieldType`
+ * (slide number, date/time, header/footer, slide title, docproperty) has its
+ * run text replaced via {@link substituteFieldText}, matching React's
+ * per-run substitution in `text-segment-render`. When omitted, the output is
+ * byte-identical to the no-context path (substitution is a strict no-op).
+ *
+ * `segmentOverrides` replaces the element's own `textSegments` for this render
+ * only. It exists for `a:linkedTxbx` chains, where the segments a box paints are
+ * not its authored segments but the slice the chain's overflow distribution gave
+ * it (see `getOverflowSegments`). It mirrors React's `renderTextSegments`
+ * `segmentOverrides` argument, so all five bindings resolve a chain identically.
+ * Everything downstream (autofit scale, paragraph indents, bullets) still comes
+ * from the element, exactly as React does. Inline editors opt into preserving
+ * trailing empty paragraphs because these are editable caret destinations;
+ * static rendering keeps its established trailing-separator trimming policy.
+ */
+export declare function buildParagraphs(element: PptxElement, fieldContext?: FieldSubstitutionContext, segmentOverrides?: readonly TextSegment[], options?: {
+    preserveTrailingEmpty?: boolean;
+    /**
+     * `false` leaves the `text-east-asian-breaks` pieces out of the runs, for
+     * a caller that rebuilds them itself from `RenderParagraph.eastAsianBreaks`
+     * (React, which re-joins each segment's pieces into one span).
+     */
+    eastAsianRunPieces?: boolean;
+}): RenderParagraph[];
+//# sourceMappingURL=text-paragraphs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-paragraphs.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-paragraphs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAWhE,OAAO,KAAK,EAAgB,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEvE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAiB1E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAC9B,OAAO,EAAE,WAAW,EACpB,YAAY,CAAC,EAAE,wBAAwB,EACvC,gBAAgB,CAAC,EAAE,SAAS,WAAW,EAAE,EACzC,OAAO,CAAC,EAAE;IACT,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC7B,GACC,eAAe,EAAE,CA4MnB"}

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

@@ -0,0 +1,39 @@
+/**
+ * The decoration extras a run's own CSS does not cover on its own: what a
+ * NESTED span inside it must repeat, and the underline-style / double-strike
+ * variant CSS layered on top of the boolean `text-decoration`.
+ *
+ * Split out of `text-run-style` to keep that module focused and small.
+ */
+import type { TextSegment } from 'ooxml-core/pptx';
+import type { RunStyle } from './text-run-style.js';
+/**
+ * The decoration properties a NESTED span inside a run has to repeat.
+ *
+ * `text-decoration-line` and its colour / style / thickness companions do not
+ * inherit: an ancestor's underline is *drawn through* its inline descendants,
+ * but each descendant still computes `none` of its own. Four bindings never
+ * notice, because shared's per-word split (`splitStyledRun`) clones the whole
+ * run style onto every piece, so the element that directly parents the text
+ * carries the underline. React renders one span per run and nests its per-word
+ * metric pieces and per-script font spans INSIDE it, so the text's own parent
+ * declared no decoration and a hyperlink (underlined by PowerPoint's default,
+ * see {@link segmentStyleToCss} in `text-run-style.ts`) reported
+ * `text-decoration-line: none` where the other four reported `underline`.
+ *
+ * @returns The decoration subset to merge onto a nested span, or `undefined`
+ *          when the run carries no decoration and the span needs nothing.
+ */
+export declare function nestedTextDecorationStyle(style: RunStyle): RunStyle | undefined;
+/**
+ * Layer the underline-style / double-strike *variant* decoration CSS
+ * (`text-decoration-style` / `-thickness` / `text-underline-offset`) onto a run
+ * style. Kept separate from `segmentStyleToCss` (in `text-run-style.ts`) so
+ * that helper's contract (boolean `textDecoration` only) stays stable for its
+ * other consumers; this is applied additively by `buildParagraphs` when
+ * building each run, mirroring React's segment renderer
+ * (`text-segment-render.tsx`), which applies `resolveUnderlineDecorationStyle`
+ * over the boolean underline.
+ */
+export declare function applyUnderlineVariant(style: RunStyle, seg: TextSegment): void;
+//# sourceMappingURL=text-run-decoration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-run-decoration.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-run-decoration.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAe/E;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,WAAW,GAAG,IAAI,CAoC7E"}

package/dist/pptx/render/text-run-effects.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Per-run text-effect style composer, shared by every binding's text renderer.
+ *
+ * Pure, framework-agnostic. Mirrors React's per-run effect composition in
+ * `packages/react/src/viewer/utils/text-segment-render.tsx`: it folds the
+ * gradient/pattern fill record, the merged `text-shadow` (outer + preset), an
+ * `inset box-shadow` (inner shadow), the merged `filter` chain (glow + blur +
+ * soft-edge + HSL), and the alpha `opacity` into ONE neutral CSS record
+ * (`Record<string, string | number>`). Each binding casts the record into its
+ * own style type at the call site.
+ *
+ * Reflection (`a:reflection`) is NOT part of this record: unlike the other
+ * effects, it cannot be expressed as CSS properties on the run's own span (a
+ * mirrored copy needs its own DOM node), so it renders as a separate
+ * mirrored-sibling wrapper - see `./reflection`'s `getTextReflectionWrapperStyle`,
+ * called by `paragraph-run-build.ts` and carried on `BuiltRun.reflection`, the
+ * same shape a shape/picture's reflection takes (`ComputedEffectStyle.reflection`).
+ *
+ * Returns an EMPTY record (`{}`) for a plain run that carries none of these
+ * effects, so wiring it into an existing run-style builder is a strict no-op
+ * for ordinary text.
+ *
+ * The block/body-level 3D scene wrapper (`buildTextBody3DSceneStyle`) stays in
+ * {@link ./text-effects-3d}; it is applied to the text body container, not the
+ * individual run.
+ */
+import type { TextStyle } from 'ooxml-core/pptx';
+import type { TextCssProperties } from './text-fill.js';
+/**
+ * Combine all text-run CSS `filter` effects into a single space-joined chain:
+ * glow, blur, soft edge, then HSL (in that order). Returns `undefined` when
+ * no filter effect applies.
+ *
+ * Inner shadow (`a:innerShdw`) is NOT part of this chain: `filter:
+ * drop-shadow(...)` can only ever paint OUTSIDE an element's silhouette, so
+ * it is composed as a `box-shadow: inset` in {@link buildRunEffectStyle}
+ * instead - see {@link buildTextInnerShadowCss}'s doc comment.
+ */
+export declare function buildTextRunFilterChain(style: TextStyle): string | undefined;
+/**
+ * Compose the per-run text-effect CSS for a run's `TextStyle` into a single
+ * neutral CSS record.
+ *
+ * Composition (matching React's `renderSingleSegment` span style):
+ *  - gradient / pattern fill via the `background-clip: text` technique
+ *    (spreads the fill record's `background` / `backgroundClip` /
+ *    `WebkitBackgroundClip` / `WebkitTextFillColor` keys);
+ *  - `textShadow` from {@link buildTextShadowCss} (outer + preset);
+ *  - `boxShadow` from {@link buildTextInnerShadowCss} (`inset`, so it renders
+ *    inside the run's own line-fragment box rather than around the outside);
+ *  - `filter` from {@link buildTextRunFilterChain} (glow + blur + soft-edge +
+ *    HSL);
+ *  - `opacity` from {@link getTextAlphaOpacity} (alpha modulation).
+ *
+ * Reflection is deliberately absent: see the module doc.
+ *
+ * Only keys for the effects that are actually present are set, so the result is
+ * `{}` for a plain run.
+ */
+export declare function buildRunEffectStyle(style: TextStyle): TextCssProperties;
+//# sourceMappingURL=text-run-effects.d.ts.map

package/dist/pptx/render/text-run-effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-run-effects.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-run-effects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAYjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAmB5E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS,GAAG,iBAAiB,CA6BvE"}

package/dist/pptx/render/text-run-gradient-span.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Stitch a gradient/pattern text fill (`background-clip: text`, see
+ * `text-fill.ts`) into ONE continuous fill across every consecutive run that
+ * shares the identical gradient/pattern, instead of each run repainting the
+ * same 0%-100% fill inside its own (narrower) box.
+ *
+ * `splitStyledRun` (`text-run-spacing.ts`) already keeps a single gradient RUN
+ * from being fragmented into per-word pieces, which fixes the fill restarting
+ * INSIDE one run. It cannot fix two authored SIBLING runs that both carry the
+ * identical gradient (`p(r('GRADIENT ', grad) + r('SPANS RUNS', grad))`,
+ * verified against PowerPoint through COM: it paints "GRADIENT SPANS RUNS" as
+ * one uninterrupted fill, not two): each run is still its own inline box, and
+ * `background-clip: text` still scopes to that box alone. Sizing the
+ * `background` to the group's total measured width and offsetting each run's
+ * `background-position` by its own position within that width paints the
+ * identical CSS gradient/pattern image once, sliced across the group.
+ */
+import type { RunStyle } from './text-run-style.js';
+/** The minimal shape this needs from a rendered run (structurally a `BuiltRun`). */
+export interface GradientSpanRun {
+    text: string;
+    style: RunStyle;
+}
+/**
+ * Mutate `runs` in place: every maximal group of consecutive entries whose
+ * `style.background` is the SAME gradient/pattern text-fill string gets a
+ * `backgroundSize` equal to the group's total measured width and a
+ * `backgroundPosition` offset by its own cumulative position in the group.
+ *
+ * A group of one (a plain run, or an isolated gradient run with plain
+ * neighbours) is left untouched - the default `background-size`/
+ * `background-position` already paint exactly that run's own box, which is
+ * the correct, unchanged behaviour.
+ *
+ * Measuring returns `0` outside a DOM (no `document`), in which case the
+ * group is left as authored rather than dividing by a zero total.
+ */
+export declare function stitchContinuousGradientFill(runs: readonly GradientSpanRun[]): void;
+//# sourceMappingURL=text-run-gradient-span.d.ts.map

package/dist/pptx/render/text-run-gradient-span.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-run-gradient-span.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-run-gradient-span.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAsCjD,oFAAoF;AACpF,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,QAAQ,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,SAAS,eAAe,EAAE,GAAG,IAAI,CA4BnF"}

package/dist/pptx/render/text-run-hollow.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Hollow / outline-only text (`a:rPr > a:noFill`) fill decision.
+ *
+ * Split out of `text-run-style` to keep that module focused and small: this
+ * piece has no dependency on `RunStyle` or any other run-style plumbing, so it
+ * stands on its own rather than adding to the per-run CSS builder's size.
+ */
+/** The run properties {@link hollowTextFillStyle} decides from. */
+export interface HollowTextFillInput {
+    /** `a:rPr > a:noFill`: the glyph interior is not painted. */
+    textFillNone?: boolean;
+    /** `a:rPr > a:ln/@w` in px, if the run carries an outline. */
+    textOutlineWidth?: number;
+    /** The outline's own colour, if it declared one. */
+    textOutlineColor?: string;
+}
+/** What the run is ALREADY painting, before the hollow decision is applied. */
+export interface HollowTextPaintedStyle {
+    /** The colour the cascade resolved for this run. */
+    color?: string;
+    /** The `-webkit-text-stroke` already emitted, if any. */
+    textStroke?: string;
+}
+/** The CSS a hollow run needs, to be merged over its existing run style. */
+export interface HollowTextFillStyle {
+    color: string;
+    WebkitTextFillColor: string;
+    /** Re-pinned outline; present only when the stroke was `currentColor`. */
+    WebkitTextStroke?: string;
+}
+/**
+ * Hollow / outline-only text (`a:rPr > a:noFill`): the glyph INTERIOR is not
+ * painted, which is what makes standard WordArt outline text readable - the
+ * `a:ln` stroke draws the letterform and the fill is left empty.
+ *
+ * A hollow run always still carries a `color`, because the parsed run style
+ * merges the resolved theme / placeholder / master cascade underneath the run's
+ * own properties, and that inherited colour fills the slot `a:noFill`
+ * deliberately left empty. So this must be applied OVER the run's resolved
+ * colour, never instead of resolving one.
+ *
+ * `-webkit-text-fill-color` is the property that actually does this and every
+ * current engine ships it (Chromium, WebKit and Gecko, prefix included).
+ * `color: transparent` is the fallback for anything that does not: it loses
+ * `currentColor` for the stroke, so it is only the second choice, but
+ * transparent-and-outlined beats solid-and-wrong.
+ *
+ * A decision function rather than a mutation, because the bindings do not all
+ * build their run style the same way: four of them go through
+ * {@link segmentStyleToCss} (in `text-run-style.ts`), while React's
+ * `text-segment-render` assembles its own `React.CSSProperties` (per-word
+ * metric tracking, script-font spans). Both merge the SAME object, which is
+ * what stops the fifth binding drifting - React had no hollow-text branch at
+ * all and painted the inherited colour.
+ *
+ * @param s       - The run's `a:noFill` / outline properties.
+ * @param painted - What the caller has already put on the run.
+ * @returns The CSS to merge, or `undefined` when the run is not hollow.
+ */
+export declare function hollowTextFillStyle(s: HollowTextFillInput, painted?: HollowTextPaintedStyle): HollowTextFillStyle | undefined;
+//# sourceMappingURL=text-run-hollow.d.ts.map

package/dist/pptx/render/text-run-hollow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-run-hollow.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-run-hollow.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,mEAAmE;AACnE,MAAM,WAAW,mBAAmB;IACnC,6DAA6D;IAC7D,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,8DAA8D;IAC9D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,oDAAoD;IACpD,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,+EAA+E;AAC/E,MAAM,WAAW,sBAAsB;IACtC,oDAAoD;IACpD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,4EAA4E;AAC5E,MAAM,WAAW,mBAAmB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,mBAAmB,CAClC,CAAC,EAAE,mBAAmB,EACtB,OAAO,GAAE,sBAA2B,GAClC,mBAAmB,GAAG,SAAS,CAejC"}