ooxml-ui 0.30.1 → 1.0.0

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

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

@@ -0,0 +1,27 @@
+/**
+ * Glyph outlines traced from the browser's own rendering, for WordArt
+ * envelope glyphs whose font FILE is not obtainable (a system font with no
+ * embedded copy and no catalogue webfont). The glyph is drawn large on an
+ * offscreen canvas in exactly the CSS font an SVG `<text>` would use, and its
+ * coverage raster is contoured at 50% (marching squares with sub-pixel
+ * interpolation), so the result is the outline of the glyph the reader's
+ * browser actually renders - the same glyph the `<text>` fallback would show
+ * - and can be warped point by point like a parsed font outline.
+ *
+ * At {@link TRACE_SIZE_PX} the traced edge sits within a small fraction of a
+ * raster pixel of the true outline (under 0.1% of the em), far below what is
+ * visible after scaling back to slide size.
+ */
+import type { EnvelopeFontSpec } from './text-warp-envelope-types.js';
+import type { GlyphOutlineCommand } from './text-warp-glyph-outline.js';
+/** The font size glyphs are rasterised at for tracing. */
+export declare const TRACE_SIZE_PX = 512;
+/**
+ * The traced outline of `char` in `font`, positioned at `(x, y)` (baseline
+ * origin) and scaled to the font's size. Returns `undefined` when tracing is
+ * unavailable (no DOM canvas), `[]` for a glyph with no ink.
+ */
+export declare function traceGlyphOutlineCommands(char: string, font: EnvelopeFontSpec, x: number, y: number): GlyphOutlineCommand[] | undefined;
+/** Test hook: forget traced glyphs and the tracing canvas. */
+export declare function resetGlyphTraceCache(): void;
+//# sourceMappingURL=text-warp-glyph-trace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-glyph-trace.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-glyph-trace.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,mBAAmB,EAAgB,MAAM,2BAA2B,CAAC;AAGnF,0DAA0D;AAC1D,eAAO,MAAM,aAAa,MAAM,CAAC;AA4GjC;;;;GAIG;AACH,wBAAgB,yBAAyB,CACxC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,gBAAgB,EACtB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACP,mBAAmB,EAAE,GAAG,SAAS,CAwBnC;AAED,8DAA8D;AAC9D,wBAAgB,oBAAoB,IAAI,IAAI,CAG3C"}

package/dist/pptx/render/text-warp-opentype-parser.d.ts

@@ -0,0 +1,12 @@
+import type { Font } from 'opentype.js';
+export type OpenTypeFontParser = (buffer: ArrayBuffer) => Font;
+type OpenTypeModuleShape = {
+    parse?: OpenTypeFontParser;
+    default?: {
+        parse?: OpenTypeFontParser;
+    };
+};
+/** Resolve opentype.js as either its ESM namespace or its CommonJS default object. */
+export declare function parseOpenTypeFont(buffer: ArrayBuffer, module?: OpenTypeModuleShape): Font;
+export {};
+//# sourceMappingURL=text-warp-opentype-parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-opentype-parser.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-opentype-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAGxC,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;AAE/D,KAAK,mBAAmB,GAAG;IAC1B,KAAK,CAAC,EAAE,kBAAkB,CAAC;IAC3B,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,kBAAkB,CAAA;KAAE,CAAC;CACzC,CAAC;AAEF,sFAAsF;AACtF,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,WAAW,EACnB,MAAM,GAAE,mBAAsE,GAC5E,IAAI,CAMN"}

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

