text-shaper 0.0.1 → 0.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025
+Copyright (c) 2025 wiedymi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,3 +19,8 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+---
+
+Portions of the rasterizer are based on FreeType (https://freetype.org).
+FreeType is copyright (c) 1996-2024 The FreeType Project.

package/README.md

@@ -3,7 +3,7 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![GitHub Sponsors](https://img.shields.io/badge/Sponsor-vivy--company-ea4aaa)](https://github.com/sponsors/vivy-company)
 
-Pure TypeScript text shaping engine. A port of [rustybuzz](https://github.com/RazrFalcon/rustybuzz)/[HarfBuzz](https://github.com/harfbuzz/harfbuzz) for the browser and Node.js.
+Pure TypeScript text shaping engine with OpenType layout, TrueType hinting, and FreeType-style rasterization. Works in browsers and Bun/Node.js with zero dependencies.
 
 ## Features
 
@@ -13,6 +13,9 @@ Pure TypeScript text shaping engine. A port of [rustybuzz](https://github.com/Ra
 - **AAT Support**: morx, kerx, trak tables for Apple fonts
 - **Color Fonts**: SVG, sbix, CBDT/CBLC tables
 - **BiDi**: UAX #9 bidirectional text algorithm
+- **Rasterization**: FreeType-style grayscale, LCD subpixel, and monochrome rendering
+- **TrueType Hinting**: Full bytecode interpreter (150+ opcodes)
+- **Texture Atlas**: GPU-ready glyph atlas generation with shelf packing
 - **Zero Dependencies**: Pure TypeScript, works in browser and Node.js
 
 ## Installation
@@ -106,6 +109,26 @@ const svg = shapedTextToSVG(font, glyphBuffer, { fontSize: 48 });
 - `shapedTextToSVG(font, buffer, options)` - Render shaped text to SVG
 - `renderShapedText(ctx, font, buffer, options)` - Render to Canvas 2D context
 
+### Rasterization
+
+```typescript
+import { Font, rasterizeGlyph, buildAtlas, PixelMode } from "text-shaper";
+
+// Rasterize a single glyph
+const glyph = rasterizeGlyph(font, glyphId, 48, {
+  pixelMode: PixelMode.Gray,  // Gray, Mono, or LCD
+  hinting: true,              // Enable TrueType hinting
+});
+
+// Build a texture atlas for GPU rendering
+const atlas = buildAtlas(font, glyphIds, {
+  fontSize: 32,
+  padding: 1,
+  pixelMode: PixelMode.Gray,
+  hinting: true,
+});
+```
+
 ### Feature Helpers
 
 ```typescript
@@ -156,6 +179,9 @@ COLR, CPAL, SVG, sbix, CBDT, CBLC
 ### Vertical
 vhea, vmtx, VORG
 
+### Hinting
+fpgm, prep, cvt, gasp
+
 ## License
 
 [MIT](LICENSE)

package/dist/font/brotli/context.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Context lookup tables for Brotli decompression
+ * Based on brotli.js reference implementation (Apache 2.0 License)
+ */
+export declare const CONTEXT_LOOKUP: Uint8Array<ArrayBuffer>;
+export declare const CONTEXT_LOOKUP_OFFSETS: Uint16Array<ArrayBuffer>;

package/dist/font/brotli/decode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Pure TypeScript Brotli Decompressor
+ * Based on the brotli.js reference implementation (MIT License)
+ * https://github.com/devongovett/brotli.js
+ */
+/**
+ * Decompress Brotli-compressed data
+ */
+export declare function decompress(data: Uint8Array): Uint8Array;

package/dist/font/brotli/dictionary.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Brotli static dictionary
+ * Based on brotli.js reference implementation (Apache 2.0 License)
+ *
+ * The dictionary is loaded lazily to avoid bloating the initial bundle.
+ */
+export declare const DICTIONARY_OFFSETS_BY_LENGTH: Uint32Array<ArrayBuffer>;
+export declare const DICTIONARY_SIZE_BITS_BY_LENGTH: Uint8Array<ArrayBuffer>;
+export declare const MIN_DICTIONARY_WORD_LENGTH = 4;
+export declare const MAX_DICTIONARY_WORD_LENGTH = 24;
+export declare const DICTIONARY: Uint8Array<ArrayBuffer>;

package/dist/font/brotli/transform.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Dictionary word transformations for Brotli decompression
+ * Based on brotli.js reference implementation (Apache 2.0 License)
+ */
+interface Transform {
+    prefix: Uint8Array;
+    transform: number;
+    suffix: Uint8Array;
+}
+export declare const TRANSFORMS: Transform[];
+export declare function transformDictionaryWord(dst: Uint8Array, idx: number, wordOffset: number, len: number, transformIdx: number, dictionary: Uint8Array): number;
+export {};

package/dist/font/font.d.ts

@@ -8,7 +8,9 @@ import { type Cff2Table } from "./tables/cff2.ts";
 import { type CmapTable } from "./tables/cmap.ts";
 import { type ColrTable } from "./tables/colr.ts";
 import { type CpalTable } from "./tables/cpal.ts";
+import { type FeatTable } from "./tables/feat.ts";
 import { type FvarTable } from "./tables/fvar.ts";
+import { type GaspTable } from "./tables/gasp.ts";
 import { type GdefTable } from "./tables/gdef.ts";
 import { type Contour, type GlyfTable, type Glyph } from "./tables/glyf.ts";
 import { type GposTable } from "./tables/gpos.ts";
@@ -16,6 +18,7 @@ import { type GsubTable } from "./tables/gsub.ts";
 import { type GvarTable } from "./tables/gvar.ts";
 import { type HeadTable } from "./tables/head.ts";
 import { type HheaTable } from "./tables/hhea.ts";
+import { type CvtTable, type FpgmTable, type PrepTable } from "./tables/hinting.ts";
 import { type HmtxTable } from "./tables/hmtx.ts";
 import { type HvarTable } from "./tables/hvar.ts";
 import { type JstfTable } from "./tables/jstf.ts";
@@ -30,7 +33,6 @@ import { type NameTable } from "./tables/name.ts";
 import { type Os2Table } from "./tables/os2.ts";
 import { type PostTable } from "./tables/post.ts";
 import { type SbixTable } from "./tables/sbix.ts";
-import { type FeatTable } from "./tables/feat.ts";
 import { type StatTable } from "./tables/stat.ts";
 import { type SvgTable } from "./tables/svg.ts";
 import { type TrakTable } from "./tables/trak.ts";
@@ -89,12 +91,18 @@ export declare class Font {
     private _cbdt;
     private _cblc;
     private _feat;
+    private _fpgm;
+    private _prep;
+    private _cvt;
+    private _gasp;
     private constructor();
-    /** Load font from ArrayBuffer */
+    /** Load font from ArrayBuffer (sync - does not support WOFF2) */
     static load(buffer: ArrayBuffer, options?: FontLoadOptions): Font;
-    /** Load font from URL (works in browser and Bun) */
+    /** Load font from ArrayBuffer with WOFF2 support (async) */
+    static loadAsync(buffer: ArrayBuffer, options?: FontLoadOptions): Promise<Font>;
+    /** Load font from URL (works in browser and Bun, supports WOFF2) */
     static fromURL(url: string, options?: FontLoadOptions): Promise<Font>;
-    /** Load font from file path (Bun only) */
+    /** Load font from file path (Bun only, supports WOFF2) */
     static fromFile(path: string, options?: FontLoadOptions): Promise<Font>;
     /** Check if font has a specific table */
     hasTable(tag: Tag): boolean;
@@ -141,6 +149,10 @@ export declare class Font {
     get cblc(): CblcTable | null;
     get cbdt(): CbdtTable | null;
     get feat(): FeatTable | null;
+    get fpgm(): FpgmTable | null;
+    get prep(): PrepTable | null;
+    get cvtTable(): CvtTable | null;
+    get gasp(): GaspTable | null;
     /** Number of glyphs in the font */
     get numGlyphs(): number;
     /** Units per em */
@@ -163,6 +175,8 @@ export declare class Font {
     get hasAATLayout(): boolean;
     /** Is this a color font? */
     get isColorFont(): boolean;
+    /** Does this font have TrueType hinting? */
+    get hasHinting(): boolean;
     /** Get glyph ID for a Unicode codepoint */
     glyphId(codepoint: number): GlyphId;
     /** Get glyph ID for a character */
@@ -173,7 +187,7 @@ export declare class Font {
     leftSideBearing(glyphId: GlyphId): number;
     /** List all table tags in the font */
     listTables(): string[];
-    /** Get raw glyph data (simple or composite) */
+    /** Get raw glyph data (simple or composite) - TrueType only */
     getGlyph(glyphId: GlyphId): Glyph | null;
     /** Get flattened contours for a glyph (resolves composites) */
     getGlyphContours(glyphId: GlyphId): Contour[] | null;

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

@@ -78,6 +78,10 @@ export interface PrivateDict {
 }
 export interface FDDict extends PrivateDict {
     fontName?: string;
+    /** Private dict offset and size [size, offset] */
+    private?: [number, number];
+    /** Local subroutines for this FD (parsed from private dict subrs offset) */
+    localSubrs?: Uint8Array[];
 }
 export interface FDSelect {
     format: number;

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

@@ -0,0 +1,54 @@
+/**
+ * gasp table - Grid-fitting And Scan-conversion Procedure
+ *
+ * This table controls when grid-fitting (hinting) and anti-aliasing
+ * should be applied based on the rendering size (ppem).
+ */
+import type { Reader } from "../binary/reader.ts";
+/**
+ * Gasp behavior flags
+ */
+export declare const GaspFlag: {
+    /** Use grid-fitting (hinting) */
+    readonly GridFit: 1;
+    /** Use gray-scale rendering (anti-aliasing) */
+    readonly DoGray: 2;
+    /** Use symmetric grid-fitting (ClearType) */
+    readonly SymmetricGridFit: 4;
+    /** Use symmetric smoothing (ClearType) */
+    readonly SymmetricSmoothing: 8;
+};
+/**
+ * A ppem range with associated behavior
+ */
+export interface GaspRange {
+    /** Maximum ppem for this range (inclusive) */
+    maxPPEM: number;
+    /** Behavior flags for this range */
+    behavior: number;
+}
+/**
+ * gasp table
+ */
+export interface GaspTable {
+    /** Version (0 or 1) */
+    version: number;
+    /** Ranges sorted by maxPPEM */
+    ranges: GaspRange[];
+}
+/**
+ * Parse gasp table
+ */
+export declare function parseGasp(reader: Reader): GaspTable;
+/**
+ * Get behavior flags for a specific ppem
+ */
+export declare function getGaspBehavior(gasp: GaspTable, ppem: number): number;
+/**
+ * Check if grid-fitting should be used
+ */
+export declare function shouldGridFit(gasp: GaspTable, ppem: number): boolean;
+/**
+ * Check if gray-scale rendering should be used
+ */
+export declare function shouldDoGray(gasp: GaspTable, ppem: number): boolean;

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

@@ -33,6 +33,9 @@ export interface GdefTable {
     markGlyphSets: MarkGlyphSets | null;
 }
 export declare function parseGdef(reader: Reader): GdefTable;
+export declare function parseAttachList(reader: Reader): Map<GlyphId, AttachPoint>;
+export declare function parseLigCaretList(reader: Reader): Map<GlyphId, LigatureCaret>;
+export declare function parseMarkGlyphSets(reader: Reader): MarkGlyphSets;
 /** Get glyph class from GDEF */
 export declare function getGlyphClass(gdef: GdefTable | null, glyphId: GlyphId): GlyphClass | 0;
 /** Check if glyph is a base glyph */

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

@@ -36,6 +36,8 @@ export interface GlyphPoint {
     x: number;
     y: number;
     onCurve: boolean;
+    /** True if this is a cubic bezier control point (CFF fonts) */
+    cubic?: boolean;
 }
 /** A contour is a closed path of points */
 export type Contour = GlyphPoint[];

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

@@ -0,0 +1,38 @@
+import type { Reader } from "../binary/reader.ts";
+/**
+ * fpgm table - Font program
+ * Contains TrueType instructions to be executed once when the font is loaded
+ */
+export interface FpgmTable {
+    /** Raw bytecode instructions */
+    instructions: Uint8Array;
+}
+/**
+ * prep table - CVT program (Control Value Program)
+ * Contains TrueType instructions executed whenever the font size or transformation changes
+ */
+export interface PrepTable {
+    /** Raw bytecode instructions */
+    instructions: Uint8Array;
+}
+/**
+ * cvt table - Control Value Table
+ * Contains values referenced by TrueType instructions for consistent spacing/positioning
+ * Values are in FUnits (font design units)
+ */
+export interface CvtTable {
+    /** Control values (FWORD, i.e., int16 in font units) */
+    values: Int16Array;
+}
+/**
+ * Parse fpgm table
+ */
+export declare function parseFpgm(reader: Reader): FpgmTable;
+/**
+ * Parse prep table
+ */
+export declare function parsePrep(reader: Reader): PrepTable;
+/**
+ * Parse cvt table
+ */
+export declare function parseCvt(reader: Reader): CvtTable;

package/dist/font/woff2.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WOFF2 to SFNT Converter
+ *
+ * Converts WOFF2 compressed fonts back to raw TTF/OTF format.
+ * Reference: https://www.w3.org/TR/WOFF2/
+ */
+/** Convert WOFF2 to SFNT */
+export declare function woff2ToSfnt(buffer: ArrayBuffer): Promise<ArrayBuffer>;

package/dist/hinting/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TrueType Hinting Module
+ *
+ * Implements the TrueType bytecode interpreter for grid-fitting.
+ */
+export { execute, runCVTProgram, runFontProgram, runGlyphProgram, runProgram, setCodeRange, } from "./interpreter.ts";
+export { createHintingEngine, executeFontProgram, type GlyphOutline, type HintedGlyph, type HintingEngine, hintedToPixels, hintGlyph, loadCVTProgram, loadFontProgram, setSize, } from "./programs.ts";
+export { compensate, parseSuperRound, round, roundDownToGrid, roundOff, roundSuper, roundSuper45, roundToDoubleGrid, roundToGrid, roundToHalfGrid, roundUpToGrid, } from "./rounding.ts";
+export { type CallRecord, CodeRange, createDefaultGraphicsState, createExecContext, createGlyphZone, type ExecContext, type F2Dot14, type F26Dot6, type FunctionDef, type GlyphZone, type GraphicsState, type InstructionDef, Opcode, type Point, RoundMode, TouchFlag, type UnitVector, } from "./types.ts";

package/dist/hinting/instructions/arithmetic.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Arithmetic and logic instructions
+ */
+import type { ExecContext } from "../types.ts";
+/** ADD - Add top two values */
+export declare function ADD(ctx: ExecContext): void;
+/** SUB - Subtract top two values */
+export declare function SUB(ctx: ExecContext): void;
+/** DIV - Divide (26.6 fixed-point) */
+export declare function DIV(ctx: ExecContext): void;
+/** MUL - Multiply (26.6 fixed-point) */
+export declare function MUL(ctx: ExecContext): void;
+/** ABS - Absolute value */
+export declare function ABS(ctx: ExecContext): void;
+/** NEG - Negate */
+export declare function NEG(ctx: ExecContext): void;
+/** FLOOR - Floor to 26.6 integer (multiple of 64) */
+export declare function FLOOR(ctx: ExecContext): void;
+/** CEILING - Ceiling to 26.6 integer (multiple of 64) */
+export declare function CEILING(ctx: ExecContext): void;
+/** MAX - Maximum of top two */
+export declare function MAX(ctx: ExecContext): void;
+/** MIN - Minimum of top two */
+export declare function MIN(ctx: ExecContext): void;
+/** LT - Less than */
+export declare function LT(ctx: ExecContext): void;
+/** LTEQ - Less than or equal */
+export declare function LTEQ(ctx: ExecContext): void;
+/** GT - Greater than */
+export declare function GT(ctx: ExecContext): void;
+/** GTEQ - Greater than or equal */
+export declare function GTEQ(ctx: ExecContext): void;
+/** EQ - Equal */
+export declare function EQ(ctx: ExecContext): void;
+/** NEQ - Not equal */
+export declare function NEQ(ctx: ExecContext): void;
+/** ODD - Test if odd (after rounding to pixels) */
+export declare function ODD(ctx: ExecContext): void;
+/** EVEN - Test if even (after rounding to pixels) */
+export declare function EVEN(ctx: ExecContext): void;
+/** AND - Logical AND */
+export declare function AND(ctx: ExecContext): void;
+/** OR - Logical OR */
+export declare function OR(ctx: ExecContext): void;
+/** NOT - Logical NOT */
+export declare function NOT(ctx: ExecContext): void;

package/dist/hinting/instructions/control-flow.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Control flow instructions
+ */
+import type { ExecContext } from "../types.ts";
+/** IF - Conditional branch */
+export declare function IF(ctx: ExecContext): void;
+/** ELSE - Alternative branch */
+export declare function ELSE(ctx: ExecContext): void;
+/** EIF - End IF */
+export declare function EIF(_ctx: ExecContext): void;
+/** JMPR - Jump relative */
+export declare function JMPR(ctx: ExecContext): void;
+/** JROT - Jump relative on true */
+export declare function JROT(ctx: ExecContext): void;
+/** JROF - Jump relative on false */
+export declare function JROF(ctx: ExecContext): void;
+/** FDEF - Define function */
+export declare function FDEF(ctx: ExecContext): void;
+/** ENDF - End function definition */
+export declare function ENDF(ctx: ExecContext): void;
+/** CALL - Call function */
+export declare function CALL(ctx: ExecContext): void;
+/** LOOPCALL - Call function with loop count */
+export declare function LOOPCALL(ctx: ExecContext): void;
+/** IDEF - Define instruction */
+export declare function IDEF(ctx: ExecContext): void;

package/dist/hinting/instructions/delta.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Delta instructions
+ *
+ * These instructions allow fine-tuning of point positions and CVT values
+ * at specific pixel-per-em (ppem) sizes. This is useful for fixing
+ * rendering issues that only appear at certain sizes.
+ */
+import type { ExecContext } from "../types.ts";
+/**
+ * DELTAP1 - Delta exception point (ppem 0-15 + deltaBase)
+ */
+export declare function DELTAP1(ctx: ExecContext): void;
+/**
+ * DELTAP2 - Delta exception point (ppem 16-31 + deltaBase)
+ */
+export declare function DELTAP2(ctx: ExecContext): void;
+/**
+ * DELTAP3 - Delta exception point (ppem 32-47 + deltaBase)
+ */
+export declare function DELTAP3(ctx: ExecContext): void;
+/**
+ * DELTAC1 - Delta exception CVT (ppem 0-15 + deltaBase)
+ */
+export declare function DELTAC1(ctx: ExecContext): void;
+/**
+ * DELTAC2 - Delta exception CVT (ppem 16-31 + deltaBase)
+ */
+export declare function DELTAC2(ctx: ExecContext): void;
+/**
+ * DELTAC3 - Delta exception CVT (ppem 32-47 + deltaBase)
+ */
+export declare function DELTAC3(ctx: ExecContext): void;

package/dist/hinting/instructions/graphics-state.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Graphics state manipulation instructions
+ */
+import { type ExecContext } from "../types.ts";
+/** SVTCA - Set vectors to coordinate axis (both projection and freedom) */
+export declare function SVTCA(ctx: ExecContext, axis: 0 | 1): void;
+/** SPVTCA - Set projection vector to coordinate axis */
+export declare function SPVTCA(ctx: ExecContext, axis: 0 | 1): void;
+/** SFVTCA - Set freedom vector to coordinate axis */
+export declare function SFVTCA(ctx: ExecContext, axis: 0 | 1): void;
+/** SPVTL - Set projection vector to line */
+export declare function SPVTL(ctx: ExecContext, perpendicular: boolean): void;
+/** SFVTL - Set freedom vector to line */
+export declare function SFVTL(ctx: ExecContext, perpendicular: boolean): void;
+/** SDPVTL - Set dual projection vector to line (only sets dualVector, not projVector) */
+export declare function SDPVTL(ctx: ExecContext, perpendicular: boolean): void;
+/** SPVFS - Set projection vector from stack */
+export declare function SPVFS(ctx: ExecContext): void;
+/** SFVFS - Set freedom vector from stack */
+export declare function SFVFS(ctx: ExecContext): void;
+/** GPV - Get projection vector */
+export declare function GPV(ctx: ExecContext): void;
+/** GFV - Get freedom vector */
+export declare function GFV(ctx: ExecContext): void;
+/** SFVTPV - Set freedom vector to projection vector */
+export declare function SFVTPV(ctx: ExecContext): void;
+/** SRP0 - Set reference point 0 */
+export declare function SRP0(ctx: ExecContext): void;
+/** SRP1 - Set reference point 1 */
+export declare function SRP1(ctx: ExecContext): void;
+/** SRP2 - Set reference point 2 */
+export declare function SRP2(ctx: ExecContext): void;
+/** SZP0 - Set zone pointer 0 */
+export declare function SZP0(ctx: ExecContext): void;
+/** SZP1 - Set zone pointer 1 */
+export declare function SZP1(ctx: ExecContext): void;
+/** SZP2 - Set zone pointer 2 */
+export declare function SZP2(ctx: ExecContext): void;
+/** SZPS - Set all zone pointers */
+export declare function SZPS(ctx: ExecContext): void;
+/** SLOOP - Set loop counter */
+export declare function SLOOP(ctx: ExecContext): void;
+/** SMD - Set minimum distance */
+export declare function SMD(ctx: ExecContext): void;
+/** SCVTCI - Set control value table cut-in */
+export declare function SCVTCI(ctx: ExecContext): void;
+/** SSWCI - Set single width cut-in */
+export declare function SSWCI(ctx: ExecContext): void;
+/** SSW - Set single width value */
+export declare function SSW(ctx: ExecContext): void;
+/** SDB - Set delta base */
+export declare function SDB(ctx: ExecContext): void;
+/** SDS - Set delta shift */
+export declare function SDS(ctx: ExecContext): void;
+/** RTG - Round to grid */
+export declare function RTG(ctx: ExecContext): void;
+/** RTHG - Round to half grid */
+export declare function RTHG(ctx: ExecContext): void;
+/** RTDG - Round to double grid */
+export declare function RTDG(ctx: ExecContext): void;
+/** RDTG - Round down to grid */
+export declare function RDTG(ctx: ExecContext): void;
+/** RUTG - Round up to grid */
+export declare function RUTG(ctx: ExecContext): void;
+/** ROFF - Rounding off */
+export declare function ROFF(ctx: ExecContext): void;
+/** SROUND - Super round */
+export declare function SROUND(ctx: ExecContext): void;
+/** S45ROUND - Super round 45 degrees */
+export declare function S45ROUND(ctx: ExecContext): void;
+/** FLIPON - Turn auto-flip on */
+export declare function FLIPON(ctx: ExecContext): void;
+/** FLIPOFF - Turn auto-flip off */
+export declare function FLIPOFF(ctx: ExecContext): void;
+/** SCANCTRL - Set scan conversion control */
+export declare function SCANCTRL(ctx: ExecContext): void;
+/** SCANTYPE - Set scan type */
+export declare function SCANTYPE(ctx: ExecContext): void;
+/** INSTCTRL - Set instruction control */
+export declare function INSTCTRL(ctx: ExecContext): void;
+/** GETINFO - Get font engine info */
+export declare function GETINFO(ctx: ExecContext): void;
+/** RS - Read storage */
+export declare function RS(ctx: ExecContext): void;
+/** WS - Write storage */
+export declare function WS(ctx: ExecContext): void;
+/** RCVT - Read CVT value */
+export declare function RCVT(ctx: ExecContext): void;
+/** WCVTP - Write CVT value in pixels */
+export declare function WCVTP(ctx: ExecContext): void;
+/** WCVTF - Write CVT value in font units */
+export declare function WCVTF(ctx: ExecContext): void;
+/** UTP - UnTouch Point */
+export declare function UTP(ctx: ExecContext): void;

package/dist/hinting/instructions/interpolate.d.ts

@@ -0,0 +1,16 @@
+/**
+ * IUP - Interpolate Untouched Points
+ *
+ * This instruction interpolates all points that haven't been touched
+ * by previous hinting instructions. It's typically called near the end
+ * of glyph hinting to smooth out the positions of all remaining points.
+ */
+import { type ExecContext } from "../types.ts";
+/**
+ * Interpolate untouched points in X direction
+ */
+export declare function IUP_X(ctx: ExecContext): void;
+/**
+ * Interpolate untouched points in Y direction
+ */
+export declare function IUP_Y(ctx: ExecContext): void;

package/dist/hinting/instructions/points.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Point movement instructions
+ *
+ * These are the core hinting operations that actually move glyph points.
+ */
+import { type ExecContext, type F26Dot6, type GlyphZone, type Point } from "../types.ts";
+/**
+ * Project a point onto the projection vector
+ */
+export declare function project(ctx: ExecContext, p: Point): F26Dot6;
+/**
+ * Project using dual vector (for original positions)
+ */
+export declare function dualProject(ctx: ExecContext, p: Point): F26Dot6;
+/**
+ * Move a point along the freedom vector
+ */
+export declare function movePoint(ctx: ExecContext, zone: GlyphZone, pointIndex: number, distance: F26Dot6): void;
+/**
+ * Get current position of a point projected onto projection vector
+ */
+export declare function getCurrent(ctx: ExecContext, zone: GlyphZone, pointIndex: number): F26Dot6;
+/**
+ * Get original position of a point projected onto dual vector
+ */
+export declare function getOriginal(ctx: ExecContext, zone: GlyphZone, pointIndex: number): F26Dot6;
+/**
+ * Mark point as touched in the current direction
+ */
+export declare function touchPoint(ctx: ExecContext, zone: GlyphZone, pointIndex: number): void;
+/** MDAP - Move Direct Absolute Point */
+export declare function MDAP(ctx: ExecContext, doRound: boolean): void;
+/** MIAP - Move Indirect Absolute Point (uses CVT) */
+export declare function MIAP(ctx: ExecContext, doRound: boolean): void;
+/** MDRP - Move Direct Relative Point */
+export declare function MDRP(ctx: ExecContext, flags: number): void;
+/** MIRP - Move Indirect Relative Point (uses CVT) */
+export declare function MIRP(ctx: ExecContext, flags: number): void;
+/** SHP - Shift Point using reference point */
+export declare function SHP(ctx: ExecContext, useRp1: boolean): void;
+/** SHC - Shift Contour using reference point */
+export declare function SHC(ctx: ExecContext, useRp1: boolean): void;
+/** SHZ - Shift Zone using reference point */
+export declare function SHZ(ctx: ExecContext, useRp1: boolean): void;
+/** SHPIX - Shift Point by Pixel Amount */
+export declare function SHPIX(ctx: ExecContext): void;
+/** IP - Interpolate Point */
+export declare function IP(ctx: ExecContext): void;
+/** ALIGNRP - Align to Reference Point */
+export declare function ALIGNRP(ctx: ExecContext): void;
+/** MSIRP - Move Stack Indirect Relative Point */
+export declare function MSIRP(ctx: ExecContext, setRp0: boolean): void;
+/** ISECT - Move Point to Intersection of two lines */
+export declare function ISECT(ctx: ExecContext): void;
+/** ALIGNPTS - Align two points */
+export declare function ALIGNPTS(ctx: ExecContext): void;
+/** GC - Get Coordinate projected onto projection vector */
+export declare function GC(ctx: ExecContext, useOriginal: boolean): void;
+/** SCFS - Set Coordinate From Stack */
+export declare function SCFS(ctx: ExecContext): void;
+/** MD - Measure Distance between two points */
+export declare function MD(ctx: ExecContext, useOriginal: boolean): void;
+/** MPPEM - Measure Pixels Per EM */
+export declare function MPPEM(ctx: ExecContext): void;
+/** MPS - Measure Point Size */
+export declare function MPS(ctx: ExecContext): void;
+/** FLIPPT - Flip on-curve/off-curve flag */
+export declare function FLIPPT(ctx: ExecContext): void;
+/** FLIPRGON - Set on-curve flag for range */
+export declare function FLIPRGON(ctx: ExecContext): void;
+/** FLIPRGOFF - Clear on-curve flag for range */
+export declare function FLIPRGOFF(ctx: ExecContext): void;
+/** ROUND - Round value */
+export declare function ROUND(ctx: ExecContext, _colorIndex: number): void;
+/** NROUND - No-round (just applies engine compensation) */
+export declare function NROUND(ctx: ExecContext, _colorIndex: number): void;

package/dist/hinting/instructions/stack.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Stack manipulation instructions
+ */
+import type { ExecContext } from "../types.ts";
+/** DUP - Duplicate top of stack */
+export declare function DUP(ctx: ExecContext): void;
+/** POP - Pop top of stack */
+export declare function POP(ctx: ExecContext): void;
+/** CLEAR - Clear the entire stack */
+export declare function CLEAR(ctx: ExecContext): void;
+/** SWAP - Swap top two elements */
+export declare function SWAP(ctx: ExecContext): void;
+/** DEPTH - Push stack depth */
+export declare function DEPTH(ctx: ExecContext): void;
+/** CINDEX - Copy indexed element to top */
+export declare function CINDEX(ctx: ExecContext): void;
+/** MINDEX - Move indexed element to top */
+export declare function MINDEX(ctx: ExecContext): void;
+/** ROLL - Roll top three elements */
+export declare function ROLL(ctx: ExecContext): void;
+/** Push byte(s) from instruction stream */
+export declare function PUSHB(ctx: ExecContext, count: number): void;
+/** Push word(s) from instruction stream */
+export declare function PUSHW(ctx: ExecContext, count: number): void;
+/** NPUSHB - Push N bytes */
+export declare function NPUSHB(ctx: ExecContext): void;
+/** NPUSHW - Push N words */
+export declare function NPUSHW(ctx: ExecContext): void;