text-shaper 0.1.1 → 0.1.3

package/dist/fluent/pipe.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Pipe-style functional utilities for composing transforms and rendering
+ *
+ * Provides an alternative to the builder pattern for users who prefer
+ * functional composition.
+ */
+import type { Font } from "../font/font.ts";
+import { type AsymmetricStrokeOptions } from "../raster/asymmetric-stroke.ts";
+import type { Gradient } from "../raster/gradient.ts";
+import { type MsdfOptions } from "../raster/msdf.ts";
+import { type SdfOptions } from "../raster/sdf.ts";
+import type { LineCap, LineJoin, StrokerOptions } from "../raster/stroker.ts";
+import type { Bitmap, PixelMode, RasterizeOptions } from "../raster/types.ts";
+import type { Matrix2D, Matrix3x3 } from "../render/outline-transform.ts";
+import type { GlyphPath } from "../render/path.ts";
+import type { GlyphId } from "../types.ts";
+/**
+ * Compose functions left-to-right
+ *
+ * @example
+ * ```typescript
+ * const result = pipe(
+ *   getGlyphPath(font, glyphId),
+ *   scale(2, 2),
+ *   rotate(Math.PI / 4),
+ *   rasterize({ width: 100, height: 100 }),
+ *   blur(5),
+ *   toRGBA
+ * );
+ * ```
+ */
+export declare function pipe<A>(a: A): A;
+export declare function pipe<A, B>(a: A, ab: (a: A) => B): B;
+export declare function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
+export declare function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
+export declare function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
+export declare function pipe<A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
+export declare function pipe<A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;
+export declare function pipe<A, B, C, D, E, F, G, H>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): H;
+/**
+ * Get glyph path from font (for use with pipe)
+ */
+export declare function fromGlyph(font: Font, glyphId: GlyphId): GlyphPath | null;
+/**
+ * Scale path uniformly or non-uniformly
+ */
+export declare function scale(sx: number, sy?: number): (path: GlyphPath) => GlyphPath;
+/**
+ * Translate path by offset
+ */
+export declare function translate(dx: number, dy: number): (path: GlyphPath) => GlyphPath;
+/**
+ * Rotate path by angle in radians
+ */
+export declare function rotate(angle: number): (path: GlyphPath) => GlyphPath;
+/**
+ * Rotate path by angle in degrees
+ */
+export declare function rotateDeg(angleDeg: number): (path: GlyphPath) => GlyphPath;
+/**
+ * Shear/skew path
+ */
+export declare function shear(shearX: number, shearY: number): (path: GlyphPath) => GlyphPath;
+/**
+ * Apply italic slant (angle in degrees)
+ */
+export declare function italic(angleDeg: number): (path: GlyphPath) => GlyphPath;
+/**
+ * Apply custom 2D affine matrix
+ */
+export declare function matrix(m: Matrix2D): (path: GlyphPath) => GlyphPath;
+/**
+ * Apply 3D perspective matrix
+ */
+export declare function perspective(m: Matrix3x3): (path: GlyphPath) => GlyphPath;
+/**
+ * Embolden path
+ */
+export declare function emboldenPath(strength: number): (path: GlyphPath) => GlyphPath;
+/**
+ * Condense/expand path horizontally
+ */
+export declare function condensePath(factor: number): (path: GlyphPath) => GlyphPath;
+/**
+ * Apply oblique/slant to path
+ */
+export declare function obliquePath(slant: number): (path: GlyphPath) => GlyphPath;
+/**
+ * Stroke path to create outline
+ */
+export declare function strokePath(options: StrokerOptions): (path: GlyphPath) => GlyphPath;
+export declare function strokePath(width: number, cap?: LineCap, join?: LineJoin): (path: GlyphPath) => GlyphPath;
+/**
+ * Clone path
+ */
+export declare function clone(): (path: GlyphPath) => GlyphPath;
+/**
+ * Combine multiple paths
+ */
+export declare function combinePaths(paths: GlyphPath[]): GlyphPath;
+/**
+ * Asymmetric stroke with independent X/Y border widths
+ */
+export declare function strokeAsymmetric(options: AsymmetricStrokeOptions): (path: GlyphPath) => {
+    outer: GlyphPath;
+    inner: GlyphPath;
+};
+/**
+ * Asymmetric stroke combined (both inner and outer as single fillable path)
+ */
+export declare function strokeAsymmetricCombined(options: AsymmetricStrokeOptions): (path: GlyphPath) => GlyphPath;
+/**
+ * Rasterize path to bitmap
+ */
+export declare function rasterize(options: RasterizeOptions): (path: GlyphPath) => Bitmap;
+/**
+ * Rasterize with auto-computed size from bounds
+ */
+export declare function rasterizeAuto(options?: {
+    padding?: number;
+    scale?: number;
+    pixelMode?: PixelMode;
+}): (path: GlyphPath) => Bitmap;
+/**
+ * Rasterize with gradient fill
+ */
+export declare function rasterizeWithGradient(gradient: Gradient, options: RasterizeOptions): (path: GlyphPath) => Bitmap;
+/**
+ * Render path as Signed Distance Field
+ */
+export declare function renderSdf(options: SdfOptions): (path: GlyphPath) => Bitmap;
+/**
+ * Render path as Multi-channel Signed Distance Field
+ */
+export declare function renderMsdf(options: MsdfOptions): (path: GlyphPath) => Bitmap;
+/**
+ * Gaussian blur bitmap
+ */
+export declare function blur(radius: number): (bitmap: Bitmap) => Bitmap;
+/**
+ * Box blur bitmap
+ */
+export declare function boxBlur(radius: number): (bitmap: Bitmap) => Bitmap;
+/**
+ * Cascade blur (fast for large radii)
+ */
+export declare function cascadeBlur(radiusX: number, radiusY?: number): (bitmap: Bitmap) => Bitmap;
+/**
+ * Adaptive blur (auto-selects best algorithm)
+ */
+export declare function adaptiveBlur(radiusX: number, radiusY?: number): (bitmap: Bitmap) => Bitmap;
+/**
+ * Fast Gaussian blur using cascade algorithm
+ * Recommended for large radii (> 3 pixels)
+ */
+export declare function fastBlur(radius: number): (bitmap: Bitmap) => Bitmap;
+/**
+ * Embolden bitmap operator
+ */
+export declare function embolden(xStrength: number, yStrength?: number): (bitmap: Bitmap) => Bitmap;
+/**
+ * Shift bitmap position
+ */
+export declare function shift(dx: number, dy: number): (bitmap: Bitmap) => Bitmap;
+/**
+ * Resize bitmap with nearest-neighbor
+ */
+export declare function resize(width: number, height: number): (bitmap: Bitmap) => Bitmap;
+/**
+ * Resize bitmap with bilinear interpolation
+ */
+export declare function resizeBilinear(width: number, height: number): (bitmap: Bitmap) => Bitmap;
+/**
+ * Pad bitmap
+ */
+export declare function pad(left: number, top: number, right: number, bottom: number): (bitmap: Bitmap) => Bitmap;
+export declare function pad(all: number): (bitmap: Bitmap) => Bitmap;
+/**
+ * Convert bitmap to different pixel mode
+ */
+export declare function convert(targetMode: PixelMode): (bitmap: Bitmap) => Bitmap;
+/**
+ * Convert bitmap to RGBA array
+ */
+export declare function toRGBA(bitmap: Bitmap): Uint8Array;
+/**
+ * Convert bitmap to grayscale array
+ */
+export declare function toGray(bitmap: Bitmap): Uint8Array;
+/**
+ * Convert path to SVG string
+ */
+export declare function toSVG(options?: {
+    flipY?: boolean;
+    scale?: number;
+}): (path: GlyphPath) => string;
+/**
+ * Copy bitmap
+ */
+export declare function copy(bitmap: Bitmap): Bitmap;

