text-shaper 0.0.1

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

@@ -0,0 +1,79 @@
+import type { int16, uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * BASE table - Baseline alignment data
+ * Provides baseline offsets for scripts to align mixed-script text
+ */
+/** Baseline tags */
+export declare const BaselineTag: {
+    /** Hanging baseline (Devanagari, Tibetan) */
+    readonly hang: 1751215719;
+    /** Ideographic character face bottom edge (CJK) */
+    readonly icfb: 1768121954;
+    /** Ideographic character face top edge (CJK) */
+    readonly icft: 1768121972;
+    /** Ideographic em-box bottom edge (CJK) */
+    readonly ideo: 1768187247;
+    /** Ideographic em-box top edge */
+    readonly idtp: 1768191088;
+    /** Mathematical baseline (math layout) */
+    readonly math: 1835103336;
+    /** Roman baseline (Latin, Greek, Cyrillic) */
+    readonly romn: 1919905134;
+};
+/** A single baseline value */
+export interface BaselineValue {
+    baselineTag: number;
+    coordinate: int16;
+}
+/** Min/max extent values */
+export interface MinMaxRecord {
+    minCoord: int16 | null;
+    maxCoord: int16 | null;
+}
+/** Feature-specific min/max values */
+export interface FeatMinMaxRecord {
+    featureTag: number;
+    minCoord: int16 | null;
+    maxCoord: int16 | null;
+}
+/** Base values for a script */
+export interface BaseValues {
+    defaultBaselineIndex: uint16;
+    baseCoords: int16[];
+}
+/** MinMax values for a language system */
+export interface MinMax {
+    minCoord: int16 | null;
+    maxCoord: int16 | null;
+    featMinMaxRecords: FeatMinMaxRecord[];
+}
+/** Base script record */
+export interface BaseScriptRecord {
+    scriptTag: number;
+    baseValues: BaseValues | null;
+    defaultMinMax: MinMax | null;
+    baseLangSysRecords: Map<number, MinMax>;
+}
+/** Axis table (horizontal or vertical) */
+export interface AxisTable {
+    baseTagList: number[];
+    baseScriptList: BaseScriptRecord[];
+}
+/** BASE table */
+export interface BaseTable {
+    majorVersion: uint16;
+    minorVersion: uint16;
+    horizAxis: AxisTable | null;
+    vertAxis: AxisTable | null;
+}
+export declare function parseBase(reader: Reader): BaseTable;
+/** Get baseline value for a script */
+export declare function getBaselineForScript(base: BaseTable, scriptTag: number, baselineTag: number, horizontal?: boolean): int16 | null;
+/** Get default baseline for a script */
+export declare function getDefaultBaseline(base: BaseTable, scriptTag: number, horizontal?: boolean): {
+    tag: number;
+    coordinate: int16;
+} | null;
+/** Get min/max extent for a script/language */
+export declare function getMinMaxExtent(base: BaseTable, scriptTag: number, languageTag?: number, horizontal?: boolean): MinMaxRecord | null;

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

@@ -0,0 +1,120 @@
+import type { GlyphId, int8, uint8, uint16, uint32 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * Color Bitmap Data Table (CBDT)
+ * Google's color bitmap table for emoji fonts
+ * Used together with CBLC (Color Bitmap Location Table)
+ */
+export interface CbdtTable {
+    majorVersion: uint16;
+    minorVersion: uint16;
+    /** Raw data for bitmap lookup */
+    data: Uint8Array;
+}
+/**
+ * Color Bitmap Location Table (CBLC)
+ * Index for looking up bitmaps in CBDT
+ */
+export interface CblcTable {
+    majorVersion: uint16;
+    minorVersion: uint16;
+    bitmapSizes: BitmapSize[];
+}
+/**
+ * Bitmap size record
+ */
+export interface BitmapSize {
+    indexSubTableArrayOffset: uint32;
+    indexTablesSize: uint32;
+    numberOfIndexSubTables: uint32;
+    colorRef: uint32;
+    hori: SbitLineMetrics;
+    vert: SbitLineMetrics;
+    startGlyphIndex: GlyphId;
+    endGlyphIndex: GlyphId;
+    ppemX: uint8;
+    ppemY: uint8;
+    bitDepth: uint8;
+    flags: int8;
+    indexSubTables: IndexSubTable[];
+}
+/**
+ * Line metrics for bitmap glyphs
+ */
+export interface SbitLineMetrics {
+    ascender: int8;
+    descender: int8;
+    widthMax: uint8;
+    caretSlopeNumerator: int8;
+    caretSlopeDenominator: int8;
+    caretOffset: int8;
+    minOriginSB: int8;
+    minAdvanceSB: int8;
+    maxBeforeBL: int8;
+    minAfterBL: int8;
+    pad1: int8;
+    pad2: int8;
+}
+/**
+ * Index sub-table for glyph lookup
+ */
+export interface IndexSubTable {
+    firstGlyphIndex: GlyphId;
+    lastGlyphIndex: GlyphId;
+    indexFormat: uint16;
+    imageFormat: uint16;
+    imageDataOffset: uint32;
+    /** Glyph offsets (format-dependent) */
+    glyphOffsets: Map<GlyphId, {
+        offset: uint32;
+        length: uint32;
+    }>;
+}
+/**
+ * Bitmap glyph metrics
+ */
+export interface GlyphBitmapMetrics {
+    height: uint8;
+    width: uint8;
+    bearingX: int8;
+    bearingY: int8;
+    advance: uint8;
+}
+/**
+ * Bitmap glyph data
+ */
+export interface BitmapGlyph {
+    metrics: GlyphBitmapMetrics;
+    imageFormat: uint16;
+    data: Uint8Array;
+}
+/**
+ * Image formats in CBDT
+ */
+export declare const CbdtImageFormat: {
+    readonly SmallMetrics: 1;
+    readonly SmallMetricsPng: 17;
+    readonly BigMetrics: 2;
+    readonly BigMetricsPng: 18;
+    readonly CompressedPng: 19;
+};
+/**
+ * Parse CBLC table
+ */
+export declare function parseCblc(reader: Reader): CblcTable;
+/**
+ * Parse CBDT table
+ */
+export declare function parseCbdt(reader: Reader): CbdtTable;
+/**
+ * Get bitmap glyph from CBDT using CBLC index
+ */
+export declare function getBitmapGlyph(cblc: CblcTable, cbdt: CbdtTable, glyphId: GlyphId, ppem: number): BitmapGlyph | null;
+/**
+ * Check if glyph has color bitmap
+ */
+export declare function hasColorBitmap(cblc: CblcTable, glyphId: GlyphId, ppem?: number): boolean;
+/**
+ * Get available ppem sizes for color bitmaps
+ */
+export declare function getColorBitmapSizes(cblc: CblcTable): number[];

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

@@ -0,0 +1,16 @@
+import type { GlyphId } from "../../types.ts";
+import type { CffTable } from "./cff.ts";
+import type { Cff2Table } from "./cff2.ts";
+import type { Contour } from "./glyf.ts";
+/**
+ * Execute a CFF charstring and return contours
+ */
+export declare function executeCffCharString(cff: CffTable, glyphId: GlyphId, fontIndex?: number): Contour[] | null;
+/**
+ * Execute a CFF2 charstring with variation support
+ */
+export declare function executeCff2CharString(cff2: Cff2Table, glyphId: GlyphId, axisCoords?: number[] | null): Contour[] | null;
+/**
+ * Get glyph width from CFF charstring
+ */
+export declare function getCffGlyphWidth(cff: CffTable, _glyphId: GlyphId, fontIndex?: number): number;

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

@@ -0,0 +1,93 @@
+import { Reader } from "../binary/reader.ts";
+/**
+ * CFF (Compact Font Format) table parser
+ * Used by OpenType fonts with PostScript outlines
+ */
+export interface CffTable {
+    version: {
+        major: number;
+        minor: number;
+    };
+    names: string[];
+    topDicts: TopDict[];
+    strings: string[];
+    globalSubrs: Uint8Array[];
+    charStrings: Uint8Array[][];
+    localSubrs: Uint8Array[][];
+    fdArrays: FDDict[][];
+    fdSelects: FDSelect[];
+}
+export interface TopDict {
+    version?: string;
+    notice?: string;
+    copyright?: string;
+    fullName?: string;
+    familyName?: string;
+    weight?: string;
+    isFixedPitch?: boolean;
+    italicAngle?: number;
+    underlinePosition?: number;
+    underlineThickness?: number;
+    paintType?: number;
+    charstringType?: number;
+    fontMatrix?: number[];
+    uniqueID?: number;
+    fontBBox?: number[];
+    strokeWidth?: number;
+    charset?: number;
+    encoding?: number;
+    charStrings?: number;
+    private?: [number, number];
+    syntheticBase?: number;
+    postScript?: string;
+    baseFontName?: string;
+    baseFontBlend?: number[];
+    ros?: {
+        registry: string;
+        ordering: string;
+        supplement: number;
+    };
+    cidFontVersion?: number;
+    cidFontRevision?: number;
+    cidFontType?: number;
+    cidCount?: number;
+    uidBase?: number;
+    fdArray?: number;
+    fdSelect?: number;
+    fontName?: string;
+}
+export interface PrivateDict {
+    blueValues?: number[];
+    otherBlues?: number[];
+    familyBlues?: number[];
+    familyOtherBlues?: number[];
+    blueScale?: number;
+    blueShift?: number;
+    blueFuzz?: number;
+    stdHW?: number;
+    stdVW?: number;
+    stemSnapH?: number[];
+    stemSnapV?: number[];
+    forceBold?: boolean;
+    languageGroup?: number;
+    expansionFactor?: number;
+    initialRandomSeed?: number;
+    subrs?: number;
+    defaultWidthX?: number;
+    nominalWidthX?: number;
+}
+export interface FDDict extends PrivateDict {
+    fontName?: string;
+}
+export interface FDSelect {
+    format: number;
+    select: (glyphId: number) => number;
+}
+/**
+ * Parse CFF table
+ */
+export declare function parseCff(reader: Reader): CffTable;
+/**
+ * Get string by SID
+ */
+export declare function getCffString(cff: CffTable, sid: number): string;

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

@@ -0,0 +1,85 @@
+import { Reader } from "../binary/reader.ts";
+/**
+ * CFF2 (Compact Font Format 2) table parser
+ * Used by variable fonts with PostScript outlines
+ */
+export interface Cff2Table {
+    version: {
+        major: number;
+        minor: number;
+    };
+    topDict: Cff2TopDict;
+    globalSubrs: Uint8Array[];
+    charStrings: Uint8Array[];
+    fdArray: Cff2FDDict[];
+    fdSelect: Cff2FDSelect | null;
+    vstore: ItemVariationStore | null;
+}
+export interface Cff2TopDict {
+    charStrings?: number;
+    fdArray?: number;
+    fdSelect?: number;
+    vstore?: number;
+    fontMatrix?: number[];
+}
+export interface Cff2PrivateDict {
+    blueValues?: number[];
+    otherBlues?: number[];
+    familyBlues?: number[];
+    familyOtherBlues?: number[];
+    blueScale?: number;
+    blueShift?: number;
+    blueFuzz?: number;
+    stdHW?: number;
+    stdVW?: number;
+    stemSnapH?: number[];
+    stemSnapV?: number[];
+    languageGroup?: number;
+    expansionFactor?: number;
+    subrs?: number;
+    vsindex?: number;
+    blend?: number[];
+}
+export interface Cff2FDDict {
+    fontName?: string;
+    private?: Cff2PrivateDict;
+    privateOffset?: number;
+    privateSize?: number;
+    localSubrs?: Uint8Array[];
+}
+export interface Cff2FDSelect {
+    format: number;
+    select: (glyphId: number) => number;
+}
+export interface ItemVariationStore {
+    format: number;
+    variationRegionList: VariationRegionList;
+    itemVariationData: ItemVariationData[];
+}
+export interface VariationRegionList {
+    axisCount: number;
+    regionCount: number;
+    regions: VariationRegion[];
+}
+export interface VariationRegion {
+    axes: RegionAxisCoordinates[];
+}
+export interface RegionAxisCoordinates {
+    startCoord: number;
+    peakCoord: number;
+    endCoord: number;
+}
+export interface ItemVariationData {
+    itemCount: number;
+    regionIndexCount: number;
+    regionIndexes: number[];
+    deltaSets: number[][];
+}
+/**
+ * Parse CFF2 table
+ */
+export declare function parseCff2(reader: Reader): Cff2Table;
+/**
+ * Calculate variation delta for given coordinates
+ */
+export declare function calculateVariationDelta(vstore: ItemVariationStore, outerIndex: number, innerIndex: number, normalizedCoords: number[]): number;

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

@@ -0,0 +1,81 @@
+import type { GlyphId, uint16, uint32 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/** Platform IDs */
+export declare enum PlatformId {
+    Unicode = 0,
+    Macintosh = 1,
+    ISO = 2,// deprecated
+    Windows = 3,
+    Custom = 4
+}
+/** Encoding record in cmap header */
+export interface EncodingRecord {
+    platformId: uint16;
+    encodingId: uint16;
+    offset: uint32;
+}
+/** Base interface for cmap subtables */
+interface CmapSubtableBase {
+    format: number;
+    lookup(codepoint: number): GlyphId | undefined;
+}
+/** Format 0: Byte encoding table (legacy, 256 entries) */
+interface CmapFormat0 extends CmapSubtableBase {
+    format: 0;
+    glyphIdArray: Uint8Array;
+}
+/** Format 4: Segment mapping to delta values (BMP characters) */
+interface CmapFormat4 extends CmapSubtableBase {
+    format: 4;
+    segCount: number;
+    endCodes: Uint16Array;
+    startCodes: Uint16Array;
+    idDeltas: Int16Array;
+    idRangeOffsets: Uint16Array;
+    glyphIdArray: Uint16Array;
+}
+/** Format 12: Segmented coverage (full Unicode) */
+interface CmapFormat12 extends CmapSubtableBase {
+    format: 12;
+    groups: Array<{
+        startCharCode: uint32;
+        endCharCode: uint32;
+        startGlyphId: uint32;
+    }>;
+}
+/** Variation selector record */
+interface VariationSelectorRecord {
+    varSelector: number;
+    defaultUVS: Array<{
+        startUnicodeValue: number;
+        additionalCount: number;
+    }> | null;
+    nonDefaultUVS: Array<{
+        unicodeValue: number;
+        glyphId: GlyphId;
+    }> | null;
+}
+/** Format 14: Unicode Variation Sequences */
+interface CmapFormat14 extends CmapSubtableBase {
+    format: 14;
+    varSelectorRecords: VariationSelectorRecord[];
+    lookupVariation(codepoint: number, variationSelector: number): GlyphId | undefined | "default";
+}
+export type CmapSubtable = CmapFormat0 | CmapFormat4 | CmapFormat12 | CmapFormat14;
+/** Character to glyph index mapping table */
+export interface CmapTable {
+    version: uint16;
+    numTables: uint16;
+    encodingRecords: EncodingRecord[];
+    subtables: Map<string, CmapSubtable>;
+    /** Best subtable for Unicode lookup */
+    bestSubtable: CmapSubtable | null;
+}
+export declare function parseCmap(reader: Reader, tableLength: number): CmapTable;
+/** Get glyph ID for a codepoint using the best subtable */
+export declare function getGlyphId(cmap: CmapTable, codepoint: number): GlyphId;
+/** Get glyph ID for a variation sequence (base + variation selector) */
+export declare function getVariationGlyphId(cmap: CmapTable, codepoint: number, variationSelector: number): GlyphId | undefined;
+/** Check if a codepoint is a variation selector */
+export declare function isVariationSelector(codepoint: number): boolean;
+export {};