three-text 0.2.17 → 0.2.19

package/README.md

@@ -4,7 +4,7 @@
 [![TypeScript](https://img.shields.io/badge/built%20with-TypeScript-007acc.svg)](https://www.typescriptlang.org/)
 [![License: AGPL v3](https://img.shields.io/badge/License-AGPL_v3_or_later-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
 
-A high fidelity 3D font renderer and text layout engine for the web
+High fidelity 3D mesh font geometry and text layout engine for the web
 
 ![Screenshot of three-text example file](https://countertype.com/assets/three-text/3D.png)
 
@@ -15,11 +15,7 @@ A high fidelity 3D font renderer and text layout engine for the web
 > [!CAUTION]
 > three-text is an alpha release and the API may break rapidly. This warning will last at least through the end of 2025. If API stability is important to you, consider pinning your version. Community feedback is encouraged; please open an issue if you have any suggestions or feedback, thank you
 
-
-          text: `three-text is a 3D font geometry and text layout library for the web. Its supports TTF, OTF, and WOFF font files. For layout, it uses Tex-based parameters for breaking text into paragraphs across multiple lines and supports CJK and RTL scripts. three-text caches the geometries it generates for low CPU overhead in languages with lots of repeating glyphs. Variable fonts are supported as static instances at a given axis coordinate, and can be animated by re-drawing each frame with new coordinates. The library has a framework-agnostic core that returns raw vertex data, with lightweight adapters for Three.js, React Three Fiber, p5.js, WebGL and WebGPU. Under the hood, three-text relies on HarfBuzz for text shaping, Knuth-Plass line breaking, Liang hyphenation, libtess by Eric Veach for tessellation, curve polygonization from Maxim Shemanarev's Anti-Grain Geometry, and Visvalingam-Whyatt line simplification`,
-
-
-**three-text** is a 3D font geometry and text layout library for the web. It supports TTF, OTF, and WOFF font files. For layout, it uses [TeX](https://en.wikipedia.org/wiki/TeX)-based parameters for breaking text into paragraphs across multiple lines and supports CJK and RTL scripts. three-text caches the geometries it generates for low CPU overhead in languages with lots of repeating glyphs. Variable fonts are supported as static instances at a given axis coordinate, and can be animated by re-drawing each frame with new coordinates
+**three-text** is a 3D mesh font geometry and text layout library for the web. It supports TTF, OTF, and WOFF font files. For layout, it uses [TeX](https://en.wikipedia.org/wiki/TeX)-based parameters for breaking text into paragraphs across multiple lines and supports CJK and RTL scripts. three-text caches the geometries it generates for low CPU overhead in languages with lots of repeating glyphs. Variable fonts are supported as static instances at a given axis coordinate, and can be animated by re-drawing each frame with new coordinates
 
 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)
 
@@ -556,7 +552,7 @@ const text = await Text.create({
 
 Values can be boolean (`true`/`false`) to enable or disable, or numeric for features accepting variant indices. Explicitly disabling a feature overrides the font's defaults
 
-Common tags include [`liga`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_ko#liga) (ligatures), [`kern`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_ko#kern) (kerning), [`calt`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_ae#calt) (contextual alternates), and [`smcp`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_pt#smcp) (small capitals). Number styling uses [`lnum`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_ko#lnum)/[`onum`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_ko#onum)/[`tnum`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_pt#tnum). Stylistic alternates are [`ss01`-`ss20`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_pt#ss01--ss20) and [`cv01`-`cv99`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_ae#cv01--cv99). Feature availability depends on the font
+Common tags include [`liga`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_ko#liga) (ligatures),  [`calt`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_ae#calt) (contextual alternates), [`tnum`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_pt#tnum) (tabular numbers), sylistic alternates [`ss01`-`ss20`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_pt#ss01--ss20) and character variants [`cv01`-`cv99`](https://learn.microsoft.com/en-us/typography/opentype/spec/features_ae#cv01--cv99). Feature availability depends on the font
 
 ### Per-glyph attributes
 
@@ -736,6 +732,10 @@ Initializes HarfBuzz WebAssembly. Called automatically by `create()`, but can be
 
 Preloads hyphenation patterns for specified languages. Useful for avoiding async pattern loading during text rendering
 
+##### `Text.setMaxFontCacheMemoryMB(limitMB: number): void`
+
+Sets an upper bound for the font cache, measured by the raw font buffer size, eviction is FIFO by insertion order
+
 #### Instance Methods
 
 The following methods are available on instances created by `Text.create()`:
@@ -753,7 +753,7 @@ Below are the most important configuration interfaces. For a complete list of al
 ```typescript
 interface TextOptions {
   text: string; // Text content to render
-  font?: string | ArrayBuffer; // Font file path or buffer (TTF, OTF, or WOFF)
+  font: string | ArrayBuffer; // Font file path or buffer (TTF, OTF, or WOFF)
   size?: number; // Font size in scene units (default: 72)
   depth?: number; // Extrusion depth (default: 0)
   lineHeight?: number; // Line height multiplier (default: 1.0)

package/dist/index.cjs

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.2.17
+ * three-text v0.2.19
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -81,7 +81,9 @@ class PerformanceLogger {
         // Find the metric in reverse order (most recent first)
         for (let i = this.metrics.length - 1; i >= 0; i--) {
             const metric = this.metrics[i];
-            if (metric.name === name && metric.startTime === startTime && !metric.endTime) {
+            if (metric.name === name &&
+                metric.startTime === startTime &&
+                !metric.endTime) {
                 metric.endTime = endTime;
                 metric.duration = duration;
                 break;
@@ -469,7 +471,9 @@ class LineBreak {
             const char = chars[i];
             const nextChar = i < chars.length - 1 ? chars[i + 1] : null;
             if (/\s/.test(char)) {
-                const width = widths ? (widths[i] ?? measureText(char)) : measureText(char);
+                const width = widths
+                    ? (widths[i] ?? measureText(char))
+                    : measureText(char);
                 items.push({
                     type: ItemType.GLUE,
                     width,
@@ -842,7 +846,9 @@ class LineBreak {
             if (breaks.length === 0) {
                 // For first emergency attempt, use initialEmergencyStretch
                 // For subsequent iterations (short line detection), progressively increase
-                currentEmergencyStretch = initialEmergencyStretch + (iteration * width * SHORT_LINE_EMERGENCY_STRETCH_INCREMENT);
+                currentEmergencyStretch =
+                    initialEmergencyStretch +
+                        iteration * width * SHORT_LINE_EMERGENCY_STRETCH_INCREMENT;
                 breaks = LineBreak.findBreakpoints(currentItems, width, tolerance, looseness, true, currentEmergencyStretch, context);
             }
             // Last resort: allow higher badness (but not infinite)
@@ -1723,12 +1729,12 @@ class FontMetadataExtractor {
         try {
             if (gsubTableOffset) {
                 const gsubData = this.extractFeatureDataFromTable(view, gsubTableOffset, nameTableOffset);
-                gsubData.features.forEach(f => features.add(f));
+                gsubData.features.forEach((f) => features.add(f));
                 Object.assign(featureNames, gsubData.names);
             }
             if (gposTableOffset) {
                 const gposData = this.extractFeatureDataFromTable(view, gposTableOffset, nameTableOffset);
-                gposData.features.forEach(f => features.add(f));
+                gposData.features.forEach((f) => features.add(f));
                 Object.assign(featureNames, gposData.names);
             }
         }
@@ -2727,7 +2733,9 @@ class Tessellator {
             tessContours = originalContours;
         }
         let extrusionContours = needsExtrusionContours
-            ? originalContours ?? this.pathsToContours(paths)
+            ? needsWindingReversal
+                ? tessContours
+                : (originalContours ?? this.pathsToContours(paths))
             : [];
         if (removeOverlaps) {
             logger.log('Two-pass: boundary extraction then triangulation');
@@ -2749,24 +2757,6 @@ class Tessellator {
         }
         else {
             logger.log(`Single-pass triangulation for ${isCFF ? 'CFF' : 'TTF'}`);
-            // TTF contours may have inconsistent winding; check if we need normalization
-            if (needsExtrusionContours && !isCFF) {
-                const needsNormalization = this.needsWindingNormalization(extrusionContours);
-                if (needsNormalization) {
-                    logger.log('Complex topology detected, running boundary pass for winding normalization');
-                    perfLogger.start('Tessellator.windingNormalization', {
-                        contourCount: extrusionContours.length
-                    });
-                    const boundaryResult = this.performTessellation(extrusionContours, 'boundary');
-                    perfLogger.end('Tessellator.windingNormalization');
-                    if (boundaryResult) {
-                        extrusionContours = this.boundaryToContours(boundaryResult);
-                    }
-                }
-                else {
-                    logger.log('Simple topology, skipping winding normalization');
-                }
-            }
         }
         perfLogger.start('Tessellator.triangulationPass', {
             contourCount: tessContours.length
@@ -2778,7 +2768,10 @@ class Tessellator {
                 ? 'libtess returned empty result from triangulation pass'
                 : 'libtess returned empty result from single-pass triangulation';
             logger.warn(warning);
-            return { triangles: { vertices: [], indices: [] }, contours: extrusionContours };
+            return {
+                triangles: { vertices: [], indices: [] },
+                contours: extrusionContours
+            };
         }
         return {
             triangles: {
@@ -2948,28 +2941,58 @@ class Tessellator {
 
 class Extruder {
     constructor() { }
+    packEdge(a, b) {
+        const lo = a < b ? a : b;
+        const hi = a < b ? b : a;
+        return lo * 0x100000000 + hi;
+    }
     extrude(geometry, depth = 0, unitsPerEm) {
         const points = geometry.triangles.vertices;
         const triangleIndices = geometry.triangles.indices;
         const numPoints = points.length / 2;
-        // Count side-wall segments (4 vertices + 6 indices per segment)
-        let sideSegments = 0;
+        // Count boundary edges for side walls (4 vertices + 6 indices per edge)
+        let boundaryEdges = [];
         if (depth !== 0) {
-            for (const contour of geometry.contours) {
-                // Contours are closed (last point repeats first)
-                const contourPoints = contour.length / 2;
-                if (contourPoints >= 2)
-                    sideSegments += contourPoints - 1;
+            const counts = new Map();
+            const oriented = new Map();
+            for (let i = 0; i < triangleIndices.length; i += 3) {
+                const a = triangleIndices[i];
+                const b = triangleIndices[i + 1];
+                const c = triangleIndices[i + 2];
+                const k0 = this.packEdge(a, b);
+                const n0 = (counts.get(k0) ?? 0) + 1;
+                counts.set(k0, n0);
+                if (n0 === 1)
+                    oriented.set(k0, [a, b]);
+                const k1 = this.packEdge(b, c);
+                const n1 = (counts.get(k1) ?? 0) + 1;
+                counts.set(k1, n1);
+                if (n1 === 1)
+                    oriented.set(k1, [b, c]);
+                const k2 = this.packEdge(c, a);
+                const n2 = (counts.get(k2) ?? 0) + 1;
+                counts.set(k2, n2);
+                if (n2 === 1)
+                    oriented.set(k2, [c, a]);
+            }
+            boundaryEdges = [];
+            for (const [key, count] of counts) {
+                if (count !== 1)
+                    continue;
+                const edge = oriented.get(key);
+                if (edge)
+                    boundaryEdges.push(edge);
             }
         }
-        const sideVertexCount = depth === 0 ? 0 : sideSegments * 4;
+        const sideEdgeCount = depth === 0 ? 0 : boundaryEdges.length;
+        const sideVertexCount = depth === 0 ? 0 : sideEdgeCount * 4;
         const baseVertexCount = depth === 0 ? numPoints : numPoints * 2;
         const vertexCount = baseVertexCount + sideVertexCount;
         const vertices = new Float32Array(vertexCount * 3);
         const normals = new Float32Array(vertexCount * 3);
         const indexCount = depth === 0
             ? triangleIndices.length
-            : triangleIndices.length * 2 + sideSegments * 6;
+            : triangleIndices.length * 2 + sideEdgeCount * 6;
         const indices = new Uint32Array(indexCount);
         if (depth === 0) {
             // Single-sided flat geometry at z=0
@@ -3025,60 +3048,62 @@ class Extruder {
         // Side walls
         let nextVertex = numPoints * 2;
         let idxPos = triangleIndices.length * 2;
-        for (const contour of geometry.contours) {
-            for (let i = 0; i < contour.length - 2; i += 2) {
-                const p0x = contour[i];
-                const p0y = contour[i + 1];
-                const p1x = contour[i + 2];
-                const p1y = contour[i + 3];
-                // Perpendicular normal for this wall segment
-                const ex = p1x - p0x;
-                const ey = p1y - p0y;
-                const lenSq = ex * ex + ey * ey;
-                let nx = 0;
-                let ny = 0;
-                if (lenSq > 0) {
-                    const invLen = 1 / Math.sqrt(lenSq);
-                    nx = ey * invLen;
-                    ny = -ex * invLen;
-                }
-                const baseVertex = nextVertex;
-                const base = baseVertex * 3;
-                // Wall quad: front edge at z=0, back edge at z=depth
-                vertices[base] = p0x;
-                vertices[base + 1] = p0y;
-                vertices[base + 2] = 0;
-                vertices[base + 3] = p1x;
-                vertices[base + 4] = p1y;
-                vertices[base + 5] = 0;
-                vertices[base + 6] = p0x;
-                vertices[base + 7] = p0y;
-                vertices[base + 8] = backZ;
-                vertices[base + 9] = p1x;
-                vertices[base + 10] = p1y;
-                vertices[base + 11] = backZ;
-                // Wall normals point perpendicular to edge
-                normals[base] = nx;
-                normals[base + 1] = ny;
-                normals[base + 2] = 0;
-                normals[base + 3] = nx;
-                normals[base + 4] = ny;
-                normals[base + 5] = 0;
-                normals[base + 6] = nx;
-                normals[base + 7] = ny;
-                normals[base + 8] = 0;
-                normals[base + 9] = nx;
-                normals[base + 10] = ny;
-                normals[base + 11] = 0;
-                // Two triangles per wall segment
-                indices[idxPos++] = baseVertex;
-                indices[idxPos++] = baseVertex + 1;
-                indices[idxPos++] = baseVertex + 2;
-                indices[idxPos++] = baseVertex + 1;
-                indices[idxPos++] = baseVertex + 3;
-                indices[idxPos++] = baseVertex + 2;
-                nextVertex += 4;
-            }
+        for (let e = 0; e < boundaryEdges.length; e++) {
+            const [u, v] = boundaryEdges[e];
+            const u2 = u * 2;
+            const v2 = v * 2;
+            const p0x = points[u2];
+            const p0y = points[u2 + 1];
+            const p1x = points[v2];
+            const p1y = points[v2 + 1];
+            // Perpendicular normal for this wall segment
+            // Uses the edge direction from the cap triangulation so winding does not depend on contour direction
+            const ex = p1x - p0x;
+            const ey = p1y - p0y;
+            const lenSq = ex * ex + ey * ey;
+            let nx = 0;
+            let ny = 0;
+            if (lenSq > 0) {
+                const invLen = 1 / Math.sqrt(lenSq);
+                nx = ey * invLen;
+                ny = -ex * invLen;
+            }
+            const baseVertex = nextVertex;
+            const base = baseVertex * 3;
+            // Wall quad: front edge at z=0, back edge at z=depth
+            vertices[base] = p0x;
+            vertices[base + 1] = p0y;
+            vertices[base + 2] = 0;
+            vertices[base + 3] = p1x;
+            vertices[base + 4] = p1y;
+            vertices[base + 5] = 0;
+            vertices[base + 6] = p0x;
+            vertices[base + 7] = p0y;
+            vertices[base + 8] = backZ;
+            vertices[base + 9] = p1x;
+            vertices[base + 10] = p1y;
+            vertices[base + 11] = backZ;
+            // Wall normals point perpendicular to edge
+            normals[base] = nx;
+            normals[base + 1] = ny;
+            normals[base + 2] = 0;
+            normals[base + 3] = nx;
+            normals[base + 4] = ny;
+            normals[base + 5] = 0;
+            normals[base + 6] = nx;
+            normals[base + 7] = ny;
+            normals[base + 8] = 0;
+            normals[base + 9] = nx;
+            normals[base + 10] = ny;
+            normals[base + 11] = 0;
+            // Two triangles per wall segment
+            indices[idxPos++] = baseVertex;
+            indices[idxPos++] = baseVertex + 1;
+            indices[idxPos++] = baseVertex + 2;
+            indices[idxPos++] = baseVertex + 1;
+            indices[idxPos++] = baseVertex + 3;
+            indices[idxPos++] = baseVertex + 2;
+            nextVertex += 4;
         }
         return { vertices, normals, indices };
     }
@@ -3403,9 +3428,7 @@ class PathOptimizer {
             const v1LenSq = v1x * v1x + v1y * v1y;
             const v2LenSq = v2x * v2x + v2y * v2y;
             const minLenSq = this.config.minSegmentLength * this.config.minSegmentLength;
-            if (angle > threshold ||
-                v1LenSq < minLenSq ||
-                v2LenSq < minLenSq) {
+            if (angle > threshold || v1LenSq < minLenSq || v2LenSq < minLenSq) {
                 result.push(current);
             }
             else {
@@ -4167,7 +4190,7 @@ class GlyphGeometryBuilder {
                         const relativePositions = cluster.glyphs.map((g) => new Vec3(g.x ?? 0, g.y ?? 0, 0));
                         boundaryGroups = this.clusterer.cluster(clusterGlyphContours, relativePositions);
                         this.clusteringCache.set(cacheKey, {
-                            glyphIds: cluster.glyphs.map(g => g.g),
+                            glyphIds: cluster.glyphs.map((g) => g.g),
                             groups: boundaryGroups
                         });
                     }
@@ -4177,7 +4200,7 @@ class GlyphGeometryBuilder {
                 // Use glyph-level caching when separateGlyphs is set or when cluster contains colored text
                 const forceSeparate = separateGlyphs || clusterHasColoredGlyphs;
                 // Iterate over the geometric groups identified by BoundaryClusterer
-                // logical groups (words) split into geometric sub-groups (e.g. "aa", "XX", "bb")
+                // logical groups (words) split into geometric sub-groups
                 for (const groupIndices of boundaryGroups) {
                     const isOverlappingGroup = groupIndices.length > 1;
                     const shouldCluster = isOverlappingGroup && !forceSeparate;
@@ -4557,7 +4580,8 @@ class TextShaper {
                     if (LineBreak.isCJOpeningPunctuation(currentChar)) {
                         shouldApply = false;
                     }
-                    if (LineBreak.isCJPunctuation(currentChar) && LineBreak.isCJPunctuation(nextChar)) {
+                    if (LineBreak.isCJPunctuation(currentChar) &&
+                        LineBreak.isCJPunctuation(nextChar)) {
                         shouldApply = false;
                     }
                     if (shouldApply) {
@@ -5361,7 +5385,7 @@ class Text {
     // Stringify with sorted keys for cache stability
     static stableStringify(obj) {
         const keys = Object.keys(obj).sort();
-        const pairs = keys.map(k => `${k}:${obj[k]}`);
+        const pairs = keys.map((k) => `${k}:${obj[k]}`);
         return pairs.join(',');
     }
     constructor() {
@@ -5599,7 +5623,9 @@ class Text {
             // to selectively use glyph-level caching (separate vertices) only for clusters containing
             // colored text, while non-colored clusters can still use fast cluster-level merging
             let coloredTextIndices;
-            if (options.color && typeof options.color === 'object' && !Array.isArray(options.color)) {
+            if (options.color &&
+                typeof options.color === 'object' &&
+                !Array.isArray(options.color)) {
                 if (options.color.byText || options.color.byCharRange) {
                     // Build the set manually since glyphs don't exist yet
                     coloredTextIndices = new Set();
@@ -5704,7 +5730,9 @@ class Text {
         const depthScale = this.loadedFont.upem / size;
         const rawDepthInFontUnits = depth * depthScale;
         const minExtrudeDepth = this.loadedFont.upem * 0.000025;
-        const depthInFontUnits = rawDepthInFontUnits <= 0 ? 0 : Math.max(rawDepthInFontUnits, minExtrudeDepth);
+        const depthInFontUnits = rawDepthInFontUnits <= 0
+            ? 0
+            : Math.max(rawDepthInFontUnits, minExtrudeDepth);
         if (!this.textLayout) {
             this.textLayout = new TextLayout(this.loadedFont);
         }
@@ -5876,10 +5904,12 @@ class Text {
         planeBounds.max.z *= finalScale;
         for (let i = 0; i < glyphInfoArray.length; i++) {
             const glyphInfo = glyphInfoArray[i];
-            glyphInfo.bounds.min.x = glyphInfo.bounds.min.x * finalScale + offsetScaled;
+            glyphInfo.bounds.min.x =
+                glyphInfo.bounds.min.x * finalScale + offsetScaled;
             glyphInfo.bounds.min.y *= finalScale;
             glyphInfo.bounds.min.z *= finalScale;
-            glyphInfo.bounds.max.x = glyphInfo.bounds.max.x * finalScale + offsetScaled;
+            glyphInfo.bounds.max.x =
+                glyphInfo.bounds.max.x * finalScale + offsetScaled;
             glyphInfo.bounds.max.y *= finalScale;
             glyphInfo.bounds.max.z *= finalScale;
         }
@@ -5942,13 +5972,11 @@ class Text {
     static registerPattern(language, pattern) {
         Text.patternCache.set(language, pattern);
     }
-    static clearFontCache() {
-        Text.fontCache.clear();
-        Text.fontCacheMemoryBytes = 0;
-    }
     static setMaxFontCacheMemoryMB(limitMB) {
         Text.maxFontCacheMemoryBytes =
-            limitMB === Infinity ? Infinity : Math.max(1, Math.floor(limitMB)) * 1024 * 1024;
+            limitMB === Infinity
+                ? Infinity
+                : Math.max(1, Math.floor(limitMB)) * 1024 * 1024;
         Text.enforceFontCacheMemoryLimit();
     }
     getLoadedFont() {

package/dist/index.d.ts

@@ -5,6 +5,45 @@ interface HyphenationTrieNode {
     };
 }
 
+interface LRUCacheOptions<K, V> {
+    maxEntries?: number;
+    maxMemoryBytes?: number;
+    calculateSize?: (value: V) => number;
+    onEvict?: (key: K, value: V) => void;
+}
+interface CacheStats {
+    hits: number;
+    misses: number;
+    evictions: number;
+    size: number;
+    memoryUsage: number;
+}
+declare class LRUCache<K, V> {
+    private cache;
+    private head;
+    private tail;
+    private stats;
+    private options;
+    constructor(options?: LRUCacheOptions<K, V>);
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): void;
+    delete(key: K): boolean;
+    clear(): void;
+    getStats(): CacheStats & {
+        hitRate: number;
+        memoryUsageMB: number;
+    };
+    keys(): K[];
+    get size(): number;
+    private evictIfNeeded;
+    private evictTail;
+    private addToHead;
+    private removeNode;
+    private removeTail;
+    private moveToHead;
+}
+
 interface BoundingBox {
     min: {
         x: number;
@@ -221,13 +260,19 @@ interface TextGeometryInfo {
         pointsRemovedByVisvalingam: number;
         pointsRemovedByColinear: number;
         originalPointCount: number;
-    };
+    } & Partial<CacheStats & {
+        hitRate: number;
+        memoryUsageMB: number;
+    }>;
     query(options: TextQueryOptions): TextRange[];
     coloredRanges?: ColoredRange[];
 }
 interface TextHandle extends TextGeometryInfo {
     getLoadedFont(): LoadedFont | undefined;
-    getCacheStatistics(): any;
+    getCacheStatistics(): (CacheStats & {
+        hitRate: number;
+        memoryUsageMB: number;
+    }) | null;
     clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<TextOptions>): Promise<TextHandle>;
@@ -266,7 +311,7 @@ interface ColoredRange {
 }
 interface TextOptions {
     text: string;
-    font?: string | ArrayBuffer;
+    font: string | ArrayBuffer;
     size?: number;
     depth?: number;
     lineHeight?: number;
@@ -367,7 +412,6 @@ declare class Text {
     getFontMetrics(): FontMetrics;
     static preloadPatterns(languages: string[], patternsPath?: string): Promise<void>;
     static registerPattern(language: string, pattern: HyphenationTrieNode): void;
-    static clearFontCache(): void;
     static setMaxFontCacheMemoryMB(limitMB: number): void;
     getLoadedFont(): LoadedFont | undefined;
     measureTextWidth(text: string, letterSpacing?: number): number;
@@ -436,45 +480,6 @@ declare class FontMetadataExtractor {
     static getFontMetrics(metrics: ExtractedMetrics): FontMetrics;
 }
 
-interface LRUCacheOptions<K, V> {
-    maxEntries?: number;
-    maxMemoryBytes?: number;
-    calculateSize?: (value: V) => number;
-    onEvict?: (key: K, value: V) => void;
-}
-interface CacheStats {
-    hits: number;
-    misses: number;
-    evictions: number;
-    size: number;
-    memoryUsage: number;
-}
-declare class LRUCache<K, V> {
-    private cache;
-    private head;
-    private tail;
-    private stats;
-    private options;
-    constructor(options?: LRUCacheOptions<K, V>);
-    get(key: K): V | undefined;
-    has(key: K): boolean;
-    set(key: K, value: V): void;
-    delete(key: K): boolean;
-    clear(): void;
-    getStats(): CacheStats & {
-        hitRate: number;
-        memoryUsageMB: number;
-    };
-    keys(): K[];
-    get size(): number;
-    private evictIfNeeded;
-    private evictTail;
-    private addToHead;
-    private removeNode;
-    private removeTail;
-    private moveToHead;
-}
-
 declare const globalGlyphCache: LRUCache<string, GlyphData>;
 declare function createGlyphCache(maxCacheSizeMB?: number): LRUCache<string, GlyphData>;