package/dist/fluent/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Shared types for the fluent API
+ */
+import type { FillRule, PixelMode } from "../raster/types.ts";
+import type { Matrix2D, Matrix3x3 } from "../render/outline-transform.ts";
+/**
+ * Accumulated transform state for lazy evaluation
+ */
+export interface TransformState {
+    /** 2D affine transform matrix */
+    matrix2D: Matrix2D;
+    /** 3D perspective matrix (takes precedence over matrix2D if set) */
+    matrix3D: Matrix3x3 | null;
+}
+/**
+ * Options for rasterization
+ */
+export interface RasterOptions {
+    /** Bitmap width in pixels */
+    width?: number;
+    /** Bitmap height in pixels */
+    height?: number;
+    /** Scale factor applied during rasterization */
+    scale?: number;
+    /** X offset for rasterization */
+    offsetX?: number;
+    /** Y offset for rasterization */
+    offsetY?: number;
+    /** Padding around the glyph */
+    padding?: number;
+    /** Pixel mode (Gray, Mono, LCD, etc.) */
+    pixelMode?: PixelMode;
+    /** Fill rule for path filling */
+    fillRule?: FillRule;
+    /** Flip Y axis (default true for screen coordinates) */
+    flipY?: boolean;
+}
+/**
+ * Options for auto-sized rasterization
+ */
+export interface AutoRasterOptions {
+    /** Padding around the glyph (default: 1) */
+    padding?: number;
+    /** Scale factor (default: 1) */
+    scale?: number;
+    /** Pixel mode (default: Gray) */
+    pixelMode?: PixelMode;
+    /** Fill rule (default: NonZero) */
+    fillRule?: FillRule;
+    /** Flip Y axis (default: true) */
+    flipY?: boolean;
+}
+/**
+ * Options for SVG output
+ */
+export interface SVGOptions {
+    /** Flip Y axis (default: true) */
+    flipY?: boolean;
+    /** Scale factor */
+    scale?: number;
+}
+/**
+ * Options for SVG element output
+ */
+export interface SVGElementOptions {
+    /** Font size for scaling */
+    fontSize?: number;
+    /** Fill color */
+    fill?: string;
+    /** Stroke color */
+    stroke?: string;
+    /** Stroke width */
+    strokeWidth?: number;
+}
+/**
+ * Options for canvas rendering
+ */
+export interface CanvasOptions {
+    /** Flip Y axis (default: true) */
+    flipY?: boolean;
+    /** Scale factor */
+    scale?: number;
+    /** X offset */
+    offsetX?: number;
+    /** Y offset */
+    offsetY?: number;
+    /** Fill color (set to "none" to skip fill) */
+    fill?: string;
+    /** Stroke color */
+    stroke?: string;
+    /** Stroke width */
+    strokeWidth?: number;
+}

