ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/paragraph-run-enrich.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Per-run extras layered onto a {@link BuiltRun} by `paragraph-run-build.ts`:
+ * per-script font spans, measured tab-stop layout, and the `a:reflection`
+ * mirrored-sibling wrapper. Split out to keep that module focused on the
+ * run-splitting pipeline itself.
+ *
+ * The script/tab extras were React-only before this module existed
+ * (`text-segment-render` / `text-tab-layout.tsx`); they now reach all five
+ * bindings through the same `BuiltRun` fields React itself consumes.
+ */
+import type { TextSegment, TextStyle } from 'ooxml-core/pptx';
+import type { ReflectionWrapperStyle } from './reflection.js';
+import type { RunFontSpec } from './text-metric-tracking.js';
+import type { RunStyle } from './text-run-style.js';
+import type { ScriptFontFields, ScriptFontPiece } from './text-script-fonts.js';
+import { resolveScriptFontSet } from './text-script-fonts.js';
+import type { TabRenderContext, TabStopSpec } from './text-tab-layout.js';
+import type { TabbedLineRun } from './text-tab-run-build.js';
+/** The two per-run extras a rendered piece may carry. */
+export interface RunExtras {
+    scriptRuns?: ScriptFontPiece[];
+    tabLines?: TabbedLineRun[];
+}
+/** Everything {@link resolveRunExtrasContext} needs from the paragraph builder. */
+export interface RunExtrasInput {
+    seg: TextSegment;
+    style: RunStyle;
+    runFont: RunFontSpec;
+    blockFont: RunFontSpec;
+    blockScriptStyle: ScriptFontFields | undefined;
+    tabStops: TabStopSpec[] | undefined;
+    defaultTabSize: number | undefined;
+    /** Whether the paragraph is right-to-left. */
+    rtl?: boolean;
+}
+/** Per-segment context, resolved once and reused across a run's word pieces. */
+export interface RunExtrasContext {
+    scriptFonts: ReturnType<typeof resolveScriptFontSet>;
+    baseFontFamily: string;
+    tabContext: TabRenderContext | undefined;
+}
+/**
+ * Resolve the per-script font set and (when the segment declares tab stops) a
+ * measurement context, once per segment rather than once per word-piece.
+ */
+export declare function resolveRunExtrasContext(input: RunExtrasInput): RunExtrasContext;
+/**
+ * Attach the tab-layout extra for a piece of text that contains `\t`, or
+ * `undefined` when the segment authors no tab stops (the common case).
+ */
+export declare function buildTabLinesFor(text: string, ctx: RunExtrasContext, style: RunStyle, underlineWords?: boolean): TabbedLineRun[] | undefined;
+/**
+ * Attach the per-script font split for a piece of text, or `undefined` when
+ * the run declares no script font distinct from its own `a:latin` face.
+ */
+export declare function buildScriptRunsFor(text: string, ctx: RunExtrasContext, style: RunStyle): ScriptFontPiece[] | undefined;
+/**
+ * `a:reflection` mirrored-sibling wrapper for a segment's runs, or `undefined`
+ * for the common no-reflection case. `-webkit-box-reflect`'s old scope never
+ * reached the equation branch above it in `buildParagraphRuns` (it `continue`s
+ * before this is even called), so this only ever needs to be attached to a
+ * ruby run, a tab-lines run, or a per-word metric-split piece - never an
+ * equation.
+ *
+ * The element-height argument approximates the run's own box with its font
+ * size (matching the ruby-annotation fallback size right above this call
+ * site): `getTextReflectionWrapperStyle` only uses it for `@endPos`, which
+ * core's text-run parser does not extract yet (see `reflection.ts`'s module
+ * doc), so it is currently inert for text - kept anyway so a text reflection
+ * measures sensibly the day that parser gap closes.
+ */
+export declare function resolveRunReflection(segStyle: TextStyle | undefined, blockFont: RunFontSpec): ReflectionWrapperStyle | undefined;
+/**
+ * Set `run.reflection` on a `BuiltRun`-shaped object when a reflection was
+ * resolved by {@link resolveRunReflection}; a one-line no-op otherwise. `T` is
+ * `paragraph-run-build.ts`'s `BuiltRun` (kept generic here so this module does
+ * not have to import that type back from its own caller).
+ */
+export declare function applyRunReflection<T extends {
+    reflection?: ReflectionWrapperStyle;
+}>(run: T, reflection: ReflectionWrapperStyle | undefined): void;
+//# sourceMappingURL=paragraph-run-enrich.d.ts.map

