text-shaper 0.0.1 → 0.1.1

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

@@ -0,0 +1,61 @@
+/**
+ * Decompose path commands into rasterizer calls
+ */
+import { type GlyphPath } from "../render/path.ts";
+import type { GrayRaster } from "./gray-raster.ts";
+import { FillRule } from "./types.ts";
+/**
+ * Outline validation error types (like FreeType's error codes)
+ */
+export declare enum OutlineError {
+    Ok = 0,
+    InvalidOutline = 1,
+    InvalidArgument = 2,
+    EmptyOutline = 3
+}
+/**
+ * Validation result with error code and message
+ */
+export interface ValidationResult {
+    error: OutlineError;
+    message?: string;
+}
+/**
+ * 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)
+ */
+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)
+ */
+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
+ */
+export declare function getPathBounds(path: GlyphPath, scale: number, flipY?: boolean): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+} | 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
+ */
+export declare function getFillRuleFromFlags(path: GlyphPath | null | undefined, defaultRule?: FillRule): FillRule;

package/dist/raster/rasterize.d.ts

@@ -0,0 +1,43 @@
+/**
+ * High-level rasterization API
+ */
+import type { Font } from "../font/font.ts";
+import { type GlyphPath } from "../render/path.ts";
+import type { GlyphId } from "../types.ts";
+import { type Bitmap, PixelMode, type RasterizedGlyph, type RasterizeOptions } from "./types.ts";
+/**
+ * Rasterize a glyph path to a bitmap
+ */
+export declare function rasterizePath(path: GlyphPath, options: RasterizeOptions): Bitmap;
+/**
+ * Rasterize a glyph from a font
+ */
+export declare function rasterizeGlyph(font: Font, glyphId: GlyphId, fontSize: number, options?: {
+    pixelMode?: PixelMode;
+    padding?: number;
+    /** Use TrueType hinting if available */
+    hinting?: boolean;
+}): RasterizedGlyph | null;
+/**
+ * Rasterize text string using shaped glyphs
+ */
+export declare function rasterizeText(font: Font, text: string, fontSize: number, options?: {
+    pixelMode?: PixelMode;
+    padding?: number;
+}): Bitmap | null;
+/**
+ * Export bitmap to raw RGBA pixels (for WebGL textures, etc.)
+ */
+export declare function bitmapToRGBA(bitmap: Bitmap): Uint8Array;
+/**
+ * Export bitmap to grayscale array
+ */
+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 { 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";

package/dist/raster/sdf.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Signed Distance Field (SDF) rasterizer
+ *
+ * For each pixel, compute the shortest distance to the outline.
+ * Positive values are inside the outline, negative are outside.
+ * This allows GPU text rendering at any scale.
+ *
+ * Algorithm:
+ * 1. For each pixel center, find the minimum distance to all outline edges
+ * 2. Determine sign based on whether point is inside or outside the outline
+ * 3. Normalize and encode to 0-255 (128 = on the edge)
+ */
+import type { GlyphPath } from "../render/path.ts";
+import { type Bitmap } from "./types.ts";
+/**
+ * Options for SDF rendering
+ */
+export interface SdfOptions {
+    /** 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;
+}
+/**
+ * Render a glyph path as a signed distance field
+ */
+export declare function renderSdf(path: GlyphPath, options: SdfOptions): Bitmap;

package/dist/raster/stroker.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Path Stroker
+ *
+ * Converts a path outline into a stroked outline that can be filled.
+ * Based on FreeType's ftstroke.c algorithm.
+ *
+ * The stroker generates two borders (inside and outside) by offsetting
+ * the original path by half the stroke width in both directions.
+ */
+import type { GlyphPath } from "../render/path.ts";
+/** Line cap styles */
+export type LineCap = "butt" | "round" | "square";
+/** Line join styles */
+export type LineJoin = "miter" | "round" | "bevel";
+/** Stroker options */
+export interface StrokerOptions {
+    /** Stroke width in font units */
+    width: number;
+    /** Line cap style (default: "butt") */
+    lineCap?: LineCap;
+    /** Line join style (default: "miter") */
+    lineJoin?: LineJoin;
+    /** Miter limit for miter joins (default: 4) */
+    miterLimit?: number;
+}
+/**
+ * Stroke a glyph path, producing a new path that represents the stroked outline
+ */
+export declare function strokePath(path: GlyphPath, options: StrokerOptions): GlyphPath;

package/dist/raster/synth.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Synthetic Font Effects
+ *
+ * Provides transformations for creating synthetic bold, italic, and other effects
+ * on glyph outlines. These are useful for fonts that don't have native bold/italic
+ * variants.
+ */
+import type { GlyphPath } from "../render/path.ts";
+/**
+ * Apply oblique (slant/italic) transformation to a path
+ *
+ * @param path - The glyph path to transform
+ * @param slant - Tangent of the slant angle (0.2 = ~12 degrees, typical italic)
+ * @returns New path with slant applied
+ *
+ * Transform: x' = x + y * slant, y' = y
+ */
+export declare function obliquePath(path: GlyphPath, slant: number): GlyphPath;
+/**
+ * Apply general 2D affine transformation to a path
+ *
+ * @param path - The glyph path to transform
+ * @param matrix - 2D transformation matrix [a, b, c, d, e, f]
+ * @returns New path with transformation applied
+ *
+ * Transform: x' = a*x + c*y + e, y' = b*x + d*y + f
+ */
+export declare function transformPath(path: GlyphPath, matrix: [number, number, number, number, number, number]): GlyphPath;
+/**
+ * Apply horizontal scaling (condensing/expanding) to a path
+ *
+ * @param path - The glyph path to transform
+ * @param factor - Horizontal scale factor (< 1 = narrower, > 1 = wider)
+ * @returns New path with horizontal scaling applied
+ *
+ * Transform: x' = x * factor, y' = y
+ */
+export declare function condensePath(path: GlyphPath, factor: number): GlyphPath;
+/**
+ * Embolden (make bolder) a path by offsetting the outline
+ *
+ * This implementation uses a simplified approach that offsets each contour
+ * outward by moving points along the normal direction. For production use,
+ * a proper stroking algorithm would be more accurate.
+ *
+ * @param path - The glyph path to embolden
+ * @param strength - Offset strength in font units (positive = bolder, negative = thinner)
+ * @returns New path with emboldening applied
+ */
+export declare function emboldenPath(path: GlyphPath, strength: number): GlyphPath;

package/dist/raster/types.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Rasterizer types - FreeType-style bitmap rendering
+ */
+import type { GlyphPath } from "../render/path.ts";
+/**
+ * Pixel modes for bitmap output
+ */
+export declare enum PixelMode {
+    /** 1-bit per pixel, 8 pixels per byte */
+    Mono = 0,
+    /** 8-bit grayscale, 1 byte per pixel */
+    Gray = 1,
+    /** 24-bit LCD subpixel RGB, 3 bytes per pixel */
+    LCD = 2,
+    /** 24-bit LCD subpixel vertical RGB */
+    LCD_V = 3,
+    /** 32-bit RGBA, 4 bytes per pixel */
+    RGBA = 4
+}
+/**
+ * Fill rule for outline rendering
+ */
+export declare enum FillRule {
+    /** Non-zero winding rule (default) */
+    NonZero = 0,
+    /** Even-odd (alternating) fill rule */
+    EvenOdd = 1
+}
+/**
+ * Bitmap buffer for rasterized glyphs
+ */
+export interface Bitmap {
+    /** Pixel buffer */
+    buffer: Uint8Array;
+    /** Width in pixels */
+    width: number;
+    /** Height in pixels */
+    rows: number;
+    /** Bytes per row (may include padding) */
+    pitch: number;
+    /** Pixel format */
+    pixelMode: PixelMode;
+    /** Number of gray levels (256 for 8-bit) */
+    numGrays: number;
+}
+/**
+ * A single horizontal span of pixels (for direct rendering)
+ */
+export interface Span {
+    /** X position of span start */
+    x: number;
+    /** Length in pixels */
+    len: number;
+    /** Coverage value 0-255 */
+    coverage: number;
+}
+/**
+ * Callback for span-based rendering
+ * @template T User data type passed through from render call
+ */
+export type SpanFunc<T = void> = (y: number, spans: Span[], userData: T) => void;
+/**
+ * Rasterization parameters
+ */
+export interface RasterParams {
+    /** Target bitmap (null for span callback mode) */
+    target?: Bitmap;
+    /** Source outline path */
+    source: GlyphPath;
+    /** Fill rule */
+    fillRule?: FillRule;
+    /** Span callback for direct rendering */
+    spanFunc?: SpanFunc;
+    /** Clip box (in pixels) */
+    clipBox?: {
+        xMin: number;
+        yMin: number;
+        xMax: number;
+        yMax: number;
+    };
+}
+/**
+ * Options for rasterizing a glyph
+ */
+export interface RasterizeOptions {
+    /** 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;
+    /** Pixel mode */
+    pixelMode?: PixelMode;
+    /** Fill rule */
+    fillRule?: FillRule;
+    /** Flip Y axis (font coords are Y-up, bitmap is Y-down) */
+    flipY?: boolean;
+}
+/**
+ * Result of glyph rasterization
+ */
+export interface RasterizedGlyph {
+    /** Pixel data */
+    bitmap: Bitmap;
+    /** Bearing X (offset from origin to left edge) */
+    bearingX: number;
+    /** Bearing Y (offset from origin to top edge) */
+    bearingY: number;
+}
+/**
+ * Glyph metrics for atlas building
+ */
+export interface GlyphMetrics {
+    /** Glyph ID */
+    glyphId: number;
+    /** X position in atlas */
+    atlasX: number;
+    /** Y position in atlas */
+    atlasY: number;
+    /** Width in atlas */
+    width: number;
+    /** Height in atlas */
+    height: number;
+    /** Bearing X */
+    bearingX: number;
+    /** Bearing Y */
+    bearingY: number;
+    /** Horizontal advance */
+    advance: number;
+}
+/**
+ * Texture atlas containing multiple glyphs
+ */
+export interface GlyphAtlas {
+    /** Atlas bitmap */
+    bitmap: Bitmap;
+    /** Glyph metrics indexed by glyph ID */
+    glyphs: Map<number, GlyphMetrics>;
+    /** Font size used for rendering */
+    fontSize: number;
+}
+/**
+ * Options for building a glyph atlas
+ */
+export interface AtlasOptions {
+    /** Font size in pixels */
+    fontSize: number;
+    /** Padding between glyphs */
+    padding?: number;
+    /** Maximum atlas width */
+    maxWidth?: number;
+    /** Maximum atlas height */
+    maxHeight?: number;
+    /** Pixel mode */
+    pixelMode?: PixelMode;
+    /** Enable hinting */
+    hinting?: boolean;
+}
+/**
+ * Create an empty bitmap
+ */
+export declare function createBitmap(width: number, height: number, pixelMode?: PixelMode): Bitmap;
+/**
+ * Clear a bitmap to zero
+ */
+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)
+ */
+export declare function createBottomUpBitmap(width: number, height: number, pixelMode?: PixelMode): Bitmap;

package/dist/render/path.d.ts

@@ -30,6 +30,19 @@ export type PathCommand = {
 } | {
     type: "Z";
 };
+/**
+ * Outline flags (like FreeType's FT_OUTLINE_* flags)
+ */
+export declare enum OutlineFlags {
+    /** No flags */
+    None = 0,
+    /** Use even-odd fill rule instead of non-zero winding */
+    EvenOddFill = 1,
+    /** Outline has been hinted */
+    HighPrecision = 2,
+    /** Outline is a single stroke (not filled) */
+    SinglePass = 4
+}
 /**
  * A glyph path is a series of drawing commands
  */
@@ -41,10 +54,12 @@ export interface GlyphPath {
         xMax: number;
         yMax: number;
     } | null;
+    /** Outline flags (like FreeType's FT_OUTLINE_* flags) */
+    flags?: OutlineFlags;
 }
 /**
- * Convert TrueType contours to path commands
- * TrueType uses quadratic Bézier curves with on-curve and off-curve points
+ * Convert contours to path commands
+ * Handles both TrueType (quadratic Béziers) and CFF (cubic Béziers)
  */
 export declare function contourToPath(contour: Contour): PathCommand[];
 /**
@@ -58,6 +73,21 @@ export declare function pathToSVG(path: GlyphPath, options?: {
     flipY?: boolean;
     scale?: number;
 }): string;
+/**
+ * Render options for stroke/fill
+ */
+export interface RenderOptions {
+    flipY?: boolean;
+    scale?: number;
+    offsetX?: number;
+    offsetY?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    lineCap?: CanvasLineCap;
+    lineJoin?: CanvasLineJoin;
+    miterLimit?: number;
+}
 /**
  * Render path commands to a Canvas 2D context
  */
