text-shaper 0.1.1 → 0.1.3

package/dist/raster/blur.d.ts

@@ -5,16 +5,27 @@ import { type Bitmap } from "./types.ts";
 /**
  * Generate 1D Gaussian kernel
  * Uses Gaussian function: exp(-x²/(2σ²))
+ *
+ * @param radius Blur radius (sigma value)
+ * @returns Normalized Gaussian kernel weights
  */
 export declare function createGaussianKernel(radius: number): Float32Array;
 /**
  * Gaussian blur implementation using separable 2-pass algorithm
  * Modifies bitmap in-place and returns it
+ *
+ * @param bitmap Bitmap to blur (modified in-place)
+ * @param radius Blur radius in pixels
+ * @returns The same bitmap after blur is applied
  */
 export declare function gaussianBlur(bitmap: Bitmap, radius: number): Bitmap;
 /**
  * Box blur using running sum for O(1) per pixel
  * Modifies bitmap in-place and returns it
+ *
+ * @param bitmap Bitmap to blur (modified in-place)
+ * @param radius Blur radius in pixels
+ * @returns The same bitmap after blur is applied
  */
 export declare function boxBlur(bitmap: Bitmap, radius: number): Bitmap;
 /**

package/dist/raster/cascade-blur.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Cascade Blur Algorithm
+ *
+ * High-performance Gaussian blur for large radii using pyramid scaling.
+ *
+ * The key insight: to blur with large radius efficiently:
+ * 1. Scale down the image by factor of 2 (with smooth kernel)
+ * 2. Apply blur with smaller kernel on reduced image
+ * 3. Scale back up (with smooth kernel)
+ *
+ * The shrink/expand kernels [1, 5, 10, 10, 5, 1]/32 provide sufficient
+ * smoothness to maintain 8-bit precision through multiple cascade levels.
+ *
+ * Performance: O(n) per pixel regardless of blur radius
+ * Traditional Gaussian: O(r) per pixel where r is radius
+ */
+import { type Bitmap } from "./types.ts";
+/**
+ * Cascade Gaussian blur with asymmetric X/Y radii
+ * High-performance blur using pyramid scaling for large radii
+ * @param bitmap Input bitmap to blur
+ * @param radiusX Blur radius along X axis in pixels
+ * @param radiusY Blur radius along Y axis in pixels (defaults to radiusX)
+ * @returns New bitmap with blur applied (dimensions may change)
+ */
+export declare function cascadeBlur(bitmap: Bitmap, radiusX: number, radiusY?: number): Bitmap;
+/**
+ * Fast Gaussian blur using cascade algorithm
+ * This is the recommended blur function for large radii (> 3 pixels)
+ * @param bitmap Input bitmap to blur
+ * @param radius Blur radius in pixels
+ * @returns New bitmap with blur applied (dimensions may change)
+ */
+export declare function fastGaussianBlur(bitmap: Bitmap, radius: number): Bitmap;
+/**
+ * Adaptive blur that chooses the best algorithm based on radius
+ * For small radii (≤ 3): uses simple separable Gaussian (more precise)
+ * For large radii (> 3): uses cascade algorithm (faster)
+ * @param bitmap Input bitmap to blur
+ * @param radiusX Horizontal blur radius in pixels
+ * @param radiusY Vertical blur radius in pixels (defaults to radiusX)
+ * @returns Blurred bitmap using the optimal algorithm
+ */
+export declare function adaptiveBlur(bitmap: Bitmap, radiusX: number, radiusY?: number): Bitmap;

package/dist/raster/cell.d.ts

@@ -110,6 +110,30 @@ export declare class CellBuffer {
         y: number;
         cells: Cell[];
     }>;
