text-shaper 0.0.1 → 0.1.1

package/dist/hinting/interpreter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * TrueType Bytecode Interpreter
+ *
+ * Main dispatch loop for executing TrueType hinting instructions.
+ */
+import { CodeRange, type ExecContext } from "./types.ts";
+/**
+ * Execute bytecode from the current instruction pointer
+ */
+export declare function execute(ctx: ExecContext): void;
+/**
+ * Set up execution context with code range
+ */
+export declare function setCodeRange(ctx: ExecContext, range: CodeRange, code: Uint8Array): void;
+/**
+ * Run code in a specific range
+ */
+export declare function runProgram(ctx: ExecContext, range: CodeRange): void;
+/**
+ * Run the font program (fpgm table)
+ */
+export declare function runFontProgram(ctx: ExecContext): void;
+/**
+ * Run the CVT program (prep table)
+ */
+export declare function runCVTProgram(ctx: ExecContext): void;
+/**
+ * Run glyph instructions
+ */
+export declare function runGlyphProgram(ctx: ExecContext, instructions: Uint8Array): void;

package/dist/hinting/programs.d.ts

@@ -0,0 +1,88 @@
+/**
+ * TrueType Hinting Program Execution
+ *
+ * This module handles the setup and execution of TrueType hinting programs:
+ * - fpgm: Font program (executed once when font is loaded)
+ * - prep: CVT program (executed when size changes)
+ * - glyph: Per-glyph instructions
+ */
+import { type ExecContext } from "./types.ts";
+/**
+ * Hinting engine for a font
+ */
+export interface HintingEngine {
+    /** Execution context */
+    ctx: ExecContext;
+    /** Units per EM from font */
+    unitsPerEM: number;
+    /** Has fpgm been executed */
+    fpgmExecuted: boolean;
+    /** Current ppem (prep needs re-run if this changes) */
+    currentPpem: number;
+}
+/**
+ * Create a hinting engine for a font
+ */
+export declare function createHintingEngine(unitsPerEM: number, maxStack?: number, maxStorage?: number, maxFDefs?: number, maxTwilightPoints?: number, cvtValues?: Int32Array): HintingEngine;
+/**
+ * Load font program (fpgm table)
+ */
+export declare function loadFontProgram(engine: HintingEngine, fpgm: Uint8Array): void;
+/**
+ * Load CVT program (prep table)
+ */
+export declare function loadCVTProgram(engine: HintingEngine, prep: Uint8Array): void;
+/**
+ * Execute fpgm (should be called once after font load)
+ */
+export declare function executeFontProgram(engine: HintingEngine): string | null;
+/**
+ * Set up for a specific size and execute prep if needed
+ */
+export declare function setSize(engine: HintingEngine, ppem: number, pointSize: number): string | null;
+/**
+ * Glyph outline for hinting
+ */
+export interface GlyphOutline {
+    /** X coordinates in font units */
+    xCoords: number[];
+    /** Y coordinates in font units */
+    yCoords: number[];
+    /** Point flags (bit 0 = on-curve) */
+    flags: Uint8Array;
+    /** End point indices for each contour */
+    contourEnds: number[];
+    /** Glyph instructions */
+    instructions: Uint8Array;
+    /** Left side bearing in font units (for phantom point) */
+    lsb?: number;
+    /** Advance width in font units (for phantom point) */
+    advanceWidth?: number;
+    /** Top side bearing in font units (for vertical phantom point) */
+    tsb?: number;
+    /** Advance height in font units (for vertical phantom point) */
+    advanceHeight?: number;
+}
+/**
+ * Hinted glyph result
+ */
+export interface HintedGlyph {
+    /** Hinted X coordinates in 26.6 pixels */
+    xCoords: number[];
+    /** Hinted Y coordinates in 26.6 pixels */
+    yCoords: number[];
+    /** Point flags */
+    flags: Uint8Array;
+    /** Contour end indices */
+    contourEnds: number[];
+    /** Error message if hinting failed */
+    error: string | null;
+}
+/**
+ * Hint a glyph
+ */
+export declare function hintGlyph(engine: HintingEngine, outline: GlyphOutline): HintedGlyph;
+/**
+ * Convert hinted coordinates from 26.6 to floating point pixels
+ */
+export declare function hintedToPixels(coords: number[]): number[];