package/dist/pptx/render/paragraph-run-enrich.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph-run-enrich.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/paragraph-run-enrich.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG9D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAE3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAwB,MAAM,qBAAqB,CAAC;AACjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAG1D,yDAAyD;AACzD,MAAM,WAAW,SAAS;IACzB,UAAU,CAAC,EAAE,eAAe,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;CAC3B;AAED,mFAAmF;AACnF,MAAM,WAAW,cAAc;IAC9B,GAAG,EAAE,WAAW,CAAC;IACjB,KAAK,EAAE,QAAQ,CAAC;IAChB,OAAO,EAAE,WAAW,CAAC;IACrB,SAAS,EAAE,WAAW,CAAC;IACvB,gBAAgB,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC/C,QAAQ,EAAE,WAAW,EAAE,GAAG,SAAS,CAAC;IACpC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,8CAA8C;IAC9C,GAAG,CAAC,EAAE,OAAO,CAAC;CACd;AAED,gFAAgF;AAChF,MAAM,WAAW,gBAAgB;IAChC,WAAW,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;IACrD,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,gBAAgB,GAAG,SAAS,CAAC;CACzC;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,cAAc,GAAG,gBAAgB,CAiB/E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,gBAAgB,EACrB,KAAK,EAAE,QAAQ,EACf,cAAc,UAAQ,GACpB,aAAa,EAAE,GAAG,SAAS,CAW7B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,gBAAgB,EACrB,KAAK,EAAE,QAAQ,GACb,eAAe,EAAE,GAAG,SAAS,CAO/B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE,SAAS,GAAG,SAAS,EAC/B,SAAS,EAAE,WAAW,GACpB,sBAAsB,GAAG,SAAS,CASpC;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS;IAAE,UAAU,CAAC,EAAE,sBAAsB,CAAA;CAAE,EACnF,GAAG,EAAE,CAAC,EACN,UAAU,EAAE,sBAAsB,GAAG,SAAS,GAC5C,IAAI,CAIN"}

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

@@ -0,0 +1,27 @@
+/**
+ * The text each segment of a paragraph renders as, and what follows it.
+ *
+ * `buildParagraphRuns` needs both: the first to build a run, the second so
+ * East Asian line breaking (`text-east-asian-breaks`) can decide a break AT a
+ * run boundary by the same rules as one inside a run. PowerPoint ignores run
+ * boundaries there (COM: `あいうえ` + a red `」たち` with `eaLnBrk="0"` puts
+ * `」` at the start of line 2, exactly as one run does).
+ *
+ * @module paragraph-run-text
+ */
+import type { TextSegment } from 'ooxml-core/pptx';
+import type { FieldSubstitutionContext } from './text-field-substitution.js';
+/**
+ * The text a segment renders: `\n` for a line break, a field's substituted
+ * value, otherwise its own text. The field's own `a:fld/a:rPr@lang` wins over
+ * the deck-wide locale for date/time formatting.
+ */
+export declare function resolveSegmentRunText(seg: TextSegment, fieldContext: FieldSubstitutionContext | undefined): string;
+/**
+ * For each segment, the text of the next segment that renders any (skipping
+ * the bullet marker and empty runs), or `undefined` when an inline equation
+ * or the paragraph end comes first: an equation is its own inline box, so no
+ * character-level rule reaches across it.
+ */
+export declare function resolveFollowingSegmentTexts(paraSegments: readonly TextSegment[], markerSegment: TextSegment | undefined, fieldContext: FieldSubstitutionContext | undefined): Array<string | undefined>;
+//# sourceMappingURL=paragraph-run-text.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph-run-text.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/paragraph-run-text.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAI1E;;;;GAIG;AACH,wBAAgB,qBAAqB,CACpC,GAAG,EAAE,WAAW,EAChB,YAAY,EAAE,wBAAwB,GAAG,SAAS,GAChD,MAAM,CAKR;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC3C,YAAY,EAAE,SAAS,WAAW,EAAE,EACpC,aAAa,EAAE,WAAW,GAAG,SAAS,EACtC,YAAY,EAAE,wBAAwB,GAAG,SAAS,GAChD,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAmB3B"}

