text-shaper 0.1.2 → 0.1.4

package/dist/layout/justify.d.ts

@@ -64,10 +64,16 @@ export interface JustifyAdjustment {
 }
 /**
  * Calculate current line width from glyph buffer
+ * @param buffer - The glyph buffer to measure
+ * @returns Total line width in font units (sum of all xAdvance values)
  */
 export declare function calculateLineWidth(buffer: GlyphBuffer): number;
 /**
  * Justify a shaped glyph buffer to fit a target width
+ * @param font - The font containing JSTF and glyph metrics
+ * @param buffer - The shaped glyph buffer to justify (modified in place)
+ * @param options - Justification options including target width and mode
+ * @returns Result containing success status, final width, and applied adjustments
  */
 export declare function justify(font: Font, buffer: GlyphBuffer, options: JustifyOptions): JustifyResult;
 /**
@@ -78,11 +84,18 @@ export interface LineBreakResult {
     breakPoints: number[];
 }
 /**
- * Break shaped text into lines at a given width
- * Uses simple greedy algorithm
+ * Break shaped text into lines at a given width using simple greedy algorithm
+ * @param buffer - The shaped glyph buffer to break into lines
+ * @param maxWidth - Maximum line width in font units
+ * @param spaceGlyph - Optional glyph ID of space character for word boundary detection
+ * @returns Object containing array of line buffers and break point indices
  */
 export declare function breakIntoLines(buffer: GlyphBuffer, maxWidth: number, spaceGlyph?: GlyphId): LineBreakResult;
 /**
  * Justify all lines in a paragraph to the same width
+ * @param font - The font containing JSTF and glyph metrics
+ * @param lines - Array of glyph buffers representing lines (modified in place)
+ * @param options - Justification options including target width and mode
+ * @returns Array of justification results, one per line
  */
 export declare function justifyParagraph(font: Font, lines: GlyphBuffer[], options: JustifyOptions): JustifyResult[];

package/dist/layout/structures/class-def.d.ts

@@ -1,15 +1,68 @@
 import type { Reader } from "../../font/binary/reader.ts";
