ooxml-ui 0.30.0 → 0.31.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-style-update.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-style-update.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAOpE,0DAA0D;AAC1D,MAAM,WAAW,qBAAqB;IACrC,iFAAiF;IACjF,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAC5B,gFAAgF;IAChF,YAAY,EAAE,mBAAmB,GAAG,IAAI,CAAC;CACzC;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,EAC3B,SAAS,EAAE,mBAAmB,GAAG,IAAI,EACrC,QAAQ,CAAC,EAAE,SAAS,WAAW,EAAE,GAC/B,qBAAqB,CA+BvB"}

package/dist/pptx/render/text-tab-decimal.d.ts

@@ -0,0 +1,3 @@
+/** Compatibility entry: the implementation lives in ooxml-core/text (`decimal-tab.ts`). */
+export { decimalSeparatorForLanguage, decimalAnchorIndex } from 'ooxml-core/text';
+//# sourceMappingURL=text-tab-decimal.d.ts.map

package/dist/pptx/render/text-tab-decimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-tab-decimal.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-tab-decimal.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,OAAO,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}

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

@@ -0,0 +1,94 @@
+/**
+ * Real tab-stop layout for text runs containing `\t` characters (framework-agnostic).
+ *
+ * OOXML `a:tab` stops carry a position, an alignment (`l`/`ctr`/`r`/`dec`) and an
+ * optional leader glyph (`dot`/`hyphen`/`underscore`). A plain CSS `tab-size` can
+ * only advance by a fixed width and ignores both alignment and leaders (see
+ * `computeTabSize` in `text-body-layout.ts`), so TOC-style rows
+ * (label ....... 12) render wrong.
+ *
+ * This module computes a measured inline layout: each text piece (the run of
+ * characters between two tabs) gets a resolved left offset honouring the
+ * applicable tab stop's alignment, and the gap before it is filled with the
+ * leader glyph. `computeTabbedLayout` is the pure positioning maths (unit
+ * tested directly); `measureTextWidth` / `fillLeader` do the canvas
+ * measurement every binding shares (a `<canvas>` 2D context works identically
+ * in every browser environment, so this is not React-specific despite living
+ * only in React before this extraction).
+ *
+ * This was React-only: the other four bindings fell back to the block-level
+ * `tab-size` for every run containing a tab, so a deck's table-of-contents
+ * slide lost its dot leaders and right-aligned page numbers in Vue, Angular,
+ * Svelte and Vanilla.
+ */
+import type { TextStyle } from 'ooxml-core/pptx';
+import type { RunFontSpec } from './text-metric-tracking.js';
+export type TabAlign = 'l' | 'ctr' | 'r' | 'dec';
+export type TabLeader = 'none' | 'dot' | 'hyphen' | 'underscore';
+/** One parsed `a:tabLst/a:tab` entry, in px from the text-body left edge. */
+export type TabStopSpec = NonNullable<TextStyle['tabStops']>[number];
+/** A single laid-out piece of a tabbed line (raw numeric layout). */
+export interface TabbedPiece {
+    /** The run of characters between this tab and the next (or line end). */
+    text: string;
+    /** Resolved left offset in px where the text starts. */
+    left: number;
+    /** Width in px of the leader gap preceding this piece (0 for the first). */
+    leaderWidth: number;
+    /** Leader glyph to repeat across the gap, or `''` for none. */
+    leaderChar: string;
+}
+/** Context needed to lay out a tabbed line (measurement font + parsed stops). */
+export interface TabRenderContext {
+    tabStops: TabStopSpec[];
+    /** Default tab interval in px (from `a:pPr/@defTabSz`). */
+    defaultTabSize: number;
+    /** Canvas `font` shorthand used to measure piece widths. */
+    font: string;
+    /**
+     * The same font, as a {@link RunFontSpec}, so a caller can compute PowerPoint's
+     * advance-width grid correction (`resolveTrackedTextWidth` /
+     * `resolveMetricTrackingPx` in `text-metric-tracking.ts`) for a tab piece
+     * without re-deriving bold/italic/size from the canvas font string.
+     */
+    runFont: RunFontSpec;
+    /** The run language's decimal separator, the anchor for `dec` stops. */
+    decimalSeparator?: string;
+    /** Whether the paragraph is right-to-left (stops measured from the right). */
+    rtl?: boolean;
+}
+/** Direction and locale inputs for {@link computeTabbedLayout}. */
+export interface TabbedLayoutOptions {
+    decimalSeparator?: string;
+    rtl?: boolean;
+}
+/**
+ * Build a {@link TabRenderContext} for a run, or `undefined` when the run has
+ * no explicit tab stops (in which case a plain CSS `tab-size` already handles
+ * left tabs and no measured layout is needed).
+ */
+export declare function buildTabContext(tabStops: TabStopSpec[] | undefined, defaultTabSize: number | undefined, fontSizePx: number, fontFamily: string, bold: boolean, italic: boolean, options?: {
+    language?: string;
+    rtl?: boolean;
+}): TabRenderContext | undefined;
+/** Map an OOXML leader token to the glyph used to fill the leader gap. */
+export declare function leaderGlyph(leader: TabLeader | undefined): string;
+/**
+ * Compute the laid-out pieces for a single line split on `\t`.
+ *
+ * `segments` is the result of `line.split('\t')`; `segments[0]` is the text
+ * before the first tab and is always placed at `left = 0`. `measure` returns
+ * the rendered width in px of a given string in the run's font.
+ */
+export declare function computeTabbedLayout(segments: string[], tabStops: TabStopSpec[], measure: (text: string) => number, defaultTabSize: number, options?: TabbedLayoutOptions): TabbedPiece[];
+/** Measure the rendered px width of `text` in the given canvas `font`. */
+export declare function measureTextWidth(text: string, font: string): number;
+/**
+ * Build a leader string long enough to fill `width` px (clipped by the
+ * caller's CSS `overflow: hidden`), measuring the glyph with `measure` rather
+ * than a fixed canvas font so this stays testable without a real DOM.
+ */
+export declare function fillLeaderWithMeasure(glyph: string, width: number, measure: (text: string) => number): string;
+/** Build a leader string long enough to fill `width` px, then clip via CSS. */
+export declare function fillLeader(glyph: string, width: number, font: string): string;
+//# sourceMappingURL=text-tab-layout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-tab-layout.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-tab-layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAG1D,MAAM,MAAM,QAAQ,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,KAAK,CAAC;AACjD,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,YAAY,CAAC;AAEjE,6EAA6E;AAC7E,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAErE,qEAAqE;AACrE,MAAM,WAAW,WAAW;IAC3B,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAC;IACpB,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,iFAAiF;AACjF,MAAM,WAAW,gBAAgB;IAChC,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,2DAA2D;IAC3D,cAAc,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,OAAO,EAAE,WAAW,CAAC;IACrB,wEAAwE;IACxE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,8EAA8E;IAC9E,GAAG,CAAC,EAAE,OAAO,CAAC;CACd;AAED,mEAAmE;AACnE,MAAM,WAAW,mBAAmB;IACnC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,GAAG,CAAC,EAAE,OAAO,CAAC;CACd;AAKD;;;;GAIG;AACH,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,WAAW,EAAE,GAAG,SAAS,EACnC,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,OAAO,EACf,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAO,GAChD,gBAAgB,GAAG,SAAS,CAa9B;AAgBD,0EAA0E;AAC1E,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAWjE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAClC,QAAQ,EAAE,MAAM,EAAE,EAClB,QAAQ,EAAE,WAAW,EAAE,EACvB,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EACjC,cAAc,EAAE,MAAM,EACtB,OAAO,GAAE,mBAAwB,GAC/B,WAAW,EAAE,CAoDf;AAuBD,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAOnE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAC/B,MAAM,CAIR;AAED,+EAA+E;AAC/E,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7E"}