@@ -73,6 +103,8 @@ export declare function pathToCanvas(ctx: CanvasRenderingContext2D | Path2D, pat
 export declare function glyphToSVG(font: Font, glyphId: GlyphId, options?: {
     fontSize?: number;
     fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
 }): string | null;
 /**
  * Render shaped text to Canvas
@@ -89,6 +121,10 @@ export declare function renderShapedText(ctx: CanvasRenderingContext2D, font: Fo
     x?: number;
     y?: number;
     fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    lineCap?: CanvasLineCap;
+    lineJoin?: CanvasLineJoin;
 }): void;
 /**
  * Generate SVG for shaped text
@@ -96,6 +132,10 @@ export declare function renderShapedText(ctx: CanvasRenderingContext2D, font: Fo
 export declare function shapedTextToSVG(font: Font, glyphs: ShapedGlyph[], options?: {
     fontSize?: number;
     fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    lineCap?: "butt" | "round" | "square";
+    lineJoin?: "miter" | "round" | "bevel";
 }): string;
 /**
  * Convert GlyphBuffer output to ShapedGlyph array
@@ -113,6 +153,10 @@ export declare function renderShapedTextWithVariation(ctx: CanvasRenderingContex
     x?: number;
     y?: number;
     fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    lineCap?: CanvasLineCap;
+    lineJoin?: CanvasLineJoin;
 }): void;
 /**
  * Generate SVG for shaped text with variable font support
@@ -120,6 +164,10 @@ export declare function renderShapedTextWithVariation(ctx: CanvasRenderingContex
 export declare function shapedTextToSVGWithVariation(font: Font, glyphs: ShapedGlyph[], axisCoords: number[], options?: {
     fontSize?: number;
     fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    lineCap?: "butt" | "round" | "square";
+    lineJoin?: "miter" | "round" | "bevel";
 }): string;
 /**
  * Calculate the total advance width of shaped text

package/dist/shaper/complex/indic.d.ts

@@ -103,6 +103,10 @@ export declare enum MatraPosition {
     BelowBase = 2,
     PostBase = 3
 }
+/**
+ * Get matra position based on codepoint
+ */
+export declare function getMatraPosition(cp: number): MatraPosition;
 /**
  * Set up masks and syllable indices for Indic shaping
  */

package/dist/types.d.ts

@@ -129,6 +129,10 @@ export declare const Tags: {
     readonly vhea: number;
     readonly vmtx: number;
     readonly VORG: number;
+    readonly fpgm: number;
+    readonly prep: number;
+    readonly cvt: number;
+    readonly gasp: number;
 };
 export declare const FeatureTags: {
     readonly ccmp: number;

package/dist/unicode/bidi/brackets.gen.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    pairs: string;
+    canonical: string;
+};
+export default _default;

package/dist/unicode/bidi/char-types.gen.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    R: string;
+    EN: string;
+    ES: string;
+    ET: string;
+    AN: string;
+    CS: string;
+    B: string;
+    S: string;
+    WS: string;
+    ON: string;
+    BN: string;
+    NSM: string;
+    AL: string;
+    LRO: string;
+    RLO: string;
+    LRE: string;
+    RLE: string;
+    PDF: string;
+    LRI: string;
+    RLI: string;
+    FSI: string;
+    PDI: string;
+};
+export default _default;