-import type { GlyphId } from "../../types.ts";
-/** Class Definition table - maps glyph IDs to class values */
-export interface ClassDef {
-    /** Get class for a glyph ID (returns 0 if not defined) */
+import type { GlyphId, uint16 } from "../../types.ts";
+/** Class range record for Format 2 */
+interface ClassRangeRecord {
+    startGlyphId: GlyphId;
+    endGlyphId: GlyphId;
+    classValue: uint16;
+}
+/**
+ * Class Definition table - maps glyph IDs to class values.
+ *
+ * IMPORTANT: This is a unified class (not interface + implementations) to ensure
+ * monomorphic call sites in V8. Polymorphic calls can be 7-8x slower!
+ */
+export declare class ClassDef {
+    private readonly startGlyphId;
+    private readonly classValueArray;
+    private readonly ranges;
+    private readonly glyphMap;
+    private readonly isEmpty;
+    private constructor();
+    /**
+     * Create an empty ClassDef
+     * @returns Empty ClassDef instance where all glyphs return class 0
+     */
+    static empty(): ClassDef;
+    /**
+     * Create Format 1 ClassDef (array of class values)
+     * @param startGlyphId - First glyph ID in the range
+     * @param classValueArray - Array of class values indexed by (glyphId - startGlyphId)
+     * @returns ClassDef instance using array lookup
+     */
+    static format1(startGlyphId: GlyphId, classValueArray: Uint16Array): ClassDef;
+    /**
+     * Create Format 2 ClassDef (ranges)
+     * @param ranges - Array of range records mapping glyph ranges to class values
+     * @returns ClassDef instance using hash map (for small tables) or binary search (for large tables)
+     */
+    static format2(ranges: ClassRangeRecord[]): ClassDef;
+    /**
+     * Get class for a glyph ID
+     * @param glyphId - The glyph ID to look up
+     * @returns Class value for the glyph, or 0 if not defined
+     */
     get(glyphId: GlyphId): number;
-    /** Get all glyphs in a specific class */
+    /**
+     * Get all glyphs in a specific class
+     * @param classValue - The class value to search for
+     * @returns Array of all glyph IDs assigned to this class
+     */
     glyphsInClass(classValue: number): GlyphId[];
 }
-/** Singleton empty ClassDef */
+/** Singleton empty ClassDef for external use */
 export declare const EMPTY_CLASS_DEF: ClassDef;
-/** Parse a Class Definition table */
+/**
+ * Parse a Class Definition table from binary data
+ * @param reader - Binary reader positioned at class definition table start
+ * @returns Parsed ClassDef instance (Format 1 or Format 2)
+ */
 export declare function parseClassDef(reader: Reader): ClassDef;
-/** Parse ClassDef from offset, or return empty if offset is 0 */
+/**
+ * Parse ClassDef from offset, or return empty if offset is 0
+ * @param reader - Binary reader positioned at parent table
+ * @param offset - Offset from reader's current position to class definition table
+ * @returns Parsed ClassDef instance, or empty ClassDef if offset is 0
+ */
 export declare function parseClassDefAt(reader: Reader, offset: number): ClassDef;
+export {};

package/dist/layout/structures/coverage.d.ts

@@ -1,17 +1,64 @@
 import type { Reader } from "../../font/binary/reader.ts";
-import type { GlyphId } from "../../types.ts";
-/** Coverage table - maps glyph IDs to coverage indices */
-export interface Coverage {
-    /** Get coverage index for a glyph ID, or null if not covered */
+import type { GlyphId, uint16 } from "../../types.ts";
+/** Range record for Format 2 */
+interface RangeRecord {
+    startGlyphId: GlyphId;
+    endGlyphId: GlyphId;
+    startCoverageIndex: uint16;
+}
+/**
+ * Coverage table - maps glyph IDs to coverage indices.
+ *
+ * IMPORTANT: This is a unified class (not interface + implementations) to ensure
+ * monomorphic call sites in V8. Polymorphic calls can be 7-8x slower!
+ */
+export declare class Coverage {
+    private readonly glyphMap;
+    private readonly ranges;
+    private readonly glyphArray;
+    readonly size: number;
+    private constructor();
+    /**
+     * Create Format 1 coverage (individual glyphs)
+     * @param glyphArray - Array of glyph IDs to cover
+     * @returns Coverage instance using hash map for O(1) lookup
+     */
+    static format1(glyphArray: Uint16Array): Coverage;
+    /**
+     * Create Format 2 coverage (ranges)
+     * @param ranges - Array of range records defining covered glyph ranges
+     * @returns Coverage instance using binary search for range lookup
+     */
+    static format2(ranges: RangeRecord[]): Coverage;
+    /**
+     * Get coverage index for a glyph ID
+     * @param glyphId - The glyph ID to look up
+     * @returns Coverage index (0-based) if glyph is covered, null otherwise
+     */
     get(glyphId: GlyphId): number | null;
-    /** Check if glyph is covered */
+    /**
+     * Check if glyph is covered
+     * @param glyphId - The glyph ID to check
+     * @returns True if the glyph is in this coverage table
+     */
     covers(glyphId: GlyphId): boolean;
-    /** Get all covered glyph IDs */
+    /**
+     * Get all covered glyph IDs
+     * @returns Array of all glyph IDs in this coverage table
+     */
     glyphs(): GlyphId[];
-    /** Number of covered glyphs */
-    readonly size: number;
 }
-/** Parse a Coverage table */
+/**
+ * Parse a Coverage table from binary data
+ * @param reader - Binary reader positioned at coverage table start
+ * @returns Parsed coverage instance (Format 1 or Format 2)
+ */
 export declare function parseCoverage(reader: Reader): Coverage;
-/** Parse Coverage from offset (creates sub-reader) */
+/**
+ * Parse Coverage from offset (creates sub-reader)
+ * @param reader - Binary reader positioned at parent table
+ * @param offset - Offset from reader's current position to coverage table
+ * @returns Parsed coverage instance
+ */
 export declare function parseCoverageAt(reader: Reader, offset: number): Coverage;
+export {};

package/dist/layout/structures/device.d.ts

@@ -18,20 +18,38 @@ export interface VariationIndexTable {
 }
 /** Combined type - can be either Device or VariationIndex */
 export type DeviceOrVariationIndex = DeviceTable | VariationIndexTable;
-/** Check if this is a VariationIndex table */
+/**
+ * Check if this is a VariationIndex table
+ * @param table - The device or variation index table to check
+ * @returns True if the table is a VariationIndex table, false if it's a Device table
+ */
 export declare function isVariationIndexTable(table: DeviceOrVariationIndex): table is VariationIndexTable;
-/** Parse Device or VariationIndex table at offset */
+/**
+ * Parse Device or VariationIndex table at offset
+ * @param reader - Binary reader positioned at the parent table
+ * @param offset - Offset from reader's current position to the device table
+ * @returns Parsed device or variation index table, or null if offset is 0
+ */
 export declare function parseDeviceAt(reader: Reader, offset: number): DeviceOrVariationIndex | null;
-/** Parse Device or VariationIndex table */
+/**
+ * Parse Device or VariationIndex table
+ * @param reader - Binary reader positioned at the device table start
+ * @returns Parsed device or variation index table
+ */
 export declare function parseDevice(reader: Reader): DeviceOrVariationIndex;
 /**
  * Get delta adjustment for a specific PPEM size
- * Returns 0 if the size is outside the table's range
+ * @param device - The device table to query
+ * @param ppem - Pixels per em size to get delta for
+ * @returns Delta adjustment value, or 0 if PPEM is outside the table's range
  */
 export declare function getDeviceDelta(device: DeviceTable, ppem: number): int16;
 /**
  * Apply Device table adjustment to a value
- * For variable fonts, this would need ItemVariationStore lookup instead
+ * @param device - The device or variation index table, or null
+ * @param value - The base value to adjust
+ * @param ppem - Pixels per em size for device table lookup
+ * @returns Adjusted value (for Device tables) or unchanged value (for VariationIndex tables or null)
  */
 export declare function applyDeviceAdjustment(device: DeviceOrVariationIndex | null, value: number, ppem: number): number;
 /**
@@ -49,6 +67,9 @@ export interface ResolvedValueRecord {
 }
 /**
  * Apply all Device adjustments to a resolved value record
+ * @param record - The value record containing placement and advance values with device tables
+ * @param ppem - Pixels per em size for device table lookups
+ * @returns Object containing adjusted xPlacement, yPlacement, xAdvance, and yAdvance values
  */
 export declare function applyDeviceAdjustments(record: ResolvedValueRecord, ppem: number): {
     xPlacement: number;

package/dist/layout/structures/layout-common.d.ts

@@ -69,9 +69,24 @@ export declare function parseScriptList(reader: Reader): ScriptList;
 export declare function parseFeatureList(reader: Reader): FeatureList;
 /** Parse lookup headers (does not parse subtables) */
 export declare function parseLookupHeaders(reader: Reader): LookupHeader[];
-/** Find script in script list */
+/**
+ * Find script in script list by tag
+ * @param scriptList - The script list to search
+ * @param scriptTag - The script tag to find (e.g., 'latn', 'arab')
+ * @returns The script table if found, null otherwise
+ */
 export declare function findScript(scriptList: ScriptList, scriptTag: Tag): Script | null;
-/** Find language system in script */
+/**
+ * Find language system in script by tag
+ * @param script - The script table to search
+ * @param langSysTag - The language system tag to find (e.g., 'ENG', 'ARA'), or null for default
+ * @returns The language system table if found, or the default language system if langSysTag is null or not found
+ */
 export declare function findLangSys(script: Script, langSysTag: Tag | null): LangSys | null;
-/** Get feature by index */
+/**
+ * Get feature by index from feature list
+ * @param featureList - The feature list to retrieve from
+ * @param index - The zero-based feature index
+ * @returns The feature record at the specified index, or null if index is out of bounds
+ */
 export declare function getFeature(featureList: FeatureList, index: number): FeatureRecord | null;

package/dist/layout/structures/set-digest.d.ts

@@ -0,0 +1,59 @@
+import type { GlyphId } from "../../types.ts";
+import type { Coverage } from "./coverage.ts";
+/**
+ * Set Digest - A Bloom filter for fast O(1) glyph membership rejection.
+ *
+ * Uses three 64-bit masks with different bit shifts (0, 4, 9) to minimize
+ * false positives. This is the same technique used by HarfBuzz/rustybuzz.
+ *
+ * The digest allows us to quickly reject glyphs that are definitely NOT
+ * in a lookup's coverage without doing expensive Coverage table lookups.
+ */
+export declare class SetDigest {
+    private mask0;
+    private mask1;
+    private mask2;
+    /**
+     * Add a single glyph to the digest
+     * @param glyphId - The glyph ID to add
+     */
+    add(glyphId: GlyphId): void;
+    /**
+     * Add a range of glyphs to the digest
+     * @param start - Start glyph ID (inclusive)
+     * @param end - End glyph ID (inclusive)
+     */
+    addRange(start: GlyphId, end: GlyphId): void;
+    /**
+     * Fast check if glyph MAY be in the set
+     * @param glyphId - The glyph ID to check
+     * @returns False if glyph is definitely NOT in the set, true if glyph MAY be in the set (false positives possible)
+     */
+    mayHave(glyphId: GlyphId): boolean;
+    /**
+     * Add all glyphs from a Coverage table to this digest
+     * @param coverage - The coverage table containing glyphs to add
+     */
+    addCoverage(coverage: Coverage): void;
+    /**
+     * Check if this digest MAY intersect with another digest
+     * @param other - The other digest to check intersection with
+     * @returns False if there is definitely NO overlap, true if there MAY be overlap (false positives possible)
+     */
+    mayIntersect(other: SetDigest): boolean;
+    /**
+     * Get raw masks for external comparison
+     * @returns Object containing the three internal mask values
+     */
+    getMasks(): {
+        mask0: number;
+        mask1: number;
+        mask2: number;
+    };
+}
+/**
+ * Create a SetDigest from multiple Coverage tables (for a lookup with multiple subtables)
+ * @param coverages - Array of coverage tables to combine into a single digest
+ * @returns A new SetDigest containing all glyphs from all coverage tables
+ */
+export declare function createLookupDigest(coverages: Coverage[]): SetDigest;

package/dist/raster/asymmetric-stroke.d.ts

@@ -30,14 +30,11 @@ export interface AsymmetricStrokeOptions {
 }
 /**
  * Stroke a path with asymmetric X/Y borders
- *
+ * For filled text with border: combine outer outline with original fill,
+ * or use outer outline alone for hollow border effect
  * @param path Input path to stroke
  * @param options Stroke options including xBorder and yBorder
  * @returns Two paths: outer (positive offset) and inner (negative offset)
- *
- * For filled text with border:
- * - Combine outer outline with original fill
- * - Or use outer outline alone for hollow border effect
  */
 export declare function strokeAsymmetric(path: GlyphPath, options: AsymmetricStrokeOptions): {
     outer: GlyphPath;
@@ -46,10 +43,17 @@ export declare function strokeAsymmetric(path: GlyphPath, options: AsymmetricStr
 /**
  * Create a combined stroke path (both inner and outer as single path)
  * This creates a ring/donut shape that can be filled
+ * @param path Input path to stroke
+ * @param options Stroke options including xBorder and yBorder
+ * @returns Single path containing both outer and inner borders as a fillable ring
  */
 export declare function strokeAsymmetricCombined(path: GlyphPath, options: AsymmetricStrokeOptions): GlyphPath;
 /**
  * Stroke with uniform border (convenience function)
+ * @param path Input path to stroke
+ * @param border Border width in font units (applied to both X and Y)
+ * @param options Additional stroke options (precision, line join, miter limit)
+ * @returns Two paths: outer and inner borders
  */
 export declare function strokeUniform(path: GlyphPath, border: number, options?: Omit<AsymmetricStrokeOptions, "xBorder" | "yBorder">): {
     outer: GlyphPath;

package/dist/raster/bitmap-utils.d.ts

@@ -5,73 +5,140 @@ import { type Bitmap, PixelMode } from "./types.ts";
 /**
  * Embolden a bitmap by dilating pixel values
  * Makes text bolder by spreading coverage in x and y directions
+ * @param bitmap Source bitmap to embolden
+ * @param xStrength Horizontal dilation strength in pixels
+ * @param yStrength Vertical dilation strength in pixels
+ * @returns New bitmap with emboldened content
  */
 export declare function emboldenBitmap(bitmap: Bitmap, xStrength: number, yStrength: number): Bitmap;
 /**
  * Convert bitmap between pixel modes
+ * @param bitmap Source bitmap to convert
+ * @param targetMode Target pixel format
+ * @returns New bitmap in the target format
  */
 export declare function convertBitmap(bitmap: Bitmap, targetMode: PixelMode): Bitmap;
 /**
  * Alpha blend src bitmap onto dst bitmap at position (x, y)
+ * @param dst Destination bitmap to blend onto (modified in place)
+ * @param src Source bitmap to blend
+ * @param x X position in destination
+ * @param y Y position in destination
+ * @param opacity Blend opacity from 0 to 1
  */
 export declare function blendBitmap(dst: Bitmap, src: Bitmap, x: number, y: number, opacity: number): void;
 /**
  * Create a deep copy of a bitmap
+ * @param bitmap Bitmap to copy
+ * @returns New bitmap with copied data
  */
 export declare function copyBitmap(bitmap: Bitmap): Bitmap;
 /**
  * Resize bitmap using nearest-neighbor interpolation
+ * @param bitmap Source bitmap to resize
+ * @param newWidth Target width in pixels
+ * @param newHeight Target height in pixels
+ * @returns New bitmap resized to target dimensions
  */
 export declare function resizeBitmap(bitmap: Bitmap, newWidth: number, newHeight: number): Bitmap;
+/**
+ * Resize bitmap using bilinear interpolation
+ * Produces smoother results than nearest-neighbor, ideal for downsampling
+ * @param bitmap Source bitmap to resize
+ * @param newWidth Target width in pixels
+ * @param newHeight Target height in pixels
+ * @returns New bitmap resized with smooth interpolation
+ */
+export declare function resizeBitmapBilinear(bitmap: Bitmap, newWidth: number, newHeight: number): Bitmap;
 /**
  * Add two bitmaps together (additive blend)
  * Result: dst = clamp(dst + src, 0, 255)
  * Used for combining glyph with shadow/glow
+ * @param dst Destination bitmap (modified in place)
+ * @param src Source bitmap to add
+ * @param srcX X offset of source in destination (default: 0)
+ * @param srcY Y offset of source in destination (default: 0)
  */
 export declare function addBitmaps(dst: Bitmap, src: Bitmap, srcX?: number, srcY?: number): void;
 /**
  * Multiply two bitmaps (multiplicative blend)
  * Result: dst = (dst * src) / 255
  * Used for masking operations
+ * @param dst Destination bitmap (modified in place)
+ * @param src Source bitmap to multiply
+ * @param srcX X offset of source in destination (default: 0)
+ * @param srcY Y offset of source in destination (default: 0)
  */
 export declare function mulBitmaps(dst: Bitmap, src: Bitmap, srcX?: number, srcY?: number): void;
 /**
  * Subtract src from dst (subtractive blend)
  * Result: dst = clamp(dst - src, 0, 255)
  * Used for outline effects
+ * @param dst Destination bitmap (modified in place)
+ * @param src Source bitmap to subtract
+ * @param srcX X offset of source in destination (default: 0)
+ * @param srcY Y offset of source in destination (default: 0)
  */
 export declare function subBitmaps(dst: Bitmap, src: Bitmap, srcX?: number, srcY?: number): void;
 /**
  * Alpha composite src over dst using src as alpha
  * Result: dst = src + dst * (1 - src/255)
  * Standard Porter-Duff "over" operation
+ * @param dst Destination bitmap (modified in place)
+ * @param src Source bitmap to composite
+ * @param srcX X offset of source in destination (default: 0)
+ * @param srcY Y offset of source in destination (default: 0)
  */
 export declare function compositeBitmaps(dst: Bitmap, src: Bitmap, srcX?: number, srcY?: number): void;
 /**
  * Shift bitmap position by integer offset
  * Creates a new bitmap with the content shifted
+ * @param bitmap Source bitmap to shift
+ * @param shiftX Horizontal shift in pixels
+ * @param shiftY Vertical shift in pixels
+ * @returns New bitmap with shifted content
  */
 export declare function shiftBitmap(bitmap: Bitmap, shiftX: number, shiftY: number): Bitmap;
 /**
  * Fix outline bitmap by removing glyph interior
  * Used when you want only the border, not the filled shape
  * Result: outline = outline - glyph (where glyph coverage > threshold)
+ * @param outlineBitmap Outline bitmap to fix (modified in place)
+ * @param glyphBitmap Glyph bitmap containing filled shape
+ * @param glyphX X position of glyph in outline (default: 0)
+ * @param glyphY Y position of glyph in outline (default: 0)
+ * @param threshold Coverage threshold for removal (default: 128)
  */
 export declare function fixOutline(outlineBitmap: Bitmap, glyphBitmap: Bitmap, glyphX?: number, glyphY?: number, threshold?: number): void;
 /**
  * Maximum blend: take the maximum of two bitmaps
  * Result: dst = max(dst, src)
  * Used for combining multiple layers
+ * @param dst Destination bitmap (modified in place)
+ * @param src Source bitmap to compare
+ * @param srcX X offset of source in destination (default: 0)
+ * @param srcY Y offset of source in destination (default: 0)
  */
 export declare function maxBitmaps(dst: Bitmap, src: Bitmap, srcX?: number, srcY?: number): void;
 /**
  * Create a padded copy of a bitmap with extra space around edges
  * Useful before blur operations to prevent edge artifacts
+ * @param bitmap Source bitmap to pad
+ * @param padLeft Left padding in pixels
+ * @param padTop Top padding in pixels
+ * @param padRight Right padding in pixels
+ * @param padBottom Bottom padding in pixels
+ * @returns New bitmap with padding added
  */
 export declare function padBitmap(bitmap: Bitmap, padLeft: number, padTop: number, padRight: number, padBottom: number): Bitmap;
 /**
  * Create an expanded bitmap that can contain both dst and src
  * Returns the expanded bitmap and the offsets for both original bitmaps
+ * @param dst Destination bitmap
+ * @param src Source bitmap to fit
+ * @param srcX X position of source relative to destination
+ * @param srcY Y position of source relative to destination
+ * @returns Expanded bitmap and offset positions for both original bitmaps
  */
 export declare function expandToFit(dst: Bitmap, src: Bitmap, srcX: number, srcY: number): {
     expanded: Bitmap;

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

@@ -17,29 +17,28 @@
 import { type Bitmap } from "./types.ts";
 /**
  * Cascade Gaussian blur with asymmetric X/Y radii
- *
- * @param bitmap Input bitmap
- * @param radiusX Blur radius along X axis
- * @param radiusY Blur radius along Y axis (defaults to radiusX)
+ * 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
+ * @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
+ * 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
      */