text-shaper 0.0.1

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

@@ -0,0 +1,168 @@
+import { type Coverage } from "../../layout/structures/coverage.ts";
+import { type DeviceOrVariationIndex } from "../../layout/structures/device.ts";
+import type { GlyphId, int16, uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * MATH table - Mathematical typesetting data
+ * Provides metrics and glyph information for math layout
+ */
+/** MathValueRecord - value with optional device correction */
+export interface MathValueRecord {
+    value: int16;
+    device: DeviceOrVariationIndex | null;
+}
+/** MathConstants - global math constants */
+export interface MathConstants {
+    scriptPercentScaleDown: int16;
+    scriptScriptPercentScaleDown: int16;
+    delimitedSubFormulaMinHeight: uint16;
+    displayOperatorMinHeight: uint16;
+    mathLeading: MathValueRecord;
+    axisHeight: MathValueRecord;
+    accentBaseHeight: MathValueRecord;
+    flattenedAccentBaseHeight: MathValueRecord;
+    subscriptShiftDown: MathValueRecord;
+    subscriptTopMax: MathValueRecord;
+    subscriptBaselineDropMin: MathValueRecord;
+    superscriptShiftUp: MathValueRecord;
+    superscriptShiftUpCramped: MathValueRecord;
+    superscriptBottomMin: MathValueRecord;
+    superscriptBaselineDropMax: MathValueRecord;
+    subSuperscriptGapMin: MathValueRecord;
+    superscriptBottomMaxWithSubscript: MathValueRecord;
+    spaceAfterScript: MathValueRecord;
+    upperLimitGapMin: MathValueRecord;
+    upperLimitBaselineRiseMin: MathValueRecord;
+    lowerLimitGapMin: MathValueRecord;
+    lowerLimitBaselineDropMin: MathValueRecord;
+    stackTopShiftUp: MathValueRecord;
+    stackTopDisplayStyleShiftUp: MathValueRecord;
+    stackBottomShiftDown: MathValueRecord;
+    stackBottomDisplayStyleShiftDown: MathValueRecord;
+    stackGapMin: MathValueRecord;
+    stackDisplayStyleGapMin: MathValueRecord;
+    stretchStackTopShiftUp: MathValueRecord;
+    stretchStackBottomShiftDown: MathValueRecord;
+    stretchStackGapAboveMin: MathValueRecord;
+    stretchStackGapBelowMin: MathValueRecord;
+    fractionNumeratorShiftUp: MathValueRecord;
+    fractionNumeratorDisplayStyleShiftUp: MathValueRecord;
+    fractionDenominatorShiftDown: MathValueRecord;
+    fractionDenominatorDisplayStyleShiftDown: MathValueRecord;
+    fractionNumeratorGapMin: MathValueRecord;
+    fractionNumDisplayStyleGapMin: MathValueRecord;
+    fractionRuleThickness: MathValueRecord;
+    fractionDenominatorGapMin: MathValueRecord;
+    fractionDenomDisplayStyleGapMin: MathValueRecord;
+    skewedFractionHorizontalGap: MathValueRecord;
+    skewedFractionVerticalGap: MathValueRecord;
+    overbarVerticalGap: MathValueRecord;
+    overbarRuleThickness: MathValueRecord;
+    overbarExtraAscender: MathValueRecord;
+    underbarVerticalGap: MathValueRecord;
+    underbarRuleThickness: MathValueRecord;
+    underbarExtraDescender: MathValueRecord;
+    radicalVerticalGap: MathValueRecord;
+    radicalDisplayStyleVerticalGap: MathValueRecord;
+    radicalRuleThickness: MathValueRecord;
+    radicalExtraAscender: MathValueRecord;
+    radicalKernBeforeDegree: MathValueRecord;
+    radicalKernAfterDegree: MathValueRecord;
+    radicalDegreeBottomRaisePercent: int16;
+}
+/** Italic correction info */
+export interface MathItalicsCorrection {
+    coverage: Coverage;
+    values: MathValueRecord[];
+}
+/** Top accent attachment */
+export interface MathTopAccentAttachment {
+    coverage: Coverage;
+    values: MathValueRecord[];
+}
+/** Extended shape coverage */
+export interface ExtendedShapeCoverage {
+    coverage: Coverage;
+}
+/** Math kern record for corner kerns */
+export interface MathKernRecord {
+    correctionHeights: MathValueRecord[];
+    kernValues: MathValueRecord[];
+}
+/** Math kern info for a glyph */
+export interface MathKernInfo {
+    topRight: MathKernRecord | null;
+    topLeft: MathKernRecord | null;
+    bottomRight: MathKernRecord | null;
+    bottomLeft: MathKernRecord | null;
+}
+/** Math kern info table */
+export interface MathKernInfoTable {
+    coverage: Coverage;
+    kernInfo: MathKernInfo[];
+}
+/** MathGlyphInfo - per-glyph math info */
+export interface MathGlyphInfo {
+    italicsCorrection: MathItalicsCorrection | null;
+    topAccentAttachment: MathTopAccentAttachment | null;
+    extendedShapeCoverage: ExtendedShapeCoverage | null;
+    kernInfo: MathKernInfoTable | null;
+}
+/** Glyph part record for assembly */
+export interface GlyphPartRecord {
+    glyphId: GlyphId;
+    startConnectorLength: uint16;
+    endConnectorLength: uint16;
+    fullAdvance: uint16;
+    partFlags: uint16;
+}
+/** Glyph assembly */
+export interface GlyphAssembly {
+    italicsCorrection: MathValueRecord;
+    parts: GlyphPartRecord[];
+}
+/** Math glyph construction */
+export interface MathGlyphConstruction {
+    glyphAssembly: GlyphAssembly | null;
+    variants: Array<{
+        variantGlyph: GlyphId;
+        advanceMeasurement: uint16;
+    }>;
+}
+/** MathVariants - glyph variants and construction */
+export interface MathVariants {
+    minConnectorOverlap: uint16;
+    vertGlyphCoverage: Coverage | null;
+    horizGlyphCoverage: Coverage | null;
+    vertGlyphConstruction: MathGlyphConstruction[];
+    horizGlyphConstruction: MathGlyphConstruction[];
+}
+/** MATH table */
+export interface MathTable {
+    majorVersion: uint16;
+    minorVersion: uint16;
+    constants: MathConstants | null;
+    glyphInfo: MathGlyphInfo | null;
+    variants: MathVariants | null;
+}
+export declare function parseMath(reader: Reader): MathTable;
+/** Get italic correction for a glyph */
+export declare function getItalicsCorrection(math: MathTable, glyphId: GlyphId): MathValueRecord | null;
+/** Get top accent attachment for a glyph */
+export declare function getTopAccentAttachment(math: MathTable, glyphId: GlyphId): MathValueRecord | null;
+/** Check if glyph is an extended shape */
+export declare function isExtendedShape(math: MathTable, glyphId: GlyphId): boolean;
+/** Get vertical glyph variants */
+export declare function getVerticalVariants(math: MathTable, glyphId: GlyphId): Array<{
+    variantGlyph: GlyphId;
+    advanceMeasurement: uint16;
+}> | null;
+/** Get horizontal glyph variants */
+export declare function getHorizontalVariants(math: MathTable, glyphId: GlyphId): Array<{
+    variantGlyph: GlyphId;
+    advanceMeasurement: uint16;
+}> | null;
+/** Get vertical glyph assembly */
+export declare function getVerticalAssembly(math: MathTable, glyphId: GlyphId): GlyphAssembly | null;
+/** Get horizontal glyph assembly */
+export declare function getHorizontalAssembly(math: MathTable, glyphId: GlyphId): GlyphAssembly | null;

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

@@ -0,0 +1,27 @@
+import type { uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/** Maximum profile table (version 0.5 - CFF) */
+export interface MaxpTable05 {
+    version: 0x00005000;
+    numGlyphs: uint16;
+}
+/** Maximum profile table (version 1.0 - TrueType) */
+export interface MaxpTable10 {
+    version: 0x00010000;
+    numGlyphs: uint16;
+    maxPoints: uint16;
+    maxContours: uint16;
+    maxCompositePoints: uint16;
+    maxCompositeContours: uint16;
+    maxZones: uint16;
+    maxTwilightPoints: uint16;
+    maxStorage: uint16;
+    maxFunctionDefs: uint16;
+    maxInstructionDefs: uint16;
+    maxStackElements: uint16;
+    maxSizeOfInstructions: uint16;
+    maxComponentElements: uint16;
+    maxComponentDepth: uint16;
+}
+export type MaxpTable = MaxpTable05 | MaxpTable10;
+export declare function parseMaxp(reader: Reader): MaxpTable;

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

@@ -0,0 +1,142 @@
+import type { GlyphId, uint16, uint32 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * Extended Glyph Metamorphosis table (morx)
+ * Apple Advanced Typography substitution
+ */
+export interface MorxTable {
+    version: number;
+    chains: MorxChain[];
+}
+/**
+ * Feature chain in morx
+ */
+export interface MorxChain {
+    defaultFlags: uint32;
+    features: MorxFeature[];
+    subtables: MorxSubtable[];
+}
+/**
+ * Feature entry
+ */
+export interface MorxFeature {
+    featureType: uint16;
+    featureSetting: uint16;
+    enableFlags: uint32;
+    disableFlags: uint32;
+}
+/**
+ * Subtable types
+ */
+export declare enum MorxSubtableType {
+    Rearrangement = 0,
+    Contextual = 1,
+    Ligature = 2,
+    NonContextual = 4,
+    Insertion = 5
+}
+/**
+ * Base subtable
+ */
+export interface MorxSubtableBase {
+    type: MorxSubtableType;
+    coverage: MorxCoverage;
+    subFeatureFlags: uint32;
+}
+export interface MorxCoverage {
+    vertical: boolean;
+    descending: boolean;
+    logical: boolean;
+}
+export type MorxSubtable = MorxRearrangementSubtable | MorxContextualSubtable | MorxLigatureSubtable | MorxNonContextualSubtable | MorxInsertionSubtable;
+/**
+ * Type 0: Rearrangement (reorders glyphs)
+ */
+export interface MorxRearrangementSubtable extends MorxSubtableBase {
+    type: MorxSubtableType.Rearrangement;
+    stateTable: StateTable<RearrangementEntry>;
+}
+export interface RearrangementEntry {
+    newState: uint16;
+    flags: uint16;
+}
+/**
+ * Type 1: Contextual substitution
+ */
+export interface MorxContextualSubtable extends MorxSubtableBase {
+    type: MorxSubtableType.Contextual;
+    stateTable: StateTable<ContextualEntry>;
+    substitutionTable: Map<GlyphId, GlyphId>[];
+}
+export interface ContextualEntry {
+    newState: uint16;
+    flags: uint16;
+    markIndex: uint16;
+    currentIndex: uint16;
+}
+/**
+ * Type 2: Ligature
+ */
+export interface MorxLigatureSubtable extends MorxSubtableBase {
+    type: MorxSubtableType.Ligature;
+    stateTable: StateTable<LigatureEntry>;
+    ligatureActions: uint32[];
+    components: uint16[];
+    ligatures: GlyphId[];
+}
+export interface LigatureEntry {
+    newState: uint16;
+    flags: uint16;
+    ligActionIndex: uint16;
+}
+/**
+ * Type 4: Non-contextual (simple substitution)
+ */
+export interface MorxNonContextualSubtable extends MorxSubtableBase {
+    type: MorxSubtableType.NonContextual;
+    lookupTable: LookupTable;
+}
+/**
+ * Type 5: Insertion
+ */
+export interface MorxInsertionSubtable extends MorxSubtableBase {
+    type: MorxSubtableType.Insertion;
+    stateTable: StateTable<InsertionEntry>;
+    insertionGlyphs: GlyphId[];
+}
+export interface InsertionEntry {
+    newState: uint16;
+    flags: uint16;
+    currentInsertIndex: uint16;
+    markedInsertIndex: uint16;
+}
+/**
+ * State table for state machine processing
+ */
+export interface StateTable<E> {
+    nClasses: uint32;
+    classTable: ClassTable;
+    stateArray: E[][];
+}
+/**
+ * Class lookup table
+ */
+export interface ClassTable {
+    format: number;
+    classArray: number[];
+}
+/**
+ * Lookup table for substitutions
+ */
+export interface LookupTable {
+    format: number;
+    mapping: Map<GlyphId, GlyphId>;
+}
+/**
+ * Parse morx table
+ */
+export declare function parseMorx(reader: Reader): MorxTable;
+/**
+ * Apply non-contextual substitution
+ */
+export declare function applyNonContextual(subtable: MorxNonContextualSubtable, glyphId: GlyphId): GlyphId | null;

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

@@ -0,0 +1,99 @@
+import type { Tag } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+import { type ItemVariationStore } from "./hvar.ts";
+/**
+ * Metrics Variations table (MVAR)
+ * Provides variations for global font metrics
+ */
+export interface MvarTable {
+    majorVersion: number;
+    minorVersion: number;
+    itemVariationStore: ItemVariationStore;
+    valueRecords: MvarValueRecord[];
+}
+export interface MvarValueRecord {
+    valueTag: Tag;
+    deltaSetOuterIndex: number;
+    deltaSetInnerIndex: number;
+}
+/**
+ * Common MVAR value tags
+ */
+export declare const MvarTags: {
+    readonly hasc: number;
+    readonly hdsc: number;
+    readonly hlgp: number;
+    readonly hcla: number;
+    readonly hcld: number;
+    readonly hcof: number;
+    readonly hcrn: number;
+    readonly hcrs: number;
+    readonly vasc: number;
+    readonly vdsc: number;
+    readonly vlgp: number;
+    readonly vcof: number;
+    readonly vcrn: number;
+    readonly vcrs: number;
+    readonly xhgt: number;
+    readonly cpht: number;
+    readonly sbxs: number;
+    readonly sbys: number;
+    readonly sbxo: number;
+    readonly sbyo: number;
+    readonly spxs: number;
+    readonly spys: number;
+    readonly spxo: number;
+    readonly spyo: number;
+    readonly strs: number;
+    readonly stro: number;
+    readonly undo: number;
+    readonly unds: number;
+    readonly gsp0: number;
+    readonly gsp1: number;
+    readonly gsp2: number;
+    readonly gsp3: number;
+};
+/**
+ * Parse MVAR table
+ */
+export declare function parseMvar(reader: Reader): MvarTable;
+/**
+ * Get metric delta by tag
+ */
+export declare function getMetricDelta(mvar: MvarTable, valueTag: Tag, coords: number[]): number;
+/**
+ * Get horizontal ascender delta
+ */
+export declare function getHAscenderDelta(mvar: MvarTable, coords: number[]): number;
+/**
+ * Get horizontal descender delta
+ */
+export declare function getHDescenderDelta(mvar: MvarTable, coords: number[]): number;
+/**
+ * Get horizontal line gap delta
+ */
+export declare function getHLineGapDelta(mvar: MvarTable, coords: number[]): number;
+/**
+ * Get x-height delta
+ */
+export declare function getXHeightDelta(mvar: MvarTable, coords: number[]): number;
+/**
+ * Get cap height delta
+ */
+export declare function getCapHeightDelta(mvar: MvarTable, coords: number[]): number;
+/**
+ * Get underline offset delta
+ */
+export declare function getUnderlineOffsetDelta(mvar: MvarTable, coords: number[]): number;
+/**
+ * Get underline size delta
+ */
+export declare function getUnderlineSizeDelta(mvar: MvarTable, coords: number[]): number;
+/**
+ * Get strikeout offset delta
+ */
+export declare function getStrikeoutOffsetDelta(mvar: MvarTable, coords: number[]): number;
+/**
+ * Get strikeout size delta
+ */
+export declare function getStrikeoutSizeDelta(mvar: MvarTable, coords: number[]): number;

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

@@ -0,0 +1,75 @@
+import type { uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/** Name IDs */
+export declare const NameId: {
+    readonly Copyright: 0;
+    readonly FontFamily: 1;
+    readonly FontSubfamily: 2;
+    readonly UniqueID: 3;
+    readonly FullName: 4;
+    readonly Version: 5;
+    readonly PostScriptName: 6;
+    readonly Trademark: 7;
+    readonly Manufacturer: 8;
+    readonly Designer: 9;
+    readonly Description: 10;
+    readonly ManufacturerURL: 11;
+    readonly DesignerURL: 12;
+    readonly License: 13;
+    readonly LicenseURL: 14;
+    readonly Reserved: 15;
+    readonly TypographicFamily: 16;
+    readonly TypographicSubfamily: 17;
+    readonly CompatibleFullName: 18;
+    readonly SampleText: 19;
+    readonly PostScriptCIDFindfontName: 20;
+    readonly WWSFamily: 21;
+    readonly WWSSubfamily: 22;
+    readonly LightBackgroundPalette: 23;
+    readonly DarkBackgroundPalette: 24;
+    readonly VariationsPostScriptNamePrefix: 25;
+};
+/** Platform IDs */
+export declare const PlatformId: {
+    readonly Unicode: 0;
+    readonly Macintosh: 1;
+    readonly Reserved: 2;
+    readonly Windows: 3;
+};
+/** Windows encoding IDs */
+export declare const WindowsEncodingId: {
+    readonly Symbol: 0;
+    readonly UnicodeBMP: 1;
+    readonly ShiftJIS: 2;
+    readonly PRC: 3;
+    readonly Big5: 4;
+    readonly Wansung: 5;
+    readonly Johab: 6;
+    readonly UnicodeFullRepertoire: 10;
+};
+/** A single name record */
+export interface NameRecord {
+    platformId: uint16;
+    encodingId: uint16;
+    languageId: uint16;
+    nameId: uint16;
+    value: string;
+}
+/** Name table */
+export interface NameTable {
+    format: uint16;
+    records: NameRecord[];
+}
+export declare function parseName(reader: Reader): NameTable;
+/** Get a specific name by ID, preferring Windows Unicode */
+export declare function getNameById(table: NameTable, nameId: number, languageId?: number): string | null;
+/** Get font family name */
+export declare function getFontFamily(table: NameTable): string | null;
+/** Get font subfamily (style) */
+export declare function getFontSubfamily(table: NameTable): string | null;
+/** Get full font name */
+export declare function getFullName(table: NameTable): string | null;
+/** Get PostScript name */
+export declare function getPostScriptName(table: NameTable): string | null;
+/** Get version string */
+export declare function getVersion(table: NameTable): string | null;

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

@@ -0,0 +1,102 @@
+import type { int16, uint8, uint16, uint32 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * OS/2 table - Font metrics and classification
+ * Contains Windows-specific metrics and font embedding information
+ */
+export interface Os2Table {
+    version: uint16;
+    xAvgCharWidth: int16;
+    usWeightClass: uint16;
+    usWidthClass: uint16;
+    fsType: uint16;
+    ySubscriptXSize: int16;
+    ySubscriptYSize: int16;
+    ySubscriptXOffset: int16;
+    ySubscriptYOffset: int16;
+    ySuperscriptXSize: int16;
+    ySuperscriptYSize: int16;
+    ySuperscriptXOffset: int16;
+    ySuperscriptYOffset: int16;
+    yStrikeoutSize: int16;
+    yStrikeoutPosition: int16;
+    sFamilyClass: int16;
+    panose: uint8[];
+    ulUnicodeRange1: uint32;
+    ulUnicodeRange2: uint32;
+    ulUnicodeRange3: uint32;
+    ulUnicodeRange4: uint32;
+    achVendID: string;
+    fsSelection: uint16;
+    usFirstCharIndex: uint16;
+    usLastCharIndex: uint16;
+    sTypoAscender: int16;
+    sTypoDescender: int16;
+    sTypoLineGap: int16;
+    usWinAscent: uint16;
+    usWinDescent: uint16;
+    ulCodePageRange1?: uint32;
+    ulCodePageRange2?: uint32;
+    sxHeight?: int16;
+    sCapHeight?: int16;
+    usDefaultChar?: uint16;
+    usBreakChar?: uint16;
+    usMaxContext?: uint16;
+    usLowerOpticalPointSize?: uint16;
+    usUpperOpticalPointSize?: uint16;
+}
+/** Weight class constants */
+export declare const WeightClass: {
+    readonly Thin: 100;
+    readonly ExtraLight: 200;
+    readonly Light: 300;
+    readonly Normal: 400;
+    readonly Medium: 500;
+    readonly SemiBold: 600;
+    readonly Bold: 700;
+    readonly ExtraBold: 800;
+    readonly Black: 900;
+};
+/** Width class constants */
+export declare const WidthClass: {
+    readonly UltraCondensed: 1;
+    readonly ExtraCondensed: 2;
+    readonly Condensed: 3;
+    readonly SemiCondensed: 4;
+    readonly Normal: 5;
+    readonly SemiExpanded: 6;
+    readonly Expanded: 7;
+    readonly ExtraExpanded: 8;
+    readonly UltraExpanded: 9;
+};
+/** Font selection flags (fsSelection) */
+export declare const FsSelection: {
+    readonly Italic: 1;
+    readonly Underscore: 2;
+    readonly Negative: 4;
+    readonly Outlined: 8;
+    readonly Strikeout: 16;
+    readonly Bold: 32;
+    readonly Regular: 64;
+    readonly UseTypoMetrics: 128;
+    readonly WWS: 256;
+    readonly Oblique: 512;
+};
+/** Font embedding permissions (fsType) */
+export declare const FsType: {
+    readonly InstallableEmbedding: 0;
+    readonly RestrictedLicense: 2;
+    readonly PreviewAndPrint: 4;
+    readonly Editable: 8;
+    readonly NoSubsetting: 256;
+    readonly BitmapOnly: 512;
+};
+export declare function parseOs2(reader: Reader): Os2Table;
+/** Check if font is italic */
+export declare function isItalic(os2: Os2Table): boolean;
+/** Check if font is bold */
+export declare function isBold(os2: Os2Table): boolean;
+/** Check if USE_TYPO_METRICS flag is set */
+export declare function useTypoMetrics(os2: Os2Table): boolean;
+/** Get embedding permission level */
+export declare function getEmbeddingPermission(os2: Os2Table): "installable" | "restricted" | "preview" | "editable";

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

@@ -0,0 +1,25 @@
+import type { int16, uint16, uint32 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * post table - PostScript font information
+ * Contains additional PostScript info like glyph names and italic angle
+ */
+export interface PostTable {
+    version: number;
+    italicAngle: number;
+    underlinePosition: int16;
+    underlineThickness: int16;
+    isFixedPitch: uint32;
+    minMemType42: uint32;
+    maxMemType42: uint32;
+    minMemType1: uint32;
+    maxMemType1: uint32;
+    numberOfGlyphs?: uint16;
+    glyphNameIndex?: uint16[];
+    names?: string[];
+}
+export declare function parsePost(reader: Reader): PostTable;
+/** Get glyph name by glyph ID */
+export declare function getGlyphName(post: PostTable, glyphId: number): string | null;
+/** Check if font is monospaced */
+export declare function isMonospaced(post: PostTable): boolean;

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

@@ -0,0 +1,65 @@
+import type { GlyphId, int16, uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * Standard Bitmap Graphics table (sbix)
+ * Apple's bitmap/PNG glyph table for color emoji and bitmap fonts
+ */
+export interface SbixTable {
+    version: uint16;
+    flags: uint16;
+    strikes: SbixStrike[];
+}
+/**
+ * Strike (bitmap size) in sbix
+ */
+export interface SbixStrike {
+    ppem: uint16;
+    ppi: uint16;
+    glyphData: Map<GlyphId, SbixGlyph>;
+}
+/**
+ * Glyph data in sbix
+ */
+export interface SbixGlyph {
+    originOffsetX: int16;
+    originOffsetY: int16;
+    graphicType: string;
+    data: Uint8Array;
+}
+/**
+ * Common graphic types in sbix
+ */
+export declare const SbixGraphicType: {
+    readonly PNG: "png ";
+    readonly JPG: "jpg ";
+    readonly TIFF: "tiff";
+    readonly PDF: "pdf ";
+    readonly MASK: "mask";
+    readonly DUPE: "dupe";
+};
+/**
+ * Parse sbix table
+ */
+export declare function parseSbix(reader: Reader, numGlyphs: number): SbixTable;
+/**
+ * Get glyph bitmap for a specific ppem
+ * Returns the best matching strike
+ */
+export declare function getGlyphBitmap(sbix: SbixTable, glyphId: GlyphId, ppem: number): SbixGlyph | null;
+/**
+ * Get exact ppem strike
+ */
+export declare function getStrikeForPpem(sbix: SbixTable, ppem: number): SbixStrike | null;
+/**
+ * Get all available ppem sizes
+ */
+export declare function getAvailablePpemSizes(sbix: SbixTable): number[];
+/**
+ * Check if glyph has bitmap data
+ */
+export declare function hasGlyphBitmap(sbix: SbixTable, glyphId: GlyphId, ppem?: number): boolean;
+/**
+ * Resolve dupe graphic type
+ * Returns the actual glyph data for duplicates
+ */
+export declare function resolveDupeGlyph(sbix: SbixTable, strike: SbixStrike, glyph: SbixGlyph): SbixGlyph | null;