package/dist/pptx/render/paragraph-spacing.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Per-paragraph line-height and vertical margins (`a:lnSpc` / `a:spcBef` /
+ * `a:spcAft`), resolved against the text body's own spacing.
+ *
+ * Split out of `text-paragraphs` to keep the builder focused; every binding
+ * reaches it through the same barrel, so the import path is unchanged.
+ */
+import type { TextStyle } from 'ooxml-core/pptx';
+/** Resolved per-paragraph line-height + space-before/after. */
+export interface ParagraphSpacing {
+    /** Unitless multiplier (`a:spcPct`) or a `"<n>pt"` / `"<n>px"` string (`a:spcPts`). */
+    lineHeight?: number | string;
+    /**
+     * `margin-top` in px. Always `undefined`: PowerPoint never renders a
+     * paragraph's own `a:spcBef` as space above it - see
+     * {@link resolveParagraphSpacing}'s doc comment. Kept on the type for API
+     * stability (every binding's paragraph renderer already reads it and maps
+     * it to `margin-top`, so removing the field is unnecessary churn); it is
+     * simply never populated any more.
+     */
+    spaceBeforePx?: number;
+    /**
+     * `margin-bottom` in px, from BOTH this paragraph's own `a:spcAft` AND its
+     * own `a:spcBef` combined - see {@link resolveParagraphSpacing}.
+     */
+    spaceAfterPx?: number;
+}
+/** Input for {@link resolveParagraphSpacing}. */
+export interface ParagraphSpacingInput {
+    /** This paragraph's own `a:pPr` geometry (from its first segment). */
+    paraProps: TextStyle | undefined;
+    /** The text body's style, used as the inheritance fallback. */
+    bodyStyle?: TextStyle | undefined;
+    /** True for the first paragraph in the body. */
+    isFirst?: boolean;
+    /** True for the last paragraph in the body. */
+    isLast?: boolean;
+    /**
+     * `a:bodyPr/@spcFirstLastPara`. Gates two things, each scoped to ONE edge
+     * paragraph only: the very first paragraph's own `spcBef`, and the very
+     * last paragraph's own `spcAft`. Off (the default, including omitted)
+     * suppresses both; every other paragraph's own spacing is unaffected by
+     * this flag either way. See {@link resolveParagraphSpacing} for how a
+     * paragraph's own `spcBef` and `spcAft` combine once resolved - that part
+     * is NOT what this flag controls, and is where the real complexity in
+     * this area actually lives.
+     *
+     * Measured over PowerPoint COM (`TextRange2.Paragraphs(n).BoundTop` /
+     * `.BoundHeight`) on bodies of N=1, 2, 3 and 4 paragraphs, both with
+     * uniform `spcBef=40pt`/`spcAft=30pt` and with every paragraph carrying a
+     * DISTINCT `spcBef`/`spcAft` pair (11/21, 32/42, 53/63, 74/84 pt) so a
+     * measured number can be traced to exactly one paragraph's authored value
+     * rather than several candidates that happen to sum the same:
+     *
+     * - The first paragraph's own `BoundHeight` grows by exactly ITS OWN
+     *   `spcBef` when the flag is on (e.g. 42.6pt -> 53.6pt on the distinct-
+     *   value deck, a +11pt delta matching p1's own 11pt `spcBef` exactly);
+     *   its `BoundTop` never moves either way. The last paragraph's own
+     *   `BoundHeight` mirrors it for `spcAft` (95.6pt -> 179.6pt, +84pt,
+     *   matching p4's own 84pt `spcAft` exactly).
+     * - Every paragraph strictly between the first and last is completely
+     *   unaffected by the flag in every N tested: its own gap to the next
+     *   paragraph is identical whether the flag is omitted, `"0"` or `"1"`.
+     *
+     * This confirms an earlier reading of the ORIGINAL 3-paragraph,
+     * `BoundTop`-only measurement (`project_spcfirstlastpara_com_measurement`
+     * memory), which concluded the flag "governs the SECOND paragraph's
+     * before-spacing": with only 3 paragraphs and uniform spacing, "p1's own
+     * spcBef, rendered after p1 instead of before it" and "p2's own spcBef"
+     * are numerically indistinguishable (both predict the exact same gap).
+     * The distinct-value deck (which paragraph's specific number shows up)
+     * and the `BoundHeight` reads (which paragraph's box the change lives in)
+     * together rule that reading out: it is the edge paragraph's OWN value,
+     * not its neighbour's.
+     */
+    spaceFirstLast?: boolean;
+    /**
+     * `a:normAutofit/@lnSpcReduction`: the shrink-to-fit line-spacing reduction,
+     * in 0..1. Applied to a resolved proportional (`a:spcPct`) line-height the
+     * same way `computeAutoFitTextStyle` applies it at the block level - it has
+     * to be applied here too because a paragraph or body line-spacing value
+     * produces an explicit per-paragraph `line-height`, which always outranks
+     * the block's own CSS `line-height` in the cascade. Not applied to an exact
+     * (`a:spcPts`) line-height: PowerPoint's reduction only affects the
+     * proportional form.
+     */
+    lineSpacingReduction?: number;
+}
+/**
+ * Resolve a paragraph's line-height and vertical margin.
+ *
+ * OOXML puts line spacing (`a:lnSpc`), space-before (`a:spcBef`) and
+ * space-after (`a:spcAft`) on the paragraph, so collapsing them into one
+ * body-level padding gives every paragraph the same gap and loses the authored
+ * rhythm. Values the paragraph does not set fall back to the text body's, and
+ * an exact measure (`a:spcPts`) beats a proportional one (`a:spcPct`) taken
+ * from the same level; a paragraph's own multiplier is never mixed with an
+ * exact value inherited from the body.
+ *
+ * **A paragraph's own `spcBef` is never rendered as space above it.** This
+ * function used to (and every other rendering engine's intuition says it
+ * should) emit the resolved `spcBef` as THIS paragraph's own `margin-top` and
+ * `spcAft` as its own `margin-bottom`, so the visible gap between paragraph i
+ * and i+1 came out as `spcAft(i) + spcBef(i+1)` (two independent, adjacent,
+ * non-collapsing flex-item margins). Measured over PowerPoint COM with a
+ * DISTINCT `spcBef`/`spcAft` pair on every paragraph (so a measured gap can be
+ * traced to exactly one paragraph's authored value, unlike a uniform deck
+ * where every hypothesis predicts the same total): that is wrong. An isolation
+ * deck makes it unambiguous - three paragraphs, only the MIDDLE one authoring
+ * a `spcBef` of 100pt (everything else 0) - measured `BoundTop` gaps:
+ *
+ * | gap    | measured  |
+ * | ------ | --------- |
+ * | p1->p2 | line only (21.6pt); p2's 100pt `spcBef` contributes NOTHING |
+ * | p2->p3 | line + 100pt; ALL of it lands here, after p2, not before    |
+ *
+ * A paragraph's own `spcBef` and its own `spcAft` are both folded into the
+ * SAME trailing gap (the one after that paragraph), never the leading one;
+ * `spcBef` behaves as a second `spcAft` contribution, not as its mirror image.
+ * The one exception is the two paragraphs `spaceFirstLast` gates (see that
+ * field's doc comment): the very first paragraph's own `spcBef` and the very
+ * last paragraph's own `spcAft`, each defaulting to suppressed. Cross-checked
+ * against a 4-paragraph deck with four distinct `spcBef`/`spcAft` pairs (own
+ * `BoundHeight` per paragraph matches `line + effective(spcBef) +
+ * effective(spcAft)` to 0.1pt on every paragraph, in every `spaceFirstLast`
+ * state) and against the original 3-paragraph uniform-value deck (which this
+ * model reproduces exactly - see the test file).
+ *
+ * `paragraphSpacingBefore` / `paragraphSpacingAfter` are already px from core.
+ */
+export declare function resolveParagraphSpacing(input: ParagraphSpacingInput): ParagraphSpacing;
+//# sourceMappingURL=paragraph-spacing.d.ts.map