package/dist/font/face.d.ts

@@ -11,6 +11,8 @@ export declare class Face {
     private _coords;
     /** User-space axis values */
     private _variations;
+    /** Cached advance width deltas for variable fonts (glyphId -> delta) */
+    private _advanceDeltas;
     constructor(font: Font, variations?: Record<string, number> | Variation[]);
     /**
      * Set variation axis values

package/dist/font/font.d.ts

@@ -198,6 +198,20 @@ export declare class Font {
         xMax: number;
         yMax: number;
     } | null;
+    /**
+     * Get contours and bounds for a glyph in a single operation.
+     * More efficient than calling getGlyphContours + getGlyphBounds separately
+     * as it only parses the glyph once.
+     */
+    getGlyphContoursAndBounds(glyphId: GlyphId): {
+        contours: Contour[];
+        bounds: {
+            xMin: number;
+            yMin: number;
+            xMax: number;
+            yMax: number;
+        } | null;
+    } | null;
     /** Get contours for a glyph with variation applied */
     getGlyphContoursWithVariation(glyphId: GlyphId, axisCoords: number[]): Contour[] | null;
 }

package/dist/font/tables/cff.d.ts

@@ -88,7 +88,9 @@ export interface FDSelect {
     select: (glyphId: number) => number;
 }
 /**
- * Parse CFF table
+ * Parse CFF table - Compact Font Format for PostScript outlines
+ * @param reader - Reader positioned at start of CFF table
+ * @returns Parsed CFF table with CharStrings, DICTs, and subroutines
  */
 export declare function parseCff(reader: Reader): CffTable;
 /**

package/dist/font/tables/colr.d.ts

@@ -245,7 +245,10 @@ export interface VarColorStop extends ColorStop {
     varIndexBase?: number;
 }
 /**
- * Parse COLR table
+ * Parse COLR table - color glyph definitions with layered or gradient fills
+ * Supports both v0 (simple layers) and v1 (advanced paint operations)
+ * @param reader - Reader positioned at start of COLR table
+ * @returns Parsed COLR table with color layer and paint definitions
  */
 export declare function parseColr(reader: Reader): ColrTable;
 /**

package/dist/font/tables/fvar.d.ts

@@ -56,7 +56,9 @@ export declare const AxisTags: {
     readonly opsz: 1869640570;
 };
 /**
- * Parse fvar table
+ * Parse fvar table - font variations defining axes and named instances
+ * @param reader - Reader positioned at start of fvar table
+ * @returns Parsed fvar table with variation axes and instances
  */
 export declare function parseFvar(reader: Reader): FvarTable;
 /**

package/dist/font/tables/glyf.d.ts

@@ -97,6 +97,19 @@ export declare function flattenCompositeGlyph(glyf: GlyfTable, loca: LocaTable,
  * Get all contours for a glyph, flattening composites
  */
 export declare function getGlyphContours(glyf: GlyfTable, loca: LocaTable, glyphId: GlyphId): Contour[];