package/dist/hinting/rounding.d.ts

@@ -0,0 +1,51 @@
+/**
+ * TrueType rounding functions
+ *
+ * These implement the various rounding modes used by the interpreter.
+ */
+import { type F26Dot6, type GraphicsState } from "./types.ts";
+/**
+ * Round to grid (nearest integer pixel)
+ */
+export declare function roundToGrid(distance: F26Dot6, compensation: F26Dot6): F26Dot6;
+/**
+ * Round to half grid (nearest half pixel)
+ */
+export declare function roundToHalfGrid(distance: F26Dot6, compensation: F26Dot6): F26Dot6;
+/**
+ * Round to double grid (nearest half pixel boundary)
+ */
+export declare function roundToDoubleGrid(distance: F26Dot6, compensation: F26Dot6): F26Dot6;
+/**
+ * Round down to grid (floor to pixel)
+ */
+export declare function roundDownToGrid(distance: F26Dot6, compensation: F26Dot6): F26Dot6;
+/**
+ * Round up to grid (ceiling to pixel)
+ */
+export declare function roundUpToGrid(distance: F26Dot6, compensation: F26Dot6): F26Dot6;
+/**
+ * No rounding
+ */
+export declare function roundOff(distance: F26Dot6, _compensation: F26Dot6): F26Dot6;
+/**
+ * Super rounding (parametric rounding)
+ */
+export declare function roundSuper(distance: F26Dot6, compensation: F26Dot6, GS: GraphicsState): F26Dot6;
+/**
+ * Super rounding 45 degrees (for diagonal lines)
+ */
+export declare function roundSuper45(distance: F26Dot6, compensation: F26Dot6, GS: GraphicsState): F26Dot6;
+/**
+ * Apply current rounding mode
+ */
+export declare function round(distance: F26Dot6, compensation: F26Dot6, GS: GraphicsState): F26Dot6;
+/**
+ * Parse SROUND/S45ROUND selector byte
+ */
+export declare function parseSuperRound(selector: number, GS: GraphicsState): void;
+/**
+ * Compensate distance for engine characteristics
+ * Used with ROUND and movement instructions
+ */
+export declare function compensate(_distance: F26Dot6, _GS: GraphicsState): F26Dot6;

package/dist/hinting/types.d.ts