package/dist/pptx/render/text-tab-run-build.d.ts

@@ -0,0 +1,85 @@
+/**
+ * CSS-ready tab layout for one run's text, built on the pure positioning maths
+ * in `text-tab-layout.ts`.
+ *
+ * `buildRunTabLines` is the "pure decision function" every binding maps
+ * mechanically onto its own template: it splits a run's text on `\n`, lays out
+ * each line's `\t`-separated pieces against the paragraph's tab stops, and
+ * returns, per piece, CSS a binding spreads verbatim onto a nested span (plus
+ * a ready-filled leader string for the gap before it). A binding renders
+ * nothing but `pieces.map(...)`; the alignment/leader decision itself never
+ * has to be reimplemented per framework.
+ */
+import type { RunStyle } from './text-run-style.js';
+import type { TabRenderContext } from './text-tab-layout.js';
+/** One tabbed-line piece, ready to spread onto a binding's own span element. */
+export interface TabbedRunPiece {
+    text: string;
+    /**
+     * CSS for the span that wraps `text`: inline-block layout, this run's own
+     * decoration repeated, and this piece's own PowerPoint advance-width
+     * correction as `letter-spacing` (see `buildTabbedLine`). The piece is
+     * nested inside the run's own span, and neither property inherits the way a
+     * caller would want: `text-decoration-*` does not inherit into a nested
+     * element at all (an ancestor's underline is drawn *through* its
+     * descendants, but each descendant still computes `none` of its own), so a
+     * caller passes the run's decoration subset (`nestedTextDecorationStyle`) to
+     * have it repeated here; `letter-spacing` DOES inherit, which is exactly why
+     * this piece sets it explicitly rather than only when non-zero - the run's
+     * container span carries its own (wrong, whole-text) correction that would
+     * otherwise leak in.
+     */
+    style: RunStyle;
+    /** CSS for the leader-fill span preceding this piece, or `undefined` when there is no gap to fill. */
+    leaderStyle?: RunStyle;
+    /** Leader glyphs sized to fill `leaderStyle`'s width. Present only alongside `leaderStyle`. */
+    leaderText?: string;
+    /**
+     * `a:rPr/@u="words"` per-word/gap sub-pieces of THIS tab piece's own text
+     * (see `splitWordsForUnderline`), present only when the run's underline is
+     * `words`. A tab-separated piece is otherwise rendered as a single span
+     * (`text` + `style`), which underlines it continuously - correct for a
+     * one-word piece, but wrong for a piece like `"Hello World"` between two tab
+     * stops, which needs a gap under the space. A binding renders one SIBLING
+     * span per entry IN PLACE OF the piece's single `text` span: each entry's
+     * `style` is the piece's own `style` (the same inline-block layout and
+     * advance-width correction, so the line measures exactly as before), with
+     * the underline stripped on a gap entry. They must be siblings, not spans
+     * nested inside the piece span: an ancestor's underline is drawn through
+     * every inline descendant, so a nested gap could not lose it. `text`/`style`
+     * stay the continuous-underline fallback for a binding that does not
+     * render this field.
+     */
+    words?: Array<{
+        text: string;
+        style: RunStyle;
+    }>;
+}
+/** One `\n`-split line of a run's tabbed text. */
+export interface TabbedLineRun {
+    pieces: TabbedRunPiece[];
+}
+/**
+ * Build the per-line tabbed layout for a whole run's text.
+ *
+ * A run is laid out on its own (the tab stop's cursor starts at the run's own
+ * left edge): this matches PowerPoint for the common case a tab-containing run
+ * is authored as one run per line (a TOC "label \t page" row), which is what
+ * every reported case of this bug looked like. A run whose line is split
+ * across several *sibling* runs (different styles before/after the tab) is a
+ * rarer authoring pattern this does not attempt to solve, matching the scope
+ * of the React implementation this was extracted from.
+ *
+ * @param text             The run's rendered text (post field-substitution).
+ * @param ctx              Parsed tab stops + the run's measurement font.
+ * @param nestedDecoration This run's decoration subset, repeated onto every
+ *                         piece span (see {@link TabbedRunPiece.style}).
+ * @param measure           Injectable width function; defaults to a real
+ *                          canvas measurement in `ctx.font`.
+ * @param underlineWords    `a:rPr/@u="words"`: split each piece's text into
+ *                          per-word/gap sub-pieces (see
+ *                          {@link TabbedRunPiece.words}) instead of leaving it
+ *                          continuously underlined.
+ */
+export declare function buildRunTabLines(text: string, ctx: TabRenderContext, nestedDecoration?: RunStyle, measure?: (text: string) => number, underlineWords?: boolean): TabbedLineRun[];
+//# sourceMappingURL=text-tab-run-build.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-tab-run-build.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-tab-run-build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAG1D,gFAAgF;AAChF,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;;;;;;OAaG;IACH,KAAK,EAAE,QAAQ,CAAC;IAChB,sGAAsG;IACtG,WAAW,CAAC,EAAE,QAAQ,CAAC;IACvB,+FAA+F;IAC/F,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC;CACjD;AAED,kDAAkD;AAClD,MAAM,WAAW,aAAa;IAC7B,MAAM,EAAE,cAAc,EAAE,CAAC;CACzB;AAoFD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,gBAAgB,EACrB,gBAAgB,CAAC,EAAE,QAAQ,EAC3B,OAAO,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAA6C,EACxE,cAAc,UAAQ,GACpB,aAAa,EAAE,CAIjB"}

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

