three-text 0.4.2 → 0.4.3

package/dist/index.cjs

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.4.2
+ * three-text v0.4.3
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -2502,6 +2502,12 @@ class Tessellator {
         logger.log(`Tessellator: removeOverlaps=${removeOverlaps}, processing ${valid.length} paths`);
         return this.tessellate(valid, removeOverlaps, isCFF, needsExtrusionContours);
     }
+    processContours(contours, removeOverlaps = true, isCFF = false, needsExtrusionContours = true) {
+        if (contours.length === 0) {
+            return { triangles: { vertices: [], indices: [] }, contours: [] };
+        }
+        return this.tessellateContours(contours, removeOverlaps, isCFF, needsExtrusionContours);
+    }
     tessellate(paths, removeOverlaps, isCFF, needsExtrusionContours) {
         // libtess expects CCW winding; TTF outer contours are CW
         const needsWindingReversal = !isCFF && !removeOverlaps;
@@ -2566,6 +2572,68 @@ class Tessellator {
             contours: extrusionContours
         };
     }
+    tessellateContours(contours, removeOverlaps, isCFF, needsExtrusionContours) {
+        const needsWindingReversal = !isCFF && !removeOverlaps;
+        let originalContours;
+        let tessContours;
+        if (needsWindingReversal) {
+            tessContours = this.reverseContours(contours);
+            if (removeOverlaps || needsExtrusionContours) {
+                originalContours = contours;
+            }
+        }
+        else {
+            originalContours = contours;
+            tessContours = contours;
+        }
+        let extrusionContours = needsExtrusionContours
+            ? needsWindingReversal
+                ? tessContours
+                : (originalContours ?? contours)
+            : [];
+        if (removeOverlaps) {
+            logger.log('Two-pass: boundary extraction then triangulation');
+            perfLogger.start('Tessellator.boundaryPass', {
+                contourCount: tessContours.length
+            });
+            const boundaryResult = this.performTessellation(originalContours, 'boundary');
+            perfLogger.end('Tessellator.boundaryPass');
+            if (!boundaryResult) {
+                logger.warn('libtess returned empty result from boundary pass');
+                return { triangles: { vertices: [], indices: [] }, contours: [] };
+            }
+            tessContours = this.boundaryToContours(boundaryResult);
+            if (needsExtrusionContours) {
+                extrusionContours = tessContours;
+            }
+            logger.log(`Boundary pass created ${tessContours.length} contours. Starting triangulation pass.`);
+        }
+        else {
+            logger.log(`Single-pass triangulation for ${isCFF ? 'CFF' : 'TTF'}`);
+        }
+        perfLogger.start('Tessellator.triangulationPass', {
+            contourCount: tessContours.length
+        });
+        const triangleResult = this.performTessellation(tessContours, 'triangles');
+        perfLogger.end('Tessellator.triangulationPass');
+        if (!triangleResult) {
+            const warning = removeOverlaps
+                ? '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: triangleResult.vertices,
+                indices: triangleResult.indices || []
+            },
+            contours: extrusionContours
+        };
+    }
     pathsToContours(paths, reversePoints = false) {
         const contours = new Array(paths.length);
         for (let p = 0; p < paths.length; p++) {
@@ -2603,6 +2671,35 @@ class Tessellator {
         }
         return contours;
     }
+    reverseContours(contours) {
+        const reversed = new Array(contours.length);
+        for (let i = 0; i < contours.length; i++) {
+            reversed[i] = this.reverseContour(contours[i]);
+        }
+        return reversed;
+    }
+    reverseContour(contour) {
+        const len = contour.length;
+        if (len === 0)
+            return [];
+        const isClosed = len >= 4 &&
+            contour[0] === contour[len - 2] &&
+            contour[1] === contour[len - 1];
+        const end = isClosed ? len - 2 : len;
+        if (end === 0)
+            return [];
+        const reversed = new Array(end + 2);
+        let out = 0;
+        for (let i = end - 2; i >= 0; i -= 2) {
+            reversed[out++] = contour[i];
+            reversed[out++] = contour[i + 1];
+        }
+        if (out >= 2) {
+            reversed[out++] = reversed[0];
+            reversed[out++] = reversed[1];
+        }
+        return reversed;
+    }
     performTessellation(contours, mode) {
         const tess = new libtess_minExports.GluTesselator();
         tess.gluTessProperty(libtess_minExports.gluEnum.GLU_TESS_WINDING_RULE, libtess_minExports.windingRule.GLU_TESS_WINDING_NONZERO);
@@ -2729,80 +2826,86 @@ class Extruder {
     extrude(geometry, depth = 0, unitsPerEm) {
         const points = geometry.triangles.vertices;
         const triangleIndices = geometry.triangles.indices;
-        const numPoints = points.length / 2;
-        // Boundary edges are those that appear in exactly one triangle
+        const contours = geometry.contours;
+        const pointLen = points.length;
+        const numPoints = pointLen / 2;
+        // Prefer contours for side walls; fall back to triangle edges
         let boundaryEdges = [];
+        let sideEdgeCount = 0;
+        let useContours = false;
         if (depth !== 0) {
-            // 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];
-                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]);
+            if (contours.length > 0) {
+                useContours = true;
+                for (const contour of contours) {
+                    const contourPointCount = contour.length >> 1;
+                    if (contourPointCount >= 2) {
+                        sideEdgeCount += contourPointCount - 1;
+                    }
                 }
             }
-            boundaryEdges = [];
-            for (const [v0, v1, count] of edgeMap.values()) {
-                if (count === 1) {
-                    boundaryEdges.push([v0, v1]);
+            else {
+                // Use a directionless key (min/max) to detect shared edges
+                // Store the directed edge (a->b) and mark as null when seen twice
+                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];
+                    let key, packed;
+                    if (a < b) {
+                        key = (a << 16) | b;
+                    }
+                    else {
+                        key = (b << 16) | a;
+                    }
+                    packed = (a << 16) | b;
+                    let data = edgeMap.get(key);
+                    if (data === undefined) {
+                        edgeMap.set(key, packed);
+                    }
+                    else if (data !== null) {
+                        edgeMap.set(key, null);
+                    }
+                    if (b < c) {
+                        key = (b << 16) | c;
+                    }
+                    else {
+                        key = (c << 16) | b;
+                    }
+                    packed = (b << 16) | c;
+                    data = edgeMap.get(key);
+                    if (data === undefined) {
+                        edgeMap.set(key, packed);
+                    }
+                    else if (data !== null) {
+                        edgeMap.set(key, null);
+                    }
+                    if (c < a) {
+                        key = (c << 16) | a;
+                    }
+                    else {
+                        key = (a << 16) | c;
+                    }
+                    packed = (c << 16) | a;
+                    data = edgeMap.get(key);
+                    if (data === undefined) {
+                        edgeMap.set(key, packed);
+                    }
+                    else if (data !== null) {
+                        edgeMap.set(key, null);
+                    }
                 }
+                boundaryEdges = [];
+                for (const packedEdge of edgeMap.values()) {
+                    if (packedEdge === null)
+                        continue;
+                    boundaryEdges.push(packedEdge >>> 16, packedEdge & 0xffff);
+                }
+                sideEdgeCount = boundaryEdges.length >> 1;
             }
         }
-        const sideEdgeCount = depth === 0 ? 0 : boundaryEdges.length;
-        const sideVertexCount = depth === 0 ? 0 : sideEdgeCount * 4;
+        const sideVertexCount = sideEdgeCount * 4;
         const baseVertexCount = depth === 0 ? numPoints : numPoints * 2;
         const vertexCount = baseVertexCount + sideVertexCount;
         const vertices = new Float32Array(vertexCount * 3);
@@ -2812,26 +2915,24 @@ class Extruder {
             : triangleIndices.length * 2 + sideEdgeCount * 6;
         const indices = new Uint32Array(indexCount);
         if (depth === 0) {
-            let vPos = 0;
-            for (let i = 0; i < points.length; i += 2) {
-                vertices[vPos] = points[i];
-                vertices[vPos + 1] = points[i + 1];
+            for (let p = 0, vPos = 0; p < pointLen; p += 2, vPos += 3) {
+                vertices[vPos] = points[p];
+                vertices[vPos + 1] = points[p + 1];
                 vertices[vPos + 2] = 0;
                 normals[vPos] = 0;
                 normals[vPos + 1] = 0;
                 normals[vPos + 2] = 1;
-                vPos += 3;
             }
             indices.set(triangleIndices);
             return { vertices, normals, indices };
         }
         const minBackOffset = unitsPerEm * 0.000025;
         const backZ = depth <= minBackOffset ? minBackOffset : depth;
-        for (let p = 0, vi = 0; p < points.length; p += 2, vi++) {
+        const backOffset = numPoints * 3;
+        for (let p = 0, vi = 0, base0 = 0; p < pointLen; p += 2, vi++, base0 += 3) {
             const x = points[p];
             const y = points[p + 1];
             // Cap at z=0
-            const base0 = vi * 3;
             vertices[base0] = x;
             vertices[base0 + 1] = y;
             vertices[base0 + 2] = 0;
@@ -2839,7 +2940,7 @@ class Extruder {
             normals[base0 + 1] = 0;
             normals[base0 + 2] = -1;
             // Cap at z=depth
-            const baseD = (numPoints + vi) * 3;
+            const baseD = base0 + backOffset;
             vertices[baseD] = x;
             vertices[baseD + 1] = y;
             vertices[baseD + 2] = backZ;
@@ -2858,61 +2959,119 @@ class Extruder {
         }
         let nextVertex = numPoints * 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];
-            const ex = p1x - p0x;
-            const ey = p1y - p0y;
-            const lenSq = ex * ex + ey * ey;
-            let nx = 0;
-            let ny = 0;
-            if (lenSq > 1e-10) {
-                const invLen = 1 / Math.sqrt(lenSq);
-                nx = ey * invLen;
-                ny = -ex * invLen;
-            }
-            const base = nextVertex * 3;
-            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;
-            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;
-            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;
+        if (useContours) {
+            for (const contour of contours) {
+                const contourLen = contour.length;
+                if (contourLen < 4)
+                    continue;
+                for (let i = 0; i < contourLen - 2; i += 2) {
+                    const p0x = contour[i];
+                    const p0y = contour[i + 1];
+                    const p1x = contour[i + 2];
+                    const p1y = contour[i + 3];
+                    const ex = p1x - p0x;
+                    const ey = p1y - p0y;
+                    const lenSq = ex * ex + ey * ey;
+                    let nx = 0;
+                    let ny = 0;
+                    if (lenSq > 1e-10) {
+                        const invLen = 1 / Math.sqrt(lenSq);
+                        nx = ey * invLen;
+                        ny = -ex * invLen;
+                    }
+                    const base = nextVertex * 3;
+                    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;
+                    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;
+                    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;
+                }
+            }
+        }
+        else {
+            for (let e = 0; e < sideEdgeCount; e++) {
+                const edgeIndex = e << 1;
+                const u = boundaryEdges[edgeIndex];
+                const v = boundaryEdges[edgeIndex + 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];
+                const ex = p1x - p0x;
+                const ey = p1y - p0y;
+                const lenSq = ex * ex + ey * ey;
+                let nx = 0;
+                let ny = 0;
+                if (lenSq > 1e-10) {
+                    const invLen = 1 / Math.sqrt(lenSq);
+                    nx = ey * invLen;
+                    ny = -ex * invLen;
+                }
+                const base = nextVertex * 3;
+                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;
+                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;
+                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 };
     }
@@ -3899,6 +4058,9 @@ class GlyphGeometryBuilder {
         this.fontId = 'default';
         this.cacheKeyPrefix = 'default';
         this.emptyGlyphs = new Set();
+        this.clusterPositions = [];
+        this.clusterContoursScratch = [];
+        this.taskScratch = [];
         this.cache = cache;
         this.loadedFont = loadedFont;
         this.tessellator = new Tessellator();
@@ -3984,14 +4146,28 @@ class GlyphGeometryBuilder {
         else {
             perfLogger.start('GlyphGeometryBuilder.buildInstancedGeometry');
         }
-        const tasks = [];
+        const tasks = this.taskScratch;
+        tasks.length = 0;
+        let taskCount = 0;
         let totalVertexFloats = 0;
         let totalNormalFloats = 0;
         let totalIndexCount = 0;
         let vertexCursor = 0; // vertex offset (not float offset)
         const pushTask = (data, px, py, pz) => {
             const vertexStart = vertexCursor;
-            tasks.push({ data, px, py, pz, vertexStart });
+            let task = tasks[taskCount];
+            if (task) {
+                task.data = data;
+                task.px = px;
+                task.py = py;
+                task.pz = pz;
+                task.vertexStart = vertexStart;
+            }
+            else {
+                task = { data, px, py, pz, vertexStart };
+                tasks[taskCount] = task;
+            }
+            taskCount++;
             totalVertexFloats += data.vertices.length;
             totalNormalFloats += data.normals.length;
             totalIndexCount += data.indices.length;
@@ -4041,8 +4217,21 @@ class GlyphGeometryBuilder {
                         boundaryGroups = cached.groups;
                     }
                     else {
-                        const relativePositions = cluster.glyphs.map((g) => new Vec3(g.x ?? 0, g.y ?? 0, 0));
-                        boundaryGroups = this.clusterer.cluster(clusterGlyphContours, relativePositions);
+                        const glyphCount = cluster.glyphs.length;
+                        if (this.clusterPositions.length < glyphCount) {
+                            for (let i = this.clusterPositions.length; i < glyphCount; i++) {
+                                this.clusterPositions.push(new Vec3(0, 0, 0));
+                            }
+                        }
+                        this.clusterPositions.length = glyphCount;
+                        for (let i = 0; i < glyphCount; i++) {
+                            const glyph = cluster.glyphs[i];
+                            const pos = this.clusterPositions[i];
+                            pos.x = glyph.x ?? 0;
+                            pos.y = glyph.y ?? 0;
+                            pos.z = 0;
+                        }
+                        boundaryGroups = this.clusterer.cluster(clusterGlyphContours, this.clusterPositions);
                         this.clusteringCache.set(cacheKey, {
                             glyphIds: cluster.glyphs.map((g) => g.g),
                             positions: cluster.glyphs.map((g) => ({
@@ -4099,7 +4288,8 @@ class GlyphGeometryBuilder {
                         const clusterKey = this.getClusterKey(subClusterGlyphs, depth, removeOverlaps);
                         let cachedCluster = this.wordCache.get(clusterKey);
                         if (!cachedCluster) {
-                            const clusterPaths = [];
+                            const clusterContours = this.clusterContoursScratch;
+                            let contourIndex = 0;
                             const refX = subClusterGlyphs[0].x ?? 0;
                             const refY = subClusterGlyphs[0].y ?? 0;
                             for (let i = 0; i < groupIndices.length; i++) {
@@ -4109,13 +4299,38 @@ class GlyphGeometryBuilder {
                                 const relX = (glyph.x ?? 0) - refX;
                                 const relY = (glyph.y ?? 0) - refY;
                                 for (const path of glyphContours.paths) {
-                                    clusterPaths.push({
-                                        ...path,
-                                        points: path.points.map((p) => new Vec2(p.x + relX, p.y + relY))
-                                    });
+                                    const points = path.points;
+                                    const pointCount = points.length;
+                                    if (pointCount < 3)
+                                        continue;
+                                    const isClosed = pointCount > 1 &&
+                                        points[0].x === points[pointCount - 1].x &&
+                                        points[0].y === points[pointCount - 1].y;
+                                    const end = isClosed ? pointCount - 1 : pointCount;
+                                    const needed = (end + 1) * 2;
+                                    let contour = clusterContours[contourIndex];
+                                    if (!contour || contour.length < needed) {
+                                        contour = new Array(needed);
+                                        clusterContours[contourIndex] = contour;
+                                    }
+                                    else {
+                                        contour.length = needed;
+                                    }
+                                    let out = 0;
+                                    for (let k = 0; k < end; k++) {
+                                        const pt = points[k];
+                                        contour[out++] = pt.x + relX;
+                                        contour[out++] = pt.y + relY;
+                                    }
+                                    if (out >= 2) {
+                                        contour[out++] = contour[0];
+                                        contour[out++] = contour[1];
+                                    }
+                                    contourIndex++;
                                 }
                             }
-                            cachedCluster = this.tessellateGlyphCluster(clusterPaths, depth, isCFF);
+                            clusterContours.length = contourIndex;
+                            cachedCluster = this.tessellateGlyphCluster(clusterContours, depth, isCFF);
                             this.wordCache.set(clusterKey, cachedCluster);
                         }
                         // Calculate the absolute position of this sub-cluster based on its first glyph
@@ -4170,6 +4385,7 @@ class GlyphGeometryBuilder {
                 }
             }
         }
+        tasks.length = taskCount;
         // Allocate exact-sized buffers and fill once
         const vertexArray = new Float32Array(totalVertexFloats);
         const normalArray = new Float32Array(totalNormalFloats);
@@ -4185,17 +4401,27 @@ class GlyphGeometryBuilder {
             const px = task.px;
             const py = task.py;
             const pz = task.pz;
-            for (let j = 0; j < v.length; j += 3) {
-                vertexArray[vertexPos++] = (v[j] + px) * scale;
-                vertexArray[vertexPos++] = (v[j + 1] + py) * scale;
-                vertexArray[vertexPos++] = (v[j + 2] + pz) * scale;
-            }
+            const offsetX = px * scale;
+            const offsetY = py * scale;
+            const offsetZ = pz * scale;
+            const vLen = v.length;
+            let outPos = vertexPos;
+            for (let j = 0; j < vLen; j += 3) {
+                vertexArray[outPos] = v[j] * scale + offsetX;
+                vertexArray[outPos + 1] = v[j + 1] * scale + offsetY;
+                vertexArray[outPos + 2] = v[j + 2] * scale + offsetZ;
+                outPos += 3;
+            }
+            vertexPos = outPos;
             normalArray.set(n, normalPos);
             normalPos += n.length;
             const vertexStart = task.vertexStart;
-            for (let j = 0; j < idx.length; j++) {
-                indexArray[indexPos++] = idx[j] + vertexStart;
+            const idxLen = idx.length;
+            let outIndexPos = indexPos;
+            for (let j = 0; j < idxLen; j++) {
+                indexArray[outIndexPos++] = idx[j] + vertexStart;
             }
+            indexPos = outIndexPos;
         }
         perfLogger.end('GlyphGeometryBuilder.buildInstancedGeometry');
         planeBounds.min.x *= scale;
@@ -4293,8 +4519,8 @@ class GlyphGeometryBuilder {
         this.contourCache.set(key, contours);
         return contours;
     }
-    tessellateGlyphCluster(paths, depth, isCFF) {
-        const processedGeometry = this.tessellator.process(paths, true, isCFF, depth !== 0);
+    tessellateGlyphCluster(contours, depth, isCFF) {
+        const processedGeometry = this.tessellator.processContours(contours, true, isCFF, depth !== 0);
         return this.extrudeAndPackage(processedGeometry, depth);
     }
     extrudeAndPackage(processedGeometry, depth) {