@@ -0,0 +1,86 @@
+/**
+ * Best-effort glyph-outline font source for `text-warp-glyph-outline.ts`.
+ *
+ * Parses actual font FILES (TrueType/CFF) with `opentype.js` so a WordArt
+ * envelope glyph can be warped as its real outline instead of an affine
+ * approximation of its bounding box (see that module's doc comment). Outlines
+ * are obtainable from two places, matching CLAUDE.md's Rule 2 "pure decision
+ * function" shape: this module only ever produces a `Font | undefined`
+ * lookup, never touches the DOM, and never decides how a binding renders.
+ *
+ *  - Embedded fonts (`PptxEmbeddedFont[]`): the deck's own loader already
+ *    holds the clear-text bytes in memory (see
+ *    `embedded-fonts.ts`'s `resolveEmbeddedFontClearBytes`), so parsing is
+ *    synchronous and needs no network round-trip.
+ *  - Catalogue webfonts (Google Fonts): the family's actual `.woff2` bytes
+ *    are fetched separately from the `<link rel=stylesheet>` each binding
+ *    already injects for on-screen text (see
+ *    `text-warp-outline-webfont-fetch.ts`), since the stylesheet alone
+ *    carries no usable glyph geometry.
+ *
+ * A font this cache cannot resolve (parse failure, unknown family, a webfont
+ * fetch still in flight, or a system font with no file the browser exposes at
+ * all) simply has no entry: {@link createGlyphOutlineLookup} then traces the
+ * glyph the browser renders instead (`text-warp-glyph-trace.ts`), and only
+ * without a DOM canvas does the layout fall back to an affine fit.
+ */
+import type { Font } from 'opentype.js';
+import type { PptxEmbeddedFont } from 'ooxml-core/pptx';
+import type { GlyphOutlineCommand } from './text-warp-glyph-outline.js';
+/**
+ * Caches parsed `opentype.js` fonts by `(family, bold, italic)`.
+ *
+ * A binding constructs one instance per loaded deck, calls
+ * {@link registerEmbeddedFonts} (synchronous) as soon as the deck's embedded
+ * fonts are known, optionally feeds it webfont bytes as they arrive via
+ * {@link registerFontBytes}, and passes `.get(...)` into
+ * `buildGlyphEnvelope`'s `getOutlineFont` option.
+ */
+export declare class GlyphOutlineFontCache {
+    private readonly fonts;
+    private readonly attempted;
+    /** The parsed font for `(family, bold, italic)`, or `undefined` if unavailable. */
+    get(family: string | undefined, bold: boolean | undefined, italic: boolean | undefined): Font | undefined;
+    /** True once this `(family, bold, italic)` has been looked up, whether or not it resolved. */
+    hasAttempted(family: string, bold: boolean, italic: boolean): boolean;
+    /**
+     * Synchronously parse every embedded font whose bytes are already
+     * resolvable, no network involved. Safe to call repeatedly (e.g. once per
+     * render) with the same list: already-resolved or already-failed entries
+     * are skipped.
+     */
+    registerEmbeddedFonts(fonts: readonly PptxEmbeddedFont[]): void;
+    /**
+     * Register raw bytes fetched separately for `(family, bold, italic)` (see
+     * `text-warp-outline-webfont-fetch.ts`). Returns whether parsing
+     * succeeded; a caller that owns re-rendering can use this to know whether
+     * a re-render is worth triggering.
+     */
+    registerFontBytes(family: string, bold: boolean, italic: boolean, bytes: Uint8Array): boolean;
+}
+/**
+ * Extract one glyph's outline commands from `font`, positioned at `(x, y)`
+ * (the glyph's own baseline origin, matching `EnvelopeGlyphPlacement.x`/`.y`)
+ * and scaled to `fontSizePx`.
+ *
+ * Returns `[]` for whitespace (no visible outline; still a resolvable
+ * result, distinct from "unobtainable") and `undefined` when `font` cannot
+ * shape `char` at all, so the caller falls back to the affine transform.
+ */
+export declare function extractGlyphOutlineCommands(font: Font, char: string, x: number, y: number, fontSizePx: number): GlyphOutlineCommand[] | undefined;
+/** A minimal font-spec shape, structurally compatible with `EnvelopeFontSpec`. */
+export interface GlyphOutlineCacheFontSpec {
+    fontFamily?: string;
+    fontSizePx?: number;
+    bold?: boolean;
+    italic?: boolean;
+}
+/**
+ * Build the `getGlyphOutline` callback `buildGlyphEnvelopeBlock` (in
+ * `text-warp-envelope-layout.ts`) accepts: looks up `cache` for the segment's
+ * resolved font and, if found, extracts that glyph's outline from the font
+ * file; otherwise traces the browser's own rendering of the glyph (see
+ * `text-warp-glyph-trace.ts`). `undefined` only without a DOM canvas.
+ */
+export declare function createGlyphOutlineLookup(cache: GlyphOutlineFontCache): (char: string, font: GlyphOutlineCacheFontSpec, x: number, y: number) => GlyphOutlineCommand[] | undefined;
+//# sourceMappingURL=text-warp-outline-font-cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-outline-font-cache.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-outline-font-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAIxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AA8BrE;;;;;;;;GAQG;AACH,qBAAa,qBAAqB;IACjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2B;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;IAE/C,mFAAmF;IACnF,GAAG,CACF,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,IAAI,EAAE,OAAO,GAAG,SAAS,EACzB,MAAM,EAAE,OAAO,GAAG,SAAS,GACzB,IAAI,GAAG,SAAS,CAKlB;IAED,8FAA8F;IAC9F,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAEpE;IAED;;;;;OAKG;IACH,qBAAqB,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAAG,IAAI,CAqB9D;IAED;;;;;OAKG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAY5F;CACD;AAKD;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAC1C,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,UAAU,EAAE,MAAM,GAChB,mBAAmB,EAAE,GAAG,SAAS,CA6BnC;AAED,kFAAkF;AAClF,MAAM,WAAW,yBAAyB;IACzC,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;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACvC,KAAK,EAAE,qBAAqB,GAC1B,CACF,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,yBAAyB,EAC/B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,KACL,mBAAmB,EAAE,GAAG,SAAS,CAerC"}

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