@@ -0,0 +1,3 @@
+export { resolveThemeFont, tintColor, shadeColor, THEME_COLOR_TINT_ROWS, THEME_COLOR_LABELS, buildThemeColorGrid, themeColorLabel, themeColorSchemeToSwatches, } from 'ooxml-core/pptx/editor/render/text-theme';
+export type { ThemeColorTintRow } from 'ooxml-core/pptx/editor/render/text-theme';
+//# sourceMappingURL=text-theme.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-theme.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-theme.ts"],"names":[],"mappings":"AACA,OAAO,EACN,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,0BAA0B,GAC1B,MAAM,0CAA0C,CAAC;AAClD,YAAY,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAC"}

package/dist/pptx/render/text-warp-envelope-block.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Unwarped layout of a WordArt envelope text block, the input to the
+ * envelope mapping (`text-warp-envelope-map.ts`). Measured against
+ * PowerPoint COM renders (2026-09-24, see `docs/guide/visual-effects.md`):
+ *
+ *  - Paragraphs stack as ordinary lines: baseline to baseline is
+ *    `1.2 * ((1 - k) * S_prev + k * S_next)` for the lines' largest font
+ *    sizes `S` ({@link LINE_PITCH_EM}, {@link BASELINE_FRACTION}); the 1.2em
+ *    pitch held for all seven fonts measured (Arial, Times New Roman,
+ *    Calibri, Georgia, Verdana, Segoe UI, Cambria, each within 0.3%).
+ *  - Lines are aligned against the widest line, and are NOT each stretched
+ *    to the box: a short line keeps its natural width inside the block.
+ *  - The block box is the union of every glyph's INK box vertically, and
+ *    horizontally the union of ink boxes plus the full advance box of
+ *    whitespace (a leading or trailing space widens the block).
+ */
+import type { EnvelopeBlockBox } from './text-warp-envelope-map.js';
+import type { EnvelopeAlign, EnvelopeFontSpec, EnvelopeSegmentInput, GlyphOutlineLookup } from './text-warp-envelope-types.js';
+import type { GlyphOutlineCommand } from './text-warp-glyph-outline.js';
+/** PowerPoint's single-spaced line pitch, in ems of the line's largest font. */
+export declare const LINE_PITCH_EM = 1.2;
+/** One glyph placed in the unwarped block. */
+export interface EnvelopeBlockGlyph {
+    char: string;
+    segmentIndex: number;
+    font: EnvelopeFontSpec;
+    /** Left advance edge (layout units). */
+    x: number;
+    /** Baseline (layout units). */
+    baseline: number;
+    advance: number;
+    /** The glyph's outline at `(x, baseline)`, when obtainable. */
+    outline?: GlyphOutlineCommand[];
+    /** Ink box; `undefined` for whitespace. */
+    ink?: EnvelopeBlockBox;
+}
+/** The unwarped block: glyphs per paragraph plus the box the warp normalises by. */
+export interface EnvelopeBlockLayout {
+    lines: EnvelopeBlockGlyph[][];
+    box: EnvelopeBlockBox | undefined;
+}
+/**
+ * Lay out `paragraphs` (each a list of styled runs) unwarped, and measure
+ * the block box. The box is `undefined` when nothing on any line has ink.
+ */
+export declare function layoutEnvelopeBlock(paragraphs: EnvelopeSegmentInput[][], align: EnvelopeAlign, getGlyphOutline?: GlyphOutlineLookup): EnvelopeBlockLayout;
+//# sourceMappingURL=text-warp-envelope-block.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-envelope-block.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-envelope-block.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAMjE,OAAO,KAAK,EACX,aAAa,EACb,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,EAClB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAGrE,gFAAgF;AAChF,eAAO,MAAM,aAAa,MAAM,CAAC;AAUjC,8CAA8C;AAC9C,MAAM,WAAW,kBAAkB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,gBAAgB,CAAC;IACvB,wCAAwC;IACxC,CAAC,EAAE,MAAM,CAAC;IACV,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,OAAO,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAChC,2CAA2C;IAC3C,GAAG,CAAC,EAAE,gBAAgB,CAAC;CACvB;AAED,oFAAoF;AACpF,MAAM,WAAW,mBAAmB;IACnC,KAAK,EAAE,kBAAkB,EAAE,EAAE,CAAC;IAC9B,GAAG,EAAE,gBAAgB,GAAG,SAAS,CAAC;CAClC;AAkDD;;;GAGG;AACH,wBAAgB,mBAAmB,CAClC,UAAU,EAAE,oBAAoB,EAAE,EAAE,EACpC,KAAK,EAAE,aAAa,EACpB,eAAe,CAAC,EAAE,kBAAkB,GAClC,mBAAmB,CA0DrB"}