package/dist/pptx/render/paragraph-spacing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph-spacing.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/paragraph-spacing.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAOjD,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAChC,uFAAuF;IACvF,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,iDAAiD;AACjD,MAAM,WAAW,qBAAqB;IACrC,sEAAsE;IACtE,SAAS,EAAE,SAAS,GAAG,SAAS,CAAC;IACjC,+DAA+D;IAC/D,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IAClC,gDAAgD;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,+CAA+C;IAC/C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;OASG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,qBAAqB,GAAG,gBAAgB,CA8CtF"}

package/dist/pptx/render/paragraph-strut.d.ts

@@ -0,0 +1,49 @@
+import type { TextSegment } from 'ooxml-core/pptx';
+/**
+ * Font size (px) that a paragraph's CSS line box should be built from, or
+ * `undefined` when the paragraph declares nothing of its own.
+ *
+ * ## Why this exists
+ *
+ * Every binding renders a text body as one container whose `font-size` is the
+ * shape's default run size and whose `line-height` is a unitless ratio. Each
+ * run then gets its own explicit `font-size` on its `<span>`. That looks
+ * right until a paragraph's runs are SMALLER than the shape default: CSS still
+ * builds every line box against the block container's own font metrics (the
+ * "strut"), so a paragraph of 8pt runs inside a body defaulting to 14pt is
+ * laid out on 14pt line boxes. PowerPoint sizes each line from the runs
+ * actually on it, so our text came out with visibly airy leading and
+ * overflowed its shape - the taller the shape default relative to the runs,
+ * the worse the drift.
+ *
+ * Returning the paragraph's own dominant run size lets a binding set it as the
+ * paragraph element's `font-size`, which re-bases the strut without touching
+ * any run: the spans keep their explicit sizes, and the unitless
+ * `line-height` ratio resolves against the paragraph instead of the body.
+ *
+ * The SMALLEST run wins, not the largest. A run's own `font-size` already
+ * sizes ITS line correctly through ordinary inline layout (a non-replaced
+ * inline element's line-box contribution is its own font-size times the
+ * inherited unitless `line-height`, independent of the container's strut),
+ * so the strut only needs to stop the invisible per-line minimum from being
+ * BIGGER than the smallest real content - using the largest run instead
+ * inflates every wrapped line of the paragraph to that run's height, even
+ * lines the large run never appears on. COM-verified against
+ * `audit-text/pp/s16.png` (`gen.py` slide 16): a paragraph of "small HUGE
+ * small wraps onto the / second line of text" wraps into two lines, and
+ * PowerPoint sizes line 2 (only the 12pt "small" text) tightly under line 1,
+ * not with the airy gap a 48pt-based strut produces. Bullet marker segments
+ * are excluded: a bullet glyph never drives the height of the line it marks.
+ * Text runs count even when they carry `bulletInfo`, as the first run of an
+ * `a:buNone` paragraph or of a paragraph bulleted in the editor does.
+ *
+ * `fontScale` is `a:normAutofit/@fontScale` (see `resolveAutoFitFontScale`),
+ * the same multiplier every run's own rendered size is scaled by. Segment
+ * styles carry their pre-shrink authored size, so the strut has to apply the
+ * same scale or the paragraph's line box stays sized for the unshrunk text
+ * while every run inside it renders smaller - defeating the shrink for any
+ * paragraph that sets its own (or inherits the body's) line spacing, which is
+ * effectively every paragraph.
+ */
+export declare function resolveParagraphStrutFontSize(segments: ReadonlyArray<Pick<TextSegment, 'style' | 'bulletInfo' | 'text' | 'fieldType' | 'isLineBreak'>>, bodyFontSize: number | undefined, fontScale?: number): number | undefined;
+//# sourceMappingURL=paragraph-strut.d.ts.map