@@ -0,0 +1,17 @@
+/** `fetch`-shaped dependency, injected so this stays testable without a real network. */
+export type FetchLike = (url: string) => Promise<{
+    ok: boolean;
+    text: () => Promise<string>;
+    arrayBuffer: () => Promise<ArrayBuffer>;
+}>;
+/**
+ * Fetch the outline-ready bytes for `referencedFamily` (the family as
+ * referenced in the deck, e.g. "Calibri") at `cssHref` (the same href
+ * `resolveGoogleWebfontHref` built), resolving through the same
+ * canonical/metric-clone lookup `matchGoogleWebfontFragments` used to decide
+ * what the stylesheet actually serves.
+ *
+ * Returns `undefined` on any failure; never throws.
+ */
+export declare function fetchGoogleWebfontOutlineBytes(cssHref: string, referencedFamily: string, bold: boolean, italic: boolean, fetchImpl: FetchLike): Promise<Uint8Array | undefined>;
+//# sourceMappingURL=text-warp-outline-webfont-fetch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-outline-webfont-fetch.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-outline-webfont-fetch.ts"],"names":[],"mappings":"AAmFA,yFAAyF;AACzF,MAAM,MAAM,SAAS,GAAG,CACvB,GAAG,EAAE,MAAM,KACP,OAAO,CAAC;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAAC,WAAW,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAA;CAAE,CAAC,CAAC;AAEpG;;;;;;;;GAQG;AACH,wBAAsB,8BAA8B,CACnD,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,MAAM,EACxB,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,OAAO,EACf,SAAS,EAAE,SAAS,GAClB,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAyBjC"}