+    /**
+     * Iterate scanlines directly without allocating cell arrays
+     * Returns first cell index for each row, caller walks linked list via pool
+     */
+    iterateScanlines(): Generator<{
+        y: number;
+        firstCellIndex: number;
+    }>;
+    /**
+     * Get the cell pool for direct access during sweep
+     */
+    getPool(): Cell[];
+    /**
+     * Get the null cell index (sentinel value)
+     */
+    getNullIndex(): number;
+    /**
+     * Get ycells array for direct iteration (avoids generator overhead)
+     */
+    getYCells(): number[];
+    /**
+     * Get band minimum Y for coordinate calculation
+     */
+    getBandMinY(): number;
     /**
      * Iterate cells for a single row (for band sweep)
      */

package/dist/raster/fixed-point.d.ts

@@ -57,7 +57,7 @@ export declare function upscale(x: number): number;
 export declare function downscale(x: number): number;
 /**
  * Multiply two fixed-point numbers and divide, avoiding overflow
- * Computes (a * b) / c with 64-bit intermediate precision
+ * Computes (a * b) / c with 64-bit intermediate precision when needed
  */
 export declare function mulDiv(a: number, b: number, c: number): number;
 /**

package/dist/raster/gradient.d.ts

@@ -48,14 +48,29 @@ export interface RadialGradient {
 export type Gradient = LinearGradient | RadialGradient;
 /**
  * Get color at position in gradient
+ *
+ * @param gradient Linear or radial gradient definition
+ * @param x X coordinate
+ * @param y Y coordinate
+ * @returns RGBA color at position (0-255 each)
  */
 export declare function interpolateGradient(gradient: Gradient, x: number, y: number): [number, number, number, number];
 /**
  * Create a bitmap filled with gradient (no path)
+ *
+ * @param width Width in pixels
+ * @param height Height in pixels
+ * @param gradient Linear or radial gradient definition
+ * @returns RGBA bitmap filled with gradient
  */
 export declare function createGradientBitmap(width: number, height: number, gradient: Gradient): Bitmap;
 /**
  * Rasterize path with gradient fill
  * First rasterizes path to get coverage mask, then fills with gradient
+ *
+ * @param path Glyph path to rasterize
+ * @param gradient Linear or radial gradient definition
+ * @param options Rasterization options (width, height, scale, etc.)
+ * @returns RGBA bitmap with gradient-filled path
  */
 export declare function rasterizePathWithGradient(path: GlyphPath, gradient: Gradient, options: RasterizeOptions): Bitmap;

package/dist/raster/gray-raster.d.ts

