ooxml-ui 0.30.0 → 0.31.0

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

@@ -0,0 +1,92 @@
+/**
+ * Per-run facts a rendered paragraph carries besides its text and CSS: the
+ * run's HYPERLINK and its inline EQUATION (framework-agnostic).
+ *
+ * Both are authored on the run (`a:r > a:rPr > a:hlinkClick` /
+ * `a:hlinkMouseOver`, and an `m:oMath` sibling that core stamps onto its own
+ * segment), and both need a different ELEMENT around the run - an `<a>` and a
+ * MathML host - rather than a different style, which is why they are modelled
+ * separately from {@link RunStyle} instead of being folded into it.
+ *
+ * Before this existed, `buildParagraphs` returned `{ text, style }` only, so a
+ * hyperlinked run rendered as plain text in Vue, Svelte and Vanilla (the link
+ * was silently dropped) and Angular compensated with a text-prefix walk that
+ * re-attached the metadata to shared's runs by matching their characters. This
+ * module is that walk's replacement: resolve once, in the builder, for all five.
+ */
+import type { TextSegment, TextStyle } from 'ooxml-core/pptx';
+/** A run's resolved hyperlink target. */
+export interface RunHyperlink {
+    /**
+     * The URL to hand a click handler. For an internal `ppaction://hlinksldjump`
+     * the resolved slide index is appended as a `slideIndex` query parameter, so
+     * the target survives a callback whose only argument is the URL (see
+     * `parsePpactionUrl`, which reads it back off).
+     */
+    url: string;
+    /**
+     * A safe, renderable `href` for a plain `<a>`, or `undefined` when the target
+     * is an internal `ppaction://` action or fails the URL safety check. A
+     * binding with no click handler renders the run as text in that case, which
+     * is what every binding did for every link before this field existed.
+     */
+    href?: string;
+    /** `a:hlinkClick/@tooltip`, for the anchor's `title`. */
+    tooltip?: string;
+    /**
+     * `<a target>` for a real (non-`ppaction://`) hyperlink, from
+     * `a:hlinkClick/@tgtFrame` when authored, else `_blank` (every binding's
+     * pre-existing hardcoded default). Only meaningful alongside {@link href}.
+     */
+    target?: string;
+    /** `<a rel>` paired with {@link target} (see `resolveHyperlinkTargetAttrs`). */
+    rel?: string;
+    /** Resolved target slide for an internal slide jump. */
+    targetSlideIndex?: number;
+    /**
+     * True when the target came from `a:hlinkMouseOver` rather than
+     * `a:hlinkClick`: PowerPoint follows it on hover, not on click, so a binding
+     * that renders a plain anchor should not make it look clickable.
+     */
+    onHover?: boolean;
+}
+/** An inline equation run (`m:oMath`), rendered as MathML rather than text. */
+export interface RunEquation {
+    /** The raw OMML node, for `convertOmmlToMathMl`. */
+    xml: Record<string, unknown>;
+    /** Display number for a numbered equation, without its parentheses. */
+    number?: string;
+}
+/**
+ * Resolve a run style's hyperlink into a renderable descriptor, or `undefined`
+ * when the run carries none.
+ *
+ * `a:hlinkClick` wins over `a:hlinkMouseOver` when a run authors both, matching
+ * PowerPoint: the click target is the one a reader reaches deliberately.
+ */
+export declare function resolveRunHyperlink(style: TextStyle | undefined): RunHyperlink | undefined;
+/**
+ * The sanitised MathML markup for an inline equation run, or `''` when the OMML
+ * converts to nothing (a binding then renders its own "unsupported" chip).
+ *
+ * Here rather than in each binding because the pair (convert, then sanitise) is
+ * a security-relevant order: the markup is injected as HTML, so skipping the
+ * sanitiser is an injection, and four bindings were each spelling the pair out
+ * by hand at their own call site.
+ */
+export declare function runEquationMathMl(equation: RunEquation): string;
+/** Resolve a segment's inline equation, or `undefined` when it carries none. */
+export declare function resolveRunEquation(seg: TextSegment): RunEquation | undefined;
+/**
+ * Whether a text body is nothing BUT equations: at least one `m:oMath` segment
+ * and no visible prose around it.
+ *
+ * Vue, Svelte and Vanilla hand an equation-bearing element wholesale to their
+ * standalone equation renderer, which lays the maths out centred in the box.
+ * That is right for an inserted equation shape and wrong for a sentence with a
+ * formula in the middle of it, which it reduced to the formula alone. This is
+ * the test that keeps the wholesale path for the first case and lets the second
+ * render through `buildParagraphs`, where the equation is now a run in place.
+ */
+export declare function isEquationOnlyText(segments: readonly TextSegment[] | undefined): boolean;
+//# sourceMappingURL=text-run-meta.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-run-meta.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-run-meta.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAQ9D,yCAAyC;AACzC,MAAM,WAAW,YAAY;IAC5B;;;;;OAKG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,+EAA+E;AAC/E,MAAM,WAAW,WAAW;IAC3B,oDAAoD;IACpD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7B,uEAAuE;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CA+B1F;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,CAG/D;AAED,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAS5E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,SAAS,GAAG,OAAO,CAoBxF"}

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

