three-text 0.3.0 → 0.3.2

package/dist/index.umd.js

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.3.0
+ * three-text v0.3.2
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -1636,9 +1636,7 @@
     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;
@@ -1658,6 +1656,10 @@
         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) {
@@ -1759,7 +1761,6 @@
             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
@@ -1791,9 +1792,7 @@
         }
         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);
@@ -1818,10 +1817,8 @@
         }
         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);
@@ -1830,26 +1827,22 @@
                     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;
             }
@@ -1857,7 +1850,210 @@
                 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 {
@@ -1956,7 +2152,6 @@
             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
@@ -1972,29 +2167,27 @@
             }
             // 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;
@@ -2054,7 +2247,7 @@
                 }
                 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) {
@@ -2066,7 +2259,6 @@
                         };
                     }
                 }
-                const featureData = FontMetadataExtractor.extractFeatureTags(fontBuffer);
                 return {
                     hb,
                     fontBlob,
@@ -4369,7 +4561,7 @@
             buffer.destroy();
             const clusters = [];
             let currentClusterGlyphs = [];
-            let currentClusterText = '';
+            let clusterTextChars = [];
             let clusterStartX = 0;
             let clusterStartY = 0;
             let cursorX = lineInfo.xOffset;
@@ -4379,17 +4571,24 @@
             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.
@@ -4397,12 +4596,12 @@
                 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;
@@ -4415,32 +4614,31 @@
                     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;
                         }
@@ -4449,10 +4647,13 @@
                         }
                     }
                 }
+                else {
+                    nextCharIsCJK = undefined;
+                }
             }
             if (currentClusterGlyphs.length > 0) {
                 clusters.push({
-                    text: currentClusterText,
+                    text: clusterTextChars.join(''),
                     glyphs: currentClusterGlyphs,
                     position: new Vec3(clusterStartX, clusterStartY, cursorZ)
                 });
@@ -5246,8 +5447,13 @@
         // 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 = '';
@@ -5282,7 +5488,6 @@
             const loadedFont = await Text.resolveFont(options);
             const text = new Text();
             text.setLoadedFont(loadedFont);
-            // Pass full options so createGeometry honors maxCacheSizeMB etc
             const result = await text.createGeometry(options);
             // Recursive update function
             const update = async (newOptions) => {
@@ -5463,10 +5668,7 @@
                 options = updatedOptions;
                 this.updateFontVariations(options);
                 if (!this.geometryBuilder) {
-                    const cache = options.maxCacheSizeMB
-                        ? createGlyphCache()
-                        : globalGlyphCache;
-                    this.geometryBuilder = new GlyphGeometryBuilder(cache, this.loadedFont);
+                    this.geometryBuilder = new GlyphGeometryBuilder(globalGlyphCache, this.loadedFont);
                     this.geometryBuilder.setFontId(this.currentFontId);
                 }
                 this.geometryBuilder.setCurveFidelityConfig(options.curveFidelity);
@@ -5484,16 +5686,19 @@
                 // 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);
                                     }
@@ -5511,7 +5716,7 @@
                     }
                 }
                 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;
@@ -5635,7 +5840,7 @@
                 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 = [];
@@ -5666,36 +5871,50 @@
                     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];
+                if (color.byText && byTextMatches) {
+                    const 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]);
+                        }
+                    }
+                    for (const match of byTextMatches) {
+                        const targetColor = color.byText[match.pattern];
+                        if (!targetColor)
+                            continue;
+                        const matchGlyphs = [];
+                        const lineIndicesSet = new Set();
+                        for (let i = match.start; i < match.end; i++) {
+                            const glyphs = glyphsByTextIndex.get(i);
+                            if (glyphs) {
+                                for (const glyph of glyphs) {
+                                    matchGlyphs.push(glyph);
+                                    lineIndicesSet.add(glyph.lineIndex);
+                                    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
-                            });
+                            }
                         }
-                    });
+                        coloredRanges.push({
+                            start: match.start,
+                            end: match.end,
+                            originalText: match.pattern,
+                            color: targetColor,
+                            bounds: [],
+                            glyphs: matchGlyphs,
+                            lineIndices: Array.from(lineIndicesSet).sort((a, b) => a - b)
+                        });
+                    }
                 }
                 // Apply range coloring
                 if (color.byCharRange) {
@@ -5728,7 +5947,7 @@
             }
             return { colors, coloredRanges };
         }
-        finalizeGeometry(vertices, normals, indices, glyphInfoArray, planeBounds, options, originalText) {
+        finalizeGeometry(vertices, normals, indices, glyphInfoArray, planeBounds, options, originalText, byTextMatches) {
             const { layout = {} } = options;
             const { width, align = layout.direction === 'rtl' ? 'right' : 'left' } = layout;
             if (!this.textLayout) {
@@ -5754,7 +5973,7 @@
             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;
             }
@@ -5776,13 +5995,18 @@
                     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
             };