@@ -0,0 +1,369 @@
+/**
+ * TrueType Hinting Types
+ *
+ * Based on FreeType's ttinterp.h and ttobjs.h
+ */
+/**
+ * 26.6 fixed-point number (used for coordinates)
+ */
+export type F26Dot6 = number;
+/**
+ * 2.14 fixed-point number (used for unit vectors)
+ */
+export type F2Dot14 = number;
+/**
+ * Unit vector in 2.14 format
+ */
+export interface UnitVector {
+    x: F2Dot14;
+    y: F2Dot14;
+}
+/**
+ * Point coordinate
+ */
+export interface Point {
+    x: F26Dot6;
+    y: F26Dot6;
+}
+/**
+ * Rounding mode for ROUND instruction
+ */
+export declare enum RoundMode {
+    ToHalfGrid = 0,
+    ToGrid = 1,
+    ToDoubleGrid = 2,
+    DownToGrid = 3,
+    UpToGrid = 4,
+    Off = 5,
+    Super = 6,
+    Super45 = 7
+}
+/**
+ * Touch flags for points
+ */
+export declare enum TouchFlag {
+    X = 1,
+    Y = 2,
+    Both = 3
+}
+/**
+ * Glyph zone - holds glyph points
+ */
+export interface GlyphZone {
+    /** Number of points */
+    nPoints: number;
+    /** Number of contours */
+    nContours: number;
+    /** Original point positions (before hinting) */
+    org: Point[];
+    /** Current point positions (after hinting) */
+    cur: Point[];
+    /** Original unscaled positions */
+    orus: Point[];
+    /** Touch flags per point */
+    tags: Uint8Array;
+    /** Contour end indices */
+    contours: Uint16Array;
+}
+/**
+ * TrueType Graphics State
+ *
+ * Contains all state variables that control how instructions operate
+ */
+export interface GraphicsState {
+    rp0: number;
+    rp1: number;
+    rp2: number;
+    dualVector: UnitVector;
+    projVector: UnitVector;
+    freeVector: UnitVector;
+    loop: number;
+    minimumDistance: F26Dot6;
+    roundState: RoundMode;
+    autoFlip: boolean;
+    controlValueCutIn: F26Dot6;
+    singleWidthCutIn: F26Dot6;
+    singleWidthValue: F26Dot6;
+    deltaBase: number;
+    deltaShift: number;
+    instructControl: number;
+    scanControl: number;
+    scanType: number;
+    gep0: number;
+    gep1: number;
+    gep2: number;
+    period: F26Dot6;
+    phase: F26Dot6;
+    threshold: F26Dot6;
+}
+/**
+ * Create default graphics state
+ */
+export declare function createDefaultGraphicsState(): GraphicsState;
+/**
+ * Function definition (from FDEF instruction)
+ */
+export interface FunctionDef {
+    /** Function number */
+    id: number;
+    /** Start offset in bytecode */
+    start: number;
+    /** End offset (just after ENDF) */
+    end: number;
+    /** Active (has been defined) */
+    active: boolean;
+    /** Which code range */
+    range: CodeRange;
+}
+/**
+ * Instruction definition (from IDEF instruction)
+ */
+export interface InstructionDef {
+    /** Opcode being redefined */
+    opcode: number;
+    /** Start offset */
+    start: number;
+    /** End offset */
+    end: number;
+    /** Active */
+    active: boolean;
+    /** Code range */
+    range: CodeRange;
+}
+/**
+ * Code range type
+ */
+export declare enum CodeRange {
+    None = 0,
+    Font = 1,// fpgm table
+    CVT = 2,// prep table
+    Glyph = 3
+}
+/**
+ * Call stack record
+ */
+export interface CallRecord {
+    /** Caller's instruction pointer */
+    callerIP: number;
+    /** Caller's code range */
+    callerRange: CodeRange;
+    /** Function definition */
+    def: FunctionDef;
+    /** Loop count (for LOOPCALL) */
+    count: number;
+}
+/**
+ * Execution context for the TrueType interpreter
+ */
+export interface ExecContext {
+    GS: GraphicsState;
+    defaultGS: GraphicsState;
+    zp0: GlyphZone;
+    zp1: GlyphZone;
+    zp2: GlyphZone;
+    twilight: GlyphZone;
+    pts: GlyphZone;
+    stack: Int32Array;
+    stackTop: number;
+    IP: number;
+    code: Uint8Array;
+    codeSize: number;
+    currentRange: CodeRange;
+    opcode: number;
+    numArgs: number;
+    cvt: Int32Array;
+    cvtSize: number;
+    storage: Int32Array;
+    storageSize: number;
+    FDefs: FunctionDef[];
+    maxFDefs: number;
+    IDefs: InstructionDef[];
+    maxIDefs: number;
+    callStack: CallRecord[];
+    callStackTop: number;
+    maxCallStack: number;
+    codeRanges: Map<CodeRange, {
+        code: Uint8Array;
+        size: number;
+    }>;
+    ppem: number;
+    pointSize: number;
+    scale: number;
+    error: string | null;
+    instructionCount: number;
+    maxInstructions: number;
+}
+/**
+ * Create an empty glyph zone
+ */
+export declare function createGlyphZone(maxPoints: number, maxContours: number): GlyphZone;
+/**
+ * Create execution context
+ */
+export declare function createExecContext(maxStack?: number, maxStorage?: number, maxFDefs?: number, maxIDefs?: number, maxCallStack?: number, maxTwilightPoints?: number): ExecContext;
+/**
+ * TrueType Opcodes
+ */
+export declare const Opcode: {
+    readonly NPUSHB: 64;
+    readonly NPUSHW: 65;
+    readonly PUSHB_0: 176;
+    readonly PUSHB_1: 177;
+    readonly PUSHB_2: 178;
+    readonly PUSHB_3: 179;
+    readonly PUSHB_4: 180;
+    readonly PUSHB_5: 181;
+    readonly PUSHB_6: 182;
+    readonly PUSHB_7: 183;
+    readonly PUSHW_0: 184;
+    readonly PUSHW_1: 185;
+    readonly PUSHW_2: 186;
+    readonly PUSHW_3: 187;
+    readonly PUSHW_4: 188;
+    readonly PUSHW_5: 189;
+    readonly PUSHW_6: 190;
+    readonly PUSHW_7: 191;
+    readonly RS: 67;
+    readonly WS: 66;
+    readonly RCVT: 69;
+    readonly WCVTP: 68;
+    readonly WCVTF: 112;
+    readonly DUP: 32;
+    readonly POP: 33;
+    readonly CLEAR: 34;
+    readonly SWAP: 35;
+    readonly DEPTH: 36;
+    readonly CINDEX: 37;
+    readonly MINDEX: 38;
+    readonly ROLL: 138;
+    readonly ADD: 96;
+    readonly SUB: 97;
+    readonly DIV: 98;
+    readonly MUL: 99;
+    readonly ABS: 100;
+    readonly NEG: 101;
+    readonly FLOOR: 102;
+    readonly CEILING: 103;
+    readonly MAX: 139;
+    readonly MIN: 140;
+    readonly LT: 80;
+    readonly LTEQ: 81;
+    readonly GT: 82;
+    readonly GTEQ: 83;
+    readonly EQ: 84;
+    readonly NEQ: 85;
+    readonly ODD: 86;
+    readonly EVEN: 87;
+    readonly AND: 90;
+    readonly OR: 91;
+    readonly NOT: 92;
+    readonly IF: 88;
+    readonly ELSE: 27;
+    readonly EIF: 89;
+    readonly JMPR: 28;
+    readonly JROT: 120;
+    readonly JROF: 121;
+    readonly FDEF: 44;
+    readonly ENDF: 45;
+    readonly CALL: 43;
+    readonly LOOPCALL: 42;
+    readonly IDEF: 137;
+    readonly SVTCA_Y: 0;
+    readonly SVTCA_X: 1;
+    readonly SPVTCA_Y: 2;
+    readonly SPVTCA_X: 3;
+    readonly SFVTCA_Y: 4;
+    readonly SFVTCA_X: 5;
+    readonly SPVTL_0: 6;
+    readonly SPVTL_1: 7;
+    readonly SFVTL_0: 8;
+    readonly SFVTL_1: 9;
+    readonly SDPVTL_0: 134;
+    readonly SDPVTL_1: 135;
+    readonly SPVFS: 10;
+    readonly SFVFS: 11;
+    readonly GPV: 12;
+    readonly GFV: 13;
+    readonly SFVTPV: 14;
+    readonly ISECT: 15;
+    readonly SRP0: 16;
+    readonly SRP1: 17;
+    readonly SRP2: 18;
+    readonly SZP0: 19;
+    readonly SZP1: 20;
+    readonly SZP2: 21;
+    readonly SZPS: 22;
+    readonly SLOOP: 23;
+    readonly RTG: 24;
+    readonly RTHG: 25;
+    readonly SMD: 26;
+    readonly RDTG: 125;
+    readonly RUTG: 124;
+    readonly ROFF: 122;
+    readonly SROUND: 118;
+    readonly S45ROUND: 119;
+    readonly SCVTCI: 29;
+    readonly SSWCI: 30;
+    readonly SSW: 31;
+    readonly FLIPON: 77;
+    readonly FLIPOFF: 78;
+    readonly SANGW: 126;
+    readonly SDB: 94;
+    readonly SDS: 95;
+    readonly GC_0: 70;
+    readonly GC_1: 71;
+    readonly SCFS: 72;
+    readonly MD_0: 73;
+    readonly MD_1: 74;
+    readonly MPPEM: 75;
+    readonly MPS: 76;
+    readonly FLIPPT: 128;
+    readonly FLIPRGON: 129;
+    readonly FLIPRGOFF: 130;
+    readonly SHP_0: 50;
+    readonly SHP_1: 51;
+    readonly SHC_0: 52;
+    readonly SHC_1: 53;
+    readonly SHZ_0: 54;
+    readonly SHZ_1: 55;
+    readonly SHPIX: 56;
+    readonly IP: 57;
+    readonly MSIRP_0: 58;
+    readonly MSIRP_1: 59;
+    readonly ALIGNRP: 60;
+    readonly RTDG: 61;
+    readonly MIAP_0: 62;
+    readonly MIAP_1: 63;
+    readonly ALIGNPTS: 39;
+    readonly UTP: 41;
+    readonly MDAP_0: 46;
+    readonly MDAP_1: 47;
+    readonly IUP_Y: 48;
+    readonly IUP_X: 49;
+    readonly DELTAP1: 93;
+    readonly DELTAP2: 113;
+    readonly DELTAP3: 114;
+    readonly DELTAC1: 115;
+    readonly DELTAC2: 116;
+    readonly DELTAC3: 117;
+    readonly ROUND_0: 104;
+    readonly ROUND_1: 105;
+    readonly ROUND_2: 106;
+    readonly ROUND_3: 107;
+    readonly NROUND_0: 108;
+    readonly NROUND_1: 109;
+    readonly NROUND_2: 110;
+    readonly NROUND_3: 111;
+    readonly GETINFO: 136;
+    readonly INSTCTRL: 142;
+    readonly SCANCTRL: 133;
+    readonly SCANTYPE: 141;
+    readonly AA: 127;
+    readonly DEBUG: 79;
+    readonly MDRP_BASE: 192;
+    readonly MIRP_BASE: 224;
+};
+/**
+ * Number of values popped from stack for each opcode
+ */
+export declare const OpcodePops: Record<number, number>;