@@ -0,0 +1,38 @@
+/**
+ * `text-run-ruby`: the phonetic guide (`a:ruby`, furigana / pinyin) as a
+ * framework-neutral run field.
+ *
+ * Core has always parsed a ruby run in full (`rubyText`, `rubyAlignment`,
+ * `rubyFontSize`, `rubyStyle`) and has always saved it back, but the annotation
+ * was RENDERED in React alone: `buildParagraphs` never read `seg.rubyText`, so
+ * the guide simply vanished in Vue, Angular, Svelte and Vanilla (the base text
+ * still painted, which is why nothing looked broken).
+ *
+ * This module resolves the annotation into a `{ text, style }` descriptor that
+ * rides the run, so each binding renders the same `<ruby>` / `<rt>` markup from
+ * the same decision.
+ *
+ * @module render/text-run-ruby
+ */
+import type { TextSegment } from 'ooxml-core/pptx';
+import type { RunFontSpec } from './text-metric-tracking.js';
+import type { RunStyle } from './text-run-style.js';
+/** A run's phonetic guide, ready to render as `<rt>` above the base text. */
+export interface RunRuby {
+    /** The annotation itself (`a:ruby/a:rt`), e.g. the furigana reading. */
+    text: string;
+    /** Inline style for the `<rt>` element (size, family, alignment, colour). */
+    style: RunStyle;
+}
+/**
+ * Resolve a segment's phonetic guide, or `undefined` when it carries none.
+ *
+ * @param segment    The authored segment (already field-substituted upstream).
+ * @param baseFontSizePx The rendered size of the base text, in px.
+ * @param blockFont  What a run inheriting no font of its own takes from the body.
+ * @param baseColor  The base run's resolved colour, used when the annotation
+ *                   declares none.
+ * @returns The annotation and its `<rt>` style, or `undefined`.
+ */
+export declare function resolveRunRuby(segment: TextSegment, baseFontSizePx: number, blockFont: RunFontSpec, baseColor?: string): RunRuby | undefined;
+//# sourceMappingURL=text-run-ruby.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-run-ruby.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-run-ruby.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAKnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,6EAA6E;AAC7E,MAAM,WAAW,OAAO;IACvB,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,KAAK,EAAE,QAAQ,CAAC;CAChB;AA4BD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC7B,OAAO,EAAE,WAAW,EACpB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,WAAW,EACtB,SAAS,CAAC,EAAE,MAAM,GAChB,OAAO,GAAG,SAAS,CAmBrB"}

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

@@ -0,0 +1,61 @@
+/**
+ * Per-run letter-spacing helpers: the authored `a:rPr/@spc` character spacing,
+ * combining it with a measured metric-tracking correction, and splitting one
+ * styled run into the per-word / per-gap pieces a line needs to wrap the way
+ * PowerPoint wrapped it (and, separately, the way `a:rPr/@u="words"` needs it
+ * underlined).
+ *
+ * Split out of `text-run-style` to keep that module focused and small.
+ */
+import type { TextSegment } from 'ooxml-core/pptx';
+import type { RunFontSpec } from './text-metric-tracking.js';
+import type { RunStyle } from './text-run-style.js';
+/**
+ * The authored `a:rPr/@spc` character spacing in CSS px (hundredths of a point).
+ * The measured PowerPoint metric compensation layers on top of this, so callers
+ * that re-derive a per-piece `letter-spacing` need the authored part on its own.
+ */
+export declare function authoredLetterSpacingPx(style: TextSegment['style']): number;
+/** `letter-spacing` for a run piece: authored spacing plus its own tracking. */
+export declare function pieceLetterSpacing(authoredPx: number, tracking: number): string | undefined;
+/**
+ * Remove the underline decoration (and the style/thickness/offset/colour CSS
+ * that only describes an underline's own appearance) from a piece's style,
+ * while preserving any OTHER decoration line it carries (`line-through`).
+ *
+ * D2-G3: `a:rPr/@u="words"` underlines only the non-whitespace characters of
+ * a run, leaving inter-word spaces unmarked - distinct from `sng`'s continuous
+ * line. Used on the whitespace pieces {@link splitStyledRun} produces for such
+ * a run; a word piece keeps its style untouched.
+ */
+export declare function stripUnderlineDecoration(style: RunStyle): RunStyle;
+/**
+ * Split one styled run into the per-word / per-gap runs that make a LINE
+ * measure what PowerPoint measured (see `splitRunForMetrics`), further split
+ * at word/whitespace boundaries when the run is `a:rPr/@u="words"` so the
+ * whitespace pieces render undecorated (D2-G3).
+ *
+ * Every binding that renders one span per run gets exact wrapping by emitting
+ * these instead of the single run, so this is the one place the "which pieces,
+ * what spacing" decision lives: shared's `buildParagraphs` covers Vue, Svelte
+ * and Vanilla, Angular's own paragraph builder calls it directly, and React
+ * splits inside its span.
+ *
+ * Returns a single entry (the run unchanged) when there is nothing to split,
+ * which is the common case for short labels and one-word runs.
+ *
+ * @param underlineWords Whether the run's underline is `a:rPr/@u="words"`
+ *   (checked by the caller against the segment's `underline`/`underlineStyle`).
+ *   The metric-tracking boundary (whitespace vs. non-whitespace) already
+ *   coincides with the underline-word boundary whenever a real measurer is
+ *   available, but a piece can still straddle both when it is not (no
+ *   `document`/canvas, e.g. a non-browser render), so this re-splits each
+ *   metric piece with the independent, measurement-free
+ *   {@link splitWordsForUnderline} rather than assuming the metric split
+ *   already gives word/gap granularity.
+ */
+export declare function splitStyledRun(text: string, style: RunStyle, font: RunFontSpec, authoredPx: number, underlineWords?: boolean): Array<{
+    text: string;
+    style: RunStyle;
+}>;
+//# sourceMappingURL=text-run-spacing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-run-spacing.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-run-spacing.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAKjD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,MAAM,CAG3E;AAED,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG3F;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAkBlE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAC7B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,MAAM,EAClB,cAAc,UAAQ,GACpB,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAA;CAAE,CAAC,CAgD1C"}

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

