three-text 0.2.19 → 0.3.0

package/dist/index.umd.js

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.2.19
+ * three-text v0.3.0
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -2386,231 +2386,50 @@
         }
     }
 
-    // Generic LRU (Least Recently Used) cache with optional memory-based eviction
-    class LRUCache {
-        constructor(options = {}) {
+    // Map-based cache with no eviction policy
+    class Cache {
+        constructor() {
             this.cache = new Map();
-            this.head = null;
-            this.tail = null;
-            this.stats = {
-                hits: 0,
-                misses: 0,
-                evictions: 0,
-                size: 0,
-                memoryUsage: 0
-            };
-            this.options = {
-                maxEntries: options.maxEntries ?? Infinity,
-                maxMemoryBytes: options.maxMemoryBytes ?? Infinity,
-                calculateSize: options.calculateSize ?? (() => 0),
-                onEvict: options.onEvict
-            };
         }
         get(key) {
-            const node = this.cache.get(key);
-            if (node) {
-                this.stats.hits++;
-                this.moveToHead(node);
-                return node.value;
-            }
-            else {
-                this.stats.misses++;
-                return undefined;
-            }
+            return this.cache.get(key);
         }
         has(key) {
             return this.cache.has(key);
         }
         set(key, value) {
-            // If key already exists, update it
-            const existingNode = this.cache.get(key);
-            if (existingNode) {
-                const oldSize = this.options.calculateSize(existingNode.value);
-                const newSize = this.options.calculateSize(value);
-                this.stats.memoryUsage = this.stats.memoryUsage - oldSize + newSize;
-                existingNode.value = value;
-                this.moveToHead(existingNode);
-                return;
-            }
-            const size = this.options.calculateSize(value);
-            // Evict entries if we exceed limits
-            this.evictIfNeeded(size);
-            // Create new node
-            const node = {
-                key,
-                value,
-                prev: null,
-                next: null
-            };
-            this.cache.set(key, node);
-            this.addToHead(node);
-            this.stats.size = this.cache.size;
-            this.stats.memoryUsage += size;
+            this.cache.set(key, value);
         }
         delete(key) {
-            const node = this.cache.get(key);
-            if (!node)
-                return false;
-            const size = this.options.calculateSize(node.value);
-            this.removeNode(node);
-            this.cache.delete(key);
-            this.stats.size = this.cache.size;
-            this.stats.memoryUsage -= size;
-            if (this.options.onEvict) {
-                this.options.onEvict(key, node.value);
-            }
-            return true;
+            return this.cache.delete(key);
         }
         clear() {
-            if (this.options.onEvict) {
-                for (const [key, node] of this.cache) {
-                    this.options.onEvict(key, node.value);
-                }
-            }
             this.cache.clear();
-            this.head = null;
-            this.tail = null;
-            this.stats = {
-                hits: 0,
-                misses: 0,
-                evictions: 0,
-                size: 0,
-                memoryUsage: 0
-            };
-        }
-        getStats() {
-            const total = this.stats.hits + this.stats.misses;
-            const hitRate = total > 0 ? (this.stats.hits / total) * 100 : 0;
-            const memoryUsageMB = this.stats.memoryUsage / (1024 * 1024);
-            return {
-                ...this.stats,
-                hitRate,
-                memoryUsageMB
-            };
-        }
-        keys() {
-            const keys = [];
-            let current = this.head;
-            while (current) {
-                keys.push(current.key);
-                current = current.next;
-            }
-            return keys;
         }
         get size() {
             return this.cache.size;
         }
-        evictIfNeeded(requiredSize) {
-            // Evict by entry count
-            while (this.cache.size >= this.options.maxEntries && this.tail) {
-                this.evictTail();
-            }
-            // Evict by memory usage
-            if (this.options.maxMemoryBytes < Infinity) {
-                while (this.tail &&
-                    this.stats.memoryUsage + requiredSize > this.options.maxMemoryBytes) {
-                    this.evictTail();
-                }
-            }
-        }
-        evictTail() {
-            if (!this.tail)
-                return;
-            const nodeToRemove = this.tail;
-            const size = this.options.calculateSize(nodeToRemove.value);
-            this.removeTail();
-            this.cache.delete(nodeToRemove.key);
-            this.stats.size = this.cache.size;
-            this.stats.memoryUsage -= size;
-            this.stats.evictions++;
-            if (this.options.onEvict) {
-                this.options.onEvict(nodeToRemove.key, nodeToRemove.value);
-            }
-        }
-        addToHead(node) {
-            node.prev = null;
-            node.next = null;
-            if (!this.head) {
-                this.head = this.tail = node;
-            }
-            else {
-                node.next = this.head;
-                this.head.prev = node;
-                this.head = node;
-            }
-        }
-        removeNode(node) {
-            if (node.prev) {
-                node.prev.next = node.next;
-            }
-            else {
-                this.head = node.next;
-            }
-            if (node.next) {
-                node.next.prev = node.prev;
-            }
-            else {
-                this.tail = node.prev;
-            }
-        }
-        removeTail() {
-            if (this.tail) {
-                this.removeNode(this.tail);
-            }
+        keys() {
+            return Array.from(this.cache.keys());
         }
-        moveToHead(node) {
-            if (node === this.head)
-                return;
-            this.removeNode(node);
-            this.addToHead(node);
+        getStats() {
+            return {
+                size: this.cache.size
+            };
         }
     }
 
-    const DEFAULT_CACHE_SIZE_MB = 250;
     function getGlyphCacheKey(fontId, glyphId, depth, removeOverlaps) {
         const roundedDepth = Math.round(depth * 1000) / 1000;
         return `${fontId}_${glyphId}_${roundedDepth}_${removeOverlaps}`;
     }
-    function calculateGlyphMemoryUsage(glyph) {
-        let size = 0;
-        size += glyph.vertices.length * 4;
-        size += glyph.normals.length * 4;
-        size += glyph.indices.length * glyph.indices.BYTES_PER_ELEMENT;
-        size += 24; // 2 Vec3s
-        size += 256; // Object overhead
-        return size;
+    const globalGlyphCache = new Cache();
+    function createGlyphCache() {
+        return new Cache();
     }
-    const globalGlyphCache = new LRUCache({
-        maxEntries: Infinity,
-        maxMemoryBytes: DEFAULT_CACHE_SIZE_MB * 1024 * 1024,
-        calculateSize: calculateGlyphMemoryUsage
-    });
-    function createGlyphCache(maxCacheSizeMB = DEFAULT_CACHE_SIZE_MB) {
-        return new LRUCache({
-            maxEntries: Infinity,
-            maxMemoryBytes: maxCacheSizeMB * 1024 * 1024,
-            calculateSize: calculateGlyphMemoryUsage
-        });
-    }
-    // Shared across builder instances: contour extraction, word clustering, boundary grouping
-    const globalContourCache = new LRUCache({
-        maxEntries: 1000,
-        calculateSize: (contours) => {
-            let size = 0;
-            for (const path of contours.paths) {
-                size += path.points.length * 16; // Vec2 = 2 floats * 8 bytes
-            }
-            return size + 64; // bounds overhead
-        }
-    });
-    const globalWordCache = new LRUCache({
-        maxEntries: 1000,
-        calculateSize: calculateGlyphMemoryUsage
-    });
-    const globalClusteringCache = new LRUCache({
-        maxEntries: 2000,
-        calculateSize: () => 1
-    });
+    const globalContourCache = new Cache();
+    const globalWordCache = new Cache();
+    const globalClusteringCache = new Cache();
 
     var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -2945,47 +2764,79 @@
 
     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 boundary edges for side walls (4 vertices + 6 indices per edge)
+            // Boundary edges are those that appear in exactly one triangle
             let boundaryEdges = [];
             if (depth !== 0) {
-                const counts = new Map();
-                const oriented = new Map();
-                for (let i = 0; i < triangleIndices.length; i += 3) {
+                // Pack edge pair into integer key: (min << 16) | max
+                // Fits glyph vertex indices comfortably, good hash distribution
+                const edgeMap = new Map();
+                const triLen = triangleIndices.length;
+                for (let i = 0; i < triLen; 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]);
+                    let key, v0, v1;
+                    if (a < b) {
+                        key = (a << 16) | b;
+                        v0 = a;
+                        v1 = b;
+                    }
+                    else {
+                        key = (b << 16) | a;
+                        v0 = a;
+                        v1 = b;
+                    }
+                    let data = edgeMap.get(key);
+                    if (data) {
+                        data[2]++;
+                    }
+                    else {
+                        edgeMap.set(key, [v0, v1, 1]);
+                    }
+                    if (b < c) {
+                        key = (b << 16) | c;
+                        v0 = b;
+                        v1 = c;
+                    }
+                    else {
+                        key = (c << 16) | b;
+                        v0 = b;
+                        v1 = c;
+                    }
+                    data = edgeMap.get(key);
+                    if (data) {
+                        data[2]++;
+                    }
+                    else {
+                        edgeMap.set(key, [v0, v1, 1]);
+                    }
+                    if (c < a) {
+                        key = (c << 16) | a;
+                        v0 = c;
+                        v1 = a;
+                    }
+                    else {
+                        key = (a << 16) | c;
+                        v0 = c;
+                        v1 = a;
+                    }
+                    data = edgeMap.get(key);
+                    if (data) {
+                        data[2]++;
+                    }
+                    else {
+                        edgeMap.set(key, [v0, v1, 1]);
+                    }
                 }
                 boundaryEdges = [];
-                for (const [key, count] of counts) {
-                    if (count !== 1)
-                        continue;
-                    const edge = oriented.get(key);
-                    if (edge)
-                        boundaryEdges.push(edge);
+                for (const [v0, v1, count] of edgeMap.values()) {
+                    if (count === 1) {
+                        boundaryEdges.push([v0, v1]);
+                    }
                 }
             }
             const sideEdgeCount = depth === 0 ? 0 : boundaryEdges.length;
@@ -2999,7 +2850,6 @@
                 : triangleIndices.length * 2 + sideEdgeCount * 6;
             const indices = new Uint32Array(indexCount);
             if (depth === 0) {
-                // Single-sided flat geometry at z=0
                 let vPos = 0;
                 for (let i = 0; i < points.length; i += 2) {
                     vertices[vPos] = points[i];
@@ -3010,16 +2860,11 @@
                     normals[vPos + 2] = 1;
                     vPos += 3;
                 }
-                // libtess outputs CCW, use as-is for +Z facing geometry
-                for (let i = 0; i < triangleIndices.length; i++) {
-                    indices[i] = triangleIndices[i];
-                }
+                indices.set(triangleIndices);
                 return { vertices, normals, indices };
             }
-            // Extruded geometry: front at z=0, back at z=depth
             const minBackOffset = unitsPerEm * 0.000025;
             const backZ = depth <= minBackOffset ? minBackOffset : depth;
-            // Generate both caps in one pass
             for (let p = 0, vi = 0; p < points.length; p += 2, vi++) {
                 const x = points[p];
                 const y = points[p + 1];
@@ -3040,41 +2885,39 @@
                 normals[baseD + 1] = 0;
                 normals[baseD + 2] = 1;
             }
-            // libtess outputs CCW triangles (viewed from +Z)
-            // Z=0 cap faces -Z, reverse winding
-            for (let i = 0; i < triangleIndices.length; i++) {
-                indices[i] = triangleIndices[triangleIndices.length - 1 - i];
+            // Front cap faces -Z, reverse winding from libtess CCW output
+            const triLen = triangleIndices.length;
+            for (let i = 0; i < triLen; i++) {
+                indices[i] = triangleIndices[triLen - 1 - i];
             }
-            // Z=depth cap faces +Z, use original winding
-            for (let i = 0; i < triangleIndices.length; i++) {
-                indices[triangleIndices.length + i] = triangleIndices[i] + numPoints;
+            // Back cap faces +Z, use original winding
+            for (let i = 0; i < triLen; i++) {
+                indices[triLen + i] = triangleIndices[i] + numPoints;
             }
-            // Side walls
             let nextVertex = numPoints * 2;
-            let idxPos = triangleIndices.length * 2;
-            for (let e = 0; e < boundaryEdges.length; e++) {
-                const [u, v] = boundaryEdges[e];
-                const u2 = u * 2;
-                const v2 = v * 2;
+            let idxPos = triLen * 2;
+            const numEdges = boundaryEdges.length;
+            for (let e = 0; e < numEdges; e++) {
+                const edge = boundaryEdges[e];
+                const u = edge[0];
+                const v = edge[1];
+                const u2 = u << 1;
+                const v2 = v << 1;
                 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) {
+                if (lenSq > 1e-10) {
                     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
+                const base = nextVertex * 3;
                 vertices[base] = p0x;
                 vertices[base + 1] = p0y;
                 vertices[base + 2] = 0;
@@ -3087,7 +2930,6 @@
                 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;
@@ -3100,13 +2942,14 @@
                 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;
+                const baseVertex = nextVertex;
+                indices[idxPos] = baseVertex;
+                indices[idxPos + 1] = baseVertex + 1;
+                indices[idxPos + 2] = baseVertex + 2;
+                indices[idxPos + 3] = baseVertex + 1;
+                indices[idxPos + 4] = baseVertex + 3;
+                indices[idxPos + 5] = baseVertex + 2;
+                idxPos += 6;
                 nextVertex += 4;
             }
             return { vertices, normals, indices };
@@ -4123,7 +3966,7 @@
             ].join('|');
         }
         // Build instanced geometry from glyph contours
-        buildInstancedGeometry(clustersByLine, depth, removeOverlaps, isCFF, separateGlyphs = false, coloredTextIndices) {
+        buildInstancedGeometry(clustersByLine, depth, removeOverlaps, isCFF, scale, separateGlyphs = false, coloredTextIndices) {
             if (isLogEnabled) {
                 let wordCount = 0;
                 for (let i = 0; i < clustersByLine.length; i++) {
@@ -4301,9 +4144,9 @@
                 const py = task.py;
                 const pz = task.pz;
                 for (let j = 0; j < v.length; j += 3) {
-                    vertexArray[vertexPos++] = v[j] + px;
-                    vertexArray[vertexPos++] = v[j + 1] + py;
-                    vertexArray[vertexPos++] = v[j + 2] + pz;
+                    vertexArray[vertexPos++] = (v[j] + px) * scale;
+                    vertexArray[vertexPos++] = (v[j + 1] + py) * scale;
+                    vertexArray[vertexPos++] = (v[j + 2] + pz) * scale;
                 }
                 normalArray.set(n, normalPos);
                 normalPos += n.length;
@@ -4313,6 +4156,20 @@
                 }
             }
             perfLogger.end('GlyphGeometryBuilder.buildInstancedGeometry');
+            planeBounds.min.x *= scale;
+            planeBounds.min.y *= scale;
+            planeBounds.min.z *= scale;
+            planeBounds.max.x *= scale;
+            planeBounds.max.y *= scale;
+            planeBounds.max.z *= scale;
+            for (let i = 0; i < glyphInfos.length; i++) {
+                glyphInfos[i].bounds.min.x *= scale;
+                glyphInfos[i].bounds.min.y *= scale;
+                glyphInfos[i].bounds.min.z *= scale;
+                glyphInfos[i].bounds.max.x *= scale;
+                glyphInfos[i].bounds.max.y *= scale;
+                glyphInfos[i].bounds.max.z *= scale;
+            }
             return {
                 vertices: vertexArray,
                 normals: normalArray,
@@ -4324,7 +4181,6 @@
         getClusterKey(glyphs, depth, removeOverlaps) {
             if (glyphs.length === 0)
                 return '';
-            // Normalize positions relative to the first glyph in the cluster
             const refX = glyphs[0].x ?? 0;
             const refY = glyphs[0].y ?? 0;
             const parts = glyphs.map((g) => {
@@ -5379,6 +5235,7 @@
     }
 
     const DEFAULT_MAX_TEXT_LENGTH = 100000;
+    const DEFAULT_FONT_SIZE = 72;
     class Text {
         static { this.patternCache = new Map(); }
         static { this.hbInitPromise = null; }
@@ -5452,7 +5309,7 @@
                 return {
                     ...newResult,
                     getLoadedFont: () => text.getLoadedFont(),
-                    getCacheStatistics: () => text.getCacheStatistics(),
+                    getCacheSize: () => text.getCacheSize(),
                     clearCache: () => text.clearCache(),
                     measureTextWidth: (textString, letterSpacing) => text.measureTextWidth(textString, letterSpacing),
                     update
@@ -5461,7 +5318,7 @@
             return {
                 ...result,
                 getLoadedFont: () => text.getLoadedFont(),
-                getCacheStatistics: () => text.getCacheStatistics(),
+                getCacheSize: () => text.getCacheSize(),
                 clearCache: () => text.clearCache(),
                 measureTextWidth: (textString, letterSpacing) => text.measureTextWidth(textString, letterSpacing),
                 update
@@ -5593,7 +5450,7 @@
         async createGeometry(options) {
             perfLogger.start('Text.createGeometry', {
                 textLength: options.text.length,
-                size: options.size || 72,
+                size: options.size || DEFAULT_FONT_SIZE,
                 hasLayout: !!options.layout,
                 mode: 'cached'
             });
@@ -5607,7 +5464,7 @@
                 this.updateFontVariations(options);
                 if (!this.geometryBuilder) {
                     const cache = options.maxCacheSizeMB
-                        ? createGlyphCache(options.maxCacheSizeMB)
+                        ? createGlyphCache()
                         : globalGlyphCache;
                     this.geometryBuilder = new GlyphGeometryBuilder(cache, this.loadedFont);
                     this.geometryBuilder.setFontId(this.currentFontId);
@@ -5653,10 +5510,9 @@
                         }
                     }
                 }
-                const shapedResult = this.geometryBuilder.buildInstancedGeometry(clustersByLine, layoutData.depth, shouldRemoveOverlaps, this.loadedFont.metrics.isCFF, options.separateGlyphsWithAttributes || false, coloredTextIndices);
-                const cacheStats = this.geometryBuilder.getCacheStats();
-                const result = this.finalizeGeometry(shapedResult.vertices, shapedResult.normals, shapedResult.indices, shapedResult.glyphInfos, shapedResult.planeBounds, options, cacheStats, options.text);
-                if (options.separateGlyphsWithAttributes) {
+                const shapedResult = this.geometryBuilder.buildInstancedGeometry(clustersByLine, layoutData.depth, shouldRemoveOverlaps, this.loadedFont.metrics.isCFF, layoutData.pixelsPerFontUnit, options.perGlyphAttributes ?? false, coloredTextIndices);
+                const result = this.finalizeGeometry(shapedResult.vertices, shapedResult.normals, shapedResult.indices, shapedResult.glyphInfos, shapedResult.planeBounds, options, options.text);
+                if (options.perGlyphAttributes) {
                     const glyphAttrs = this.createGlyphAttributes(result.vertices.length / 3, result.glyphs);
                     result.glyphAttributes = glyphAttrs;
                 }
@@ -5723,16 +5579,16 @@
             if (!this.loadedFont) {
                 throw new Error('Font not loaded. Use Text.create() with a font option');
             }
-            const { text, size = 72, depth = 0, lineHeight = 1.0, letterSpacing = 0, layout = {} } = options;
+            const { text, size = DEFAULT_FONT_SIZE, depth = 0, lineHeight = 1.0, letterSpacing = 0, layout = {} } = options;
             const { width, direction = 'ltr', align = direction === 'rtl' ? 'right' : 'left', respectExistingBreaks = true, hyphenate = true, language = 'en-us', tolerance = DEFAULT_TOLERANCE, pretolerance = DEFAULT_PRETOLERANCE, emergencyStretch = DEFAULT_EMERGENCY_STRETCH, autoEmergencyStretch, hyphenationPatterns, lefthyphenmin, righthyphenmin, linepenalty, adjdemerits, hyphenpenalty, exhyphenpenalty, doublehyphendemerits, looseness, disableShortLineDetection, shortLineThreshold } = layout;
+            const fontUnitsPerPixel = this.loadedFont.upem / size;
             let widthInFontUnits;
             if (width !== undefined) {
-                widthInFontUnits = width * (this.loadedFont.upem / size);
+                widthInFontUnits = width * fontUnitsPerPixel;
             }
             // Keep depth behavior consistent with Extruder: extremely small non-zero depths
-            // are clamped to a minimum back offset so the back face is not coplanar.
-            const depthScale = this.loadedFont.upem / size;
-            const rawDepthInFontUnits = depth * depthScale;
+            // are clamped to a minimum back offset to prevent Z fighting
+            const rawDepthInFontUnits = depth * fontUnitsPerPixel;
             const minExtrudeDepth = this.loadedFont.upem * 0.000025;
             const depthInFontUnits = rawDepthInFontUnits <= 0
                 ? 0
@@ -5775,7 +5631,8 @@
                 align,
                 direction,
                 depth: depthInFontUnits,
-                size
+                size,
+                pixelsPerFontUnit: 1 / fontUnitsPerPixel
             };
         }
         applyColorSystem(vertices, glyphInfoArray, color, originalText) {
@@ -5871,8 +5728,8 @@
             }
             return { colors, coloredRanges };
         }
-        finalizeGeometry(vertices, normals, indices, glyphInfoArray, planeBounds, options, cacheStats, originalText) {
-            const { layout = {}, size = 72 } = options;
+        finalizeGeometry(vertices, normals, indices, glyphInfoArray, planeBounds, options, originalText) {
+            const { layout = {} } = options;
             const { width, align = layout.direction === 'rtl' ? 'right' : 'left' } = layout;
             if (!this.textLayout) {
                 this.textLayout = new TextLayout(this.loadedFont);
@@ -5885,37 +5742,14 @@
             const offset = alignmentResult.offset;
             planeBounds.min.x = alignmentResult.adjustedBounds.min.x;
             planeBounds.max.x = alignmentResult.adjustedBounds.max.x;
-            const finalScale = size / this.loadedFont.upem;
-            const offsetScaled = offset * finalScale;
-            // Scale vertices only (normals are unit vectors, don't scale)
-            if (offsetScaled === 0) {
-                for (let i = 0; i < vertices.length; i++) {
-                    vertices[i] *= finalScale;
-                }
-            }
-            else {
+            if (offset !== 0) {
                 for (let i = 0; i < vertices.length; i += 3) {
-                    vertices[i] = vertices[i] * finalScale + offsetScaled;
-                    vertices[i + 1] *= finalScale;
-                    vertices[i + 2] *= finalScale;
-                }
-            }
-            planeBounds.min.x *= finalScale;
-            planeBounds.min.y *= finalScale;
-            planeBounds.min.z *= finalScale;
-            planeBounds.max.x *= finalScale;
-            planeBounds.max.y *= finalScale;
-            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.y *= finalScale;
-                glyphInfo.bounds.min.z *= finalScale;
-                glyphInfo.bounds.max.x =
-                    glyphInfo.bounds.max.x * finalScale + offsetScaled;
-                glyphInfo.bounds.max.y *= finalScale;
-                glyphInfo.bounds.max.z *= finalScale;
+                    vertices[i] += offset;
+                }
+                for (let i = 0; i < glyphInfoArray.length; i++) {
+                    glyphInfoArray[i].bounds.min.x += offset;
+                    glyphInfoArray[i].bounds.max.x += offset;
+                }
             }
             let colors;
             let coloredRanges;
@@ -5940,8 +5774,7 @@
                     verticesGenerated,
                     pointsRemovedByVisvalingam: optimizationStats.pointsRemovedByVisvalingam,
                     pointsRemovedByColinear: optimizationStats.pointsRemovedByColinear,
-                    originalPointCount: optimizationStats.originalPointCount,
-                    ...(cacheStats || {})
+                    originalPointCount: optimizationStats.originalPointCount
                 },
                 query: (options) => {
                     if (!originalText) {
@@ -5992,11 +5825,11 @@
             }
             return TextMeasurer.measureTextWidth(this.loadedFont, text, letterSpacing);
         }
-        getCacheStatistics() {
+        getCacheSize() {
             if (this.geometryBuilder) {
-                return this.geometryBuilder.getCacheStats();
+                return this.geometryBuilder.getCacheStats().size;
             }
-            return null;
+            return 0;
         }
         clearCache() {
             if (this.geometryBuilder) {
@@ -6007,25 +5840,45 @@
             const glyphCenters = new Float32Array(vertexCount * 3);
             const glyphIndices = new Float32Array(vertexCount);
             const glyphLineIndices = new Float32Array(vertexCount);
-            glyphs.forEach((glyph, index) => {
+            const glyphProgress = new Float32Array(vertexCount);
+            const glyphBaselineY = new Float32Array(vertexCount);
+            let minX = Infinity;
+            let maxX = -Infinity;
+            for (let i = 0; i < glyphs.length; i++) {
+                const cx = (glyphs[i].bounds.min.x + glyphs[i].bounds.max.x) / 2;
+                if (cx < minX)
+                    minX = cx;
+                if (cx > maxX)
+                    maxX = cx;
+            }
+            const range = maxX - minX;
+            for (let index = 0; index < glyphs.length; index++) {
+                const glyph = glyphs[index];
                 const centerX = (glyph.bounds.min.x + glyph.bounds.max.x) / 2;
                 const centerY = (glyph.bounds.min.y + glyph.bounds.max.y) / 2;
                 const centerZ = (glyph.bounds.min.z + glyph.bounds.max.z) / 2;
-                for (let i = 0; i < glyph.vertexCount; i++) {
-                    const vertexIndex = glyph.vertexStart + i;
-                    if (vertexIndex < vertexCount) {
-                        glyphCenters[vertexIndex * 3] = centerX;
-                        glyphCenters[vertexIndex * 3 + 1] = centerY;
-                        glyphCenters[vertexIndex * 3 + 2] = centerZ;
-                        glyphIndices[vertexIndex] = index;
-                        glyphLineIndices[vertexIndex] = glyph.lineIndex;
-                    }
+                const baselineY = glyph.bounds.min.y;
+                const progress = range > 0 ? (centerX - minX) / range : 0;
+                const start = glyph.vertexStart;
+                const end = Math.min(start + glyph.vertexCount, vertexCount);
+                if (end <= start)
+                    continue;
+                glyphIndices.fill(index, start, end);
+                glyphLineIndices.fill(glyph.lineIndex, start, end);
+                glyphProgress.fill(progress, start, end);
+                glyphBaselineY.fill(baselineY, start, end);
+                for (let v = start * 3; v < end * 3; v += 3) {
+                    glyphCenters[v] = centerX;
+                    glyphCenters[v + 1] = centerY;
+                    glyphCenters[v + 2] = centerZ;
                 }
-            });
+            }
             return {
                 glyphCenter: glyphCenters,
                 glyphIndex: glyphIndices,
-                glyphLineIndex: glyphLineIndices
+                glyphLineIndex: glyphLineIndices,
+                glyphProgress,
+                glyphBaselineY
             };
         }
         resetHelpers() {