package/dist/pptx/render/paragraph-strut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph-strut.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/paragraph-strut.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAKnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,6BAA6B,CAC5C,QAAQ,EAAE,aAAa,CACtB,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,YAAY,GAAG,MAAM,GAAG,WAAW,GAAG,aAAa,CAAC,CAChF,EACD,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,SAAS,SAAI,GACX,MAAM,GAAG,SAAS,CAsBpB"}

package/dist/pptx/render/paragraph-trailing-space.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Trailing spaces at the end of a right-aligned or centred paragraph.
+ *
+ * PowerPoint ignores a paragraph's trailing spaces when it aligns the line:
+ * `"Right aligned trailing spaces      "` with `algn="r"` puts the `s` of
+ * `spaces` on the right margin (COM-verified, audit-text slide 18). The text
+ * block renders with `white-space: pre-wrap`, where Chromium keeps those
+ * preserved spaces in the line it aligns, so the visible text sat a space
+ * run's width short of the margin. Dropping them from the render model (the
+ * document itself is untouched) gives PowerPoint's placement.
+ *
+ * @module paragraph-trailing-space
+ */
+/** The run fields this pass reads; anything with extras is left alone. */
+export interface TrimmableRun {
+    text: string;
+    equation?: unknown;
+    tabLines?: unknown;
+    scriptRuns?: unknown;
+    ruby?: unknown;
+    underlineWordPieces?: unknown;
+    /** A hanging punctuation mark's advance (`text-east-asian-breaks`), never trimmed. */
+    hangingSpace?: boolean;
+}
+/**
+ * Drop the paragraph-final whitespace from `runs` when the paragraph's
+ * alignment would otherwise let it push the visible text off the margin.
+ * Returns `runs` itself when nothing changes.
+ */
+export declare function trimParagraphTrailingSpaces<T extends TrimmableRun>(runs: T[], cssAlign: string | undefined, rtl: boolean): T[];
+//# sourceMappingURL=paragraph-trailing-space.d.ts.map

package/dist/pptx/render/paragraph-trailing-space.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph-trailing-space.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/paragraph-trailing-space.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,sFAAsF;IACtF,YAAY,CAAC,EAAE,OAAO,CAAC;CACvB;AAaD;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,YAAY,EACjE,IAAI,EAAE,CAAC,EAAE,EACT,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,GAAG,EAAE,OAAO,GACV,CAAC,EAAE,CA8BL"}

package/dist/pptx/render/paragraph-types.d.ts