@@ -0,0 +1,73 @@
+/**
+ * Per-run inline-style builder for rendered text runs (framework-agnostic).
+ *
+ * Maps a `TextSegment`'s `TextStyle` onto a neutral CSS record that every
+ * binding applies to its own run span. React included: its `text-segment-render`
+ * now starts from this record and re-resolves only the handful of properties it
+ * derives more precisely (colour/size/family fallbacks, PANOSE substitution,
+ * the `@baseline` percentage, the `@kern` threshold, per-run BiDi), each of
+ * which is documented there as a gap in this module rather than a preference.
+ * Split out of `text-paragraphs` to keep each module focused and small; this
+ * module itself later split its letter-spacing/split helpers into
+ * `text-run-spacing.ts`, its hollow-text fill decision into
+ * `text-run-hollow.ts`, and its nested-decoration / underline-variant helpers
+ * into `text-run-decoration.ts`, for the same reason.
+ */
+import type { TextSegment } from 'ooxml-core/pptx';
+import type { RunFontSpec } from './text-metric-tracking.js';
+/** A plain CSS style map (keys are CSS properties; binding-agnostic). */
+export type RunStyle = Record<string, string | number>;
+/** Super/subscript glyphs render at ~65% of the run font size (matches React). */
+export declare const BASELINE_FONT_SCALE = 0.65;
+/**
+ * Resolve `a:rPr/@kern` to a CSS `font-kerning` keyword.
+ *
+ * OOXML `@kern` is a MINIMUM FONT SIZE (hundredths of a point) above which
+ * kerning applies, not an on/off flag: `kern="1200"` means "kern this run
+ * only if it renders at 12pt or larger". `0` disables kerning outright
+ * regardless of size. Reducing it to a boolean (any non-zero value enables
+ * kerning) was shared's own behaviour before this function existed - React's
+ * `text-segment-render.tsx` already read the threshold correctly, so Vue,
+ * Angular, Svelte and Vanilla (which render `run.style` from shared verbatim)
+ * disagreed with React on any run below its authored threshold.
+ *
+ * @param kerning    `a:rPr/@kern`, in hundredths of a point (or `undefined`
+ *                   when the run authors none, which leaves kerning unset).
+ * @param fontSizePx The run's resolved font size in CSS px (already reflects
+ *                   `a:normAutofit/@fontScale` and any super/sub shrink).
+ * @returns `'normal'` / `'none'`, or `undefined` when the run authors no `@kern`.
+ */
+export declare function resolveFontKerning(kerning: number | undefined, fontSizePx: number | undefined): 'normal' | 'none' | undefined;
+/**
+ * Per-run inline style derived from a TextSegment's style.
+ *
+ * `fontScale` is the body's `a:normAutofit/@fontScale` (see
+ * `resolveAutoFitFontScale`). It has to be applied HERE and not only on the
+ * text body, because a run that authors its own `sz` overrides the body's
+ * font-size, so scaling the body alone left every authored run at full size.
+ *
+ * `context` only feeds the metric measurement behind `letter-spacing`; the
+ * emitted style still declares nothing the run did not author. It is optional:
+ * without it the run is measured with its own text and against the default
+ * font, which is what it renders with anyway when it inherits nothing.
+ */
+export interface RunStyleContext {
+    /** What the run actually renders, if not `seg.text` (field substitution). */
+    text?: string;
+    /** What the run inherits from the text body when it declares no font. */
+    blockFont?: RunFontSpec;
+    /** The paragraph says `latinLnBrk="1"` (see the Korean rule below). */
+    latinLineBreak?: boolean;
+}
+export declare function segmentStyleToCss(seg: TextSegment, fontScale?: number, context?: RunStyleContext): RunStyle;
+/**
+ * The font a run will actually paint with: its own declarations where it made
+ * them, the text body's where it did not. Bold and italic are always the run's
+ * own, because {@link segmentStyleToCss} declares both unconditionally.
+ *
+ * Exported so a caller that re-measures pieces of a run (see
+ * `splitRunForMetrics`) resolves the font exactly the way the run style did,
+ * rather than keeping a second copy of the fallback rules.
+ */
+export declare function resolveRunFont(style: RunStyle, s: NonNullable<TextSegment['style']>, blockFont?: RunFontSpec): RunFontSpec;
+//# sourceMappingURL=text-run-style.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-run-style.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-run-style.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAMnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAO1D,yEAAyE;AACzE,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;AAEvD,kFAAkF;AAClF,eAAO,MAAM,mBAAmB,OAAO,CAAC;AAoBxC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CACjC,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,UAAU,EAAE,MAAM,GAAG,SAAS,GAC5B,QAAQ,GAAG,MAAM,GAAG,SAAS,CAS/B;AAmED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,eAAe;IAC/B,6EAA6E;IAC7E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,uEAAuE;IACvE,cAAc,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,wBAAgB,iBAAiB,CAChC,GAAG,EAAE,WAAW,EAChB,SAAS,SAAI,EACb,OAAO,GAAE,eAAoB,GAC3B,QAAQ,CA6GV;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC7B,KAAK,EAAE,QAAQ,EACf,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,EACpC,SAAS,CAAC,EAAE,WAAW,GACrB,WAAW,CAUb"}