package/dist/pptx/render/text-warp-envelope-curves.d.ts

@@ -0,0 +1,19 @@
+/** Presets that carry an independent top/bottom envelope curve. */
+export declare const GLYPH_ENVELOPE_PRESETS: ReadonlySet<string>;
+/** True when `preset` should be rendered with a per-glyph two-curve envelope. */
+export declare function hasGlyphEnvelope(preset: string | undefined): boolean;
+/** Top/bottom envelope curve position, each a fraction of box height. */
+export interface EnvelopeCurveFractions {
+    top: number;
+    bottom: number;
+}
+/**
+ * The top/bottom envelope curve fractions at horizontal position `u` (0 = left
+ * edge, 1 = right edge, 0.5 = centre) for a glyph-envelope preset.
+ *
+ * Returns `undefined` for a preset outside {@link GLYPH_ENVELOPE_PRESETS}.
+ */
+export declare function envelopeCurveAt(preset: string, u: number, adj?: number, adj2?: number): EnvelopeCurveFractions | undefined;
+/** The undeformed band, exported so layout code can compute a stable scale=1 baseline. */
+export declare const NOMINAL_ENVELOPE_BAND: EnvelopeCurveFractions;
+//# sourceMappingURL=text-warp-envelope-curves.d.ts.map

package/dist/pptx/render/text-warp-envelope-curves.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-envelope-curves.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-envelope-curves.ts"],"names":[],"mappings":"AAuCA,mEAAmE;AACnE,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,MAAM,CAWrD,CAAC;AAEH,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAEpE;AAsCD,yEAAyE;AACzE,MAAM,WAAW,sBAAsB;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,MAAM,EAAE,MAAM,EACd,CAAC,EAAE,MAAM,EACT,GAAG,CAAC,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,GACX,sBAAsB,GAAG,SAAS,CAyEpC;AAcD,0FAA0F;AAC1F,eAAO,MAAM,qBAAqB,EAAE,sBAGnC,CAAC"}

package/dist/pptx/render/text-warp-envelope-layout.d.ts