@@ -0,0 +1,184 @@
+/**
+ * The two descriptor types `buildParagraphs` (in `text-paragraphs.ts`) returns:
+ * a single rendered run (`ParagraphRun`) and a rendered paragraph of them
+ * (`RenderParagraph`). Every one of the five bindings imports these two types
+ * from the package barrel to type its own run/paragraph components, so they
+ * live in their own module rather than inside the (much longer) builder that
+ * produces them - keeping `text-paragraphs.ts` itself under the repo's
+ * ~300 LOC guideline without hiding the split behind a re-export shim: the
+ * barrel (`render/index.ts`) exports this module directly, so no importer
+ * (inside `pptx-viewer-shared` or across the five bindings) has to change its
+ * import path, since every one of them already goes through the package root
+ * (`pptx-viewer-shared`), never a deep `.../text-paragraphs` path.
+ */
+import type { PictureBulletMarker } from './bullet-list.js';
+import type { ReflectionWrapperStyle } from './reflection.js';
+import type { EastAsianBreakOptions } from './text-east-asian-breaks.js';
+import type { RunEquation, RunHyperlink } from './text-run-meta.js';
+import type { RunRuby } from './text-run-ruby.js';
+import type { RunStyle } from './text-run-style.js';
+import type { ScriptFontPiece } from './text-script-fonts.js';
+import type { TabbedLineRun } from './text-tab-run-build.js';
+/** A single rendered run within a paragraph. */
+export interface ParagraphRun {
+    text: string;
+    style: RunStyle;
+    /**
+     * The run's hyperlink (`a:hlinkClick` / `a:hlinkMouseOver`), when it has one.
+     * A binding renders the run inside an `<a href>` when {@link RunHyperlink.href}
+     * is set, and routes {@link RunHyperlink.url} to its click handler otherwise
+     * (internal `ppaction://` slide jumps).
+     */
+    hyperlink?: RunHyperlink;
+    /**
+     * An inline equation (`m:oMath`) this run renders INSTEAD of `text`, which is
+     * empty for it. Emitted in the run sequence so the maths lands at its
+     * authored position between the runs around it.
+     */
+    equation?: RunEquation;
+    /**
+     * The run's phonetic guide (`a:ruby`: furigana, pinyin, bopomofo), when it
+     * has one. A binding renders `<ruby>{text}<rt style>{ruby.text}</rt></ruby>`;
+     * a run carrying one is never split per word, so the annotation appears once
+     * over the whole base run.
+     *
+     * Core parsed and saved ruby from the start, but `buildParagraphs` never read
+     * it, so the annotation rendered in React alone.
+     */
+    ruby?: RunRuby;
+    /**
+     * Index of the `textSegments` entry (of the override list when one was
+     * supplied) this run was built from.
+     *
+     * Shared splits one authored run into several per-word runs for PowerPoint's
+     * metric tracking, so this is many-to-one. It is the seam a binding uses to
+     * reach the facts the neutral model does not carry - React's find-match
+     * highlights, per-script font spans, tab stops and ruby all key off the
+     * originating segment - without regrouping the segments itself and drifting
+     * from the grouping here.
+     */
+    segmentIndex?: number;
+    /**
+     * Offset of this run's `text` within its segment's RENDERED text (after field
+     * substitution), so a caller holding per-segment character offsets can map
+     * them onto the split runs.
+     */
+    charStart?: number;
+    /**
+     * Per-script (`a:ea`/`a:cs`/`a:sym`) font-fallback pieces for this run's
+     * text, when a script it contains needs a font distinct from its own. A
+     * binding renders these as nested spans in place of `text` (see
+     * `text-script-fonts.ts`); absent for the common single-font case.
+     */
+    scriptRuns?: ScriptFontPiece[];
+    /**
+     * Measured tab-stop layout for this run's text, present when it contains an
+     * authored `\t` and the paragraph declares explicit tab stops. A binding
+     * renders these lines/pieces in place of `text`, honouring per-stop
+     * alignment and leader glyphs a plain CSS `tab-size` cannot express (see
+     * `text-tab-run-build.ts`). Absent for the common no-tab case.
+     */
+    tabLines?: TabbedLineRun[];
+    /**
+     * `a:rPr/@u="words"` word/gap pieces of a RUBY run's base text, present only
+     * when such a run's underline is `words` (the ordinary per-word split emits
+     * sibling runs instead; a tab piece carries its own `words`). Same shape as
+     * `scriptRuns` and rendered the same way, in place of `text`: a word entry
+     * carries the decoration for its own span, a gap entry is bare text. The
+     * run's own `style` has the underline stripped when this is set (see
+     * `paragraph-run-build.ts`).
+     */
+    underlineWordPieces?: ScriptFontPiece[];
+    /** The advance-carrying space after a hanging `、`/`。` (`text-east-asian-breaks`). */
+    hangingSpace?: true;
+    /**
+     * `a:reflection` mirrored-sibling wrapper style for this run (the text-run
+     * counterpart of a shape/picture's `ComputedEffectStyle.reflection`), or
+     * `undefined` for the common no-reflection case. A binding renders a sibling
+     * node just below the run's own, painted with the same text, positioned and
+     * masked by this style - see `render/reflection.ts`'s
+     * `getTextReflectionWrapperStyle`.
+     */
+    reflection?: ReflectionWrapperStyle;
+}
+/** A rendered paragraph: runs plus resolved bullet + hanging-indent metadata. */
+export interface RenderParagraph {
+    runs: ParagraphRun[];
+    /** Bullet glyph / number to render before the runs (or `undefined`). */
+    bulletMarker?: string;
+    /** Picture marker rendered before runs, or fallback metadata when unresolved. */
+    bulletPicture?: PictureBulletMarker;
+    /** Inline style for the bullet marker (font / size / colour). */
+    bulletStyle: RunStyle;
+    /** `margin-left` in px for the whole paragraph (hanging-indent layout). */
+    marginLeftPx?: number;
+    /** `text-indent` in px (first-line / hanging indent). */
+    textIndentPx?: number;
+    /**
+     * Per-paragraph `line-height` from this paragraph's own `a:pPr > a:lnSpc`.
+     * A unitless multiplier for proportional spacing (`a:spcPct`) or a `"<n>pt"`
+     * string for exact spacing (`a:spcPts`). Undefined when the paragraph does
+     * not override spacing (binding keeps the body-level line-height).
+     */
+    lineHeight?: number | string;
+    /** `margin-top` in px from this paragraph's `a:pPr > a:spcBef` (space before). */
+    spaceBeforePx?: number;
+    /** `margin-bottom` in px from this paragraph's `a:pPr > a:spcAft` (space after). */
+    spaceAfterPx?: number;
+    /**
+     * `font-size` in px to set on the paragraph element so its CSS line boxes
+     * are built from its OWN runs rather than the text body's default size.
+     * Undefined when the paragraph already matches the body default.
+     *
+     * See `resolveParagraphStrutFontSize` for why this is needed: without it a
+     * paragraph of small runs inside a larger-defaulting body is laid out on
+     * too-tall lines and overflows its shape.
+     */
+    strutFontSizePx?: number;
+    /**
+     * True when the paragraph has no runs and no bullet: an authored blank line
+     * (`<a:p><a:endParaRPr/></a:p>`).
+     *
+     * PowerPoint gives such a paragraph a full line box, which is how decks
+     * space a heading away from the bullet list under it. A binding must render
+     * something with height for it (a `<br>`), or the gap disappears and the
+     * block reads as one dense run of text (issue #131, slides 13-14).
+     */
+    isEmpty?: boolean;
+    /**
+     * Indices of this paragraph's segments in the rendered segment list (the
+     * override list when one was supplied), in authored order and INCLUDING the
+     * bullet-marker segment the runs drop.
+     *
+     * The seam a binding uses to reach paragraph facts the neutral model does not
+     * carry, without regrouping the segments itself and drifting from the
+     * grouping here - which is exactly how React ended up splitting on every
+     * `"\n"` and treating a soft `a:br` as a paragraph break.
+     */
+    segmentIndices: number[];
+    /**
+     * True when this paragraph resolves right-to-left (`a:pPr/@rtl`, or the text
+     * body's default). A binding that mirrors its hanging indent for RTL reads
+     * this; the direction itself is already in {@link paragraphStyle}.
+     */
+    rtl?: boolean;
+    /**
+     * Extra CSS for the paragraph box, beyond the margin / indent / spacing
+     * fields above: this paragraph's own `text-align` (`a:pPr/@algn`), its BiDi
+     * `direction`, and the kinsoku line-breaking rules (`@eaLnBrk`,
+     * `@latinLnBrk`, `@hangingPunct`). Absent when the paragraph overrides none
+     * of them, which is the common case.
+     *
+     * All three used to be resolved in React's private paragraph renderer only,
+     * so a deck that centred one paragraph of a left-aligned body, or set CJK
+     * break rules, rendered differently in the other four bindings.
+     */
+    paragraphStyle?: RunStyle;
+    /**
+     * `@hangingPunct` / `@eaLnBrk="0"` as resolved for this paragraph. The runs
+     * above already carry their pieces; React, which rebuilds each segment's
+     * pieces inside one span, re-applies `splitEastAsianBreaks` from this.
+     */
+    eastAsianBreaks?: EastAsianBreakOptions;
+}
+//# sourceMappingURL=paragraph-types.d.ts.map