+/**
+ * Get contours and bounds for a glyph in one parse operation.
+ * More efficient than calling getGlyphContours + getGlyphBounds separately.
+ */
+export declare function getGlyphContoursAndBounds(glyf: GlyfTable, loca: LocaTable, glyphId: GlyphId): {
+    contours: Contour[];
+    bounds: {
+        xMin: number;
+        yMin: number;
+        xMax: number;
+        yMax: number;
+    } | null;
+};
 /**
  * Get bounding box for a glyph
  */

package/dist/font/tables/gpos.d.ts

@@ -2,7 +2,8 @@ import { type ClassDef } from "../../layout/structures/class-def.ts";
 import { type Coverage } from "../../layout/structures/coverage.ts";
 import { type DeviceOrVariationIndex } from "../../layout/structures/device.ts";
 import { type FeatureList, type ScriptList } from "../../layout/structures/layout-common.ts";
-import type { GlyphId, int16, uint16 } from "../../types.ts";
+import { SetDigest } from "../../layout/structures/set-digest.ts";
+import type { GlyphId, GlyphPosition, int16, uint16 } from "../../types.ts";
 import type { Reader } from "../binary/reader.ts";
 import { type ChainingContextPosLookup, type ContextPosLookup } from "./gpos-contextual.ts";
 import { type CursivePosSubtable, type MarkBasePosSubtable, type MarkLigaturePosSubtable, type MarkMarkPosSubtable } from "./gpos-mark.ts";