@@ -0,0 +1,17 @@
+import { measureGlyphAdvances, resetGlyphEnvelopeMeasureCache } from './text-warp-envelope-measure.js';
+import type { EnvelopeAlign, EnvelopeGlyphPlacement, EnvelopeSegmentInput, GlyphOutlineLookup } from './text-warp-envelope-types.js';
+export type { EnvelopeAlign, EnvelopeFontSpec, EnvelopeGlyphPlacement, EnvelopeSegmentInput, GlyphOutlineLookup, GlyphOutlineLookupFont, } from './text-warp-envelope-types.js';
+export { measureGlyphAdvances, resetGlyphEnvelopeMeasureCache };
+/**
+ * Build every paragraph's glyph placements for one envelope-warped text
+ * block in a `width` x `height` shape box. Returns one array per paragraph
+ * (in order), each empty when the preset is outside the envelope family, the
+ * box is degenerate, or the block has no ink at all.
+ */
+export declare function buildGlyphEnvelopeBlock(preset: string, paragraphs: EnvelopeSegmentInput[][], width: number, height: number, align: EnvelopeAlign, adj?: number, adj2?: number, getGlyphOutline?: GlyphOutlineLookup): EnvelopeGlyphPlacement[][];
+/**
+ * Single-paragraph convenience wrapper around {@link buildGlyphEnvelopeBlock}:
+ * the placements for a block that consists of `segments` alone.
+ */
+export declare function buildGlyphEnvelope(preset: string, segments: EnvelopeSegmentInput[], width: number, height: number, align: EnvelopeAlign, adj?: number, adj2?: number, getGlyphOutline?: GlyphOutlineLookup): EnvelopeGlyphPlacement[];
+//# sourceMappingURL=text-warp-envelope-layout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-envelope-layout.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-envelope-layout.ts"],"names":[],"mappings":"AA8BA,OAAO,EAEN,oBAAoB,EACpB,8BAA8B,EAC9B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EACX,aAAa,EACb,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,EAClB,MAAM,4BAA4B,CAAC;AAIpC,YAAY,EACX,aAAa,EACb,gBAAgB,EAChB,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,EAClB,sBAAsB,GACtB,MAAM,4BAA4B,CAAC;AAIpC,OAAO,EAAE,oBAAoB,EAAE,8BAA8B,EAAE,CAAC;AAuChE;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACtC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,oBAAoB,EAAE,EAAE,EACpC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,EACpB,GAAG,CAAC,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,EACb,eAAe,CAAC,EAAE,kBAAkB,GAClC,sBAAsB,EAAE,EAAE,CAiB5B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,oBAAoB,EAAE,EAChC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,EACpB,GAAG,CAAC,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,EACb,eAAe,CAAC,EAAE,kBAAkB,GAClC,sBAAsB,EAAE,CAa1B"}

package/dist/pptx/render/text-warp-envelope-map.d.ts