package/dist/pptx/render/paragraph-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph-types.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/paragraph-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,gDAAgD;AAChD,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,QAAQ,CAAC;IAChB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,YAAY,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;;;;;;OAUG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,eAAe,EAAE,CAAC;IAC/B;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;IAC3B;;;;;;;;OAQG;IACH,mBAAmB,CAAC,EAAE,eAAe,EAAE,CAAC;IACxC,qFAAqF;IACrF,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,sBAAsB,CAAC;CACpC;AAED,iFAAiF;AACjF,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,wEAAwE;IACxE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iFAAiF;IACjF,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,iEAAiE;IACjE,WAAW,EAAE,QAAQ,CAAC;IACtB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yDAAyD;IACzD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,kFAAkF;IAClF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oFAAoF;IACpF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;;;OASG;IACH,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB;;;;OAIG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;IACd;;;;;;;;;;OAUG;IACH,cAAc,CAAC,EAAE,QAAQ,CAAC;IAC1B;;;;OAIG;IACH,eAAe,CAAC,EAAE,qBAAqB,CAAC;CACxC"}

package/dist/pptx/render/password-protection.d.ts

@@ -0,0 +1,6 @@
+export type PasswordValidationError = 'required' | 'mismatch' | 'tooShort' | null;
+/** Score a presentation password from 0 (very weak) to 4 (very strong). */
+export declare function getPasswordStrength(password: string): number;
+/** Validate the password pair used by the protection dialog. */
+export declare function validatePasswordPair(password: string, confirmation: string): PasswordValidationError;
+//# sourceMappingURL=password-protection.d.ts.map

