text-shaper 0.1.1 → 0.1.3

package/dist/layout/justify.d.ts

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

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

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

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

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

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

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

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

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

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

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