@@ -0,0 +1,21 @@
+/** The unwarped text block's bounding box, in layout coordinates. */
+export interface EnvelopeBlockBox {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+/** Maps an unwarped layout point onto the warped shape box. */
+export interface EnvelopeWarp {
+    map(x: number, y: number): {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Build the envelope mapping for `preset` in a `width` x `height` shape box,
+ * normalising layout points by `block`. Returns `undefined` for a preset
+ * outside the envelope family, a degenerate box, or an empty block.
+ */
+export declare function createEnvelopeWarp(preset: string, width: number, height: number, adj: number | undefined, adj2: number | undefined, block: EnvelopeBlockBox): EnvelopeWarp | undefined;
+//# sourceMappingURL=text-warp-envelope-map.d.ts.map

package/dist/pptx/render/text-warp-envelope-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-envelope-map.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-envelope-map.ts"],"names":[],"mappings":"AAsCA,qEAAqE;AACrE,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,+DAA+D;AAC/D,MAAM,WAAW,YAAY;IAC5B,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACpD;AAwDD;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,KAAK,EAAE,gBAAgB,GACrB,YAAY,GAAG,SAAS,CA2B1B"}

package/dist/pptx/render/text-warp-envelope-measure.d.ts

@@ -0,0 +1,33 @@
+import type { EnvelopeFontSpec } from './text-warp-envelope-types.js';
+/** The font size (px) `font` renders at, defaulting like every other text path. */
+export declare function envelopeFontSizePx(font: EnvelopeFontSpec): number;
+/** The CSS `font` shorthand for `font`, shared by measurement and glyph tracing. */
+export declare function toCanvasFont(font: EnvelopeFontSpec, sizePx?: number): string;
+/**
+ * Per-character advance widths for `text` set in `font`, measured in the
+ * context of the whole prefix (shaped scripts and kerning need it) so that
+ * each glyph's start (the sum of the advances before it) is kerned.
+ *
+ * Falls back to a flat `0.55em`-per-character estimate when there is no DOM
+ * to measure with (SSR, or a test environment without a 2D canvas context).
+ */
+export declare function measureGlyphAdvances(text: string, font: EnvelopeFontSpec): number[];
+/** A glyph's ink extent relative to its own origin (baseline, left advance edge). */
+export interface GlyphInkExtent {
+    left: number;
+    right: number;
+    /** Distance above the baseline (positive = up). */
+    ascent: number;
+    /** Distance below the baseline (positive = down). */
+    descent: number;
+}
+/**
+ * The ink extent of one `char` in `font` via `measureText`'s
+ * `actualBoundingBox*` metrics, used for a glyph with no outline. Returns
+ * `undefined` without a canvas or when the environment reports no ink metrics;
+ * the caller then estimates the box from the advance and font size.
+ */
+export declare function measureGlyphInk(char: string, font: EnvelopeFontSpec): GlyphInkExtent | undefined;
+/** Test hook: forget the cached measurement context. */
+export declare function resetGlyphEnvelopeMeasureCache(): void;
+//# sourceMappingURL=text-warp-envelope-measure.d.ts.map

package/dist/pptx/render/text-warp-envelope-measure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-envelope-measure.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-envelope-measure.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAgBnE,mFAAmF;AACnF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,CAEjE;AAED,oFAAoF;AACpF,wBAAgB,YAAY,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,SAA2B,GAAG,MAAM,CAG9F;AAeD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAsBnF;AAED,qFAAqF;AACrF,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,GAAG,cAAc,GAAG,SAAS,CAwBhG;AAED,wDAAwD;AACxD,wBAAgB,8BAA8B,IAAI,IAAI,CAErD"}

package/dist/pptx/render/text-warp-envelope-types.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Types for {@link buildGlyphEnvelope} (`text-warp-envelope-layout.ts`), split
+ * out to keep that file under the repo's per-file line budget.
+ */
+import type { GlyphOutlineCommand } from './text-warp-glyph-outline.js';
+import type { EnvelopeGlyphSlice } from './text-warp-glyph-slicing.js';
+/** The subset of a run's resolved style this module needs to measure it. */
+export interface EnvelopeFontSpec {
+    fontFamily?: string;
+    fontSizePx?: number;
+    bold?: boolean;
+    italic?: boolean;
+}
+/** One run's worth of glyphs to lay out along the envelope, in source order. */
+export interface EnvelopeSegmentInput {
+    text: string;
+    font: EnvelopeFontSpec;
+    /** Index into the caller's own segment/style array (carried through untouched). */
+    segmentIndex: number;
+}
+/** Where and how to draw one glyph. */
+export interface EnvelopeGlyphPlacement {
+    char: string;
+    segmentIndex: number;
+    /** SVG `x` for the (otherwise flat) `<text>` element. */
+    x: number;
+    /** SVG `y` (nominal baseline; the vertical placement is done by `transform`). */
+    y: number;
+    /**
+     * An SVG `matrix(a b c d e f)` applied to a `<text x={x} y={y}>` for this
+     * glyph: the least-squares affine fit of the envelope mapping over the
+     * glyph's ink box (see `fitGlyphEnvelopeAffine` in
+     * `text-warp-glyph-slicing.ts`). It maps from the unwarped layout space
+     * `x`/`y` are in, so it carries the horizontal placement too. Only used
+     * when `outlinePath` is absent.
+     */
+    transform: string;
+    /**
+     * Present only when this glyph needed more than one rendered piece (see
+     * `fitGlyphEnvelopeAffine` in `text-warp-glyph-slicing.ts`): a very wide
+     * glyph on a strongly-curved envelope, where `transform` alone (fit across
+     * the glyph's WHOLE width) misses how much the curve bends within that
+     * width. When present, a binding renders `slices.length` copies of this
+     * glyph instead of one, each clipped to its own `[clipX0, clipX1]` band (in
+     * the SAME coordinate space `x`/`y` are already in) and carrying its own
+     * `transform`. Absent (the overwhelmingly common case) for an ordinary
+     * caption, in which case a binding renders exactly as it did before this
+     * field existed: one `<text transform={transform}>`, no clip-path.
+     */
+    slices?: EnvelopeGlyphSlice[];
+    /**
+     * A warped SVG path `d` for this glyph's ACTUAL outline, present only when
+     * `getGlyphOutline` (passed to `buildGlyphEnvelope`) returned a real
+     * outline for this glyph's font/character. When present, a binding renders
+     * `<path d={outlinePath} fill={...}/>` instead of `<text transform>` /
+     * `slices`: every outline point (on-curve and off-curve alike) is already
+     * mapped through the envelope mapping, in shape-box coordinates, so this
+     * is not an approximation of the glyph's bounding box, unlike
+     * `transform`/`slices`. Absent (`undefined`) whenever no outline was
+     * obtainable (no font file and no DOM canvas to trace the glyph with, see
+     * `createGlyphOutlineLookup`) or the glyph is whitespace
+     * (nothing to draw either way), in which case a binding renders the
+     * `<text transform>` / `slices` fallback.
+     */
+    outlinePath?: string;
+}
+/** The minimal font-spec shape `buildGlyphEnvelopeBlock`'s `getGlyphOutline` callback receives. */
+export type GlyphOutlineLookupFont = EnvelopeFontSpec;
+/**
+ * Resolves one glyph's outline commands (already positioned at `x`, `y` and
+ * scaled to `font.fontSizePx`), or `undefined` when no outline is obtainable
+ * for this `char`/`font` (the caller falls back to the affine transform).
+ * See `text-warp-outline-font-cache.ts`'s `createGlyphOutlineLookup` for the
+ * production implementation (a parsed font file via `opentype.js`, else a
+ * glyph traced from the browser's own rendering).
+ */
+export type GlyphOutlineLookup = (char: string, font: GlyphOutlineLookupFont, x: number, y: number) => GlyphOutlineCommand[] | undefined;
+/**
+ * Horizontal line alignment. Matches `TextStyle['align']` exactly (including
+ * the distribute/Thai variants) so callers can pass it straight through
+ * without narrowing; every non-`right` non-`left`-ish value renders centred,
+ * same as `envelopeCurveAt`'s callers already treat unknown alignments.
+ */
+export type EnvelopeAlign = 'left' | 'center' | 'right' | 'justify' | 'justLow' | 'dist' | 'thaiDist' | undefined;
+//# sourceMappingURL=text-warp-envelope-types.d.ts.map

package/dist/pptx/render/text-warp-envelope-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-envelope-types.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-envelope-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,gFAAgF;AAChF,MAAM,WAAW,oBAAoB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,gBAAgB,CAAC;IACvB,mFAAmF;IACnF,YAAY,EAAE,MAAM,CAAC;CACrB;AAED,uCAAuC;AACvC,MAAM,WAAW,sBAAsB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,yDAAyD;IACzD,CAAC,EAAE,MAAM,CAAC;IACV,iFAAiF;IACjF,CAAC,EAAE,MAAM,CAAC;IACV;;;;;;;OAOG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC9B;;;;;;;;;;;;;OAaG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,mGAAmG;AACnG,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,CAAC;AAEtD;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAChC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,sBAAsB,EAC5B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,KACL,mBAAmB,EAAE,GAAG,SAAS,CAAC;AAEvC;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GACtB,MAAM,GACN,QAAQ,GACR,OAAO,GACP,SAAS,GACT,SAAS,GACT,MAAM,GACN,UAAU,GACV,SAAS,CAAC"}

package/dist/pptx/render/text-warp-glyph-outline.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Per-point glyph-outline warping for the WordArt two-curve envelope.
+ *
+ * PowerPoint warps a glyph's actual vector outline point by point through
+ * the envelope mapping (`text-warp-envelope-map.ts`). This module takes a
+ * glyph's outline commands (from a parsed font file, see
+ * `text-warp-outline-font-cache.ts`, or traced from the browser's own
+ * rendering of the glyph, see `text-warp-glyph-trace.ts`), flattens every
+ * straight line and Bezier curve into short segments, and maps each point
+ * through the warp. Flattening matters: the warp bends straight lines (a
+ * stem's top edge follows the `can` arc), so warping only a segment's end
+ * points would keep it straight where PowerPoint curves it.
+ */
+import type { EnvelopeWarp } from './text-warp-envelope-map.js';
+/**
+ * One drawing command of a glyph outline, in the unwarped layout coordinate
+ * space (the glyph positioned at its layout origin and scaled to its font
+ * size). Mirrors `opentype.js`'s `PathCommand` shape so a caller can pass its
+ * commands through with only a field rename, without this module depending
+ * on the `opentype.js` type directly.
+ */
+export type GlyphOutlineCommand = {
+    readonly type: 'M';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly type: 'L';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly type: 'C';
+    readonly x1: number;
+    readonly y1: number;
+    readonly x2: number;
+    readonly y2: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly type: 'Q';
+    readonly x1: number;
+    readonly y1: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly type: 'Z';
+};
+/** A 2-D point. */
+export interface OutlinePoint {
+    x: number;
+    y: number;
+}
+/**
+ * Flatten `commands` into closed polylines (one per contour), splitting
+ * straight lines so no piece is longer than `maxSegment`.
+ */
+export declare function flattenOutline(commands: readonly GlyphOutlineCommand[], maxSegment: number): OutlinePoint[][];
+/** The ink bounding box of `commands` (curves included), or `undefined` when empty. */
+export declare function outlineBounds(commands: readonly GlyphOutlineCommand[]): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+} | undefined;
+/**
+ * Build the warped SVG path `d` for one glyph's outline: every contour is
+ * flattened (pieces no longer than `maxSegment` layout units) and each point
+ * mapped through `warp`. Returns `undefined` for an empty outline (a
+ * whitespace glyph), so a caller can tell "nothing to draw" from "no outline".
+ */
+export declare function buildWarpedGlyphOutlinePathD(commands: readonly GlyphOutlineCommand[], warp: EnvelopeWarp, maxSegment: number): string | undefined;
+//# sourceMappingURL=text-warp-glyph-outline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-glyph-outline.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-glyph-outline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9D;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9D;IACA,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CAClB,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CAClB,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAA;CAAE,CAAC;AAE1B,mBAAmB;AACnB,MAAM,WAAW,YAAY;IAC5B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAKD;;;GAGG;AACH,wBAAgB,cAAc,CAC7B,QAAQ,EAAE,SAAS,mBAAmB,EAAE,EACxC,UAAU,EAAE,MAAM,GAChB,YAAY,EAAE,EAAE,CAsElB;AAED,uFAAuF;AACvF,wBAAgB,aAAa,CAC5B,QAAQ,EAAE,SAAS,mBAAmB,EAAE,GACtC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAc1E;AAQD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC3C,QAAQ,EAAE,SAAS,mBAAmB,EAAE,EACxC,IAAI,EAAE,YAAY,EAClB,UAAU,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAUpB"}

package/dist/pptx/render/text-warp-glyph-slicing.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Affine / piecewise-affine fallback for a WordArt envelope glyph whose
+ * outline is not obtainable (no font file and no DOM canvas to trace the
+ * browser's own rendering with, e.g. server-side rendering or a test
+ * environment). With an outline available, `text-warp-glyph-outline.ts`
+ * warps it exactly instead and none of this runs.
+ *
+ * The glyph renders as an SVG `<text>` at its unwarped layout position, with
+ * a full `matrix(a b c d e f)` least-squares fit of the envelope mapping
+ * (`text-warp-envelope-map.ts`) over its ink box. When one affine misses the
+ * mapping by more than {@link SLICE_TOLERANCE_FRACTION} of the shape box
+ * height anywhere inside the glyph box
+ * (a wide glyph on a strongly curved envelope), the glyph is split into up
+ * to {@link MAX_ENVELOPE_GLYPH_SLICES} vertical bands, each clipped to its
+ * own x-range (in the same pre-transform layout space `x`/`y` are in) and
+ * carrying its own fit, so the pieces tile the glyph.
+ */
+import type { EnvelopeWarp } from './text-warp-envelope-map.js';
+/** Never split a single glyph into more than this many rendered pieces. */
+export declare const MAX_ENVELOPE_GLYPH_SLICES = 24;
+/** One rendered piece of a glyph: clipped to its own x-band, its own affine fit. */
+export interface EnvelopeGlyphSlice {
+    /** Left edge of this slice's clip rect, in the glyph's own (pre-transform) x. */
+    clipX0: number;
+    /** Right edge of this slice's clip rect, in the glyph's own (pre-transform) x. */
+    clipX1: number;
+    /** SVG `matrix(a b c d e f)` fit of the envelope mapping over this slice. */
+    transform: string;
+}
+/** The rectangle (layout units) an affine fit covers. */
+export interface GlyphFitBox {
+    x0: number;
+    x1: number;
+    y0: number;
+    y1: number;
+}
+/** A glyph's single-affine transform plus, when one affine is not enough, its slices. */
+export interface GlyphAffineFit {
+    transform: string;
+    slices?: EnvelopeGlyphSlice[];
+}
+/**
+ * Fit the envelope mapping over a glyph's ink `box`, slicing it into
+ * vertical bands when a single affine misses by more than the tolerance.
+ */
+export declare function fitGlyphEnvelopeAffine(warp: EnvelopeWarp, box: GlyphFitBox, shapeHeight?: number): GlyphAffineFit;
+//# sourceMappingURL=text-warp-glyph-slicing.d.ts.map

package/dist/pptx/render/text-warp-glyph-slicing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-glyph-slicing.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-glyph-slicing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,2EAA2E;AAC3E,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAe5C,oFAAoF;AACpF,MAAM,WAAW,kBAAkB;IAClC,iFAAiF;IACjF,MAAM,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,MAAM,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,yDAAyD;AACzD,MAAM,WAAW,WAAW;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACX;AAyED,yFAAyF;AACzF,MAAM,WAAW,cAAc;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,kBAAkB,EAAE,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,WAAW,EAChB,WAAW,SAAI,GACb,cAAc,CA4BhB"}

package/dist/pptx/render/text-warp-glyph-trace-contour.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Marching-squares iso-contouring of a coverage raster, for
+ * `text-warp-glyph-trace.ts`. Pure (no DOM): takes a `w` x `h` array of
+ * coverage values in `[0, 1]` (row-major, sampled at pixel centres) and
+ * returns closed rings at `level`, with edge crossings linearly interpolated
+ * for sub-pixel accuracy.
+ *
+ * Rings are oriented for the SVG `nonzero` fill rule: a ring nested inside
+ * an even number of other rings (an outer contour) winds one way, one nested
+ * inside an odd number (a counter, like the hole of an `o`) the other way.
+ */
+import type { OutlinePoint } from './text-warp-glyph-outline.js';
+/**
+ * Contour `values` at `level`. The outermost row/column are treated as
+ * below `level`, so every ring closes.
+ */
+export declare function contourRaster(values: Float32Array, w: number, h: number, level: number): OutlinePoint[][];
+//# sourceMappingURL=text-warp-glyph-trace-contour.d.ts.map

package/dist/pptx/render/text-warp-glyph-trace-contour.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-glyph-trace-contour.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-glyph-trace-contour.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AA0B9D;;;GAGG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,YAAY,EACpB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,GACX,YAAY,EAAE,EAAE,CAiIlB"}