@@ -67,9 +67,15 @@ export declare class GrayRaster {
      */
     private mulDiv;
     /**
-     * Draw a quadratic Bezier curve using simple parametric sampling
+     * Draw a quadratic Bezier curve using adaptive subdivision
+     * Uses flatness test to minimize line segments at small font sizes
      */
     conicTo(cx: number, cy: number, toX: number, toY: number): void;
+    /**
+     * Recursive quadratic subdivision with flatness test
+     * Uses FreeType-style flatness: check if control point is within threshold of chord
+     */
+    private subdivConic;
     /**
      * Draw a cubic Bezier curve
      */

package/dist/raster/lcd-filter.d.ts

@@ -35,10 +35,25 @@ export declare enum LcdMode {
  * 1. Render at 3x horizontal resolution
  * 2. Apply FIR filter to reduce color fringing
  * 3. Output RGB values per pixel
+ *
+ * @param path Glyph path to rasterize
+ * @param width Width in pixels
+ * @param height Height in pixels
+ * @param scale Scale factor from font units to pixels
+ * @param offsetX X offset in pixels
+ * @param offsetY Y offset in pixels
+ * @param mode LCD subpixel mode (RGB, BGR, RGB_V, BGR_V)
+ * @param filterWeights FIR filter coefficients for reducing color fringing
+ * @returns Bitmap with LCD subpixel data (3 bytes per pixel)
  */
 export declare function rasterizeLcd(path: GlyphPath, width: number, height: number, scale: number, offsetX: number, offsetY: number, mode?: LcdMode, filterWeights?: number[]): Bitmap;
 /**
  * Convert LCD bitmap to RGBA for display
  * Uses gamma-corrected blending against a background color
+ *
+ * @param lcd LCD bitmap to convert
+ * @param bgColor Background color as RGB (0-255 each)
+ * @param fgColor Foreground color as RGB (0-255 each)
+ * @returns RGBA pixel array (4 bytes per pixel)
  */
 export declare function lcdToRGBA(lcd: Bitmap, bgColor?: [number, number, number], fgColor?: [number, number, number]): Uint8Array;

package/dist/raster/msdf.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Multi-channel Signed Distance Field (MSDF) rasterizer
+ *
+ * MSDF uses three channels (RGB) to encode distance information,
+ * allowing sharp corners to be preserved when scaling.
+ *
+ * Algorithm:
+ * 1. Decompose glyph outline into edges (lines, quadratics, cubics)
+ * 2. Color edges so adjacent edges at sharp corners have different colors
+ * 3. For each pixel, compute signed distance to nearest edge of each color
+ * 4. Store R, G, B distances in output bitmap
+ * 5. Shader reconstructs using: median(r, g, b)
+ *
+ * Reference: https://github.com/Chlumsky/msdfgen
+ */
+import type { Font } from "../font/font.ts";
+import type { GlyphPath } from "../render/path.ts";
+import { type Bitmap, type GlyphAtlas, type MsdfAtlasOptions } from "./types.ts";
+/**
+ * A 2D point
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Edge color channels for MSDF
+ * 0 = red, 1 = green, 2 = blue
+ */
+export type EdgeColor = 0 | 1 | 2;
+/**
+ * Bounding box for edge culling
+ */
+interface EdgeBounds {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+}
+/**
+ * An edge with color assignment and bounding box
+ */
+export type MsdfEdge = ({
+    type: "line";
+    p0: Point;
+    p1: Point;
+    color: EdgeColor;
+} & EdgeBounds) | ({
+    type: "quadratic";
+    p0: Point;
+    p1: Point;
+    p2: Point;
+    color: EdgeColor;
+} & EdgeBounds) | ({
+    type: "cubic";
+    p0: Point;
+    p1: Point;
+    p2: Point;
+    p3: Point;
+    color: EdgeColor;
+} & EdgeBounds);
+/**
+ * Signed distance result with parameter t
+ */
+export interface SignedDistanceResult {
+    distance: number;
+    t: number;
+}
+/**
+ * Options for MSDF rendering
+ */
+export interface MsdfOptions {
+    /** Width in pixels */
+    width: number;
+    /** Height in pixels */
+    height: number;
+    /** Scale factor (font units to pixels) */
+    scale: number;
+    /** X offset in pixels */
+    offsetX?: number;
+    /** Y offset in pixels */
+    offsetY?: number;
+    /** Flip Y axis (font coords are Y-up, bitmap is Y-down) */
+    flipY?: boolean;
+    /** Spread/radius - how far the distance field extends in pixels (default: 8) */
+    spread?: number;
+}
+/**
+ * Return the median of three numbers
+ */
+export declare function median(a: number, b: number, c: number): number;
+/**
+ * Compute signed distance from point to line segment
+ */
+export declare function signedDistanceToLine(px: number, py: number, p0: Point, p1: Point): SignedDistanceResult;
+/**
+ * Compute signed distance from point to quadratic bezier curve
+ * Uses Newton-Raphson iteration to find closest point
+ */
+export declare function signedDistanceToQuadratic(px: number, py: number, p0: Point, p1: Point, p2: Point): SignedDistanceResult;
+/**
+ * Compute signed distance from point to cubic bezier curve
+ * Uses Newton-Raphson iteration with multiple starting points
+ */
+export declare function signedDistanceToCubic(px: number, py: number, p0: Point, p1: Point, p2: Point, p3: Point): SignedDistanceResult;
+/**
+ * Assign colors to edges based on corner angles
+ * At sharp corners, adjacent edges get different colors
+ */
+export declare function assignEdgeColors(contours: MsdfEdge[][]): void;
+/**
+ * Render a glyph path as a multi-channel signed distance field
+ */
+export declare function renderMsdf(path: GlyphPath, options: MsdfOptions): Bitmap;
+/**
+ * Build an MSDF texture atlas from a set of glyphs
+ */
+export declare function buildMsdfAtlas(font: Font, glyphIds: number[], options: MsdfAtlasOptions): GlyphAtlas;
+/**
+ * Build MSDF atlas for ASCII printable characters (32-126)
+ */
+export declare function buildMsdfAsciiAtlas(font: Font, options: MsdfAtlasOptions): GlyphAtlas;
+/**
+ * Build MSDF atlas for a specific string (including all unique glyphs)
+ */
+export declare function buildMsdfStringAtlas(font: Font, text: string, options: MsdfAtlasOptions): GlyphAtlas;
+/**
+ * Export MSDF atlas as RGB texture data
+ */
+export declare function msdfAtlasToRGB(atlas: GlyphAtlas): Uint8Array;
+/**
+ * Export MSDF atlas as RGBA texture data
+ */
+export declare function msdfAtlasToRGBA(atlas: GlyphAtlas): Uint8Array;
+export {};

package/dist/raster/outline-decompose.d.ts

@@ -22,28 +22,28 @@ export interface ValidationResult {
 }
 /**
  * Validate a GlyphPath before rasterization (like FreeType's outline validation)
- *
- * Checks:
- * - Path is not null/undefined
- * - Commands array exists
- * - Path is not empty (unless allowEmpty is true)
- * - Command structure is valid
- * - Contours are properly closed (start with M, end with Z)
+ * Checks: path existence, command structure validity, and proper contour closure
+ * @param path Glyph path to validate
+ * @param allowEmpty Whether empty paths are considered valid (default: true)
+ * @returns Validation result with error code and optional message
  */
 export declare function validateOutline(path: GlyphPath | null | undefined, allowEmpty?: boolean): ValidationResult;
 /**
  * Convert a GlyphPath to rasterizer commands
- *
- * @param raster - The rasterizer instance
- * @param path - Path commands to decompose
- * @param scale - Scale factor (font units to pixels)
- * @param offsetX - X offset in pixels
- * @param offsetY - Y offset in pixels
- * @param flipY - Flip Y axis (font coords are Y-up)
+ * @param raster The rasterizer instance to receive commands
+ * @param path Path commands to decompose
+ * @param scale Scale factor (font units to pixels)
+ * @param offsetX X offset in pixels (default: 0)
+ * @param offsetY Y offset in pixels (default: 0)
+ * @param flipY Flip Y axis - font coords are Y-up, bitmap is Y-down (default: true)
  */
 export declare function decomposePath(raster: GrayRaster, path: GlyphPath, scale: number, offsetX?: number, offsetY?: number, flipY?: boolean): void;
 /**
  * Calculate bounding box of path in pixel coordinates
+ * @param path Glyph path to measure
+ * @param scale Scale factor (font units to pixels)
+ * @param flipY Flip Y axis for bitmap coordinates (default: true)
+ * @returns Bounding box in pixel coordinates, or null if path has no bounds
  */
 export declare function getPathBounds(path: GlyphPath, scale: number, flipY?: boolean): {
     minX: number;
@@ -53,9 +53,8 @@ export declare function getPathBounds(path: GlyphPath, scale: number, flipY?: bo
 } | null;
 /**
  * Get fill rule from outline flags (like FreeType's FT_OUTLINE_EVEN_ODD_FILL check)
- *
  * @param path Path with optional flags
- * @param defaultRule Default fill rule if flags not set
- * @returns Fill rule to use
+ * @param defaultRule Default fill rule if flags not set (default: NonZero)
+ * @returns Fill rule to use for rendering
  */
 export declare function getFillRuleFromFlags(path: GlyphPath | null | undefined, defaultRule?: FillRule): FillRule;

package/dist/raster/rasterize.d.ts

@@ -7,10 +7,18 @@ import type { GlyphId } from "../types.ts";
 import { type Bitmap, PixelMode, type RasterizedGlyph, type RasterizeOptions } from "./types.ts";
 /**
  * Rasterize a glyph path to a bitmap
+ * @param path Glyph path to rasterize
+ * @param options Rasterization options including dimensions, scale, and pixel mode
+ * @returns Rendered bitmap of the glyph
  */
 export declare function rasterizePath(path: GlyphPath, options: RasterizeOptions): Bitmap;
 /**
  * Rasterize a glyph from a font
+ * @param font Font containing the glyph
+ * @param glyphId ID of the glyph to rasterize
+ * @param fontSize Font size in pixels
+ * @param options Optional rendering settings (pixel mode, padding, hinting)
+ * @returns Rasterized glyph with bitmap and bearing information, or null if glyph is empty
  */
 export declare function rasterizeGlyph(font: Font, glyphId: GlyphId, fontSize: number, options?: {
     pixelMode?: PixelMode;
@@ -20,6 +28,11 @@ export declare function rasterizeGlyph(font: Font, glyphId: GlyphId, fontSize: n
 }): RasterizedGlyph | null;
 /**
  * Rasterize text string using shaped glyphs
+ * @param font Font to use for rendering
+ * @param text Text string to rasterize
+ * @param fontSize Font size in pixels
+ * @param options Optional rendering settings (pixel mode, padding)
+ * @returns Bitmap containing rendered text, or null if no glyphs
  */
 export declare function rasterizeText(font: Font, text: string, fontSize: number, options?: {
     pixelMode?: PixelMode;
@@ -27,17 +40,21 @@ export declare function rasterizeText(font: Font, text: string, fontSize: number
 }): Bitmap | null;
 /**
  * Export bitmap to raw RGBA pixels (for WebGL textures, etc.)
+ * @param bitmap Source bitmap to convert
+ * @returns RGBA pixel array (4 bytes per pixel)
  */
 export declare function bitmapToRGBA(bitmap: Bitmap): Uint8Array;
 /**
  * Export bitmap to grayscale array
+ * @param bitmap Source bitmap to convert
+ * @returns Grayscale pixel array (1 byte per pixel)
  */
 export declare function bitmapToGray(bitmap: Bitmap): Uint8Array;
 export { type BBox, evaluateCubic, evaluateQuadratic, getCubicExtrema, getExactBounds, getQuadraticExtrema, } from "./bbox.ts";
-export { blendBitmap, convertBitmap, copyBitmap, emboldenBitmap, resizeBitmap, } from "./bitmap-utils.ts";
+export { blendBitmap, convertBitmap, copyBitmap, emboldenBitmap, resizeBitmap, resizeBitmapBilinear, } from "./bitmap-utils.ts";
 export { blurBitmap, boxBlur, createGaussianKernel, gaussianBlur, } from "./blur.ts";
 export { type ColorStop, createGradientBitmap, type Gradient, interpolateGradient, type LinearGradient, type RadialGradient, rasterizePathWithGradient, } from "./gradient.ts";
 export { renderSdf, type SdfOptions } from "./sdf.ts";
 export { type LineCap, type LineJoin, type StrokerOptions, strokePath, } from "./stroker.ts";
 export { condensePath, emboldenPath, obliquePath, transformPath, } from "./synth.ts";
-export { type Bitmap, clearBitmap, createBitmap, FillRule, PixelMode, type RasterizedGlyph, type RasterizeOptions, type Span, } from "./types.ts";
+export { type Bitmap, clearBitmap, createBitmap, createBottomUpBitmap, FillRule, PixelMode, type RasterizedGlyph, type RasterizeOptions, type Span, } from "./types.ts";

package/dist/raster/sdf.d.ts

@@ -33,5 +33,8 @@ export interface SdfOptions {
 }
 /**
  * Render a glyph path as a signed distance field
+ * @param path Glyph path to render
+ * @param options SDF rendering options (dimensions, scale, spread)
+ * @returns Grayscale bitmap with signed distance field (128 = on edge, 255 = inside, 0 = outside)
  */
 export declare function renderSdf(path: GlyphPath, options: SdfOptions): Bitmap;

package/dist/raster/stroker.d.ts

@@ -25,5 +25,8 @@ export interface StrokerOptions {
 }
 /**
  * Stroke a glyph path, producing a new path that represents the stroked outline
+ * @param path Input glyph path to stroke
+ * @param options Stroke parameters (width, cap style, join style, miter limit)
+ * @returns New path representing the stroked outline that can be filled
  */
 export declare function strokePath(path: GlyphPath, options: StrokerOptions): GlyphPath;

package/dist/raster/types.d.ts

@@ -160,17 +160,41 @@ export interface AtlasOptions {
     /** Enable hinting */
     hinting?: boolean;
 }
+/**
+ * Options for building an MSDF atlas
+ */
+export interface MsdfAtlasOptions {
+    /** Font size in pixels (size of each glyph cell in the atlas) */
+    fontSize: number;
+    /** Padding between glyphs */
+    padding?: number;
+    /** Maximum atlas width */
+    maxWidth?: number;
+    /** Maximum atlas height */
+    maxHeight?: number;
+    /** SDF spread/radius in pixels (default: 4) */
+    spread?: number;
+}
 /**
  * Create an empty bitmap
+ * @param width Width in pixels
+ * @param height Height in pixels
+ * @param pixelMode Pixel format (default: Gray)
+ * @returns Empty bitmap with the specified dimensions and format
  */
 export declare function createBitmap(width: number, height: number, pixelMode?: PixelMode): Bitmap;
 /**
  * Clear a bitmap to zero
+ * @param bitmap Bitmap to clear
  */
 export declare function clearBitmap(bitmap: Bitmap): void;
 /**
  * Create a bottom-up bitmap (negative pitch)
  * Bottom-up bitmaps have row 0 at the bottom of the image,
  * which matches some graphics APIs (e.g., Windows DIB, OpenGL textures)
+ * @param width Width in pixels
+ * @param height Height in pixels
+ * @param pixelMode Pixel format (default: Gray)
+ * @returns Bottom-up bitmap with row 0 at the bottom
  */
 export declare function createBottomUpBitmap(width: number, height: number, pixelMode?: PixelMode): Bitmap;

package/dist/render/outline-transform.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Outline Transform Operations
+ *
+ * Provides geometric transformations for glyph outlines:
+ * - 90° rotation
+ * - Power-of-2 scaling
+ * - 2D affine transforms (translate, rotate, scale, shear)
+ * - 3D perspective transforms
+ * - Bounding box computation
+ */
+import type { GlyphPath } from "./path.ts";
+/**
+ * 2D affine transformation matrix [a, b, c, d, tx, ty]
+ * Transforms point (x, y) to:
+ *   x' = a*x + c*y + tx
+ *   y' = b*x + d*y + ty
+ */
+export type Matrix2D = [number, number, number, number, number, number];
+/**
+ * 3x3 transformation matrix for 2D homogeneous coordinates
+ * | m00 m01 m02 |   | x |   | x' |
+ * | m10 m11 m12 | × | y | = | y' |
+ * | m20 m21 m22 |   | 1 |   | w  |
+ *
+ * Final coordinates: (x'/w, y'/w)
+ */
+export type Matrix3x3 = [
+    [
+        number,
+        number,
+        number
+    ],
+    [
+        number,
+        number,
+        number
+    ],
+    [
+        number,
+        number,
+        number
+    ]
+];
+/**
+ * Axis-aligned bounding box
+ */
+export interface BoundingBox {
+    xMin: number;
+    yMin: number;
+    xMax: number;
+    yMax: number;
+}
+/**
+ * Control box (bounding box of control points, not tight bounds)
+ */
+export interface ControlBox extends BoundingBox {
+}
+/**
+ * Create identity 2D matrix
+ */
+export declare function identity2D(): Matrix2D;
+/**
+ * Create identity 3x3 matrix
+ */
+export declare function identity3x3(): Matrix3x3;
+/**
+ * Create translation matrix
+ */
+export declare function translate2D(tx: number, ty: number): Matrix2D;
+/**
+ * Create scale matrix
+ */
+export declare function scale2D(sx: number, sy: number): Matrix2D;
+/**
+ * Create rotation matrix (angle in radians)
+ */
+export declare function rotate2D(angle: number): Matrix2D;
+/**
+ * Create shear/skew matrix
+ */
+export declare function shear2D(shearX: number, shearY: number): Matrix2D;
+/**
+ * Multiply two 2D matrices: result = a × b
+ */
+export declare function multiply2D(a: Matrix2D, b: Matrix2D): Matrix2D;
+/**
+ * Multiply two 3x3 matrices: result = a × b
+ */
+export declare function multiply3x3(a: Matrix3x3, b: Matrix3x3): Matrix3x3;
+/**
+ * Transform a point using 2D matrix
+ */
+export declare function transformPoint2D(x: number, y: number, m: Matrix2D): {
+    x: number;
+    y: number;
+};
+/**
+ * Transform a point using 3x3 matrix (with perspective division)
+ */
+export declare function transformPoint3x3(x: number, y: number, m: Matrix3x3): {
+    x: number;
+    y: number;
+};
+/**
+ * Rotate outline by 90 degrees counter-clockwise around origin
+ * Optionally apply offset after rotation
+ */
+export declare function rotateOutline90(path: GlyphPath, offsetX?: number, offsetY?: number): GlyphPath;
+/**
+ * Scale outline by power of 2
+ * scaleOrdX/Y: shift amount (positive = enlarge, negative = shrink)
+ * e.g., scaleOrdX=1 means multiply x by 2, scaleOrdX=-1 means divide by 2
+ */
+export declare function scaleOutlinePow2(path: GlyphPath, scaleOrdX: number, scaleOrdY: number): GlyphPath;
+/**
+ * Apply 2D affine transformation to outline
+ */
+export declare function transformOutline2D(path: GlyphPath, m: Matrix2D): GlyphPath;
+/**
+ * Apply 3D perspective transformation to outline
+ * Uses homogeneous coordinates for perspective projection
+ */
+export declare function transformOutline3D(path: GlyphPath, m: Matrix3x3): GlyphPath;
+/**
+ * Compute control box (bounding box of all control points)
+ * This is faster than computing tight bounds but may be larger
+ */
+export declare function computeControlBox(path: GlyphPath): ControlBox;
+/**
+ * Compute tight bounding box (exact bounds considering curve extrema)
+ */
+export declare function computeTightBounds(path: GlyphPath): BoundingBox;
+/**
+ * Update control box with transformed outline
+ * Used for finding minimum X after 3D transform (like libass)
+ */
+export declare function updateMinTransformedX(path: GlyphPath, m: Matrix3x3, currentMinX: number): number;
+/**
+ * Translate outline by offset
+ */
+export declare function translateOutline(path: GlyphPath, dx: number, dy: number): GlyphPath;
+/**
+ * Scale outline uniformly
+ */
+export declare function scaleOutline(path: GlyphPath, sx: number, sy?: number): GlyphPath;
+/**
+ * Rotate outline by angle (in radians) around origin
+ */
+export declare function rotateOutline(path: GlyphPath, angle: number): GlyphPath;
+/**
+ * Apply italic/oblique shear to outline
+ * @param angle Italic angle in degrees (typically 12-15 for italic)
+ */
+export declare function italicizeOutline(path: GlyphPath, angle: number): GlyphPath;
+/**
+ * Create 3x3 perspective matrix
+ * @param vanishingPointX X coordinate of vanishing point
+ * @param vanishingPointY Y coordinate of vanishing point
+ * @param strength Perspective strength (0 = none, larger = more perspective)
+ */
+export declare function perspectiveMatrix(vanishingPointX: number, vanishingPointY: number, strength: number): Matrix3x3;
+/**
+ * Combine multiple paths into one
+ */
+export declare function combinePaths(paths: GlyphPath[]): GlyphPath;
+/**
+ * Clone a path
+ */
+export declare function clonePath(path: GlyphPath): GlyphPath;