package/dist/pptx/render/password-protection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password-protection.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/password-protection.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,IAAI,CAAC;AAElF,2EAA2E;AAC3E,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAqB5D;AAED,gEAAgE;AAChE,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GAClB,uBAAuB,CAWzB"}

package/dist/pptx/render/paste-special.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Paste Special (Ctrl+Alt+V) and the Paste Options mini-toolbar PowerPoint
+ * shows right after an ordinary paste. Both surfaces offer the same four
+ * choices, applied to the just-pasted clone: Keep Source Formatting, Use
+ * Destination Theme, Picture, Keep Text Only.
+ *
+ * This viewer's clipboard is an in-memory element snapshot (see
+ * `element-clipboard.ts`), not real OS clipboard formats, so "Paste Special"
+ * here means "how should the clone that `cloneElementForPaste` already
+ * produced be reshaped", not "which of several MIME payloads to decode".
+ * Three of the four formats are pure element transforms and live here; the
+ * fourth (Picture) needs a DOM rasterization step only a binding can perform,
+ * so this module only builds the resulting element once the binding hands it
+ * a rendered data URL (see {@link buildRasterPictureElement}).
+ *
+ * @module render/paste-special
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+/** The four paste formats PowerPoint's Paste Options / Paste Special offer. */
+export type PasteSpecialFormat = 'keep-source-formatting' | 'use-destination-theme' | 'picture' | 'keep-text-only';
+/** One entry in the Paste Special dialog / Paste Options toolbar. */
+export interface PasteSpecialOption {
+    id: PasteSpecialFormat;
+    /** i18n key; the binding translates it with its own translator. */
+    labelKey: string;
+}
+/**
+ * The four options, in the order PowerPoint's Paste Options toolbar shows
+ * them (Keep Source Formatting is the default/first icon).
+ */
+export declare const PASTE_SPECIAL_OPTIONS: readonly PasteSpecialOption[];
+/** Whether `element` carries any text "Keep Text Only" could keep. */
+export declare function pasteElementHasText(element: PptxElement): boolean;
+/**
+ * Apply `format` to an already-cloned pasted element (fresh id and cascade
+ * offset already applied by `cloneElementForPaste`). `keep-source-formatting`
+ * and `picture` are no-ops here: the former is the clone as-is, the latter is
+ * built separately by {@link buildRasterPictureElement} once the binding has
+ * rasterized it.
+ */
+export declare function applyPasteSpecialFormat(element: PptxElement, format: PasteSpecialFormat): PptxElement;
+/**
+ * Build the "Picture" paste result: the pasted element's own id/position/
+ * rotation, but reduced to a flattened raster image. The binding rasterizes
+ * the mounted clone's DOM node (the same `rasterizeElement` pipeline
+ * `save-as-picture.ts` uses) and hands the resulting data URL here; this
+ * function only assembles the resulting element so the decision of what a
+ * "Picture" paste contains stays in one place for all five bindings.
+ */
+export declare function buildRasterPictureElement(element: PptxElement, dataUrl: string): PptxElement;
+//# sourceMappingURL=paste-special.d.ts.map

package/dist/pptx/render/paste-special.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paste-special.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/paste-special.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,+EAA+E;AAC/E,MAAM,MAAM,kBAAkB,GAC3B,wBAAwB,GACxB,uBAAuB,GACvB,SAAS,GACT,gBAAgB,CAAC;AAEpB,qEAAqE;AACrE,MAAM,WAAW,kBAAkB;IAClC,EAAE,EAAE,kBAAkB,CAAC;IACvB,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAAS,kBAAkB,EAK9D,CAAC;AAEF,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAEjE;AAiED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACtC,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,kBAAkB,GACxB,WAAW,CAWb;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,CAW5F"}

package/dist/pptx/render/path-gradient-rect.d.ts

@@ -0,0 +1,2 @@
+export { buildRectPathGradientSvg, buildRectPathGradientImage, type RectPathGradientStop, type RectPathGradientFocalPoint, type RectPathGradientFillToRect, } from 'ooxml-core/diagram';
+//# sourceMappingURL=path-gradient-rect.d.ts.map

package/dist/pptx/render/path-gradient-rect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-gradient-rect.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/path-gradient-rect.ts"],"names":[],"mappings":"AACA,OAAO,EACN,wBAAwB,EACxB,0BAA0B,EAC1B,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,GAC/B,MAAM,oBAAoB,CAAC"}