package/dist/pptx/render/text-warp-preset-definitions.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Spec-transcribed OOXML `prstTxWarp` guide formulas for the WordArt
+ * "envelope" preset family (inflate/deflate/can), used by
+ * `text-warp-preset-sampler.ts` to sample the real top/bottom paths instead
+ * of the reconstructed sine lobes in `text-warp-envelope-curves.ts`.
+ *
+ * Source: `presetTextWarpDefinitions.xml`, the same `avLst`/`gdLst`/`pathLst`
+ * table format ECMA-376 uses for preset *shapes* (`presetShapeDefinitions.xml`),
+ * but for text warps. The file itself is not reproduced in the free ECMA-376
+ * text; this transcription was sourced from LibreOffice's OOXML export table
+ * (`oox/source/export/presetTextWarpDefinitions.xml` in LibreOffice/core,
+ * https://github.com/LibreOffice/core), which LibreOffice uses to write
+ * spec-conformant `prstTxWarp` XML when exporting its own Fontwork shapes to
+ * `.pptx` - so its numbers must round-trip correctly through real PowerPoint,
+ * unlike LibreOffice's IMPORT-side mapping (which discards the formulas in
+ * favour of LibreOffice's own Fontwork geometry, and is what an earlier
+ * investigation of this gap found and mistook for "no free source exists").
+ * Guide names, formulas, and adjustment ranges below are copied verbatim.
+ *
+ * Each preset in `presetTextWarpDefinitions.xml` draws a `pathLst` of two or
+ * more (top, bottom) path pairs: single-lobe presets (inflate/deflate/can)
+ * define exactly one pair spanning the whole shape height; the two compound
+ * "Deflate Inflate[ Deflate]" presets define one flat full-height pair (the
+ * shape's own bounding-box edges, `y = t` and `y = b`) plus one curved pair
+ * PER STACKED TEXT ROW (their own name literally lists the per-row
+ * behaviour: "Deflate Inflate" = row 0 deflates, row 1 inflates). A single
+ * line of WordArt text only ever occupies row 0, so this module's `top`/
+ * `bottom` for a compound preset is path[0] (the flat top edge) and path[1]
+ * (row 0's curve) - confirmed empirically (2026-09-06) against PowerPoint
+ * COM screenshots: measuring the per-glyph ink-height ratio across a single
+ * line of `textDeflateInflateDeflate` text against the row-0-pair
+ * prediction gave a max ratio deviation of 0.036 (glyph height predicted to
+ * within ~4% of measured, across 16 glyph positions); the alternative
+ * "outermost internal pair" reading tried first (path[1] vs path[n-2],
+ * skipping the flat edges but spanning every row) was off by up to 0.63 (63%),
+ * i.e. clearly wrong. See `text-warp-preset-sampler.test.ts` for the fixture.
+ *
+ * Coordinates are guide names to be resolved (via `ooxml-core/pptx`'s
+ * `evaluateGuides`) against a normalised `w = h = 100000` box, matching the
+ * scale PowerPoint stores `adj` values in (`textStyle.textWarpAdj` is the
+ * raw, unscaled `val` from `a:avLst`), so the resolved guide values are
+ * already fractions of `h` in `0..100000` and only need dividing by 100000.
+ */
+import type { GeometryGuide } from 'ooxml-core/pptx';
+/** A single curve segment of a preset's top or bottom path, `x` always spanning `l..r`. */
+export type WarpCurveSegment = {
+    readonly type: 'line';
+    readonly startY: string;
+    readonly endY: string;
+} | {
+    readonly type: 'quad';
+    readonly startY: string;
+    readonly ctrlY: string;
+    readonly endY: string;
+} | {
+    readonly type: 'cubic';
+    readonly startY: string;
+    readonly ctrl1Y: string;
+    readonly ctrl2Y: string;
+    readonly endY: string;
+} | {
+    readonly type: 'arc';
+    readonly penX: string;
+    readonly penY: string;
+    readonly wR: string;
+    readonly hR: string;
+    readonly stAng: string;
+    readonly swAng: string;
+};
+/** One preset's transcribed guide list plus its top/bottom curve segments. */
+export interface WarpPresetDefinition {
+    readonly defaultAdj: number;
+    readonly gdLst: readonly GeometryGuide[];
+    readonly top: WarpCurveSegment;
+    readonly bottom: WarpCurveSegment;
+}
+/** Spec-transcribed definitions, keyed by `prstTxWarp` preset name. */
+export declare const WARP_PRESET_DEFINITIONS: Readonly<Record<string, WarpPresetDefinition>>;
+//# sourceMappingURL=text-warp-preset-definitions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-preset-definitions.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-preset-definitions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,2FAA2F;AAC3F,MAAM,MAAM,gBAAgB,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzE;IACA,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACrB,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACrB,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACtB,CAAC;AAEL,8EAA8E;AAC9E,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IACzC,QAAQ,CAAC,GAAG,EAAE,gBAAgB,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;CAClC;AAeD,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CA+IlF,CAAC"}

package/dist/pptx/render/text-warp-preset-sampler.d.ts

@@ -0,0 +1,15 @@
+/** Top/bottom envelope fractions (0..1 of box height) at horizontal position `u`. */
+export interface SampledWarpCurve {
+    top: number;
+    bottom: number;
+}
+/**
+ * Sample the spec-transcribed top/bottom curve for `preset` at normalised
+ * horizontal position `u` (0 = left edge, 1 = right edge). Returns
+ * `undefined` when `preset` has no transcribed definition (the caller should
+ * fall back to a reconstruction in that case).
+ */
+export declare function sampleWarpPresetCurve(preset: string, u: number, adj: number | undefined, adj2: number | undefined): SampledWarpCurve | undefined;
+/** Preset names with a spec-transcribed definition (exported for tests/tooling). */
+export declare function hasWarpPresetDefinition(preset: string): boolean;
+//# sourceMappingURL=text-warp-preset-sampler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-preset-sampler.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-preset-sampler.ts"],"names":[],"mappings":"AA6IA,qFAAqF;AACrF,MAAM,WAAW,gBAAgB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,MAAM,EACd,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,IAAI,EAAE,MAAM,GAAG,SAAS,GACtB,gBAAgB,GAAG,SAAS,CAe9B;AAED,oFAAoF;AACpF,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE/D"}

package/dist/pptx/render/text-warp-presets.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Text-warp (WordArt "Transform") inspector-gallery data: the full ordered list
+ * of OOXML warp presets with display labels, plus a miniature SVG preview-path
+ * generator used to draw each swatch. Framework-free pure data / geometry,
+ * consumed by every binding's text-warp gallery (React / Vue / Angular).
+ *
+ * This is the UI catalogue only; the runtime warp path/CSS-transform builders
+ * live in `text-warp.ts`.
+ */
+import type { PptxTextWarpPreset } from 'ooxml-core/pptx';
+/** All standard OOXML text warp presets with display labels. */
+export declare const TEXT_WARP_PRESETS: ReadonlyArray<{
+    value: PptxTextWarpPreset;
+    label: string;
+}>;
+/** Miniature SVG preview path for a warp preset (simplified visual hint). */
+export declare function warpPreviewPath(preset: PptxTextWarpPreset): string;
+//# sourceMappingURL=text-warp-presets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-warp-presets.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/text-warp-presets.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,gEAAgE;AAChE,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC;IAC7C,KAAK,EAAE,kBAAkB,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACd,CAwCA,CAAC;AAEF,6EAA6E;AAC7E,wBAAgB,eAAe,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAuElE"}