ooxml-ui 0.30.1 → 1.0.0

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"}

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"}