package/dist/unicode/bidi/mirroring.gen.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "14>1,j>2,t>2,u>2,1a>g,2v3>1,1>1,1ge>1,1wd>1,b>1,1j>1,f>1,ai>3,-2>3,+1,8>1k0,-1jq>1y7,-1y6>1hf,-1he>1h6,-1h5>1ha,-1h8>1qi,-1pu>1,6>3u,-3s>7,6>1,1>1,f>1,1>1,+2,3>1,1>1,+13,4>1,1>1,6>1eo,-1ee>1,3>1mg,-1me>1mk,-1mj>1mi,-1mg>1mi,-1md>1,1>1,+2,1>10k,-103>1,1>1,4>1,5>1,1>1,+10,3>1,1>8,-7>8,+1,-6>7,+1,a>1,1>1,u>1,u6>1,1>1,+5,26>1,1>1,2>1,2>2,8>1,7>1,4>1,1>1,+5,b8>1,1>1,+3,1>3,-2>1,2>1,1>1,+2,c>1,3>1,1>1,+2,h>1,3>1,a>1,1>1,2>1,3>1,1>1,d>1,f>1,3>1,1a>1,1>1,6>1,7>1,13>1,k>1,1>1,+19,4>1,1>1,+2,2>1,1>1,+18,m>1,a>1,1>1,lk>1,1>1,4>1,2>1,f>1,3>1,1>1,+3,db>1,1>1,+3,3>1,1>1,+2,14qm>1,1>1,+1,6>1,4j>1,j>2,t>2,u>2,2>1,+1";
+export default _default;