package/dist/pptx/render/text-script-fonts.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Per-script (`a:ea` / `a:cs` / `a:sym`) font fallback for one run, as a pure
+ * decision function every binding maps onto its own nested-span markup.
+ *
+ * OOXML authors up to four typefaces per run (`a:latin`, `a:ea`, `a:cs`,
+ * `a:sym`), and PowerPoint paints each Unicode script category in ITS OWN
+ * font, not the run's `a:latin` face. This was React-only
+ * (`renderScriptAwareText` in `text-segment-render.tsx`): the other four
+ * bindings applied only `a:latin` to the whole run, so CJK, Arabic, Hebrew and
+ * Thai text rendered in the wrong typeface (or the browser's serif default)
+ * in Vue, Angular, Svelte and Vanilla.
+ *
+ * `resolveScriptFontSet` resolves the four faces (PANOSE-substituted, with the
+ * run falling back to the text body's own declaration); `splitRunByScriptFont`
+ * segments a run's text by script and returns, per piece, the CSS a binding
+ * spreads onto a nested span. A binding does nothing but map that descriptor:
+ * render `text` plain when a piece carries no `style` override, or a nested
+ * span with `style` when it does.
+ */
+import type { TextStyle } from 'ooxml-core/pptx';
+import type { RunStyle } from './text-run-style.js';
+/** Resolved per-script font faces for one run, already PANOSE-substituted. */
+export interface ScriptFontSet {
+    latin: string;
+    eastAsia: string;
+    complexScript: string;
+    symbol: string;
+}
+/** The `a:ea` / `a:cs` / `a:sym` typeface + PANOSE fields a run or body may carry. */
+export type ScriptFontFields = Pick<TextStyle, 'eastAsiaFont' | 'complexScriptFont' | 'symbolFont' | 'eastAsiaFontPanose' | 'complexScriptFontPanose' | 'symbolFontPanose'>;
+/**
+ * Resolve the four per-script faces for a run.
+ *
+ * Every entry goes through the SAME PANOSE substitution as the run's own
+ * `a:latin`, for two reasons. The obvious one: a bare `a:ea` name emitted on
+ * the inner script span overrides the parent's fallback chain, so a deck
+ * whose east-Asian font is not installed drops to the browser's default -
+ * which for CJK is a serif, where PowerPoint substitutes a sans. The subtle
+ * one: {@link hasDistinctScriptFonts} compares by STRING, so leaving `ea` bare
+ * while `latin` carries a substitution chain made an identical typeface look
+ * distinct and produced a needless nested span in the first place.
+ *
+ * `runFields` is checked first (`a:rPr > a:ea` etc.), then `blockFields` (the
+ * text body's own declaration), matching how a run inherits any property it
+ * does not author itself.
+ *
+ * @param runFields       The run's own per-script fields, if it authored any.
+ * @param blockFields     The text body's per-script fields, as a fallback.
+ * @param baseFontFamily  The run's already-resolved `a:latin` face (post
+ *                        substitution), used both as the `latin` entry and as
+ *                        the fallback for any script the deck names no font for.
+ */
+export declare function resolveScriptFontSet(runFields: ScriptFontFields | undefined, blockFields: ScriptFontFields | undefined, baseFontFamily: string): ScriptFontSet;
+/** One script-tagged piece of a run's text, ready for a binding's nested span. */
+export interface ScriptFontPiece {
+    text: string;
+    /**
+     * CSS for a nested span wrapping `text`, or `undefined` when this piece
+     * needs no span at all (its script's font equals the run's own, so plain
+     * text renders identically). When present it carries the `fontFamily`
+     * override plus the run's own decoration subset, repeated because
+     * `text-decoration-*` does not inherit into a nested span (see
+     * `nestedTextDecorationStyle`).
+     */
+    style?: RunStyle;
+}
+/**
+ * Split a run's text into per-script pieces, or `undefined` when it needs no
+ * split at all (the common case: `fonts` names no script distinctly from
+ * `latin`, so every character already renders in the run's own face).
+ *
+ * @param text             The run's (or one word-piece's) text.
+ * @param fonts            This run's resolved per-script faces.
+ * @param baseFontFamily   The run's own `a:latin` face, to compare against.
+ * @param nestedDecoration This run's decoration subset, repeated onto any
+ *                         piece that needs a span (see {@link ScriptFontPiece.style}).
+ */
+export declare function splitRunByScriptFont(text: string, fonts: ScriptFontSet, baseFontFamily: string, nestedDecoration?: RunStyle): ScriptFontPiece[] | undefined;
+//# sourceMappingURL=text-script-fonts.d.ts.map

package/dist/pptx/render/text-script-fonts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-script-fonts.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-script-fonts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAOjD,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CACf;AAED,sFAAsF;AACtF,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAClC,SAAS,EACP,cAAc,GACd,mBAAmB,GACnB,YAAY,GACZ,oBAAoB,GACpB,yBAAyB,GACzB,kBAAkB,CACpB,CAAC;AAWF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,gBAAgB,GAAG,SAAS,EACvC,WAAW,EAAE,gBAAgB,GAAG,SAAS,EACzC,cAAc,EAAE,MAAM,GACpB,aAAa,CAmBf;AAED,kFAAkF;AAClF,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,QAAQ,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,aAAa,EACpB,cAAc,EAAE,MAAM,EACtB,gBAAgB,CAAC,EAAE,QAAQ,GACzB,eAAe,EAAE,GAAG,SAAS,CAsB/B"}

package/dist/pptx/render/text-segment-paragraph-break.d.ts

@@ -0,0 +1,2 @@
+export { isParagraphSeparatorSegment } from 'ooxml-core/pptx/editor/render/text-segment-paragraph-break';
+//# sourceMappingURL=text-segment-paragraph-break.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-segment-paragraph-break.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-segment-paragraph-break.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,2BAA2B,EAAE,MAAM,4DAA4D,CAAC"}

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

@@ -0,0 +1,176 @@
+/**
+ * Framework-agnostic text CSS-builder helpers shared by every binding's text
+ * renderer.
+ *
+ * These are pure functions extracted from the React `viewer/utils/text-utils`
+ * layer. They return neutral CSS primitives (plain strings / numbers / literal
+ * unions of CSS keyword values), never a framework's `CSSProperties` type, so
+ * each binding can assign or cast the results into its own style object.
+ */
+import type { TextSegment, TextStyle } from 'ooxml-core/pptx';
+/** CSS `writing-mode` keyword values produced for vertical text directions. */
+export type CssWritingMode = 'vertical-rl' | 'vertical-lr';
+/** CSS `text-orientation` keyword values produced for vertical text. */
+export type CssTextOrientation = 'mixed' | 'upright' | 'sideways';
+/** CSS `direction` keyword. */
+export type CssDirection = 'rtl' | 'ltr';
+/**
+ * Map a parsed `textDirection` value to the corresponding CSS `writing-mode`.
+ *
+ * The block-progression axis (which side a new column is added on) is NOT
+ * the same for every vertical mode: `vert`/`eaVert` stack new columns to the
+ * LEFT (traditional CJK, `vertical-rl`), but `wordArtVert` (PowerPoint's
+ * "Stacked" WordArt vertical text) stacks new columns to the RIGHT, the same
+ * as `mongolianVert` and `vert270`. `wordArtVertRtl` is `wordArtVert`'s
+ * mirrored sibling and reverses that back to `vertical-rl`: in real
+ * PowerPoint (`audit-text/gen.py` slide 3, second paragraph of a `wordArtVert`
+ * body renders in a column to the RIGHT of the first, while the same body
+ * set to `wordArtVertRtl` renders its second paragraph's column to the LEFT.
+ *
+ * | textDirection      | CSS writing-mode |
+ * |--------------------|------------------|
+ * | `"vertical"`       | `vertical-rl`    |
+ * | `"eaVert"`         | `vertical-rl`    |
+ * | `"wordArtVertRtl"` | `vertical-rl`    |
+ * | `"vertical270"`    | `vertical-lr`    |
+ * | `"mongolianVert"`  | `vertical-lr`    |
+ * | `"wordArtVert"`    | `vertical-lr`    |
+ * | `"horizontal"`     | undefined        |
+ */
+export declare function toCssWritingMode(textDirection: TextStyle['textDirection'] | undefined): CssWritingMode | undefined;
+/**
+ * Resolve CSS `text-orientation` for vertical writing modes.
+ *
+ * - `"vertical"` (`a:bodyPr/@vert="vert"`): PowerPoint rotates EVERY glyph 90deg,
+ *   CJK included, so this is CSS `sideways`, not `mixed`: a CJK run under
+ *   `vert` renders rotated exactly like an adjacent Latin run, unlike the
+ *   same run under `eaVert` (`audit-text/pp/s3.png` columns 1 vs 3).
+ * - `"eaVert"`: the traditional East-Asian vertical style: CJK glyphs stay
+ *   upright and only non-CJK runs rotate (`mixed`). This is what
+ *   distinguishes it from `"vertical"` above.
+ * - `"vertical270"`: rotated 270deg, all glyphs rotated the same as `vertical`
+ *   (`sideways`), just read bottom-to-top (see `toCssVerticalDirection`).
+ * - `"wordArtVert"` / `"wordArtVertRtl"`: PowerPoint's "Stacked" WordArt style
+ *   renders every glyph upright, one per line, regardless of script
+ *   (`upright`); they differ only in which side a wrapped column grows on
+ *   (`toCssWritingMode`), not in glyph rotation.
+ * - `"mongolianVert"`: Mongolian's native vertical script stays upright, same
+ *   as CJK under `eaVert` (`mixed`).
+ * - `"horizontal"` / unset: undefined.
+ */
+export declare function toCssTextOrientation(textDirection: TextStyle['textDirection'] | undefined): CssTextOrientation | undefined;
+/**
+ * Resolve a CSS `direction` override for vertical text modes that read
+ * bottom-to-top instead of PowerPoint's usual top-to-bottom.
+ *
+ * Only `"vertical270"` (`a:bodyPr/@vert="vert270"`) reads bottom-to-top;
+ * every other vertical mode, `wordArtVertRtl` included, still reads
+ * top-to-bottom within a column (`wordArtVertRtl`'s "Rtl" is about which side
+ * a wrapped column grows on, handled by `toCssWritingMode`, not reading
+ * order). In CSS vertical writing modes, `direction: rtl` reverses the
+ * INLINE base direction from top-to-bottom to bottom-to-top, which is exactly
+ * `vertical270`'s ECMA-376 behaviour (`audit-text/pp/s3.png` column 2).
+ */
+export declare function toCssVerticalDirection(textDirection: TextStyle['textDirection'] | undefined): CssDirection | undefined;
+/**
+ * Resolve `a:bodyPr/@anchor` to a CSS `justify-content` value for the flex
+ * column {@link buildTextBodyLayoutStyle} lays paragraphs out in (D2-G5:
+ * ECMA-376 §20.1.10.2 `ST_TextAnchoringType`).
+ *
+ * `distributed`/`justified` (`dist`/`just`) stretch paragraph spacing so the
+ * text block fills the box's full vertical extent - CSS has no vertical
+ * justify-text primitive, so this approximates: `space-between` spreads
+ * multiple paragraphs across the box (the closest a flex column gets to
+ * "distribute"), and a single paragraph (nothing to distribute) falls back to
+ * centering, matching PowerPoint's own behaviour for a one-paragraph
+ * distributed body.
+ */
+export declare function resolveVerticalAnchorJustifyContent(vAlign: TextStyle['vAlign'] | undefined, textSegments: readonly TextSegment[] | undefined): string;
+/** Whether a `textDirection` value represents any vertical writing mode. */
+export declare function isVerticalTextDirection(textDirection: TextStyle['textDirection'] | undefined): boolean;
+/**
+ * Inputs to {@link computeAutoFitTextStyle} (geometry + text content).
+ *
+ * `text`, `width`, `height` and `bodyInsetVertical` are not read by
+ * {@link computeAutoFitTextStyle} itself: `spAutoFit` no longer derives a font
+ * scale from the measured text (see that function's doc comment), and
+ * `normAutofit`'s scale comes from the authored `fontScale`, not a
+ * measurement. Kept on the interface for call-site stability (`buildTextBlockStyle`
+ * already has this geometry to hand) and because they describe the shape's
+ * box, which is what actually changes size under `spAutoFit`.
+ */
+export interface AutoFitInput {
+    /** The element's text style (carries the autoFit* fields). */
+    textStyle: TextStyle | undefined;
+    /** Plain text content of the block. */
+    text: string;
+    /** Element box width in px. */
+    width: number;
+    /** Element box height in px. */
+    height: number;
+    /** Combined top + bottom body inset in px. */
+    bodyInsetVertical: number;
+    /** Whether the block has italic runs (loosens the default line height). */
+    hasItalicRuns: boolean;
+    /** Default font size in px when the style omits one. */
+    defaultFontSize: number;
+}
+/** Resolved auto-fit overrides; either field may be absent when unchanged. */
+export interface AutoFitResult {
+    fontSize?: number;
+    lineHeight?: number;
+}
+/**
+ * The `a:normAutofit/@fontScale` multiplier every RUN of a body must be painted
+ * at, or `1` when the body does not shrink its text.
+ *
+ * The body-level {@link computeAutoFitTextStyle} only scales the block's own
+ * `font-size`, which a run carrying its own `sz` (nearly every authored run)
+ * overrides, so a shrink-to-fit title painted 43% too large. Every binding's run
+ * builder multiplies by this, exactly as React's `renderSingleSegment` does.
+ *
+ * Out-of-range scales are ignored: `>= 1` is not a shrink, `<= 0` is not a size.
+ */
+export declare function resolveAutoFitFontScale(textStyle: TextStyle | undefined): number;
+/**
+ * Apply a `normAutofit` `fontScale` to an authored font size, rounded the way
+ * PowerPoint itself rounds: to the nearest WHOLE POINT, not a fractional one.
+ *
+ * COM-measured ground truth (`audit-text` corpus): a 28pt run under
+ * `fontScale="62500"` (62.5%) renders at 18pt in PowerPoint, not 17.5pt; under
+ * `fontScale="40000"` (40%) it renders at 11pt, not 11.2pt. PowerPoint never
+ * displays a fractional point size, so it rounds the scaled result before
+ * painting, and every caller that multiplies a run's own size by this scale
+ * has to round the same way or drift from the reference by up to half a
+ * point on every shrunk run. `Math.round` matches both examples
+ * (28 * 0.625 = 17.5 -> 18, half rounds up; 28 * 0.4 = 11.2 -> 11).
+ *
+ * A `fontScale` of `1` (autofit off, or out of range per
+ * {@link resolveAutoFitFontScale}) is a no-op and returns `fontSize`
+ * unrounded, so a body that never shrinks keeps sub-point authored sizes
+ * (e.g. a theme default of 10.5pt) exactly as authored.
+ */
+export declare function scaleFontSizeForAutoFit(fontSize: number, fontScale: number): number;
+/**
+ * Compute the auto-fit font-size / line-height overrides for a text block.
+ *
+ * ECMA-376 (§21.1.2.1.1 / §21.1.2.1.2) gives the two autofit modes opposite
+ * jobs, and this function only ever implements the first one:
+ *  - `a:normAutofit` (`autoFitMode: 'normal'`) scales the TEXT down to fit the
+ *    shape. PowerPoint computes and stores the exact percentage as
+ *    `fontScale` (and, separately, `lnSpcReduction` for line spacing); we
+ *    apply that authored percentage verbatim rather than re-deriving one.
+ *  - `a:spAutoFit` (`autoFitMode: 'shrink'`, the default for a new PowerPoint
+ *    text box) resizes the SHAPE to fit the text, never the font. A shape
+ *    authored or last edited in PowerPoint already has its `a:ext` on disk set
+ *    to the box PowerPoint grew or shrank to fit the text at its authored
+ *    size, so the font must render unshrunk. This function therefore applies
+ *    no override at all for `spAutoFit`: shrinking the font on top of a box
+ *    already sized to fit was rendering every default (spAutoFit) PowerPoint
+ *    text box and title smaller than PowerPoint itself renders it.
+ *
+ * Returns an empty object when auto-fit is off or no override is needed; the
+ * caller spreads the result over its own CSS object.
+ */
+export declare function computeAutoFitTextStyle(input: AutoFitInput): AutoFitResult;
+//# sourceMappingURL=text-style-helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-style-helpers.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-style-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAW9D,+EAA+E;AAC/E,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,aAAa,CAAC;AAC3D,wEAAwE;AACxE,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,GAAG,UAAU,CAAC;AAClE,+BAA+B;AAC/B,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,KAAK,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,CAC/B,aAAa,EAAE,SAAS,CAAC,eAAe,CAAC,GAAG,SAAS,GACnD,cAAc,GAAG,SAAS,CAa5B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CACnC,aAAa,EAAE,SAAS,CAAC,eAAe,CAAC,GAAG,SAAS,GACnD,kBAAkB,GAAG,SAAS,CAchC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACrC,aAAa,EAAE,SAAS,CAAC,eAAe,CAAC,GAAG,SAAS,GACnD,YAAY,GAAG,SAAS,CAK1B;AAuBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mCAAmC,CAClD,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,GAAG,SAAS,EACvC,YAAY,EAAE,SAAS,WAAW,EAAE,GAAG,SAAS,GAC9C,MAAM,CAWR;AAED,4EAA4E;AAC5E,wBAAgB,uBAAuB,CACtC,aAAa,EAAE,SAAS,CAAC,eAAe,CAAC,GAAG,SAAS,GACnD,OAAO,CAST;AAID;;;;;;;;;;GAUG;AACH,MAAM,WAAW,YAAY;IAC5B,8DAA8D;IAC9D,SAAS,EAAE,SAAS,GAAG,SAAS,CAAC;IACjC,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,8CAA8C;IAC9C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,2EAA2E;IAC3E,aAAa,EAAE,OAAO,CAAC;IACvB,wDAAwD;IACxD,eAAe,EAAE,MAAM,CAAC;CACxB;AAED,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAGhF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEnF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,YAAY,GAAG,aAAa,CAoC1E"}

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

@@ -0,0 +1,48 @@
+/**
+ * Which `TextStyle` keys belong to the text BODY and which to a RUN.
+ *
+ * `TextStyle` is one bag for three OOXML levels (`a:bodyPr`, `a:pPr`, `a:rPr`).
+ * The block builder (`text-block-style.ts`, `text-body-layout.ts`) reads the
+ * body-level keys from `element.textStyle` only; a run's style never carries
+ * them anywhere the renderer looks. So when an inline selection is active and
+ * a binding routes the WHOLE update through the selected runs, an Increase
+ * Indent (`paragraphMarginLeft`) or a vertical-alignment change lands on run
+ * styles nobody reads and nothing happens on screen.
+ *
+ * `splitTextStyleUpdate` partitions an update so a binding can merge the body
+ * half into `element.textStyle` regardless of selection and scope only the
+ * run half to the selected characters. `reconcileDecorationFlags` keeps the
+ * body-level decoration honest after a run-scoped edit, so the block's CSS
+ * `text-decoration` cannot keep painting underline over a run that was just
+ * un-underlined.
+ */
+import type { TextSegment, TextStyle } from 'ooxml-core/pptx';
+import type { TextDecorationFlag } from './selection-format-state.js';
+/**
+ * Keys read from `element.textStyle` only: `a:bodyPr` attributes, the text
+ * warp / 3D scene, autofit, and the paragraph geometry the block builder
+ * folds in as the body-wide fallback (indent, margins, spacing).
+ */
+export declare const BODY_TEXT_STYLE_KEYS: ReadonlySet<keyof TextStyle>;
+/** Whether `key` is read from the element body rather than a run. */
+export declare function isBodyTextStyleKey(key: string): boolean;
+/** An update partitioned by the level the renderer reads each key from. */
+export interface TextStyleUpdateSplit {
+    /** Keys to merge into `element.textStyle` regardless of any selection. */
+    body: Partial<TextStyle>;
+    /** Keys to scope to the selected runs (or every run without a selection). */
+    run: Partial<TextStyle>;
+}
+/** Partition `updates` into its body-level and run-level halves. Keys set to `undefined` (clears) are kept. */
+export declare function splitTextStyleUpdate(updates: Partial<TextStyle>): TextStyleUpdateSplit;
+/**
+ * Recompute the body-level value of each `flag` from the runs after a
+ * run-scoped edit: `true` only when every content run is effectively on;
+ * otherwise the body flag is dropped, and any run that was only inheriting it
+ * gets it written explicitly so its own look does not change.
+ */
+export declare function reconcileDecorationFlags(segments: readonly TextSegment[], textStyle: TextStyle | undefined, flags: readonly TextDecorationFlag[]): {
+    textStyle: TextStyle;
+    textSegments: TextSegment[];
+};
+//# sourceMappingURL=text-style-scope.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-style-scope.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-style-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAGnE;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,SAAS,CAoD5D,CAAC;AAEH,qEAAqE;AACrE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,2EAA2E;AAC3E,MAAM,WAAW,oBAAoB;IACpC,0EAA0E;IAC1E,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACzB,6EAA6E;IAC7E,GAAG,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;CACxB;AAED,+GAA+G;AAC/G,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,oBAAoB,CAOtF;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,KAAK,EAAE,SAAS,kBAAkB,EAAE,GAClC;IAAE,SAAS,EAAE,SAAS,CAAC;IAAC,YAAY,EAAE,WAAW,EAAE,CAAA;CAAE,CAwBvD"}

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

@@ -0,0 +1,30 @@
+/**
+ * The one text-style update every binding applies from the ribbon, the
+ * inspector and the inline editor's keyboard shortcuts.
+ *
+ * With an inline selection the run-level half of `updates` is scoped to the
+ * selected characters (`applyStyleToSelectedSegments`) while the body-level
+ * half (`text-style-scope.ts`) still reaches `element.textStyle`; the
+ * decoration flags the edit touched are then reconciled so the body's CSS
+ * decoration agrees with the runs. Without a selection the whole update goes
+ * to the body and to every run, the behaviour all five bindings already had.
+ */
+import type { PptxElement, TextSegment, TextStyle } from 'ooxml-core/pptx';
+import type { InlineTextSelection } from './inline-selection-utils.js';
+/** What a text-style update hands back to the binding. */
+export interface TextStyleUpdateResult {
+    /** The element patch to apply through the binding's update-element operation. */
+    patch: Partial<PptxElement>;
+    /** The selection remapped onto the new segments; `null` when there was none. */
+    newSelection: InlineTextSelection | null;
+}
+/**
+ * Build the element patch for `updates`.
+ *
+ * @param selection - The active inline text selection, or `null` for a
+ *   whole-element edit.
+ * @param segments - A fresher copy of the element's segments (a live inline
+ *   edit whose text is not yet on the model); defaults to the element's own.
+ */
+export declare function applyTextStyleUpdate(element: PptxElement, updates: Partial<TextStyle>, selection: InlineTextSelection | null, segments?: readonly TextSegment[]): TextStyleUpdateResult;
+//# sourceMappingURL=text-style-update.d.ts.map