package/dist/index.d.ts

@@ -10,6 +10,12 @@ export type { BitmapGlyph, BitmapSize, CbdtTable, CblcTable, GlyphBitmapMetrics,
 export { CbdtImageFormat, getBitmapGlyph, getColorBitmapSizes, hasColorBitmap, } from "./font/tables/cbdt.ts";
 export { executeCff2CharString, executeCffCharString, getCffGlyphWidth, } from "./font/tables/cff-charstring.ts";
 export type { CmapTable } from "./font/tables/cmap.ts";
+export type { Affine2x3, BaseGlyphPaintRecord, BaseGlyphRecord, ClipBox, ClipRecord, ColorLine, ColorStop, ColrTable, ItemVariationData, ItemVariationStore, LayerRecord, Paint, PaintColrGlyph, PaintColrLayers, PaintComposite, PaintGlyph, PaintLinearGradient, PaintRadialGradient, PaintRotate, PaintScale, PaintSkew, PaintSolid, PaintSweepGradient, PaintTransform, PaintTranslate, RegionAxisCoordinates, VarColorLine, VarColorStop, VariationRegion, } from "./font/tables/colr.ts";
+export { CompositeMode, Extend, getClipBox, getColorLayers, getColorPaint, getColorVariationDelta, getLayerPaint, hasColorGlyph, isColrV1, PaintFormat, parseColr, } from "./font/tables/colr.ts";
+export type { Color, ColorPalette, CpalTable } from "./font/tables/cpal.ts";
+export { colorToHex, colorToRgba, getColor, PaletteType, parseCpal, } from "./font/tables/cpal.ts";
+export type { FeatTable, FeatureRecord, FeatureSetting, } from "./font/tables/feat.ts";
+export { aatToOpenTypeTag, CaseSensitiveLayoutSetting, CharacterShapeSetting, ContextualAlternativesSetting, DiacriticsSetting, FeatureFlags, FeatureType, FractionsSetting, getAllFeatures, getDefaultSetting, getFeature, getSettingByValue, hasSettingValue, isExclusiveFeature, LigatureSetting, LowerCaseSetting, NumberCaseSetting, NumberSpacingSetting, openTypeTagToAat, parseFeat, SmartSwashSetting, StylisticAlternativesSetting, UpperCaseSetting, VerticalPositionSetting, } from "./font/tables/feat.ts";
 export type { FvarTable, NamedInstance, VariationAxis, } from "./font/tables/fvar.ts";
 export { normalizeAxisValue } from "./font/tables/fvar.ts";
 export type { GdefTable } from "./font/tables/gdef.ts";
@@ -32,18 +38,12 @@ export { getGlyphLocation, hasGlyphOutline } from "./font/tables/loca.ts";
 export type { MaxpTable } from "./font/tables/maxp.ts";
 export type { MorxChain, MorxSubtable, MorxTable } from "./font/tables/morx.ts";
 export { applyNonContextual, MorxSubtableType } from "./font/tables/morx.ts";
-export type { FeatTable, FeatureRecord, FeatureSetting, } from "./font/tables/feat.ts";
-export { aatToOpenTypeTag, CaseSensitiveLayoutSetting, CharacterShapeSetting, ContextualAlternativesSetting, DiacriticsSetting, FeatureFlags, FeatureType, FractionsSetting, getAllFeatures, getDefaultSetting, getFeature, getSettingByValue, hasSettingValue, isExclusiveFeature, LigatureSetting, LowerCaseSetting, NumberCaseSetting, NumberSpacingSetting, openTypeTagToAat, parseFeat, SmartSwashSetting, StylisticAlternativesSetting, UpperCaseSetting, VerticalPositionSetting, } from "./font/tables/feat.ts";
 export type { MvarTable, MvarValueRecord } from "./font/tables/mvar.ts";
 export { getCapHeightDelta, getHAscenderDelta, getHDescenderDelta, getMetricDelta, getXHeightDelta, MvarTags, } from "./font/tables/mvar.ts";
 export type { SbixGlyph, SbixStrike, SbixTable } from "./font/tables/sbix.ts";
 export { getAvailablePpemSizes, getGlyphBitmap as getSbixGlyphBitmap, getStrikeForPpem, hasGlyphBitmap, resolveDupeGlyph, SbixGraphicType, } from "./font/tables/sbix.ts";
 export type { AxisRecord, AxisValue, AxisValueFormat1, AxisValueFormat2, AxisValueFormat3, AxisValueFormat4, StatTable, } from "./font/tables/stat.ts";
 export { AxisValueFlags, findAxisValueByNameId, getAxisIndex, getAxisRecord, getAxisValueNumber, getAxisValuesForAxis, isElidableAxisValue, isOlderSiblingFont, matchAxisValue, } from "./font/tables/stat.ts";
-export type { Affine2x3, BaseGlyphPaintRecord, BaseGlyphRecord, ClipBox, ClipRecord, ColorLine, ColorStop, ColrTable, ItemVariationData, ItemVariationStore, LayerRecord, Paint, PaintColrGlyph, PaintColrLayers, PaintComposite, PaintGlyph, PaintLinearGradient, PaintRadialGradient, PaintRotate, PaintScale, PaintSkew, PaintSolid, PaintSweepGradient, PaintTransform, PaintTranslate, RegionAxisCoordinates, VarColorLine, VarColorStop, VariationRegion, } from "./font/tables/colr.ts";
-export { CompositeMode, Extend, getClipBox, getColorLayers, getColorPaint, getColorVariationDelta, getLayerPaint, hasColorGlyph, isColrV1, PaintFormat, parseColr, } from "./font/tables/colr.ts";
-export type { Color, ColorPalette, CpalTable } from "./font/tables/cpal.ts";
-export { colorToHex, colorToRgba, getColor, PaletteType, parseCpal } from "./font/tables/cpal.ts";
 export type { SvgDocumentRecord, SvgTable } from "./font/tables/svg.ts";
 export { getSvgDocument, getSvgGlyphIds, hasSvgGlyph, } from "./font/tables/svg.ts";
 export type { TrackData, TrakTable } from "./font/tables/trak.ts";
@@ -63,6 +63,16 @@ 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 { getExactBounds } from "./raster/bbox.ts";
+export { blendBitmap, convertBitmap, copyBitmap, emboldenBitmap, resizeBitmap, } from "./raster/bitmap-utils.ts";
+export { blurBitmap, boxBlur, createGaussianKernel, gaussianBlur, } from "./raster/blur.ts";
+export { type ColorStop as GradientColorStop, createGradientBitmap, type Gradient, interpolateGradient, type LinearGradient, type RadialGradient, rasterizePathWithGradient, } from "./raster/gradient.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 { clearBitmap, createBitmap, FillRule, PixelMode, } from "./raster/types.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 { applyFallbackKerning, applyFallbackMarkPositioning, } from "./shaper/fallback.ts";
@@ -71,10 +81,10 @@ export { createShapePlan, getOrCreateShapePlan, type ShapeFeature, type ShapePla
 export { type FontLike, type ShapeOptions, shape } 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 { decompose, getCombiningClass, NormalizationMode, normalize, reorderMarks, } from "./unicode/normalize.ts";
 export type { LineBreakAnalysis } from "./unicode/line-break.ts";
-export { BreakAction, BreakOpportunity, LineBreakClass, analyzeLineBreaks, analyzeLineBreaksForGlyphs, analyzeLineBreaksFromCodepoints, canBreakAt, findNextBreak, getAllBreakOpportunities, getLineBreakClass, mustBreakAt, } from "./unicode/line-break.ts";
-export type { GraphemeBoundaries, WordBoundaries } from "./unicode/segmentation.ts";
-export { GraphemeBreakProperty, WordBreakProperty, countGraphemes, findGraphemeBoundaries, findWordBoundaries, getGraphemeBreakProperty, getWordBreakProperty, splitGraphemes, splitWords, } from "./unicode/segmentation.ts";
+export { analyzeLineBreaks, analyzeLineBreaksForGlyphs, analyzeLineBreaksFromCodepoints, BreakAction, BreakOpportunity, canBreakAt, findNextBreak, getAllBreakOpportunities, getLineBreakClass, LineBreakClass, mustBreakAt, } from "./unicode/line-break.ts";
+export { decompose, getCombiningClass, NormalizationMode, normalize, reorderMarks, } from "./unicode/normalize.ts";
 export type { ScriptRun } from "./unicode/script.ts";
-export { Script, detectScript, getScript, getScriptDirection, getScriptRuns, getScriptTag, getScripts, isComplexScript, isScript, } from "./unicode/script.ts";
+export { detectScript, getScript, getScriptDirection, getScriptRuns, getScripts, getScriptTag, isComplexScript, isScript, Script, } from "./unicode/script.ts";
+export type { GraphemeBoundaries, WordBoundaries, } from "./unicode/segmentation.ts";
+export { countGraphemes, findGraphemeBoundaries, findWordBoundaries, GraphemeBreakProperty, getGraphemeBreakProperty, getWordBreakProperty, splitGraphemes, splitWords, WordBreakProperty, } from "./unicode/segmentation.ts";