three-text 0.3.1 → 0.3.3

package/dist/index.cjs

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.3.1
+ * three-text v0.3.3
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -1634,9 +1634,7 @@ const TABLE_TAG_CFF2 = 0x43464632; // 'CFF2'
 const TABLE_TAG_GSUB = 0x47535542; // 'GSUB'
 const TABLE_TAG_GPOS = 0x47504f53; // 'GPOS'
 
-// Parses the SFNT table directory for TTF/OTF fonts
-// Assumes the DataView is positioned at the start of an sfnt font (offset 0)
-// Table records are 16 bytes each starting at byte offset 12
+// SFNT table directory
 function parseTableDirectory(view) {
     const numTables = view.getUint16(4);
     const tableRecordsStart = 12;
@@ -1656,6 +1654,10 @@ function parseTableDirectory(view) {
     return tables;
 }
 
+// OpenType tag prefixes as uint16 for bitwise comparison
+const TAG_SS_PREFIX = 0x7373; // 'ss'
+const TAG_CV_PREFIX = 0x6376; // 'cv'
+const utf16beDecoder = new TextDecoder('utf-16be');
 class FontMetadataExtractor {
     static extractMetadata(fontBuffer) {
         if (!fontBuffer || fontBuffer.byteLength < 12) {
@@ -1757,7 +1759,6 @@ class FontMetadataExtractor {
         const names = {};
         for (let i = 0; i < featureCount; i++) {
             const recordOffset = featureListStart + 2 + i * 6;
-            // Decode feature tag
             const tag = String.fromCharCode(view.getUint8(recordOffset), view.getUint8(recordOffset + 1), view.getUint8(recordOffset + 2), view.getUint8(recordOffset + 3));
             features.push(tag);
             // Extract feature name for stylistic sets and character variants
@@ -1789,9 +1790,7 @@ class FontMetadataExtractor {
     }
     static extractAxisNames(view, statOffset, nameOffset) {
         try {
-            // STAT table structure
             const majorVersion = view.getUint16(statOffset);
-            // We need at least version 1.0
             if (majorVersion < 1)
                 return null;
             const designAxisSize = view.getUint16(statOffset + 4);
@@ -1816,10 +1815,8 @@ class FontMetadataExtractor {
     }
     static getNameFromNameTable(view, nameOffset, nameID) {
         try {
-            // const format = view.getUint16(nameOffset);
             const count = view.getUint16(nameOffset + 2);
             const stringOffset = view.getUint16(nameOffset + 4);
-            // Look for the name record with our nameID (preferring English)
             for (let i = 0; i < count; i++) {
                 const recordOffset = nameOffset + 6 + i * 12;
                 const platformID = view.getUint16(recordOffset);
@@ -1828,26 +1825,22 @@ class FontMetadataExtractor {
                 const recordNameID = view.getUint16(recordOffset + 6);
                 const length = view.getUint16(recordOffset + 8);
                 const offset = view.getUint16(recordOffset + 10);
-                if (recordNameID === nameID) {
-                    // Prefer Unicode or Windows platform English names
-                    if (platformID === 0 || (platformID === 3 && languageID === 0x0409)) {
-                        const stringStart = nameOffset + stringOffset + offset;
-                        const bytes = new Uint8Array(view.buffer, stringStart, length);
-                        // Decode based on platform
-                        if (platformID === 0 || (platformID === 3 && encodingID === 1)) {
-                            // UTF-16BE
-                            let str = '';
-                            for (let j = 0; j < bytes.length; j += 2) {
-                                str += String.fromCharCode((bytes[j] << 8) | bytes[j + 1]);
-                            }
-                            return str;
-                        }
-                        else {
-                            // ASCII
-                            return new TextDecoder('ascii').decode(bytes);
-                        }
+                if (recordNameID !== nameID)
+                    continue;
+                // Accept Unicode platform or Windows US English
+                if (platformID !== 0 && !(platformID === 3 && languageID === 0x0409)) {
+                    continue;
+                }
+                const stringStart = nameOffset + stringOffset + offset;
+                const bytes = new Uint8Array(view.buffer, stringStart, length);
+                if (platformID === 0 || (platformID === 3 && encodingID === 1)) {
+                    let str = '';
+                    for (let j = 0; j < bytes.length; j += 2) {
+                        str += String.fromCharCode((bytes[j] << 8) | bytes[j + 1]);
                     }
+                    return str;
                 }
+                return new TextDecoder('ascii').decode(bytes);
             }
             return null;
         }
@@ -1855,7 +1848,210 @@ class FontMetadataExtractor {
             return null;
         }
     }
-    // Priority: typo metrics > hhea metrics > win metrics > fallback, ignore line gap (Google strategy)
+    static extractAll(fontBuffer) {
+        if (!fontBuffer || fontBuffer.byteLength < 12) {
+            throw new Error('Invalid font buffer: too small to be a valid font file');
+        }
+        const view = new DataView(fontBuffer);
+        const sfntVersion = view.getUint32(0);
+        const validSignatures = [
+            FONT_SIGNATURE_TRUE_TYPE,
+            FONT_SIGNATURE_OPEN_TYPE_CFF
+        ];
+        if (!validSignatures.includes(sfntVersion)) {
+            throw new Error(`Invalid font format. Expected TTF/OTF (or WOFF), got signature: 0x${sfntVersion.toString(16)}`);
+        }
+        const tableDirectory = parseTableDirectory(view);
+        const nameTableOffset = tableDirectory.get(TABLE_TAG_NAME)?.offset ?? 0;
+        const nameIndex = nameTableOffset
+            ? this.buildNameIndex(view, nameTableOffset)
+            : null;
+        const metrics = this.extractMetricsWithIndex(view, tableDirectory, nameIndex);
+        const features = this.extractFeaturesWithIndex(view, tableDirectory, nameIndex);
+        return { metrics, features };
+    }
+    // Index name records by nameID; prefers Unicode (platform 0) or Windows US English
+    static buildNameIndex(view, nameOffset) {
+        const index = new Map();
+        const count = view.getUint16(nameOffset + 2);
+        const stringOffset = view.getUint16(nameOffset + 4);
+        for (let i = 0; i < count; i++) {
+            const recordOffset = nameOffset + 6 + i * 12;
+            const platformID = view.getUint16(recordOffset);
+            const encodingID = view.getUint16(recordOffset + 2);
+            const languageID = view.getUint16(recordOffset + 4);
+            const nameID = view.getUint16(recordOffset + 6);
+            const length = view.getUint16(recordOffset + 8);
+            const offset = view.getUint16(recordOffset + 10);
+            if (platformID === 0 || (platformID === 3 && languageID === 0x0409)) {
+                if (!index.has(nameID)) {
+                    index.set(nameID, {
+                        offset: nameOffset + stringOffset + offset,
+                        length,
+                        platformID,
+                        encodingID
+                    });
+                }
+            }
+        }
+        return index;
+    }
+    static getNameFromIndex(view, nameIndex, nameID) {
+        if (!nameIndex)
+            return null;
+        const record = nameIndex.get(nameID);
+        if (!record)
+            return null;
+        try {
+            const bytes = new Uint8Array(view.buffer, record.offset, record.length);
+            // UTF-16BE for Unicode/Windows platform with encoding 1
+            if (record.platformID === 0 ||
+                (record.platformID === 3 && record.encodingID === 1)) {
+                return utf16beDecoder.decode(bytes);
+            }
+            // ASCII fallback
+            return new TextDecoder('ascii').decode(bytes);
+        }
+        catch {
+            return null;
+        }
+    }
+    static extractMetricsWithIndex(view, tableDirectory, nameIndex) {
+        const isCFF = tableDirectory.has(TABLE_TAG_CFF) || tableDirectory.has(TABLE_TAG_CFF2);
+        const headTableOffset = tableDirectory.get(TABLE_TAG_HEAD)?.offset ?? 0;
+        const hheaTableOffset = tableDirectory.get(TABLE_TAG_HHEA)?.offset ?? 0;
+        const os2TableOffset = tableDirectory.get(TABLE_TAG_OS2)?.offset ?? 0;
+        const fvarTableOffset = tableDirectory.get(TABLE_TAG_FVAR)?.offset ?? 0;
+        const statTableOffset = tableDirectory.get(TABLE_TAG_STAT)?.offset ?? 0;
+        const unitsPerEm = headTableOffset
+            ? view.getUint16(headTableOffset + 18)
+            : 1000;
+        let hheaMetrics = null;
+        if (hheaTableOffset) {
+            hheaMetrics = {
+                ascender: view.getInt16(hheaTableOffset + 4),
+                descender: view.getInt16(hheaTableOffset + 6),
+                lineGap: view.getInt16(hheaTableOffset + 8)
+            };
+        }
+        let os2Metrics = null;
+        if (os2TableOffset) {
+            os2Metrics = {
+                typoAscender: view.getInt16(os2TableOffset + 68),
+                typoDescender: view.getInt16(os2TableOffset + 70),
+                typoLineGap: view.getInt16(os2TableOffset + 72),
+                winAscent: view.getUint16(os2TableOffset + 74),
+                winDescent: view.getUint16(os2TableOffset + 76)
+            };
+        }
+        let axisNames = null;
+        if (fvarTableOffset && statTableOffset && nameIndex) {
+            axisNames = this.extractAxisNamesWithIndex(view, statTableOffset, nameIndex);
+        }
+        return {
+            isCFF,
+            unitsPerEm,
+            hheaAscender: hheaMetrics?.ascender || null,
+            hheaDescender: hheaMetrics?.descender || null,
+            hheaLineGap: hheaMetrics?.lineGap || null,
+            typoAscender: os2Metrics?.typoAscender || null,
+            typoDescender: os2Metrics?.typoDescender || null,
+            typoLineGap: os2Metrics?.typoLineGap || null,
+            winAscent: os2Metrics?.winAscent || null,
+            winDescent: os2Metrics?.winDescent || null,
+            axisNames
+        };
+    }
+    static extractAxisNamesWithIndex(view, statOffset, nameIndex) {
+        try {
+            const majorVersion = view.getUint16(statOffset);
+            if (majorVersion < 1)
+                return null;
+            const designAxisSize = view.getUint16(statOffset + 4);
+            const designAxisCount = view.getUint16(statOffset + 6);
+            const designAxisOffset = view.getUint32(statOffset + 8);
+            const axisNames = {};
+            for (let i = 0; i < designAxisCount; i++) {
+                const axisRecordOffset = statOffset + designAxisOffset + i * designAxisSize;
+                const axisTag = String.fromCharCode(view.getUint8(axisRecordOffset), view.getUint8(axisRecordOffset + 1), view.getUint8(axisRecordOffset + 2), view.getUint8(axisRecordOffset + 3));
+                const axisNameID = view.getUint16(axisRecordOffset + 4);
+                const name = this.getNameFromIndex(view, nameIndex, axisNameID);
+                if (name) {
+                    axisNames[axisTag] = name;
+                }
+            }
+            return Object.keys(axisNames).length > 0 ? axisNames : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    static extractFeaturesWithIndex(view, tableDirectory, nameIndex) {
+        const gsubTableOffset = tableDirectory.get(TABLE_TAG_GSUB)?.offset ?? 0;
+        const gposTableOffset = tableDirectory.get(TABLE_TAG_GPOS)?.offset ?? 0;
+        // Tags stored as uint32 during iteration, converted to strings at end
+        const featureTags = new Set();
+        const featureNames = {};
+        try {
+            if (gsubTableOffset) {
+                this.extractFeatureData(view, gsubTableOffset, nameIndex, featureTags, featureNames);
+            }
+            if (gposTableOffset) {
+                this.extractFeatureData(view, gposTableOffset, nameIndex, featureTags, featureNames);
+            }
+        }
+        catch {
+            return undefined;
+        }
+        if (featureTags.size === 0)
+            return undefined;
+        // Numeric sort preserves alphabetical order for big-endian tags
+        const sortedTags = Array.from(featureTags).sort((a, b) => a - b);
+        const featureArray = sortedTags.map(this.tagToString);
+        return {
+            tags: featureArray,
+            names: Object.keys(featureNames).length > 0 ? featureNames : {}
+        };
+    }
+    static extractFeatureData(view, tableOffset, nameIndex, featureTags, featureNames) {
+        const featureListOffset = view.getUint16(tableOffset + 6);
+        const featureListStart = tableOffset + featureListOffset;
+        const featureCount = view.getUint16(featureListStart);
+        for (let i = 0; i < featureCount; i++) {
+            const recordOffset = featureListStart + 2 + i * 6;
+            const tagBytes = view.getUint32(recordOffset);
+            featureTags.add(tagBytes);
+            // Stylistic sets (ss01-ss20) and character variants (cv01-cv99) may have UI names
+            const prefix = (tagBytes >> 16) & 0xffff;
+            if (!nameIndex)
+                continue;
+            if (prefix !== TAG_SS_PREFIX && prefix !== TAG_CV_PREFIX)
+                continue;
+            const d1 = (tagBytes >> 8) & 0xff;
+            const d2 = tagBytes & 0xff;
+            if (d1 < 0x30 || d1 > 0x39 || d2 < 0x30 || d2 > 0x39)
+                continue;
+            const featureOffset = view.getUint16(recordOffset + 4);
+            const featureTableStart = featureListStart + featureOffset;
+            const featureParamsOffset = view.getUint16(featureTableStart);
+            if (featureParamsOffset === 0)
+                continue;
+            const paramsStart = featureTableStart + featureParamsOffset;
+            const version = view.getUint16(paramsStart);
+            if (version !== 0)
+                continue;
+            const nameID = view.getUint16(paramsStart + 2);
+            const name = this.getNameFromIndex(view, nameIndex, nameID);
+            if (name) {
+                const tag = String.fromCharCode((tagBytes >> 24) & 0xff, (tagBytes >> 16) & 0xff, (tagBytes >> 8) & 0xff, tagBytes & 0xff);
+                featureNames[tag] = name;
+            }
+        }
+    }
+    static tagToString(tag) {
+        return String.fromCharCode((tag >> 24) & 0xff, (tag >> 16) & 0xff, (tag >> 8) & 0xff, tag & 0xff);
+    }
+    // Metric priority: typo > hhea > win > fallback (ignoring line gap per Google's approach)
     static getVerticalMetrics(metrics) {
         if (metrics.typoAscender !== null && metrics.typoDescender !== null) {
             return {
@@ -1954,7 +2150,6 @@ class WoffConverter {
         sfntView.setUint16(6, searchRange);
         sfntView.setUint16(8, Math.floor(Math.log2(numTables)));
         sfntView.setUint16(10, numTables * 16 - searchRange);
-        // Read and decompress table directory
         let sfntOffset = 12 + numTables * 16; // Start of table data
         const tableDirectory = [];
         // Read WOFF table directory
@@ -1970,29 +2165,27 @@ class WoffConverter {
         }
         // Sort tables by tag (required for SFNT)
         tableDirectory.sort((a, b) => a.tag - b.tag);
-        // Write SFNT table directory and decompress tables
+        // Tables are independent, decompress in parallel
+        const decompressedTables = await Promise.all(tableDirectory.map(async (table) => {
+            if (table.length === table.origLength) {
+                return data.subarray(table.offset, table.offset + table.length);
+            }
+            const compressedData = data.subarray(table.offset, table.offset + table.length);
+            const decompressed = await WoffConverter.decompressZlib(compressedData);
+            if (decompressed.byteLength !== table.origLength) {
+                throw new Error(`Decompression failed: expected ${table.origLength} bytes, got ${decompressed.byteLength}`);
+            }
+            return new Uint8Array(decompressed);
+        }));
+        // Write SFNT table directory and table data
         for (let i = 0; i < numTables; i++) {
             const table = tableDirectory[i];
             const dirOffset = 12 + i * 16;
-            // Write SFNT table directory entry
             sfntView.setUint32(dirOffset, table.tag);
             sfntView.setUint32(dirOffset + 4, table.checksum);
             sfntView.setUint32(dirOffset + 8, sfntOffset);
             sfntView.setUint32(dirOffset + 12, table.origLength);
-            // Decompress or copy table data
-            if (table.length === table.origLength) {
-                // Uncompressed table - just copy
-                sfntData.set(data.subarray(table.offset, table.offset + table.length), sfntOffset);
-            }
-            else {
-                // Compressed table - decompress using DecompressionStream
-                const compressedData = data.subarray(table.offset, table.offset + table.length);
-                const decompressed = await WoffConverter.decompressZlib(compressedData);
-                if (decompressed.byteLength !== table.origLength) {
-                    throw new Error(`Decompression failed: expected ${table.origLength} bytes, got ${decompressed.byteLength}`);
-                }
-                sfntData.set(new Uint8Array(decompressed), sfntOffset);
-            }
+            sfntData.set(decompressedTables[i], sfntOffset);
             // Add padding to 4-byte boundary
             sfntOffset += table.origLength;
             const padding = (4 - (table.origLength % 4)) % 4;
@@ -2052,7 +2245,7 @@ class FontLoader {
             }
             const axisInfos = face.getAxisInfos();
             const isVariable = Object.keys(axisInfos).length > 0;
-            const metrics = FontMetadataExtractor.extractMetadata(fontBuffer);
+            const { metrics, features: featureData } = FontMetadataExtractor.extractAll(fontBuffer);
             // Merge axis names from STAT table with HarfBuzz axis info
             let variationAxes = undefined;
             if (isVariable && axisInfos) {
@@ -2064,7 +2257,6 @@ class FontLoader {
                     };
                 }
             }
-            const featureData = FontMetadataExtractor.extractFeatureTags(fontBuffer);
             return {
                 hb,
                 fontBlob,
@@ -4365,7 +4557,7 @@ class TextShaper {
         buffer.destroy();
         const clusters = [];
         let currentClusterGlyphs = [];
-        let currentClusterText = '';
+        let clusterTextChars = [];
         let clusterStartX = 0;
         let clusterStartY = 0;
         let cursorX = lineInfo.xOffset;
@@ -4375,17 +4567,24 @@ class TextShaper {
         const letterSpacingFU = letterSpacing * this.loadedFont.upem;
         const spaceAdjustment = this.calculateSpaceAdjustment(lineInfo, align, letterSpacing);
         const cjkAdjustment = this.calculateCJKAdjustment(lineInfo, align);
-        for (let i = 0; i < glyphInfos.length; i++) {
+        const lineText = lineInfo.text;
+        const lineTextLength = lineText.length;
+        const glyphCount = glyphInfos.length;
+        let nextCharIsCJK;
+        for (let i = 0; i < glyphCount; i++) {
             const glyph = glyphInfos[i];
-            const isWhitespace = /\s/.test(lineInfo.text[glyph.cl]);
+            const charIndex = glyph.cl;
+            const char = lineText[charIndex];
+            const charCode = char.charCodeAt(0);
+            const isWhitespace = charCode === 32 || charCode === 9 || charCode === 10 || charCode === 13;
             // Inserted hyphens inherit the color of the last character in the word
             if (lineInfo.endedWithHyphen &&
-                glyph.cl === lineInfo.text.length - 1 &&
-                lineInfo.text[glyph.cl] === '-') {
+                charIndex === lineTextLength - 1 &&
+                char === '-') {
                 glyph.absoluteTextIndex = lineInfo.originalEnd;
             }
             else {
-                glyph.absoluteTextIndex = lineInfo.originalStart + glyph.cl;
+                glyph.absoluteTextIndex = lineInfo.originalStart + charIndex;
             }
             glyph.lineIndex = lineIndex;
             // Cluster boundaries are based on whitespace only.
@@ -4393,12 +4592,12 @@ class TextShaper {
             if (isWhitespace) {
                 if (currentClusterGlyphs.length > 0) {
                     clusters.push({
-                        text: currentClusterText,
+                        text: clusterTextChars.join(''),
                         glyphs: currentClusterGlyphs,
                         position: new Vec3(clusterStartX, clusterStartY, cursorZ)
                     });
                     currentClusterGlyphs = [];
-                    currentClusterText = '';
+                    clusterTextChars = [];
                 }
             }
             const absoluteGlyphX = cursorX + glyph.dx;
@@ -4411,32 +4610,31 @@ class TextShaper {
                 glyph.x = absoluteGlyphX - clusterStartX;
                 glyph.y = absoluteGlyphY - clusterStartY;
                 currentClusterGlyphs.push(glyph);
-                currentClusterText += lineInfo.text[glyph.cl];
+                clusterTextChars.push(char);
             }
             cursorX += glyph.ax;
             cursorY += glyph.ay;
-            if (letterSpacingFU !== 0 && i < glyphInfos.length - 1) {
+            if (letterSpacingFU !== 0 && i < glyphCount - 1) {
                 cursorX += letterSpacingFU;
             }
             if (isWhitespace) {
                 cursorX += spaceAdjustment;
             }
             // CJK glue adjustment (must match exactly where LineBreak adds glue)
-            if (cjkAdjustment !== 0 && i < glyphInfos.length - 1 && !isWhitespace) {
-                const currentChar = lineInfo.text[glyph.cl];
+            if (cjkAdjustment !== 0 && i < glyphCount - 1 && !isWhitespace) {
                 const nextGlyph = glyphInfos[i + 1];
-                const nextChar = lineInfo.text[nextGlyph.cl];
-                const isCJKChar = LineBreak.isCJK(currentChar);
-                const nextIsCJKChar = nextChar && LineBreak.isCJK(nextChar);
-                if (isCJKChar && nextIsCJKChar) {
+                const nextChar = lineText[nextGlyph.cl];
+                const isCJK = nextCharIsCJK !== undefined ? nextCharIsCJK : LineBreak.isCJK(char);
+                nextCharIsCJK = nextChar ? LineBreak.isCJK(nextChar) : false;
+                if (isCJK && nextCharIsCJK) {
                     let shouldApply = true;
                     if (LineBreak.isCJClosingPunctuation(nextChar)) {
                         shouldApply = false;
                     }
-                    if (LineBreak.isCJOpeningPunctuation(currentChar)) {
+                    if (LineBreak.isCJOpeningPunctuation(char)) {
                         shouldApply = false;
                     }
-                    if (LineBreak.isCJPunctuation(currentChar) &&
+                    if (LineBreak.isCJPunctuation(char) &&
                         LineBreak.isCJPunctuation(nextChar)) {
                         shouldApply = false;
                     }
@@ -4445,10 +4643,13 @@ class TextShaper {
                     }
                 }
             }
+            else {
+                nextCharIsCJK = undefined;
+            }
         }
         if (currentClusterGlyphs.length > 0) {
             clusters.push({
-                text: currentClusterText,
+                text: clusterTextChars.join(''),
                 glyphs: currentClusterGlyphs,
                 position: new Vec3(clusterStartX, clusterStartY, cursorZ)
             });
@@ -5242,8 +5443,13 @@ 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]}`);
-        return pairs.join(',');
+        let result = '';
+        for (let i = 0; i < keys.length; i++) {
+            if (i > 0)
+                result += ',';
+            result += keys[i] + ':' + obj[keys[i]];
+        }
+        return result;
     }
     constructor() {
         this.currentFontId = '';
@@ -5476,16 +5682,19 @@ 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;
+            let byTextMatches;
             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
+                    // Glyphs don't exist yet, so we scan text directly
                     coloredTextIndices = new Set();
                     if (options.color.byText) {
+                        byTextMatches = [];
                         for (const pattern of Object.keys(options.color.byText)) {
                             let index = 0;
                             while ((index = options.text.indexOf(pattern, index)) !== -1) {
+                                byTextMatches.push({ pattern, start: index, end: index + pattern.length });
                                 for (let i = index; i < index + pattern.length; i++) {
                                     coloredTextIndices.add(i);
                                 }
@@ -5503,7 +5712,7 @@ class Text {
                 }
             }
             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);
+            const result = this.finalizeGeometry(shapedResult.vertices, shapedResult.normals, shapedResult.indices, shapedResult.glyphInfos, shapedResult.planeBounds, options, options.text, byTextMatches);
             if (options.perGlyphAttributes) {
                 const glyphAttrs = this.createGlyphAttributes(result.vertices.length / 3, result.glyphs);
                 result.glyphAttributes = glyphAttrs;
@@ -5627,7 +5836,7 @@ class Text {
             pixelsPerFontUnit: 1 / fontUnitsPerPixel
         };
     }
-    applyColorSystem(vertices, glyphInfoArray, color, originalText) {
+    applyColorSystem(vertices, glyphInfoArray, color, originalText, byTextMatches) {
         const vertexCount = vertices.length / 3;
         const colors = new Float32Array(vertexCount * 3);
         const coloredRanges = [];
@@ -5658,69 +5867,136 @@ class Text {
                 colors[i + 1] = defaultColor[1];
                 colors[i + 2] = defaultColor[2];
             }
-            // Apply text-based coloring using query system
-            if (color.byText) {
-                const rangeQuery = new TextRangeQuery(originalText, glyphInfoArray);
-                const textRanges = rangeQuery.execute({
-                    byText: Object.keys(color.byText)
-                });
-                textRanges.forEach((range) => {
-                    const targetColor = color.byText[range.originalText];
-                    if (targetColor) {
-                        range.glyphs.forEach((glyph) => {
-                            for (let i = 0; i < glyph.vertexCount; i++) {
-                                const vertexIndex = (glyph.vertexStart + i) * 3;
-                                if (vertexIndex >= 0 && vertexIndex < colors.length) {
-                                    colors[vertexIndex] = targetColor[0];
-                                    colors[vertexIndex + 1] = targetColor[1];
-                                    colors[vertexIndex + 2] = targetColor[2];
+            // Build glyph index once for both byText and byCharRange
+            let glyphsByTextIndex;
+            if ((color.byText && byTextMatches) || color.byCharRange) {
+                glyphsByTextIndex = new Map();
+                for (const glyph of glyphInfoArray) {
+                    const existing = glyphsByTextIndex.get(glyph.textIndex);
+                    if (existing) {
+                        existing.push(glyph);
+                    }
+                    else {
+                        glyphsByTextIndex.set(glyph.textIndex, [glyph]);
+                    }
+                }
+            }
+            if (color.byText && byTextMatches && glyphsByTextIndex) {
+                for (const match of byTextMatches) {
+                    const targetColor = color.byText[match.pattern];
+                    if (!targetColor)
+                        continue;
+                    const matchGlyphs = [];
+                    const lineGroups = new Map();
+                    for (let i = match.start; i < match.end; i++) {
+                        const glyphs = glyphsByTextIndex.get(i);
+                        if (glyphs) {
+                            for (const glyph of glyphs) {
+                                matchGlyphs.push(glyph);
+                                const lineGlyphs = lineGroups.get(glyph.lineIndex);
+                                if (lineGlyphs) {
+                                    lineGlyphs.push(glyph);
+                                }
+                                else {
+                                    lineGroups.set(glyph.lineIndex, [glyph]);
+                                }
+                                for (let v = 0; v < glyph.vertexCount; v++) {
+                                    const vertexIndex = (glyph.vertexStart + v) * 3;
+                                    if (vertexIndex >= 0 && vertexIndex < colors.length) {
+                                        colors[vertexIndex] = targetColor[0];
+                                        colors[vertexIndex + 1] = targetColor[1];
+                                        colors[vertexIndex + 2] = targetColor[2];
+                                    }
                                 }
                             }
-                        });
-                        coloredRanges.push({
-                            start: range.start,
-                            end: range.end,
-                            originalText: range.originalText,
-                            color: targetColor,
-                            bounds: range.bounds,
-                            glyphs: range.glyphs,
-                            lineIndices: range.lineIndices
-                        });
+                        }
                     }
-                });
+                    // Calculate bounds per line for collision detection
+                    const bounds = Array.from(lineGroups.values()).map((lineGlyphs) => this.calculateGlyphBounds(lineGlyphs));
+                    coloredRanges.push({
+                        start: match.start,
+                        end: match.end,
+                        originalText: match.pattern,
+                        color: targetColor,
+                        bounds,
+                        glyphs: matchGlyphs,
+                        lineIndices: Array.from(lineGroups.keys()).sort((a, b) => a - b)
+                    });
+                }
             }
             // Apply range coloring
-            if (color.byCharRange) {
-                color.byCharRange.forEach((range) => {
+            if (color.byCharRange && glyphsByTextIndex) {
+                for (const range of color.byCharRange) {
                     const rangeGlyphs = [];
-                    for (const glyph of glyphInfoArray) {
-                        if (glyph.textIndex >= range.start && glyph.textIndex < range.end) {
-                            rangeGlyphs.push(glyph);
-                            for (let i = 0; i < glyph.vertexCount; i++) {
-                                const vertexIndex = (glyph.vertexStart + i) * 3;
-                                if (vertexIndex >= 0 && vertexIndex < colors.length) {
-                                    colors[vertexIndex] = range.color[0];
-                                    colors[vertexIndex + 1] = range.color[1];
-                                    colors[vertexIndex + 2] = range.color[2];
+                    const lineGroups = new Map();
+                    for (let i = range.start; i < range.end; i++) {
+                        const glyphs = glyphsByTextIndex.get(i);
+                        if (glyphs) {
+                            for (const glyph of glyphs) {
+                                rangeGlyphs.push(glyph);
+                                const lineGlyphs = lineGroups.get(glyph.lineIndex);
+                                if (lineGlyphs) {
+                                    lineGlyphs.push(glyph);
+                                }
+                                else {
+                                    lineGroups.set(glyph.lineIndex, [glyph]);
+                                }
+                                for (let v = 0; v < glyph.vertexCount; v++) {
+                                    const vertexIndex = (glyph.vertexStart + v) * 3;
+                                    if (vertexIndex >= 0 && vertexIndex < colors.length) {
+                                        colors[vertexIndex] = range.color[0];
+                                        colors[vertexIndex + 1] = range.color[1];
+                                        colors[vertexIndex + 2] = range.color[2];
+                                    }
                                 }
                             }
                         }
                     }
+                    // Calculate bounds per line for collision detection
+                    const bounds = Array.from(lineGroups.values()).map((lineGlyphs) => this.calculateGlyphBounds(lineGlyphs));
                     coloredRanges.push({
                         start: range.start,
                         end: range.end,
                         originalText: originalText.slice(range.start, range.end),
                         color: range.color,
-                        bounds: [], // Would calculate from glyphs if needed
+                        bounds,
                         glyphs: rangeGlyphs,
-                        lineIndices: [...new Set(rangeGlyphs.map((g) => g.lineIndex))]
+                        lineIndices: Array.from(lineGroups.keys()).sort((a, b) => a - b)
                     });
-                });
+                }
             }
         }
         return { colors, coloredRanges };
     }
-    finalizeGeometry(vertices, normals, indices, glyphInfoArray, planeBounds, options, originalText) {
+    calculateGlyphBounds(glyphs) {
+        if (glyphs.length === 0) {
+            return {
+                min: { x: 0, y: 0, z: 0 },
+                max: { x: 0, y: 0, z: 0 }
+            };
+        }
+        let minX = Infinity, minY = Infinity, minZ = Infinity;
+        let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+        for (const glyph of glyphs) {
+            if (glyph.bounds.min.x < minX)
+                minX = glyph.bounds.min.x;
+            if (glyph.bounds.min.y < minY)
+                minY = glyph.bounds.min.y;
+            if (glyph.bounds.min.z < minZ)
+                minZ = glyph.bounds.min.z;
+            if (glyph.bounds.max.x > maxX)
+                maxX = glyph.bounds.max.x;
+            if (glyph.bounds.max.y > maxY)
+                maxY = glyph.bounds.max.y;
+            if (glyph.bounds.max.z > maxZ)
+                maxZ = glyph.bounds.max.z;
+        }
+        return {
+            min: { x: minX, y: minY, z: minZ },
+            max: { x: maxX, y: maxY, z: maxZ }
+        };
+    }
+    finalizeGeometry(vertices, normals, indices, glyphInfoArray, planeBounds, options, originalText, byTextMatches) {
         const { layout = {} } = options;
         const { width, align = layout.direction === 'rtl' ? 'right' : 'left' } = layout;
         if (!this.textLayout) {
@@ -5746,7 +6022,7 @@ class Text {
         let colors;
         let coloredRanges;
         if (options.color) {
-            const colorResult = this.applyColorSystem(vertices, glyphInfoArray, options.color, options.text);
+            const colorResult = this.applyColorSystem(vertices, glyphInfoArray, options.color, options.text, byTextMatches);
             colors = colorResult.colors;
             coloredRanges = colorResult.coloredRanges;
         }
@@ -5768,13 +6044,18 @@ class Text {
                 pointsRemovedByColinear: optimizationStats.pointsRemovedByColinear,
                 originalPointCount: optimizationStats.originalPointCount
             },
-            query: (options) => {
-                if (!originalText) {
-                    throw new Error('Original text not available for querying');
-                }
-                const queryInstance = new TextRangeQuery(originalText, glyphInfoArray);
-                return queryInstance.execute(options);
-            },
+            query: (() => {
+                let cachedQuery = null;
+                return (options) => {
+                    if (!originalText) {
+                        throw new Error('Original text not available for querying');
+                    }
+                    if (!cachedQuery) {
+                        cachedQuery = new TextRangeQuery(originalText, glyphInfoArray);
+                    }
+                    return cachedQuery.execute(options);
+                };
+            })(),
             coloredRanges,
             glyphAttributes: undefined
         };