three-text 0.4.7 → 0.4.9

package/README.md

@@ -19,7 +19,7 @@ High fidelity 3D mesh font geometry and text layout engine for the web
 
 The library has a framework-agnostic core that returns raw vertex data, with lightweight adapters for [Three.js](https://threejs.org), [React Three Fiber](https://docs.pmnd.rs/react-three-fiber), [p5.js](https://p5js.org), [WebGL](https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API), and [WebGPU](https://developer.mozilla.org/en-US/docs/Web/API/WebGPU_API)
 
-Under the hood, three-text relies on [HarfBuzz](https://github.com/harfbuzz/harfbuzzjs) for text shaping, [Knuth-Plass](http://www.eprg.org/G53DOC/pdfs/knuth-plass-breaking.pdf) line breaking, [Liang](https://tug.org/docs/liang/liang-thesis.pdf) hyphenation, [libtess.js](https://github.com/brendankenny/libtess.js) (based on the [GLU tessellator](https://www.songho.ca/opengl/gl_tessellation.html) by Eric Veach) for removing overlaps and triangulation, curve polygonization from Maxim Shemanarev's [Anti-Grain Geometry](https://web.archive.org/web/20060128212843/http://www.antigrain.com/research/adaptive_bezier/index.html), and [Visvalingam-Whyatt](https://hull-repository.worktribe.com/preview/376364/000870493786962263.pdf) [line simplification](https://bost.ocks.org/mike/simplify/)
+Under the hood, three-text relies on [harfbuzzjs](https://github.com/harfbuzz/harfbuzzjs) (based on [HarfBuzz](https://github.com/harfbuzz/harfbuzz) by Behdad Esfahbod et al) for text shaping, [Knuth-Plass](http://www.eprg.org/G53DOC/pdfs/knuth-plass-breaking.pdf) line breaking (with [SILE](https://github.com/sile-typesetter/sile/blob/master/core/break.lua) being the cleanest modern reference), [Liang](https://tug.org/docs/liang/liang-thesis.pdf) hyphenation and the [TeX hyphenation patterns](https://github.com/hyphenation/tex-hyphen), [libtess.js](https://github.com/brendankenny/libtess.js) (based on the [GLU tessellator](https://www.songho.ca/opengl/gl_tessellation.html) by Eric Veach) for removing overlaps and triangulation, adaptive curve polygonization from Maxim Shemanarev's [Anti-Grain Geometry](https://web.archive.org/web/20060128212843/http://www.antigrain.com/research/adaptive_bezier/index.html), [Visvalingam-Whyatt](https://hull-repository.worktribe.com/preview/376364/000870493786962263.pdf) [line simplification](https://bost.ocks.org/mike/simplify/), as well as [woff-lib](https://github.com/countertype/woff-lib) and [brotli-lib](https://github.com/countertype/brotli-lib)
 
 ## Table of contents
 
@@ -79,11 +79,11 @@ Most users will just `import { Text } from 'three-text'` for Three.js projects
 
 ```javascript
 import { Text } from 'three-text/three';
-import { decode } from 'woff2-decode'; // Optional
+import { woff2Decode } from 'woff-lib/woff2/decode';
 import * as THREE from 'three';
 
 Text.setHarfBuzzPath('/hb/hb.wasm');
-Text.enableWoff2(decode); // Enabling WOFF2 support adds ~45kb to the bundle
+Text.enableWoff2(woff2Decode); // Optional, for WOFF2 support
 const result = await Text.create({
   text: 'Hello World',
   font: '/fonts/Font.woff2',
@@ -118,14 +118,14 @@ function App() {
 
 ```javascript
 import 'three-text/p5';
-import { decode } from 'woff2-decode';
+import { woff2Decode } from 'woff-lib/woff2/decode';
 
 let font;
 let textResult;
 
 function preload() {
   loadThreeTextShaper('/hb/hb.wasm');
-  enableThreeTextWoff2(decode); // Optional, adds ~45KB to bundle
+  enableThreeTextWoff2(woff2Decode); // Optional, for WOFF2 support
   font = loadThreeTextFont('/fonts/Font.woff2');
 }
 
@@ -983,7 +983,7 @@ Synthetic component benchmarks for tessellation, extrusion, and layout are avail
 ### Development
 
 ```bash
-npm run dev          # Watch mode with rollup
+npm run dev          # Watch mode with rolldown
 npm run serve        # Start development server for demos
 ```
 

package/dist/core/Text.d.ts

@@ -0,0 +1,56 @@
+import type { TextOptions, TextHandle, FontMetrics, LoadedFont, HarfBuzzInstance } from './types';
+import type { HyphenationTrieNode } from '../hyphenation';
+declare global {
+    interface Window {
+        hbjs?: any;
+        createHarfBuzz?: () => Promise<any>;
+    }
+}
+export declare class Text {
+    private static patternCache;
+    private static hbInitPromise;
+    private static fontCache;
+    private static fontCacheMemoryBytes;
+    private static maxFontCacheMemoryBytes;
+    private static fontIdCounter;
+    static enableWoff2(decoder: (data: ArrayBuffer | Uint8Array) => Uint8Array | Promise<Uint8Array>): void;
+    private static stableStringify;
+    private fontLoader;
+    private loadedFont?;
+    private currentFontId;
+    private geometryBuilder?;
+    private textShaper?;
+    private textLayout?;
+    private constructor();
+    static setHarfBuzzPath(path: string): void;
+    static setHarfBuzzBuffer(wasmBuffer: ArrayBuffer): void;
+    static init(): Promise<HarfBuzzInstance>;
+    static create(options: TextOptions): Promise<TextHandle>;
+    private static resolveFont;
+    private static loadAndCacheFont;
+    private static trackFontCacheAdd;
+    private static trackFontCacheRemove;
+    private static enforceFontCacheMemoryLimit;
+    private static generateFontContentHash;
+    private setLoadedFont;
+    private loadFont;
+    private createGeometry;
+    private prepareHyphenation;
+    private validateOptions;
+    private updateFontVariations;
+    private prepareLayout;
+    private applyColorSystem;
+    private calculateGlyphBounds;
+    private finalizeGeometry;
+    getFontMetrics(): FontMetrics;
+    static preloadPatterns(languages: string[], patternsPath?: string): Promise<void>;
+    static registerPattern(language: string, pattern: HyphenationTrieNode): void;
+    static setMaxFontCacheMemoryMB(limitMB: number): void;
+    getLoadedFont(): LoadedFont | undefined;
+    measureTextWidth(text: string, letterSpacing?: number): number;
+    getCacheSize(): number;
+    clearCache(): void;
+    private createGlyphAttributes;
+    private resetHelpers;
+    destroy(): void;
+}

package/dist/core/cache/GlyphContourCollector.d.ts

@@ -0,0 +1,38 @@
+import { Vec2 } from '../../utils/vectors';
+import { GlyphContours } from '../types';
+import { OptimizationStats } from '../geometry/PathOptimizer';
+import { CurveFidelityConfig, GeometryOptimizationOptions } from '../types';
+export declare class GlyphContourCollector {
+    private currentGlyphId;
+    private currentTextIndex;
+    private currentGlyphPaths;
+    private currentPath;
+    private currentPoint;
+    private currentGlyphBounds;
+    private collectedGlyphs;
+    private glyphPositions;
+    private glyphTextIndices;
+    private polygonizer;
+    private pathOptimizer;
+    private currentPosition;
+    constructor(curveFidelityConfig?: CurveFidelityConfig, optimizationConfig?: GeometryOptimizationOptions);
+    setPosition(x: number, y: number): void;
+    updatePosition(dx: number, dy: number): void;
+    beginGlyph(glyphId: number, textIndex: number): void;
+    finishGlyph(): void;
+    onMoveTo(x: number, y: number): void;
+    onLineTo(x: number, y: number): void;
+    onQuadTo(cx: number, cy: number, x: number, y: number): void;
+    onCubicTo(c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number): void;
+    onClosePath(): void;
+    private finishPath;
+    private updateBounds;
+    getCollectedGlyphs(): GlyphContours[];
+    getGlyphPositions(): Vec2[];
+    getTextIndices(): number[];
+    reset(): void;
+    setCurveFidelityConfig(config?: CurveFidelityConfig): void;
+    setCurveSteps(curveSteps?: number): void;
+    setGeometryOptimization(options?: GeometryOptimizationOptions): void;
+    getOptimizationStats(): OptimizationStats;
+}

package/dist/core/cache/GlyphGeometryBuilder.d.ts

@@ -0,0 +1,60 @@
+import { GlyphGeometryInfo, LoadedFont, GlyphCluster, GlyphData } from '../types';
+import { CurveFidelityConfig, GeometryOptimizationOptions } from '../types';
+import { Cache } from '../../utils/Cache';
+export interface InstancedTextGeometry {
+    vertices: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    glyphInfos: GlyphGeometryInfo[];
+    planeBounds: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+}
+export declare class GlyphGeometryBuilder {
+    private cache;
+    private tessellator;
+    private extruder;
+    private fontId;
+    private cacheKeyPrefix;
+    private curveFidelityConfig?;
+    private curveSteps?;
+    private geometryOptimizationOptions?;
+    private clusterer;
+    private collector;
+    private drawCallbacks;
+    private loadedFont;
+    private wordCache;
+    private contourCache;
+    private clusteringCache;
+    private emptyGlyphs;
+    private clusterPositions;
+    private clusterContoursScratch;
+    private taskScratch;
+    constructor(cache: Cache<string, GlyphData>, loadedFont: LoadedFont);
+    getOptimizationStats(): import("../geometry/PathOptimizer").OptimizationStats;
+    setCurveFidelityConfig(config?: CurveFidelityConfig): void;
+    setCurveSteps(curveSteps?: number): void;
+    setGeometryOptimization(options?: GeometryOptimizationOptions): void;
+    setFontId(fontId: string): void;
+    private updateCacheKeyPrefix;
+    private getGeometryConfigSignature;
+    buildInstancedGeometry(clustersByLine: GlyphCluster[][], depth: number, removeOverlaps: boolean, isCFF: boolean, scale: number, separateGlyphs?: boolean, coloredTextIndices?: Set<number>): InstancedTextGeometry;
+    private getClusterKey;
+    private createGlyphInfo;
+    private getContoursForGlyph;
+    private tessellateGlyphCluster;
+    private extrudeAndPackage;
+    private tessellateGlyph;
+    private updatePlaneBounds;
+    getCacheStats(): import("../../utils/Cache").CacheStats;
+    clearCache(): void;
+}

package/dist/core/cache/sharedCaches.d.ts

@@ -0,0 +1,15 @@
+import { Cache } from '../../utils/Cache';
+import type { GlyphData, GlyphContours } from '../types';
+export declare function getGlyphCacheKey(fontId: string, glyphId: number, depth: number, removeOverlaps: boolean): string;
+export declare const globalGlyphCache: Cache<string, GlyphData>;
+export declare function createGlyphCache(): Cache<string, GlyphData>;
+export declare const globalContourCache: Cache<string, GlyphContours>;
+export declare const globalWordCache: Cache<string, GlyphData>;
+export declare const globalClusteringCache: Cache<string, {
+    glyphIds: number[];
+    positions: {
+        x: number;
+        y: number;
+    }[];
+    groups: number[][];
+}>;

package/dist/core/font/FontLoader.d.ts

@@ -0,0 +1,9 @@
+import { LoadedFont, HarfBuzzInstance } from '../types';
+export declare class FontLoader {
+    private getHarfBuzzInstance;
+    constructor(getHarfBuzzInstance: () => Promise<HarfBuzzInstance>);
+    loadFont(fontBuffer: ArrayBuffer, fontVariations?: {
+        [key: string]: number;
+    }): Promise<LoadedFont>;
+    static destroyFont(loadedFont: LoadedFont): void;
+}

package/dist/core/font/FontMetadata.d.ts

@@ -0,0 +1,32 @@
+import { ExtractedMetrics, FontMetrics, VerticalMetrics } from '../types';
+export interface FontDataExtraction {
+    metrics: ExtractedMetrics;
+    features: {
+        tags: string[];
+        names: {
+            [tag: string]: string;
+        };
+    } | undefined;
+}
+export declare class FontMetadataExtractor {
+    static extractMetadata(fontBuffer: ArrayBuffer): ExtractedMetrics;
+    static extractFeatureTags(fontBuffer: ArrayBuffer): {
+        tags: string[];
+        names: {
+            [tag: string]: string;
+        };
+    } | undefined;
+    private static extractFeatureDataFromTable;
+    private static extractAxisNames;
+    private static getNameFromNameTable;
+    static extractAll(fontBuffer: ArrayBuffer): FontDataExtraction;
+    private static buildNameIndex;
+    private static getNameFromIndex;
+    private static extractMetricsWithIndex;
+    private static extractAxisNamesWithIndex;
+    private static extractFeaturesWithIndex;
+    private static extractFeatureData;
+    private static tagToString;
+    static getVerticalMetrics(metrics: ExtractedMetrics): VerticalMetrics;
+    static getFontMetrics(metrics: ExtractedMetrics): FontMetrics;
+}

package/dist/core/font/TableDirectory.d.ts

@@ -0,0 +1,7 @@
+export interface TableDirectoryEntry {
+    tag: number;
+    checksum: number;
+    offset: number;
+    length: number;
+}
+export declare function parseTableDirectory(view: DataView): Map<number, TableDirectoryEntry>;

package/dist/core/font/WoffConverter.d.ts

@@ -0,0 +1,9 @@
+type Woff2Decoder = (data: ArrayBuffer | Uint8Array) => Uint8Array | Promise<Uint8Array>;
+export declare function setWoff2Decoder(decoder: Woff2Decoder): void;
+export declare class WoffConverter {
+    static detectFormat(buffer: ArrayBuffer): 'woff' | 'woff2' | 'ttf/otf';
+    static decompressWoff(woffBuffer: ArrayBuffer): Promise<ArrayBuffer>;
+    static decompressWoff2(woff2Buffer: ArrayBuffer): Promise<ArrayBuffer>;
+    private static decompressZlib;
+}
+export {};

package/dist/core/font/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const FONT_SIGNATURE_TRUE_TYPE = 65536;
+export declare const FONT_SIGNATURE_OPEN_TYPE_CFF = 1330926671;
+export declare const FONT_SIGNATURE_WOFF = 2001684038;
+export declare const FONT_SIGNATURE_WOFF2 = 2001684018;
+export declare const TABLE_TAG_HEAD = 1751474532;
+export declare const TABLE_TAG_HHEA = 1751672161;
+export declare const TABLE_TAG_OS2 = 1330851634;
+export declare const TABLE_TAG_FVAR = 1719034226;
+export declare const TABLE_TAG_STAT = 1398030676;
+export declare const TABLE_TAG_NAME = 1851878757;
+export declare const TABLE_TAG_CFF = 1128678944;
+export declare const TABLE_TAG_CFF2 = 1128678962;
+export declare const TABLE_TAG_GSUB = 1196643650;
+export declare const TABLE_TAG_GPOS = 1196445523;

package/dist/core/geometry/BoundaryClusterer.d.ts

@@ -0,0 +1,8 @@
+import { Vec3 } from '../../utils/vectors';
+import type { GlyphContours } from '../types';
+export declare class BoundaryClusterer {
+    constructor();
+    cluster(glyphContoursList: GlyphContours[], positions: Vec3[]): number[][];
+    private clusterSweepLine;
+    private getWorldBounds;
+}

package/dist/core/geometry/Extruder.d.ts

@@ -0,0 +1,10 @@
+import type { ProcessedGeometry } from '../types';
+export interface ExtrusionResult {
+    vertices: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+}
+export declare class Extruder {
+    constructor();
+    extrude(geometry: ProcessedGeometry, depth: number | undefined, unitsPerEm: number): ExtrusionResult;
+}

package/dist/core/geometry/PathOptimizer.d.ts

@@ -0,0 +1,21 @@
+import type { Path } from '../types';
+export interface OptimizationConfig {
+    enabled: boolean;
+    areaThreshold: number;
+}
+export interface OptimizationStats {
+    pointsRemovedByVisvalingam: number;
+    originalPointCount: number;
+}
+export declare const DEFAULT_OPTIMIZATION_CONFIG: OptimizationConfig;
+export declare class PathOptimizer {
+    private config;
+    private stats;
+    constructor(config: OptimizationConfig);
+    setConfig(config: OptimizationConfig): void;
+    optimizePath(path: Path): Path;
+    private simplifyPathVW;
+    private calculateTriangleArea;
+    getStats(): OptimizationStats;
+    resetStats(): void;
+}

package/dist/core/geometry/Polygonizer.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Anti-Grain Geometry - Version 2.4
+ * Copyright (C) 2002-2005 Maxim Shemanarev (McSeem)
+ *
+ * This software is a partial port of the AGG library, specifically the adaptive
+ * subdivision algorithm for polygonization. The original software was available
+ * at http://www.antigrain.com and was distributed under the BSD 3-Clause License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+import { Vec2 } from '../../utils/vectors';
+import { CurveFidelityConfig } from '../types';
+export declare const DEFAULT_CURVE_FIDELITY: CurveFidelityConfig;
+export declare const COLLINEARITY_EPSILON = 0.000001;
+export declare class Polygonizer {
+    private curveFidelityConfig;
+    private curveSteps;
+    constructor(curveFidelityConfig?: CurveFidelityConfig);
+    setCurveFidelityConfig(curveFidelityConfig?: CurveFidelityConfig): void;
+    setCurveSteps(curveSteps?: number): void;
+    polygonizeQuadratic(start: Vec2, control: Vec2, end: Vec2): Vec2[];
+    polygonizeCubic(start: Vec2, control1: Vec2, control2: Vec2, end: Vec2): Vec2[];
+    private lerp;
+    private polygonizeQuadraticFixedSteps;
+    private polygonizeCubicFixedSteps;
+    private recursiveQuadratic;
+    private recursiveCubic;
+    private addPoint;
+}

package/dist/core/geometry/Tessellator.d.ts

@@ -0,0 +1,14 @@
+import type { Path, ProcessedGeometry } from '../types';
+export declare class Tessellator {
+    process(paths: Path[], removeOverlaps?: boolean, isCFF?: boolean, needsExtrusionContours?: boolean): ProcessedGeometry;
+    processContours(contours: number[][], removeOverlaps?: boolean, isCFF?: boolean, needsExtrusionContours?: boolean): ProcessedGeometry;
+    private tessellate;
+    private tessellateContours;
+    private pathsToContours;
+    private reverseContours;
+    private reverseContour;
+    private performTessellation;
+    private boundaryToContours;
+    private needsWindingNormalization;
+    private signedArea;
+}

package/dist/core/layout/LineBreak.d.ts

@@ -0,0 +1,95 @@
+import type { TextAlign, TextDirection, LineInfo, HyphenationPatternsMap } from '../types';
+export declare enum ItemType {
+    BOX = 0,// character or word with fixed width
+    GLUE = 1,// stretchable/shrinkable space
+    PENALTY = 2,// potential breakpoint with penalty cost
+    DISCRETIONARY = 3
+}
+export declare enum FitnessClass {
+    VERY_LOOSE = 0,// lines stretching more than their stretchability
+    LOOSE = 1,// lines stretching 0.5 to 1.0 of their stretchability
+    DECENT = 2,// all other lines
+    TIGHT = 3
+}
+interface Item {
+    type: ItemType;
+    width: number;
+    text?: string;
+    originIndex?: number;
+}
+export interface Box extends Item {
+    type: ItemType.BOX;
+}
+export interface Glue extends Item {
+    type: ItemType.GLUE;
+    stretch: number;
+    shrink: number;
+}
+export interface Penalty extends Item {
+    type: ItemType.PENALTY;
+    penalty: number;
+    flagged?: boolean;
+}
+export interface Discretionary extends Item {
+    type: ItemType.DISCRETIONARY;
+    preBreak: string;
+    postBreak: string;
+    noBreak: string;
+    preBreakWidth: number;
+    penalty: number;
+    flagged?: boolean;
+}
+export interface LineBreakOptions {
+    text: string;
+    width?: number;
+    align?: TextAlign;
+    direction?: TextDirection;
+    hyphenate?: boolean;
+    language?: string;
+    measureText: (text: string) => number;
+    measureTextWidths?: (text: string) => number[];
+    respectExistingBreaks?: boolean;
+    hyphenationPatterns?: HyphenationPatternsMap;
+    unitsPerEm?: number;
+    letterSpacing?: number;
+    tolerance?: number;
+    pretolerance?: number;
+    emergencyStretch?: number;
+    autoEmergencyStretch?: number;
+    lefthyphenmin?: number;
+    righthyphenmin?: number;
+    linepenalty?: number;
+    adjdemerits?: number;
+    hyphenpenalty?: number;
+    exhyphenpenalty?: number;
+    doublehyphendemerits?: number;
+    finalhyphendemerits?: number;
+}
+interface LineBreakContext {
+    linePenalty: number;
+    adjDemerits: number;
+    doubleHyphenDemerits: number;
+    finalHyphenDemerits: number;
+    hyphenPenalty: number;
+    exHyphenPenalty: number;
+    currentAlign: TextAlign;
+    unitsPerEm?: number;
+    letterSpacingFU?: number;
+}
+export declare class LineBreak {
+    private static badness;
+    private static fitnessClass;
+    static findHyphenationPoints(word: string, language?: string, availablePatterns?: HyphenationPatternsMap, lefthyphenmin?: number, righthyphenmin?: number): number[];
+    static itemizeText(text: string, measureText: (text: string) => number, measureTextWidths: ((text: string) => number[]) | undefined, hyphenate?: boolean, language?: string, availablePatterns?: HyphenationPatternsMap, lefthyphenmin?: number, righthyphenmin?: number, context?: LineBreakContext, lineWidth?: number): Item[];
+    static isCJK(char: string): boolean;
+    static isCJClosingPunctuation(char: string): boolean;
+    static isCJOpeningPunctuation(char: string): boolean;
+    static isCJPunctuation(char: string): boolean;
+    private static itemizeCJKText;
+    private static itemizeParagraph;
+    private static itemizeWordBased;
+    private static lineBreak;
+    static breakText(options: LineBreakOptions): LineInfo[];
+    private static postLineBreak;
+}
+export {};

package/dist/core/layout/TextLayout.d.ts

@@ -0,0 +1,59 @@
+import { LineInfo, TextAlign, LoadedFont, LayoutOptions } from '../types';
+export interface TextLayoutOptions extends LayoutOptions {
+    text: string;
+    letterSpacing: number;
+}
+export interface LayoutResult {
+    lines: LineInfo[];
+}
+export interface AlignmentOptions {
+    width?: number;
+    align: TextAlign;
+    planeBounds: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+}
+export declare class TextLayout {
+    private loadedFont;
+    constructor(loadedFont: LoadedFont);
+    computeLines(options: TextLayoutOptions): LayoutResult;
+    applyAlignment(vertices: Float32Array, options: AlignmentOptions): {
+        offset: number;
+        adjustedBounds: {
+            min: {
+                x: number;
+                y: number;
+                z: number;
+            };
+            max: {
+                x: number;
+                y: number;
+                z: number;
+            };
+        };
+    };
+    computeAlignmentOffset(options: AlignmentOptions): {
+        offset: number;
+        adjustedBounds: {
+            min: {
+                x: number;
+                y: number;
+                z: number;
+            };
+            max: {
+                x: number;
+                y: number;
+                z: number;
+            };
+        };
+    };
+}

package/dist/core/layout/TextRangeQuery.d.ts

@@ -0,0 +1,11 @@
+import { GlyphGeometryInfo, TextRange, TextQueryOptions } from '../types';
+export declare class TextRangeQuery {
+    private text;
+    private glyphsByTextIndex;
+    constructor(text: string, glyphs: GlyphGeometryInfo[]);
+    execute(options: TextQueryOptions): TextRange[];
+    private findByText;
+    private findByCharRange;
+    private createTextRange;
+    private calculateBounds;
+}

package/dist/core/layout/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const FITNESS_TIGHT_THRESHOLD = 12;
+export declare const FITNESS_NORMAL_THRESHOLD = 99;
+export declare const DEFAULT_TOLERANCE = 800;
+export declare const DEFAULT_PRETOLERANCE = 100;
+export declare const DEFAULT_EMERGENCY_STRETCH = 0;
+export declare const SPACE_STRETCH_RATIO = 0.5;
+export declare const SPACE_SHRINK_RATIO: number;

package/dist/core/shaping/DrawCallbacks.d.ts

@@ -0,0 +1,19 @@
+import { LoadedFont } from '../types';
+import { GlyphContourCollector } from '../cache/GlyphContourCollector';
+export declare class DrawCallbackHandler {
+    private moveTo_func;
+    private lineTo_func;
+    private quadTo_func;
+    private cubicTo_func;
+    private closePath_func;
+    private drawFuncsPtr;
+    private collector?;
+    private position;
+    setPosition(x: number, y: number): void;
+    updatePosition(dx: number, dy: number): void;
+    setCollector(collector: GlyphContourCollector): void;
+    createDrawFuncs(font: LoadedFont, collector: GlyphContourCollector): void;
+    getDrawFuncsPtr(): number;
+    destroy(font: LoadedFont): void;
+}
+export declare function getSharedDrawCallbackHandler(font: LoadedFont): DrawCallbackHandler;

package/dist/core/shaping/HarfBuzzLoader.d.ts

@@ -0,0 +1,6 @@
+import type { HarfBuzzInstance } from '../types';
+export declare const HarfBuzzLoader: {
+    setWasmPath(path: string): void;
+    setWasmBuffer(buffer: ArrayBuffer): void;
+    getHarfBuzz(): Promise<HarfBuzzInstance>;
+};

package/dist/core/shaping/TextMeasurer.d.ts

@@ -0,0 +1,5 @@
+import type { LoadedFont } from '../types';
+export declare class TextMeasurer {
+    static measureTextWidths(loadedFont: LoadedFont, text: string, letterSpacing?: number): number[];
+    static measureTextWidth(loadedFont: LoadedFont, text: string, letterSpacing?: number): number;
+}

package/dist/core/shaping/TextShaper.d.ts

@@ -0,0 +1,35 @@
+import { LoadedFont, GlyphGeometryInfo, LineInfo, TextDirection, GlyphCluster, ColorOptions } from '../types';
+import { GlyphGeometryBuilder } from '../cache/GlyphGeometryBuilder';
+export interface ShapedResult {
+    geometry: any;
+    glyphInfos: GlyphGeometryInfo[];
+    planeBounds: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    cacheStats?: {
+        hits: number;
+        misses: number;
+        hitRate: number;
+    };
+}
+export declare class TextShaper {
+    private loadedFont;
+    private geometryBuilder;
+    private cachedSpaceWidth;
+    constructor(loadedFont: LoadedFont, geometryBuilder: GlyphGeometryBuilder);
+    shapeLines(lineInfos: LineInfo[], scaledLineHeight: number, letterSpacing: number, align: string, direction: TextDirection, color?: [number, number, number] | ColorOptions, originalText?: string): GlyphCluster[][];
+    private shapeLineIntoClusters;
+    private calculateSpaceAdjustment;
+    private calculateCJKAdjustment;
+    clearCache(): void;
+    getCacheStats(): import("../..").CacheStats;
+}