three-text 0.4.11 → 0.5.0

package/dist/three/react.d.ts

@@ -9,25 +9,57 @@ interface HyphenationTrieNode {
     };
 }
 
-interface CacheStats {
-    size: number;
+declare class Vec3 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number, y?: number, z?: number);
+    set(x: number, y: number, z: number): Vec3;
+    clone(): Vec3;
+    copy(v: Vec3): Vec3;
+    add(v: Vec3): Vec3;
+    sub(v: Vec3): Vec3;
+    multiply(scalar: number): Vec3;
+    divide(scalar: number): Vec3;
+    length(): number;
+    lengthSq(): number;
+    normalize(): Vec3;
+    dot(v: Vec3): number;
+    cross(v: Vec3): Vec3;
+    distanceTo(v: Vec3): number;
+    distanceToSquared(v: Vec3): number;
+    equals(v: Vec3): boolean;
 }
 
-interface BoundingBox {
-    min: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    max: {
-        x: number;
-        y: number;
-        z: number;
-    };
+interface HarfBuzzGlyph {
+    g: number;
+    cl: number;
+    ax: number;
+    ay: number;
+    dx: number;
+    dy: number;
+    x?: number;
+    y?: number;
+    lineIndex: number;
+    absoluteTextIndex: number;
+}
+interface GlyphCluster {
+    text: string;
+    glyphs: HarfBuzzGlyph[];
+    position: Vec3;
 }
-
 type TextAlign = 'left' | 'center' | 'right' | 'justify';
 type TextDirection = 'ltr' | 'rtl';
+interface LineInfo {
+    text: string;
+    originalStart: number;
+    originalEnd: number;
+    xOffset: number;
+    adjustmentRatio?: number;
+    isLastLine?: boolean;
+    naturalWidth?: number;
+    endedWithHyphen?: boolean;
+}
 interface LoadedFont {
     hb: HarfBuzzAPI;
     fontBlob: HarfBuzzBlob;
@@ -120,87 +152,28 @@ interface FontMetrics {
     unitsPerEm: number;
     naturalLineHeight: number;
 }
-interface PathInfo {
-    start: number;
-    count: number;
-}
-interface GlyphGeometryInfo {
-    textIndex: number;
-    lineIndex: number;
-    vertexStart: number;
-    vertexCount: number;
-    bounds: {
-        min: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        max: {
-            x: number;
-            y: number;
-            z: number;
-        };
-    };
-    paths?: PathInfo[];
-}
-interface TextRange {
-    start: number;
-    end: number;
-    originalText: string;
-    bounds: {
-        min: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        max: {
-            x: number;
-            y: number;
-            z: number;
-        };
-    }[];
-    glyphs: GlyphGeometryInfo[];
-    lineIndices: number[];
+interface TextLayoutData {
+    lines: LineInfo[];
+    scaledLineHeight: number;
+    letterSpacing: number;
+    align: string;
+    direction: TextDirection;
+    depth: number;
+    size: number;
+    pixelsPerFontUnit: number;
 }
-interface TextQueryOptions {
-    byText?: string[];
-    byCharRange?: {
-        start: number;
-        end: number;
-    }[];
+interface TextLayoutResult {
+    clustersByLine: GlyphCluster[][];
+    layoutData: TextLayoutData;
+    options: TextOptions;
+    loadedFont: LoadedFont;
+    fontId: string;
 }
-interface TextGeometryInfo {
-    vertices: Float32Array;
-    normals: Float32Array;
-    indices: Uint32Array;
-    colors?: Float32Array;
-    glyphAttributes?: {
-        glyphCenter: Float32Array;
-        glyphIndex: Float32Array;
-        glyphLineIndex: Float32Array;
-        glyphProgress: Float32Array;
-        glyphBaselineY: Float32Array;
-    };
-    glyphs: GlyphGeometryInfo[];
-    planeBounds: BoundingBox;
-    stats: {
-        trianglesGenerated: number;
-        verticesGenerated: number;
-        pointsRemovedByVisvalingam: number;
-        originalPointCount: number;
-    } & Partial<CacheStats & {
-        hitRate: number;
-        memoryUsageMB: number;
-    }>;
-    query(options: TextQueryOptions): TextRange[];
-    coloredRanges?: ColoredRange[];
-}
-interface TextHandle extends TextGeometryInfo {
+interface TextLayoutHandle extends TextLayoutResult {
     getLoadedFont(): LoadedFont | undefined;
-    getCacheSize(): number;
-    clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
-    update(options: Partial<TextOptions>): Promise<TextHandle>;
+    update(options: Partial<TextOptions>): Promise<TextLayoutHandle>;
+    dispose(): void;
 }
 interface ColorByRange {
     start: number;
@@ -214,26 +187,6 @@ interface ColorOptions {
     };
     byCharRange?: ColorByRange[];
 }
-interface ColoredRange {
-    start: number;
-    end: number;
-    originalText: string;
-    color: [number, number, number];
-    bounds: {
-        min: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        max: {
-            x: number;
-            y: number;
-            z: number;
-        };
-    }[];
-    glyphs: GlyphGeometryInfo[];
-    lineIndices: number[];
-}
 interface TextOptions {
     text: string;
     font: string | ArrayBuffer;
@@ -310,14 +263,13 @@ declare class Text$1 {
     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>;
+    static create(options: TextOptions): Promise<TextLayoutHandle>;
     private static resolveFont;
     private static loadAndCacheFont;
     private static trackFontCacheAdd;
@@ -326,23 +278,17 @@ declare class Text$1 {
     private static generateFontContentHash;
     private setLoadedFont;
     private loadFont;
-    private createGeometry;
+    private createLayout;
     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/three/react.js

@@ -1,5 +1,5 @@
 import { jsx } from 'react/jsx-runtime';
-import { forwardRef, useState, useRef, useMemo, useEffect } from 'react';
+import { useRef, forwardRef, useState, useMemo, useEffect } from 'react';
 import * as THREE from 'three';
 import { Text as Text$2 } from './index.js';
 
@@ -10,7 +10,6 @@ function deepEqual(a, b) {
         return false;
     if (typeof a !== 'object' || typeof b !== 'object')
         return false;
-    // Arrays (common in options like color, byCharRange, etc.)
     if (Array.isArray(a) || Array.isArray(b)) {
         if (!Array.isArray(a) || !Array.isArray(b))
             return false;
@@ -29,11 +28,14 @@ function deepEqual(a, b) {
     for (const key of keysA) {
         if (!Object.prototype.hasOwnProperty.call(b, key))
             return false;
-        if (!deepEqual(a[key], b[key]))
+        if (!deepEqual(a[key], b[key])) {
             return false;
+        }
     }
     return true;
 }
+// Stabilizes an object reference across renders so long as
+// its contents haven't changed (by deep comparison)
 function useDeepCompareMemo(value) {
     const ref = useRef(value);
     if (!deepEqual(value, ref.current)) {
@@ -41,6 +43,7 @@ function useDeepCompareMemo(value) {
     }
     return ref.current;
 }
+
 const Text$1 = forwardRef(function Text(props, ref) {
     const { children, font, material, position = [0, 0, 0], rotation = [0, 0, 0], scale = [1, 1, 1], onLoad, onError, vertexColors = true, ...restOptions } = props;
     const [geometry, setGeometry] = useState(null);

package/dist/types/core/Text.d.ts

@@ -1,4 +1,4 @@
-import type { TextOptions, TextHandle, FontMetrics, LoadedFont, HarfBuzzInstance } from './types';
+import type { TextOptions, TextLayoutHandle, FontMetrics, LoadedFont, HarfBuzzInstance } from './types';
 import type { HyphenationTrieNode } from '../hyphenation';
 declare global {
     interface Window {
@@ -18,14 +18,13 @@ export declare class Text {
     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>;
+    static create(options: TextOptions): Promise<TextLayoutHandle>;
     private static resolveFont;
     private static loadAndCacheFont;
     private static trackFontCacheAdd;
@@ -34,23 +33,17 @@ export declare class Text {
     private static generateFontContentHash;
     private setLoadedFont;
     private loadFont;
-    private createGeometry;
+    private createLayout;
     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/types/core/cache/sharedCaches.d.ts

@@ -1,5 +1,5 @@
 import { Cache } from '../../utils/Cache';
-import type { GlyphData, GlyphContours } from '../types';
+import type { GlyphData, GlyphContours, GlyphOutline } 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>;
@@ -13,3 +13,4 @@ export declare const globalClusteringCache: Cache<string, {
     }[];
     groups: number[][];
 }>;
+export declare const globalOutlineCache: Cache<string, GlyphOutline>;

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

@@ -1,5 +1,13 @@
 import { LoadedFont } from '../types';
-import { GlyphContourCollector } from '../cache/GlyphContourCollector';
+export interface GlyphDrawCollector {
+    setPosition(x: number, y: number): void;
+    updatePosition(dx: number, dy: number): 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;
+}
 export declare class DrawCallbackHandler {
     private moveTo_func;
     private lineTo_func;
@@ -11,8 +19,8 @@ export declare class DrawCallbackHandler {
     private position;
     setPosition(x: number, y: number): void;
     updatePosition(dx: number, dy: number): void;
-    setCollector(collector: GlyphContourCollector): void;
-    createDrawFuncs(font: LoadedFont, collector: GlyphContourCollector): void;
+    setCollector(collector: GlyphDrawCollector): void;
+    createDrawFuncs(font: LoadedFont, collector: GlyphDrawCollector): void;
     getDrawFuncsPtr(): number;
     destroy(font: LoadedFont): void;
 }

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

@@ -1,5 +1,4 @@
 import { LoadedFont, GlyphGeometryInfo, LineInfo, TextDirection, GlyphCluster, ColorOptions } from '../types';
-import { GlyphGeometryBuilder } from '../cache/GlyphGeometryBuilder';
 export interface ShapedResult {
     geometry: any;
     glyphInfos: GlyphGeometryInfo[];
@@ -23,13 +22,10 @@ export interface ShapedResult {
 }
 export declare class TextShaper {
     private loadedFont;
-    private geometryBuilder;
     private cachedSpaceWidth;
-    constructor(loadedFont: LoadedFont, geometryBuilder: GlyphGeometryBuilder);
+    constructor(loadedFont: LoadedFont);
     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;
 }

package/dist/types/core/types.d.ts

@@ -266,6 +266,90 @@ export interface TextHandle extends TextGeometryInfo {
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<TextOptions>): Promise<TextHandle>;
 }
+export type OutlineSegmentType = 0 | 1 | 2;
+export interface OutlineSegment {
+    type: OutlineSegmentType;
+    contourId: number;
+    p0: Vec2;
+    p1: Vec2;
+    p2?: Vec2;
+    p3?: Vec2;
+}
+export interface GlyphOutline {
+    glyphId: number;
+    textIndex: number;
+    segments: OutlineSegment[];
+    bounds: {
+        min: {
+            x: number;
+            y: number;
+        };
+        max: {
+            x: number;
+            y: number;
+        };
+    };
+}
+export interface VectorGlyphInfo extends GlyphGeometryInfo {
+    segmentStart: number;
+    segmentCount: number;
+}
+export interface PackedFloatTexture {
+    width: number;
+    height: number;
+    data: Float32Array;
+}
+export interface VectorTextGeometryInfo {
+    quadVertices: Float32Array;
+    quadIndices: Uint16Array;
+    instances: {
+        position: Float32Array;
+        bounds: Float32Array;
+        segmentRange: Uint32Array;
+        glyphDataIndex: Uint32Array;
+        glyphIndex: Uint32Array;
+        textIndex: Uint32Array;
+        lineIndex: Uint32Array;
+    };
+    segmentTexelsPerSegment: number;
+    segments: PackedFloatTexture;
+    segmentBounds?: PackedFloatTexture;
+    bandCount?: number;
+    bandRanges?: PackedFloatTexture;
+    bandIndices?: PackedFloatTexture;
+    xBandCount?: number;
+    xBandRanges?: PackedFloatTexture;
+    xBandIndices?: PackedFloatTexture;
+    tileCountX?: number;
+    tileCountY?: number;
+    tileRanges?: PackedFloatTexture;
+    tileIndices?: PackedFloatTexture;
+    glyphs: VectorGlyphInfo[];
+    planeBounds: BoundingBox;
+}
+export interface TextLayoutData {
+    lines: LineInfo[];
+    scaledLineHeight: number;
+    letterSpacing: number;
+    align: string;
+    direction: TextDirection;
+    depth: number;
+    size: number;
+    pixelsPerFontUnit: number;
+}
+export interface TextLayoutResult {
+    clustersByLine: GlyphCluster[][];
+    layoutData: TextLayoutData;
+    options: TextOptions;
+    loadedFont: LoadedFont;
+    fontId: string;
+}
+export interface TextLayoutHandle extends TextLayoutResult {
+    getLoadedFont(): LoadedFont | undefined;
+    measureTextWidth(text: string, letterSpacing?: number): number;
+    update(options: Partial<TextOptions>): Promise<TextLayoutHandle>;
+    dispose(): void;
+}
 export interface ColorByRange {
     start: number;
     end: number;

package/dist/types/index.d.ts

@@ -1,7 +1,11 @@
 export { Text } from './core/Text';
-export { DEFAULT_CURVE_FIDELITY } from './core/geometry/Polygonizer';
+export { MeshGeometryBuilder } from './mesh/MeshGeometryBuilder';
+export { DEFAULT_CURVE_FIDELITY } from './mesh/geometry/Polygonizer';
 export { FontMetadataExtractor } from './core/font/FontMetadata';
-export { globalGlyphCache, createGlyphCache } from './core/cache/sharedCaches';
+export { globalGlyphCache, createGlyphCache, globalOutlineCache } from './core/cache/sharedCaches';
+export { DrawCallbackHandler, getSharedDrawCallbackHandler } from './core/shaping/DrawCallbacks';
+export type { GlyphDrawCollector } from './core/shaping/DrawCallbacks';
+export { TextRangeQuery } from './core/layout/TextRangeQuery';
 export type { CacheStats } from './utils/Cache';
-export type { TextAlign, TextDirection, LineInfo, LoadedFont, HarfBuzzModule, HarfBuzzAPI, HarfBuzzBlob, HarfBuzzFace, HarfBuzzFont, HarfBuzzBuffer, HarfBuzzInstance, VariationAxis, ExtractedMetrics, VerticalMetrics, FontMetrics, ProcessedGeometry, Triangles, GlyphData, GlyphGeometryInfo, TextGeometryInfo, TextHandle, TextOptions, ColorOptions, ColorByRange, ColoredRange, PathInfo, HyphenationPatternsMap, CurveFidelityConfig, LayoutOptions, GeometryOptimizationOptions, TextRange, TextQueryOptions } from './core/types';
+export type { TextAlign, TextDirection, LineInfo, LoadedFont, HarfBuzzModule, HarfBuzzAPI, HarfBuzzBlob, HarfBuzzFace, HarfBuzzFont, HarfBuzzBuffer, HarfBuzzInstance, VariationAxis, ExtractedMetrics, VerticalMetrics, FontMetrics, ProcessedGeometry, Triangles, GlyphData, GlyphGeometryInfo, GlyphCluster, TextGeometryInfo, TextHandle, TextLayoutData, TextLayoutResult, TextLayoutHandle, TextOptions, ColorOptions, ColorByRange, ColoredRange, PathInfo, HyphenationPatternsMap, CurveFidelityConfig, LayoutOptions, GeometryOptimizationOptions, TextRange, TextQueryOptions } from './core/types';
 export type { HyphenationTrieNode } from './hyphenation';

package/dist/types/{core/cache → mesh}/GlyphContourCollector.d.ts

@@ -1,7 +1,7 @@
-import { Vec2 } from '../../utils/vectors';
-import { GlyphContours } from '../types';
-import { OptimizationStats } from '../geometry/PathOptimizer';
-import { CurveFidelityConfig, GeometryOptimizationOptions } from '../types';
+import { Vec2 } from '../utils/vectors';
+import { GlyphContours } from '../core/types';
+import { OptimizationStats } from './geometry/PathOptimizer';
+import { CurveFidelityConfig, GeometryOptimizationOptions } from '../core/types';
 export declare class GlyphContourCollector {
     private currentGlyphId;
     private currentTextIndex;

package/dist/types/{core/cache → mesh}/GlyphGeometryBuilder.d.ts

@@ -1,6 +1,6 @@
-import { GlyphGeometryInfo, LoadedFont, GlyphCluster, GlyphData } from '../types';
-import { CurveFidelityConfig, GeometryOptimizationOptions } from '../types';
-import { Cache } from '../../utils/Cache';
+import { GlyphGeometryInfo, LoadedFont, GlyphCluster, GlyphData } from '../core/types';
+import { CurveFidelityConfig, GeometryOptimizationOptions } from '../core/types';
+import { Cache } from '../utils/Cache';
 export interface InstancedTextGeometry {
     vertices: Float32Array;
     normals: Float32Array;
@@ -40,7 +40,7 @@ export declare class GlyphGeometryBuilder {
     private clusterContoursScratch;
     private taskScratch;
     constructor(cache: Cache<string, GlyphData>, loadedFont: LoadedFont);
-    getOptimizationStats(): import("../geometry/PathOptimizer").OptimizationStats;
+    getOptimizationStats(): import("./geometry/PathOptimizer").OptimizationStats;
     setCurveFidelityConfig(config?: CurveFidelityConfig): void;
     setCurveSteps(curveSteps?: number): void;
     setGeometryOptimization(options?: GeometryOptimizationOptions): void;
@@ -55,6 +55,6 @@ export declare class GlyphGeometryBuilder {
     private extrudeAndPackage;
     private tessellateGlyph;
     private updatePlaneBounds;
-    getCacheStats(): import("../../utils/Cache").CacheStats;
+    getCacheStats(): import("../utils/Cache").CacheStats;
     clearCache(): void;
 }

package/dist/types/mesh/MeshGeometryBuilder.d.ts

@@ -0,0 +1,18 @@
+import type { TextOptions, TextGeometryInfo, TextLayoutResult } from '../core/types';
+import type { LoadedFont } from '../core/types';
+export declare class MeshGeometryBuilder {
+    private geometryBuilder?;
+    private textLayout?;
+    private loadedFont;
+    private fontId;
+    constructor(loadedFont: LoadedFont, fontId: string);
+    setFont(loadedFont: LoadedFont, fontId: string): void;
+    build(layout: TextLayoutResult, options: TextOptions): TextGeometryInfo;
+    getCacheSize(): number;
+    clearCache(): void;
+    reset(): void;
+    private finalizeGeometry;
+    private applyColorSystem;
+    private calculateGlyphBounds;
+    private createGlyphAttributes;
+}

package/dist/types/{core → mesh}/geometry/BoundaryClusterer.d.ts

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

package/dist/types/{core → mesh}/geometry/Extruder.d.ts

@@ -1,4 +1,4 @@
-import type { ProcessedGeometry } from '../types';
+import type { ProcessedGeometry } from '../../core/types';
 export interface ExtrusionResult {
     vertices: Float32Array;
     normals: Float32Array;

package/dist/types/{core → mesh}/geometry/PathOptimizer.d.ts

@@ -1,4 +1,4 @@
-import type { Path } from '../types';
+import type { Path } from '../../core/types';
 export interface OptimizationConfig {
     enabled: boolean;
     areaThreshold: number;

package/dist/types/{core → mesh}/geometry/Polygonizer.d.ts

@@ -36,7 +36,7 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 import { Vec2 } from '../../utils/vectors';
-import { CurveFidelityConfig } from '../types';
+import { CurveFidelityConfig } from '../../core/types';
 export declare const DEFAULT_CURVE_FIDELITY: CurveFidelityConfig;
 export declare const COLLINEARITY_EPSILON: number;
 export declare class Polygonizer {

package/dist/types/{core → mesh}/geometry/Tessellator.d.ts

@@ -1,4 +1,4 @@
-import type { Path, ProcessedGeometry } from '../types';
+import type { Path, ProcessedGeometry } from '../../core/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;

package/dist/types/react/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+export declare function useDeepCompareMemo<T>(value: T): T;

package/dist/types/vector/GlyphOutlineCollector.d.ts

@@ -0,0 +1,25 @@
+import type { GlyphOutline } from '../core/types';
+export declare class GlyphOutlineCollector {
+    private currentGlyphId;
+    private currentTextIndex;
+    private inGlyph;
+    private currentSegments;
+    private currentPoint;
+    private contourStartPoint;
+    private contourId;
+    private currentGlyphBounds;
+    private collectedGlyphs;
+    private currentPosition;
+    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;
+    getCollectedGlyphs(): GlyphOutline[];
+    reset(): void;
+    private updateBounds;
+}

package/dist/types/vector/GlyphVectorGeometryBuilder.d.ts

@@ -0,0 +1,26 @@
+import type { GlyphCluster, LoadedFont, GlyphOutline, VectorGlyphInfo, VectorTextGeometryInfo } from '../core/types';
+import { Cache } from '../utils/Cache';
+import type { LoopBlinnInput } from './LoopBlinnGeometry';
+export declare class GlyphVectorGeometryBuilder {
+    private outlineCache;
+    private drawCallbacks;
+    private collector;
+    private loadedFont;
+    private fontId;
+    private cacheKeyPrefix;
+    private emptyGlyphs;
+    constructor(loadedFont: LoadedFont, cache?: Cache<string, GlyphOutline>);
+    setFontId(fontId: string): void;
+    clearCache(): void;
+    getCacheStats(): import("../utils/Cache").CacheStats;
+    private collectUniqueGlyphIds;
+    private computePlaneBounds;
+    buildForLoopBlinn(clustersByLine: GlyphCluster[][], scale: number): {
+        loopBlinnInput: LoopBlinnInput;
+        glyphs: VectorGlyphInfo[];
+    };
+    private getOutlineForGlyph;
+    private writeSegmentToTexture;
+    private segmentAABB;
+    buildVectorGeometry(clustersByLine: GlyphCluster[][], scale: number, segmentTextureWidth?: number, bandCount?: number, tileCountX?: number, tileCountY?: number): Omit<VectorTextGeometryInfo, 'query'>;
+}