package/package.json

@@ -1,18 +1,47 @@
 {
   "name": "text-shaper",
-  "version": "0.0.1",
-  "description": "Pure TypeScript text shaping engine",
-  "type": "module",
+  "version": "0.1.1",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "devDependencies": {
+    "@biomejs/biome": "2.3.8",
+    "@types/bun": "latest",
+    "vitepress": "^2.0.0-alpha.15",
+    "vitepress-plugin-llms": "^1.9.3"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     }
   },
-  "files": ["dist"],
+  "description": "Pure TypeScript text shaping engine with OpenType layout, TrueType hinting, and FreeType-style rasterization",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "font",
+    "text",
+    "shaping",
+    "harfbuzz",
+    "opentype",
+    "truetype",
+    "rasterizer",
+    "hinting",
+    "typography",
+    "glyph",
+    "freetype",
+    "arabic",
+    "indic",
+    "bidi",
+    "variable-fonts",
+    "lcd-rendering",
+    "texture-atlas"
+  ],
+  "license": "MIT",
   "scripts": {
     "build": "bun build ./src/index.ts --outdir ./dist --target browser --minify --sourcemap=linked",
     "build:prod": "bun build ./src/index.ts --outdir ./dist --target browser --production --sourcemap=external",
@@ -21,13 +50,11 @@
     "typecheck": "tsc --noEmit",
     "lint": "biome check --write --unsafe --max-diagnostics 99999",
     "check": "bun run typecheck && bun run lint",
-    "prepublishOnly": "bun run build:prod && bun run build:dts"
+    "prepublishOnly": "bun run build:prod && bun run build:dts",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs"
   },
-  "devDependencies": {
-    "@biomejs/biome": "2.3.8",
-    "@types/bun": "latest"
-  },
-  "peerDependencies": {
-    "typescript": "^5"
-  }
-}
+  "type": "module",
+  "types": "./dist/index.d.ts"
+}