three-text 0.2.17 → 0.2.19

package/dist/index.umd.js

@@ -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
@@ -83,7 +83,9 @@
             // 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;
@@ -471,7 +473,9 @@
                 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,
@@ -844,7 +848,9 @@
                 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)
@@ -1725,12 +1731,12 @@
             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);
                 }
             }
@@ -2731,7 +2737,9 @@
                 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');
@@ -2753,24 +2761,6 @@
             }
             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
@@ -2782,7 +2772,10 @@
                     ? '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: {
@@ -2952,28 +2945,58 @@
 
     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
@@ -3029,60 +3052,62 @@
             // 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 };
         }
@@ -3407,9 +3432,7 @@
                 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 {
@@ -4171,7 +4194,7 @@
                             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
                             });
                         }
@@ -4181,7 +4204,7 @@
                     // 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;
@@ -4561,7 +4584,8 @@
                         if (LineBreak.isCJOpeningPunctuation(currentChar)) {
                             shouldApply = false;
                         }
-                        if (LineBreak.isCJPunctuation(currentChar) && LineBreak.isCJPunctuation(nextChar)) {
+                        if (LineBreak.isCJPunctuation(currentChar) &&
+                            LineBreak.isCJPunctuation(nextChar)) {
                             shouldApply = false;
                         }
                         if (shouldApply) {
@@ -5365,7 +5389,7 @@
         // 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() {
@@ -5603,7 +5627,9 @@
                 // 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();
@@ -5708,7 +5734,9 @@
             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);
             }
@@ -5880,10 +5908,12 @@
             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;
             }
@@ -5946,13 +5976,11 @@
         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() {