@@ -45,6 +46,8 @@ export interface GposLookup {
     type: GposLookupType;
     flag: uint16;
     markFilteringSet?: uint16;
+    /** Bloom filter for fast O(1) glyph rejection */
+    digest: SetDigest;
 }
 /** Single adjustment lookup (Type 1) */
 export interface SinglePosLookup extends GposLookup {
@@ -135,3 +138,8 @@ export declare function getKerning(lookup: PairPosLookup, firstGlyph: GlyphId, s
     xAdvance1: number;
     xAdvance2: number;
 } | null;
+/**
+ * Apply kerning directly to positions, avoiding object allocation.
+ * Returns true if kerning was applied, false otherwise.
+ */
+export declare function applyKerningDirect(lookup: PairPosLookup, firstGlyph: GlyphId, secondGlyph: GlyphId, pos1: GlyphPosition, pos2: GlyphPosition): boolean;

package/dist/font/tables/gsub.d.ts

@@ -1,5 +1,6 @@
 import { type Coverage } from "../../layout/structures/coverage.ts";
 import { type FeatureList, type ScriptList } from "../../layout/structures/layout-common.ts";
+import { SetDigest } from "../../layout/structures/set-digest.ts";
 import type { GlyphId, uint16 } from "../../types.ts";
 import type { Reader } from "../binary/reader.ts";
 import { type ChainingContextSubstSubtable, type ContextSubstSubtable } from "./gsub-contextual.ts";
@@ -19,6 +20,8 @@ export interface GsubLookup {
     type: GsubLookupType;
     flag: uint16;
     markFilteringSet?: uint16;
+    /** Bloom filter for fast O(1) glyph rejection */
+    digest: SetDigest;
 }
 /** Single substitution lookup (Type 1) */
 export interface SingleSubstLookup extends GsubLookup {
@@ -105,3 +108,11 @@ export declare function applyLigatureSubst(lookup: LigatureSubstLookup, glyphIds
     ligatureGlyph: GlyphId;
     consumed: number;
 } | null;
+/**
+ * Apply ligature substitution using a Uint16Array directly (avoids Array.from allocation).
+ * glyphIds is a pre-allocated typed array, matchLen is the valid length to consider.
+ */
+export declare function applyLigatureSubstDirect(lookup: LigatureSubstLookup, glyphIds: Uint16Array, matchLen: number, startIndex: number): {
+    ligatureGlyph: GlyphId;
+    consumed: number;
+} | null;

package/dist/font/tables/gvar.d.ts

@@ -39,7 +39,10 @@ export interface PointDelta {
     y: int16;
 }
 /**
- * Parse gvar table
+ * Parse gvar table - glyph variations for TrueType outlines in variable fonts
+ * @param reader - Reader positioned at start of gvar table
+ * @param _numGlyphs - Number of glyphs (currently unused)
+ * @returns Parsed gvar table with per-glyph variation data
  */
 export declare function parseGvar(reader: Reader, _numGlyphs: number): GvarTable;
 /**
@@ -48,6 +51,12 @@ export declare function parseGvar(reader: Reader, _numGlyphs: number): GvarTable
 export declare function parsePackedDeltas(reader: Reader, count: number): number[];
 /**
  * Calculate the scalar for a tuple given axis coordinates
+ * Determines how much a variation tuple contributes based on current axis values
+ * @param peakTuple - Peak coordinates for each axis where variation is at maximum
+ * @param axisCoords - Current normalized axis coordinates
+ * @param intermediateStart - Start of intermediate region (null if not used)
+ * @param intermediateEnd - End of intermediate region (null if not used)
+ * @returns Scalar value between 0 and 1 indicating variation contribution
  */
 export declare function calculateTupleScalar(peakTuple: number[], axisCoords: number[], intermediateStart: number[] | null, intermediateEnd: number[] | null): number;
 /**

package/dist/font/tables/head.d.ts

@@ -44,4 +44,9 @@ export declare const MacStyle: {
     readonly Condensed: 32;
     readonly Extended: 64;
 };
+/**
+ * Parse head table - font header with global metrics
+ * @param reader - Reader positioned at start of head table
+ * @returns Parsed head table
+ */
 export declare function parseHead(reader: Reader): HeadTable;

package/dist/font/tables/hhea.d.ts

@@ -21,4 +21,9 @@ export interface HheaTable {
     metricDataFormat: int16;
     numberOfHMetrics: uint16;
 }
+/**
+ * Parse hhea table - horizontal header with metrics for horizontal layout
+ * @param reader - Reader positioned at start of hhea table
+ * @returns Parsed hhea table
+ */
 export declare function parseHhea(reader: Reader): HheaTable;

package/dist/font/tables/loca.d.ts

@@ -20,6 +20,9 @@ export declare function parseLoca(reader: Reader, numGlyphs: number, indexToLocF
 /**
  * Get byte offset and length for a glyph in the glyf table
  * Returns null if glyph has no outline (empty glyph)
+ * @param loca - Parsed loca table
+ * @param glyphId - Glyph ID to look up
+ * @returns Object with offset and length, or null if glyph has no outline
  */
 export declare function getGlyphLocation(loca: LocaTable, glyphId: GlyphId): {
     offset: uint32;

package/dist/font/tables/maxp.d.ts

@@ -24,4 +24,9 @@ export interface MaxpTable10 {
     maxComponentDepth: uint16;
 }
 export type MaxpTable = MaxpTable05 | MaxpTable10;
+/**
+ * Parse maxp table - maximum profile with glyph count and limits
+ * @param reader - Reader positioned at start of maxp table
+ * @returns Parsed maxp table (version 0.5 for CFF or 1.0 for TrueType)
+ */
 export declare function parseMaxp(reader: Reader): MaxpTable;

package/dist/font/tables/name.d.ts

@@ -60,6 +60,11 @@ export interface NameTable {
     format: uint16;
     records: NameRecord[];
 }
+/**
+ * Parse name table - font naming information in multiple languages
+ * @param reader - Reader positioned at start of name table
+ * @returns Parsed name table with decoded name records
+ */
 export declare function parseName(reader: Reader): NameTable;
 /** Get a specific name by ID, preferring Windows Unicode */
 export declare function getNameById(table: NameTable, nameId: number, languageId?: number): string | null;

package/dist/font/tables/os2.d.ts

@@ -91,6 +91,11 @@ export declare const FsType: {
     readonly NoSubsetting: 256;
     readonly BitmapOnly: 512;
 };
+/**
+ * Parse OS/2 table - Windows-specific metrics, weight, width, and classification
+ * @param reader - Reader positioned at start of OS/2 table
+ * @returns Parsed OS/2 table
+ */
 export declare function parseOs2(reader: Reader): Os2Table;
 /** Check if font is italic */
 export declare function isItalic(os2: Os2Table): boolean;

package/dist/font/tables/post.d.ts

@@ -18,6 +18,11 @@ export interface PostTable {
     glyphNameIndex?: uint16[];
     names?: string[];
 }
+/**
+ * Parse post table - PostScript information including glyph names
+ * @param reader - Reader positioned at start of post table
+ * @returns Parsed post table
+ */
 export declare function parsePost(reader: Reader): PostTable;
 /** Get glyph name by glyph ID */
 export declare function getGlyphName(post: PostTable, glyphId: number): string | null;

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { processContextual, processInsertion, processLigature, processRearrangement, } from "./aat/state-machine.ts";
 export { GlyphBuffer } from "./buffer/glyph-buffer.ts";
 export { UnicodeBuffer } from "./buffer/unicode-buffer.ts";
+export { adaptiveBlur as $adaptiveBlur, BitmapBuilder, bitmap, blur as $blur, boxBlur as $boxBlur, cascadeBlur as $cascadeBlur, char, clone as $clone, combine, combinePaths as $combinePaths, condensePath as $condensePath, convert as $convert, copy as $copy, embolden as $embolden, emboldenPath as $emboldenPath, fastBlur as $fastBlur, fromGlyph as $fromGlyph, glyph, glyphVar, italic as $italic, matrix as $matrix, obliquePath as $obliquePath, PathBuilder, pad as $pad, path, perspective as $perspective, pipe, rasterize as $rasterize, rasterizeAuto as $rasterizeAuto, rasterizeWithGradient as $rasterizeWithGradient, renderMsdf as $renderMsdf, renderSdf as $renderSdf, resize as $resize, resizeBilinear as $resizeBilinear, rotate as $rotate, rotateDeg as $rotateDeg, scale as $scale, shear as $shear, shift as $shift, strokeAsymmetric as $strokeAsymmetric, strokeAsymmetricCombined as $strokeAsymmetricCombined, strokePath as $strokePath, toGray as $toGray, toRGBA as $toRGBA, toSVG as $toSVG, translate as $translate, } from "./fluent/index.ts";
+export type { AutoRasterOptions, CanvasOptions, RasterOptions, SVGElementOptions, SVGOptions, TransformState, } from "./fluent/types.ts";
 export { Reader } from "./font/binary/reader.ts";
 export { createFace, Face } from "./font/face.ts";
 export { Font, type FontLoadOptions } from "./font/font.ts";
@@ -63,22 +65,27 @@ export type { DeviceOrVariationIndex, DeviceTable, VariationIndexTable, } from "
 export { applyDeviceAdjustment, getDeviceDelta, isVariationIndexTable, } from "./layout/structures/device.ts";
 export type { Condition, ConditionSet, FeatureVariationRecord, FeatureVariations, } from "./layout/structures/feature-variations.ts";
 export { applyFeatureVariations, evaluateConditionSet, findMatchingFeatureVariation, getSubstitutedLookups, } from "./layout/structures/feature-variations.ts";
+export { type AsymmetricStrokeOptions, strokeAsymmetric, strokeAsymmetricCombined, strokeUniform, } from "./raster/asymmetric-stroke.ts";
+export { atlasToAlpha, atlasToRGBA, buildAsciiAtlas, buildAtlas, buildStringAtlas, getGlyphUV, } from "./raster/atlas.ts";
 export { getExactBounds } from "./raster/bbox.ts";
-export { blendBitmap, convertBitmap, copyBitmap, emboldenBitmap, resizeBitmap, } from "./raster/bitmap-utils.ts";
+export { addBitmaps, blendBitmap, compositeBitmaps, convertBitmap, copyBitmap, emboldenBitmap, expandToFit, fixOutline, maxBitmaps, mulBitmaps, padBitmap, resizeBitmap, resizeBitmapBilinear, shiftBitmap, subBitmaps, } from "./raster/bitmap-utils.ts";
 export { blurBitmap, boxBlur, createGaussianKernel, gaussianBlur, } from "./raster/blur.ts";
+export { adaptiveBlur, cascadeBlur, fastGaussianBlur, } from "./raster/cascade-blur.ts";
 export { type ColorStop as GradientColorStop, createGradientBitmap, type Gradient, interpolateGradient, type LinearGradient, type RadialGradient, rasterizePathWithGradient, } from "./raster/gradient.ts";
+export { assignEdgeColors, buildMsdfAsciiAtlas, buildMsdfAtlas, buildMsdfStringAtlas, type MsdfEdge, type MsdfOptions, median, msdfAtlasToRGB, msdfAtlasToRGBA, type Point as MsdfPoint, renderMsdf, type SignedDistanceResult, signedDistanceToCubic, signedDistanceToLine, signedDistanceToQuadratic, } from "./raster/msdf.ts";
 export { bitmapToGray, bitmapToRGBA, rasterizeGlyph, rasterizePath, rasterizeText, } from "./raster/rasterize.ts";
 export { renderSdf, type SdfOptions } from "./raster/sdf.ts";
 export { type LineCap, type LineJoin, type StrokerOptions, strokePath, } from "./raster/stroker.ts";
-export { condensePath, emboldenPath, obliquePath, } from "./raster/synth.ts";
-export type { Bitmap, RasterizedGlyph, RasterizeOptions, Span, } from "./raster/types.ts";
+export { condensePath, emboldenPath, obliquePath } from "./raster/synth.ts";
+export type { Bitmap, GlyphAtlas, GlyphMetrics, MsdfAtlasOptions, RasterizedGlyph, RasterizeOptions, Span, } from "./raster/types.ts";
 export { clearBitmap, createBitmap, FillRule, PixelMode, } from "./raster/types.ts";
+export { type BoundingBox, type ControlBox, clonePath, combinePaths, computeControlBox, computeTightBounds, identity2D, identity3x3, italicizeOutline, type Matrix2D, type Matrix3x3, multiply2D, multiply3x3, perspectiveMatrix, rotate2D, rotateOutline, rotateOutline90, scale2D, scaleOutline, scaleOutlinePow2, shear2D, transformOutline2D, transformOutline3D, transformPoint2D, transformPoint3x3, translate2D, translateOutline, updateMinTransformedX, } from "./render/outline-transform.ts";
 export type { GlyphPath, PathCommand, ShapedGlyph } from "./render/path.ts";
-export { contourToPath, createPath2D, getGlyphPath, getGlyphPathWithVariation, getTextWidth, glyphBufferToShapedGlyphs, glyphToSVG, pathToCanvas, pathToSVG, renderShapedText, renderShapedTextWithVariation, shapedTextToSVG, shapedTextToSVGWithVariation, } from "./render/path.ts";
+export { applyMatrixToContext, contourToPath, createPath2D, getGlyphPath, getGlyphPathWithVariation, getTextWidth, glyphBufferToShapedGlyphs, glyphToSVG, matrixToSVGTransform, pathToCanvas, pathToCanvasWithMatrix, pathToCanvasWithMatrix3D, pathToSVG, pathToSVGWithMatrix, pathToSVGWithMatrix3D, renderShapedText, renderShapedTextWithVariation, shapedTextToSVG, shapedTextToSVGWithVariation, } from "./render/path.ts";
 export { applyFallbackKerning, applyFallbackMarkPositioning, } from "./shaper/fallback.ts";
 export { allSmallCaps, capitalSpacing, capsToSmallCaps, caseSensitiveForms, characterVariant, characterVariants, combineFeatures, contextualAlternates, discretionaryLigatures, feature, features, fractions, fullWidthForms, halfWidthForms, historicalLigatures, jis78Forms, jis83Forms, jis90Forms, jis2004Forms, kerning, liningFigures, oldstyleFigures, ordinals, petiteCaps, proportionalFigures, proportionalWidthForms, quarterWidthForms, ruby, scientificInferiors, simplifiedForms, slashedZero, smallCaps, standardLigatures, stylisticAlternates, stylisticSet, stylisticSets, subscript, superscript, swash, tabularFigures, thirdWidthForms, traditionalForms, verticalAlternatesRotation, verticalForms, verticalKanaAlternates, verticalLayoutFeatures, } from "./shaper/features.ts";
 export { createShapePlan, getOrCreateShapePlan, type ShapeFeature, type ShapePlan, } from "./shaper/shape-plan.ts";
-export { type FontLike, type ShapeOptions, shape } from "./shaper/shaper.ts";
+export { type FontLike, type ShapeOptions, shape, shapeInto, } from "./shaper/shaper.ts";
 export * from "./types.ts";
 export { applyMirroring, type BidiParagraph, type BidiResult, BidiType, detectDirection, getCharType, getEmbeddings, getMirror, getVisualOrder, isLTR, isRTL, processBidi, reorderGlyphs, } from "./unicode/bidi.ts";
 export type { LineBreakAnalysis } from "./unicode/line-break.ts";