three-text 0.5.2 → 0.6.0

package/dist/vector/core.js

@@ -1,7 +1,2247 @@
-import { Text as Text$1 } from '../index.js';
-import { globalOutlineCache } from '../index.js';
-import { getSharedDrawCallbackHandler } from '../index.js';
-import { TextRangeQuery } from '../index.js';
+import require$$0 from 'fs';
+
+// Cached flag check at module load time for zero-cost logging
+const isLogEnabled = (() => {
+    if (typeof window !== 'undefined' && window.THREE_TEXT_LOG) {
+        return true;
+    }
+    if (typeof globalThis !== 'undefined' &&
+        globalThis.process?.env?.THREE_TEXT_LOG === 'true') {
+        return true;
+    }
+    return false;
+})();
+class Logger {
+    warn(message, ...args) {
+        console.warn(message, ...args);
+    }
+    error(message, ...args) {
+        console.error(message, ...args);
+    }
+    log(message, ...args) {
+        isLogEnabled && console.log(message, ...args);
+    }
+}
+const logger = new Logger();
+
+class PerformanceLogger {
+    constructor() {
+        this.metrics = [];
+        this.activeTimers = new Map();
+    }
+    start(name, metadata) {
+        // Early exit if disabled - no metric collection
+        if (!isLogEnabled)
+            return;
+        const startTime = performance.now();
+        // Generate unique key for nested timing support
+        const timerKey = `${name}_${startTime}`;
+        this.activeTimers.set(timerKey, startTime);
+        this.metrics.push({
+            name,
+            startTime,
+            metadata
+        });
+    }
+    end(name) {
+        // Early exit if disabled
+        if (!isLogEnabled)
+            return null;
+        const endTime = performance.now();
+        // Find the most recent matching timer by scanning backwards
+        let timerKey;
+        let startTime;
+        for (const [key, time] of Array.from(this.activeTimers.entries()).reverse()) {
+            if (key.startsWith(`${name}_`)) {
+                timerKey = key;
+                startTime = time;
+                break;
+            }
+        }
+        if (startTime === undefined || !timerKey) {
+            logger.warn(`Performance timer "${name}" was not started`);
+            return null;
+        }
+        const duration = endTime - startTime;
+        this.activeTimers.delete(timerKey);
+        // 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) {
+                metric.endTime = endTime;
+                metric.duration = duration;
+                break;
+            }
+        }
+        console.log(`${name}: ${duration.toFixed(2)}ms`);
+        return duration;
+    }
+    getSummary() {
+        if (!isLogEnabled)
+            return {};
+        const summary = {};
+        for (const metric of this.metrics) {
+            if (!metric.duration)
+                continue;
+            const existing = summary[metric.name];
+            if (existing) {
+                existing.count++;
+                existing.totalDuration += metric.duration;
+                existing.avgDuration = existing.totalDuration / existing.count;
+                existing.lastDuration = metric.duration;
+            }
+            else {
+                summary[metric.name] = {
+                    count: 1,
+                    avgDuration: metric.duration,
+                    totalDuration: metric.duration,
+                    lastDuration: metric.duration
+                };
+            }
+        }
+        return summary;
+    }
+    printSummary() {
+        if (!isLogEnabled)
+            return;
+        const summary = this.getSummary();
+        console.table(summary);
+        console.log('Operations:', Object.keys(summary).sort().join(', '));
+    }
+    printBaseline() {
+        if (!isLogEnabled)
+            return;
+        const summary = this.getSummary();
+        Object.entries(summary).forEach(([name, stats]) => {
+            console.log(`BASELINE ${name}: ${stats.avgDuration.toFixed(2)}ms avg (${stats.count} calls)`);
+        });
+    }
+    clear() {
+        if (!isLogEnabled)
+            return;
+        this.metrics.length = 0;
+        this.activeTimers.clear();
+    }
+    time(name, fn, metadata) {
+        if (!isLogEnabled)
+            return fn();
+        this.start(name, metadata);
+        try {
+            return fn();
+        }
+        finally {
+            this.end(name);
+        }
+    }
+    async timeAsync(name, fn, metadata) {
+        if (!isLogEnabled)
+            return fn();
+        this.start(name, metadata);
+        try {
+            return await fn();
+        }
+        finally {
+            this.end(name);
+        }
+    }
+}
+// Create a single instance
+// When debug is disabled, all methods return immediately with minimal overhead
+const perfLogger = new PerformanceLogger();
+
+// TeX defaults
+const DEFAULT_TOLERANCE = 800;
+const DEFAULT_PRETOLERANCE = 100;
+const DEFAULT_EMERGENCY_STRETCH = 0;
+// In TeX, interword spacing is defined by font parameters (fontdimen):
+// - fontdimen 2: interword space
+// - fontdimen 3: interword stretch
+// - fontdimen 4: interword shrink
+// - fontdimen 7: extra space (for sentence endings)
+//
+// For Computer Modern, stretch = 1/2 space, shrink = 1/3 space,
+// which has become the default for OpenType fonts in modern
+// TeX implementations
+const SPACE_STRETCH_RATIO = 0.5; // stretch = 50% of space width (fontdimen 3 / fontdimen 2)
+const SPACE_SHRINK_RATIO = 1 / 3; // shrink = 33% of space width (fontdimen 4 / fontdimen 2)
+
+// Knuth-Plass line breaking with Liang hyphenation
+// References: break.lua (SILE), tex.web (TeX), linebreak.c (LuaTeX), pTeX, xeCJK
+var ItemType;
+(function (ItemType) {
+    ItemType[ItemType["BOX"] = 0] = "BOX";
+    ItemType[ItemType["GLUE"] = 1] = "GLUE";
+    ItemType[ItemType["PENALTY"] = 2] = "PENALTY";
+    ItemType[ItemType["DISCRETIONARY"] = 3] = "DISCRETIONARY"; // hyphenation point with pre/post/no-break forms
+})(ItemType || (ItemType = {}));
+// TeX fitness classes (tex.web lines 16099-16105)
+var FitnessClass;
+(function (FitnessClass) {
+    FitnessClass[FitnessClass["VERY_LOOSE"] = 0] = "VERY_LOOSE";
+    FitnessClass[FitnessClass["LOOSE"] = 1] = "LOOSE";
+    FitnessClass[FitnessClass["DECENT"] = 2] = "DECENT";
+    FitnessClass[FitnessClass["TIGHT"] = 3] = "TIGHT"; // lines shrinking 0.5 to 1.0 of their shrinkability
+})(FitnessClass || (FitnessClass = {}));
+// Active node management with Map for lookup by (position, fitness)
+class ActiveNodeList {
+    constructor() {
+        this.nodesByKey = new Map();
+        this.activeList = [];
+    }
+    getKey(position, fitness) {
+        return (position << 2) | fitness;
+    }
+    // Insert or update node - returns true if node was added/updated
+    insert(node) {
+        const key = this.getKey(node.position, node.fitness);
+        const existing = this.nodesByKey.get(key);
+        if (existing) {
+            // Update existing if new one is better
+            if (node.totalDemerits < existing.totalDemerits) {
+                existing.totalDemerits = node.totalDemerits;
+                existing.previous = node.previous;
+                existing.hyphenated = node.hyphenated;
+                existing.line = node.line;
+                existing.cumWidth = node.cumWidth;
+                existing.cumStretch = node.cumStretch;
+                existing.cumShrink = node.cumShrink;
+                return true;
+            }
+            return false;
+        }
+        // Add new node
+        node.active = true;
+        node.activeIndex = this.activeList.length;
+        this.activeList.push(node);
+        this.nodesByKey.set(key, node);
+        return true;
+    }
+    deactivate(node) {
+        if (!node.active)
+            return;
+        node.active = false;
+        const idx = node.activeIndex;
+        const lastIdx = this.activeList.length - 1;
+        if (idx !== lastIdx) {
+            const lastNode = this.activeList[lastIdx];
+            this.activeList[idx] = lastNode;
+            lastNode.activeIndex = idx;
+        }
+        this.activeList.pop();
+    }
+    getActive() {
+        return this.activeList;
+    }
+    size() {
+        return this.activeList.length;
+    }
+}
+// TeX parameters (tex.web lines 4934-4936, 4997-4999)
+const DEFAULT_HYPHEN_PENALTY = 50; // \hyphenpenalty
+const DEFAULT_EX_HYPHEN_PENALTY = 50; // \exhyphenpenalty
+const DEFAULT_DOUBLE_HYPHEN_DEMERITS = 10000; // \doublehyphendemerits
+const DEFAULT_FINAL_HYPHEN_DEMERITS = 5000; // \finalhyphendemerits
+const DEFAULT_LINE_PENALTY = 10; // \linepenalty
+const DEFAULT_FITNESS_DIFF_DEMERITS = 10000; // \adjdemerits
+const DEFAULT_LEFT_HYPHEN_MIN = 2; // \lefthyphenmin
+const DEFAULT_RIGHT_HYPHEN_MIN = 3; // \righthyphenmin
+// TeX special values (tex.web lines 2335, 3258, 3259)
+const INF_BAD = 10000; // inf_bad - infinitely bad badness
+const INFINITY_PENALTY = 10000; // inf_penalty - never break here
+const EJECT_PENALTY = -10000; // eject_penalty - force break here
+// Retry increment when no breakpoints found
+const EMERGENCY_STRETCH_INCREMENT = 0.1;
+class LineBreak {
+    // TeX: badness function (tex.web lines 2337-2348)
+    // Computes badness = 100 * (t/s)³ where t=adjustment, s=stretchability
+    // Simplified from TeX's fixed-point integer arithmetic to floating-point
+    //
+    // Returns INF_BAD+1 for overfull boxes so they're rejected even when
+    // threshold=INF_BAD in emergency pass
+    static badness(t, s) {
+        if (t === 0)
+            return 0;
+        if (s <= 0)
+            return INF_BAD + 1;
+        const r = Math.abs(t / s);
+        if (r > 10)
+            return INF_BAD + 1;
+        return Math.min(Math.round(100 * r ** 3), INF_BAD);
+    }
+    // TeX fitness classification (tex.web lines 16099-16105, 16799-16812)
+    // TeX uses badness thresholds 12 and 99, which correspond to ratios ~0.5 and ~1.0
+    // We use ratio directly since we compute it anyway. Well, and because SILE does
+    // it this way. Thanks Simon :)
+    static fitnessClass(ratio) {
+        if (ratio < -0.5)
+            return FitnessClass.TIGHT; // shrinking significantly
+        if (ratio < 0.5)
+            return FitnessClass.DECENT; // normal
+        if (ratio < 1)
+            return FitnessClass.LOOSE; // stretching 0.5-1.0
+        return FitnessClass.VERY_LOOSE; // stretching > 1.0
+    }
+    static findHyphenationPoints(word, language = 'en-us', availablePatterns, lefthyphenmin = DEFAULT_LEFT_HYPHEN_MIN, righthyphenmin = DEFAULT_RIGHT_HYPHEN_MIN) {
+        let patternTrie;
+        if (availablePatterns && availablePatterns[language]) {
+            patternTrie = availablePatterns[language];
+        }
+        else {
+            return [];
+        }
+        if (!patternTrie)
+            return [];
+        const lowerWord = word.toLowerCase();
+        const paddedWord = `.${lowerWord}.`;
+        const points = new Array(paddedWord.length).fill(0);
+        for (let i = 0; i < paddedWord.length; i++) {
+            let node = patternTrie;
+            for (let j = i; j < paddedWord.length; j++) {
+                const char = paddedWord[j];
+                if (!node.children || !node.children[char])
+                    break;
+                node = node.children[char];
+                if (node.patterns) {
+                    for (let k = 0; k < node.patterns.length; k++) {
+                        const pos = i + k;
+                        if (pos < points.length) {
+                            points[pos] = Math.max(points[pos], node.patterns[k]);
+                        }
+                    }
+                }
+            }
+        }
+        const hyphenPoints = [];
+        for (let i = 2; i < paddedWord.length - 2; i++) {
+            if (points[i] % 2 === 1) {
+                hyphenPoints.push(i - 1);
+            }
+        }
+        return hyphenPoints.filter((pos) => pos >= lefthyphenmin && word.length - pos >= righthyphenmin);
+    }
+    static itemizeText(text, measureText, measureTextWidths, hyphenate = false, language = 'en-us', availablePatterns, lefthyphenmin = DEFAULT_LEFT_HYPHEN_MIN, righthyphenmin = DEFAULT_RIGHT_HYPHEN_MIN, context, lineWidth) {
+        const items = [];
+        items.push(...this.itemizeParagraph(text, measureText, measureTextWidths, hyphenate, language, availablePatterns, lefthyphenmin, righthyphenmin, context, lineWidth));
+        // Final glue and penalty
+        items.push({
+            type: ItemType.GLUE,
+            width: 0,
+            stretch: 10000000,
+            shrink: 0,
+            text: '',
+            originIndex: text.length
+        });
+        items.push({
+            type: ItemType.PENALTY,
+            width: 0,
+            penalty: EJECT_PENALTY,
+            text: '',
+            originIndex: text.length
+        });
+        return items;
+    }
+    static isCJK(char) {
+        const code = char.codePointAt(0);
+        if (code === undefined)
+            return false;
+        return ((code >= 0x4e00 && code <= 0x9fff) || // CJK Unified Ideographs
+            (code >= 0x3400 && code <= 0x4dbf) || // CJK Extension A
+            (code >= 0x20000 && code <= 0x2a6df) || // CJK Extension B
+            (code >= 0x2a700 && code <= 0x2b73f) || // CJK Extension C
+            (code >= 0x2b740 && code <= 0x2b81f) || // CJK Extension D
+            (code >= 0x2b820 && code <= 0x2ceaf) || // CJK Extension E
+            (code >= 0xf900 && code <= 0xfaff) || // CJK Compatibility Ideographs
+            (code >= 0x3040 && code <= 0x309f) || // Hiragana
+            (code >= 0x30a0 && code <= 0x30ff) || // Katakana
+            (code >= 0xac00 && code <= 0xd7af) || // Hangul Syllables
+            (code >= 0x1100 && code <= 0x11ff) || // Hangul Jamo
+            (code >= 0x3130 && code <= 0x318f) || // Hangul Compatibility Jamo
+            (code >= 0xa960 && code <= 0xa97f) || // Hangul Jamo Extended-A
+            (code >= 0xd7b0 && code <= 0xd7ff) || // Hangul Jamo Extended-B
+            (code >= 0xffa0 && code <= 0xffdc) // Halfwidth Hangul
+        );
+    }
+    // Closing punctuation - no line break before (UAX #14 CL, JIS X 4051)
+    static isCJClosingPunctuation(char) {
+        const code = char.charCodeAt(0);
+        return (code === 0x3001 || // 、
+            code === 0x3002 || // 。
+            code === 0xff0c || // ，
+            code === 0xff0e || // ．
+            code === 0xff1a || // ：
+            code === 0xff1b || // ；
+            code === 0xff01 || // ！
+            code === 0xff1f || // ？
+            code === 0xff09 || // ）
+            code === 0x3011 || // 】
+            code === 0xff5d || // ｝
+            code === 0x300d || // 」
+            code === 0x300f || // 』
+            code === 0x3009 || // 〉
+            code === 0x300b || // 》
+            code === 0x3015 || // 〕
+            code === 0x3017 || // 〗
+            code === 0x3019 || // 〙
+            code === 0x301b || // 〛
+            code === 0x30fc || // ー
+            code === 0x2014 || // —
+            code === 0x2026 || // …
+            code === 0x2025 // ‥
+        );
+    }
+    // Opening punctuation - no line break after (UAX #14 OP, JIS X 4051)
+    static isCJOpeningPunctuation(char) {
+        const code = char.charCodeAt(0);
+        return (code === 0xff08 || // （
+            code === 0x3010 || // 【
+            code === 0xff5b || // ｛
+            code === 0x300c || // 「
+            code === 0x300e || // 『
+            code === 0x3008 || // 〈
+            code === 0x300a || // 《
+            code === 0x3014 || // 〔
+            code === 0x3016 || // 〖
+            code === 0x3018 || // 〘
+            code === 0x301a // 〚
+        );
+    }
+    static isCJPunctuation(char) {
+        return (this.isCJClosingPunctuation(char) || this.isCJOpeningPunctuation(char));
+    }
+    static itemizeCJKText(text, measureText, measureTextWidths, context, startOffset = 0, glueParams) {
+        const items = [];
+        const chars = Array.from(text);
+        const widths = measureTextWidths ? measureTextWidths(text) : null;
+        let textPosition = startOffset;
+        let glueWidth, glueStretch, glueShrink;
+        if (glueParams) {
+            glueWidth = glueParams.width;
+            glueStretch = glueParams.stretch;
+            glueShrink = glueParams.shrink;
+        }
+        else {
+            const baseCharWidth = measureText('字');
+            glueWidth = 0;
+            glueStretch = baseCharWidth * 0.04;
+            glueShrink = baseCharWidth * 0.04;
+        }
+        for (let i = 0; i < chars.length; i++) {
+            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);
+                items.push({
+                    type: ItemType.GLUE,
+                    width,
+                    stretch: width * SPACE_STRETCH_RATIO,
+                    shrink: width * SPACE_SHRINK_RATIO,
+                    text: char,
+                    originIndex: textPosition
+                });
+                textPosition += char.length;
+                continue;
+            }
+            items.push({
+                type: ItemType.BOX,
+                width: widths ? (widths[i] ?? measureText(char)) : measureText(char),
+                text: char,
+                originIndex: textPosition
+            });
+            textPosition += char.length;
+            if (nextChar && !/\s/.test(nextChar)) {
+                let canBreak = true;
+                if (this.isCJClosingPunctuation(nextChar))
+                    canBreak = false;
+                if (this.isCJOpeningPunctuation(char))
+                    canBreak = false;
+                const isPunctPair = this.isCJPunctuation(char) && this.isCJPunctuation(nextChar);
+                if (canBreak && !isPunctPair) {
+                    items.push({
+                        type: ItemType.GLUE,
+                        width: glueWidth,
+                        stretch: glueStretch,
+                        shrink: glueShrink,
+                        text: '',
+                        originIndex: textPosition
+                    });
+                }
+            }
+        }
+        return items;
+    }
+    static itemizeParagraph(text, measureText, measureTextWidths, hyphenate, language, availablePatterns, lefthyphenmin, righthyphenmin, context, lineWidth) {
+        const items = [];
+        const chars = Array.from(text);
+        // Inter-character glue for CJK justification
+        // Matches pTeX's default \kanjiskip behavior
+        let cjkGlueParams;
+        const getCjkGlueParams = () => {
+            if (!cjkGlueParams) {
+                const baseCharWidth = measureText('字');
+                cjkGlueParams = {
+                    width: 0,
+                    stretch: baseCharWidth * 0.04,
+                    shrink: baseCharWidth * 0.04
+                };
+            }
+            return cjkGlueParams;
+        };
+        let buffer = '';
+        let bufferStart = 0;
+        let bufferScript = null;
+        let textPosition = 0;
+        const flushBuffer = () => {
+            if (buffer.length === 0)
+                return;
+            if (bufferScript === 'cjk') {
+                items.push(...this.itemizeCJKText(buffer, measureText, measureTextWidths, context, bufferStart, getCjkGlueParams()));
+            }
+            else {
+                items.push(...this.itemizeWordBased(buffer, bufferStart, measureText, hyphenate, language, availablePatterns, lefthyphenmin, righthyphenmin, context, lineWidth));
+            }
+            buffer = '';
+            bufferScript = null;
+        };
+        for (let i = 0; i < chars.length; i++) {
+            const char = chars[i];
+            const isCJKChar = this.isCJK(char);
+            const currentScript = isCJKChar ? 'cjk' : 'word';
+            if (bufferScript !== null && bufferScript !== currentScript) {
+                flushBuffer();
+                bufferStart = textPosition;
+            }
+            if (bufferScript === null) {
+                bufferScript = currentScript;
+                bufferStart = textPosition;
+            }
+            buffer += char;
+            textPosition += char.length;
+        }
+        flushBuffer();
+        return items;
+    }
+    static itemizeWordBased(text, startOffset, measureText, hyphenate, language, availablePatterns, lefthyphenmin, righthyphenmin, context, lineWidth) {
+        const items = [];
+        const tokens = text.match(/\S+|\s+/g) || [];
+        let currentIndex = 0;
+        for (const token of tokens) {
+            const tokenStartIndex = startOffset + currentIndex;
+            if (/\s+/.test(token)) {
+                const width = measureText(token);
+                items.push({
+                    type: ItemType.GLUE,
+                    width,
+                    stretch: width * SPACE_STRETCH_RATIO,
+                    shrink: width * SPACE_SHRINK_RATIO,
+                    text: token,
+                    originIndex: tokenStartIndex
+                });
+                currentIndex += token.length;
+            }
+            else {
+                if (lineWidth && token.includes('-') && !token.includes('\u00AD')) {
+                    const tokenWidth = measureText(token);
+                    if (tokenWidth > lineWidth) {
+                        // Break long hyphenated tokens into characters (break-all behavior)
+                        const chars = Array.from(token);
+                        for (let i = 0; i < chars.length; i++) {
+                            items.push({
+                                type: ItemType.BOX,
+                                width: measureText(chars[i]),
+                                text: chars[i],
+                                originIndex: tokenStartIndex + i
+                            });
+                            if (i < chars.length - 1) {
+                                items.push({
+                                    type: ItemType.PENALTY,
+                                    width: 0,
+                                    penalty: 5000,
+                                    originIndex: tokenStartIndex + i + 1
+                                });
+                            }
+                        }
+                        currentIndex += token.length;
+                        continue;
+                    }
+                }
+                const segments = token.split(/(-)/);
+                let segmentIndex = tokenStartIndex;
+                for (const segment of segments) {
+                    if (!segment)
+                        continue;
+                    if (segment === '-') {
+                        items.push({
+                            type: ItemType.DISCRETIONARY,
+                            width: measureText('-'),
+                            preBreak: '-',
+                            postBreak: '',
+                            noBreak: '-',
+                            preBreakWidth: measureText('-'),
+                            penalty: context?.exHyphenPenalty ?? DEFAULT_EX_HYPHEN_PENALTY,
+                            flagged: true,
+                            text: '-',
+                            originIndex: segmentIndex
+                        });
+                        segmentIndex += 1;
+                    }
+                    else if (segment.includes('\u00AD')) {
+                        const parts = segment.split('\u00AD');
+                        let runningIndex = 0;
+                        for (let k = 0; k < parts.length; k++) {
+                            const partText = parts[k];
+                            if (partText.length > 0) {
+                                items.push({
+                                    type: ItemType.BOX,
+                                    width: measureText(partText),
+                                    text: partText,
+                                    originIndex: segmentIndex + runningIndex
+                                });
+                                runningIndex += partText.length;
+                            }
+                            if (k < parts.length - 1) {
+                                items.push({
+                                    type: ItemType.DISCRETIONARY,
+                                    width: 0,
+                                    preBreak: '-',
+                                    postBreak: '',
+                                    noBreak: '',
+                                    preBreakWidth: measureText('-'),
+                                    penalty: context?.hyphenPenalty ?? DEFAULT_HYPHEN_PENALTY,
+                                    flagged: true,
+                                    text: '',
+                                    originIndex: segmentIndex + runningIndex
+                                });
+                                runningIndex += 1;
+                            }
+                        }
+                    }
+                    else if (hyphenate &&
+                        segment.length >= lefthyphenmin + righthyphenmin &&
+                        /^\p{L}+$/u.test(segment)) {
+                        const hyphenPoints = this.findHyphenationPoints(segment, language, availablePatterns, lefthyphenmin, righthyphenmin);
+                        if (hyphenPoints.length > 0) {
+                            let lastPoint = 0;
+                            for (const point of hyphenPoints) {
+                                const part = segment.substring(lastPoint, point);
+                                items.push({
+                                    type: ItemType.BOX,
+                                    width: measureText(part),
+                                    text: part,
+                                    originIndex: segmentIndex + lastPoint
+                                });
+                                items.push({
+                                    type: ItemType.DISCRETIONARY,
+                                    width: 0,
+                                    preBreak: '-',
+                                    postBreak: '',
+                                    noBreak: '',
+                                    preBreakWidth: measureText('-'),
+                                    penalty: context?.hyphenPenalty ?? DEFAULT_HYPHEN_PENALTY,
+                                    flagged: true,
+                                    text: '',
+                                    originIndex: segmentIndex + point
+                                });
+                                lastPoint = point;
+                            }
+                            items.push({
+                                type: ItemType.BOX,
+                                width: measureText(segment.substring(lastPoint)),
+                                text: segment.substring(lastPoint),
+                                originIndex: segmentIndex + lastPoint
+                            });
+                        }
+                        else {
+                            const wordWidth = measureText(segment);
+                            if (lineWidth && wordWidth > lineWidth) {
+                                // Word longer than line width - break into characters
+                                const chars = Array.from(segment);
+                                for (let i = 0; i < chars.length; i++) {
+                                    items.push({
+                                        type: ItemType.BOX,
+                                        width: measureText(chars[i]),
+                                        text: chars[i],
+                                        originIndex: segmentIndex + i
+                                    });
+                                    if (i < chars.length - 1) {
+                                        items.push({
+                                            type: ItemType.PENALTY,
+                                            width: 0,
+                                            penalty: 5000,
+                                            originIndex: segmentIndex + i + 1
+                                        });
+                                    }
+                                }
+                            }
+                            else {
+                                items.push({
+                                    type: ItemType.BOX,
+                                    width: wordWidth,
+                                    text: segment,
+                                    originIndex: segmentIndex
+                                });
+                            }
+                        }
+                    }
+                    else {
+                        const wordWidth = measureText(segment);
+                        if (lineWidth && wordWidth > lineWidth) {
+                            // Word longer than line width - break into characters
+                            const chars = Array.from(segment);
+                            for (let i = 0; i < chars.length; i++) {
+                                items.push({
+                                    type: ItemType.BOX,
+                                    width: measureText(chars[i]),
+                                    text: chars[i],
+                                    originIndex: segmentIndex + i
+                                });
+                                if (i < chars.length - 1) {
+                                    items.push({
+                                        type: ItemType.PENALTY,
+                                        width: 0,
+                                        penalty: 5000,
+                                        originIndex: segmentIndex + i + 1
+                                    });
+                                }
+                            }
+                        }
+                        else {
+                            items.push({
+                                type: ItemType.BOX,
+                                width: wordWidth,
+                                text: segment,
+                                originIndex: segmentIndex
+                            });
+                        }
+                    }
+                    segmentIndex += segment.length;
+                }
+                currentIndex += token.length;
+            }
+        }
+        return items;
+    }
+    // TeX: line_break inner loop (tex.web lines 16169-17256)
+    // Finds optimal breakpoints using Knuth-Plass algorithm
+    static lineBreak(items, lineWidth, threshold, emergencyStretch, context) {
+        const activeNodes = new ActiveNodeList();
+        // Start node with zero cumulative width
+        activeNodes.insert({
+            position: 0,
+            line: 0,
+            fitness: FitnessClass.DECENT,
+            totalDemerits: 0,
+            previous: null,
+            hyphenated: false,
+            active: true,
+            activeIndex: 0,
+            cumWidth: 0,
+            cumStretch: 0,
+            cumShrink: 0
+        });
+        // Cumulative width from paragraph start, representing items[0..i-1]
+        let cumWidth = 0;
+        let cumStretch = 0;
+        let cumShrink = 0;
+        // Process each item
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            // Check if this is a legal breakpoint
+            const isBreakpoint = (item.type === ItemType.PENALTY &&
+                item.penalty < INFINITY_PENALTY) ||
+                item.type === ItemType.DISCRETIONARY ||
+                (item.type === ItemType.GLUE &&
+                    i > 0 &&
+                    items[i - 1].type === ItemType.BOX);
+            if (!isBreakpoint) {
+                // Accumulate width for non-breakpoint items
+                if (item.type === ItemType.BOX) {
+                    cumWidth += item.width;
+                }
+                else if (item.type === ItemType.GLUE) {
+                    const glue = item;
+                    cumWidth += glue.width;
+                    cumStretch += glue.stretch;
+                    cumShrink += glue.shrink;
+                }
+                else if (item.type === ItemType.DISCRETIONARY) {
+                    cumWidth += item.width;
+                }
+                continue;
+            }
+            // Get penalty and flagged status
+            let pi = 0;
+            let flagged = false;
+            if (item.type === ItemType.PENALTY) {
+                pi = item.penalty;
+                flagged = item.flagged || false;
+            }
+            else if (item.type === ItemType.DISCRETIONARY) {
+                pi = item.penalty;
+                flagged = item.flagged || false;
+            }
+            // Width added at break
+            let breakWidth = 0;
+            if (item.type === ItemType.DISCRETIONARY) {
+                breakWidth = item.preBreakWidth;
+            }
+            // Best for each fitness class
+            const bestNode = [null, null, null, null];
+            const bestDemerits = [Infinity, Infinity, Infinity, Infinity];
+            // Nodes to deactivate
+            const toDeactivate = [];
+            // Try each active node as predecessor
+            const active = activeNodes.getActive();
+            for (let j = 0; j < active.length; j++) {
+                const a = active[j];
+                // Line width from a to i
+                const lineW = cumWidth - a.cumWidth + breakWidth;
+                const lineStretch = cumStretch - a.cumStretch;
+                const lineShrink = cumShrink - a.cumShrink;
+                const shortfall = lineWidth - lineW;
+                let ratio;
+                if (shortfall > 0) {
+                    const effectiveStretch = lineStretch + emergencyStretch;
+                    ratio =
+                        effectiveStretch > 0 ? shortfall / effectiveStretch : Infinity;
+                }
+                else if (shortfall < 0) {
+                    ratio = lineShrink > 0 ? shortfall / lineShrink : -Infinity;
+                }
+                else {
+                    ratio = 0;
+                }
+                // Calculate badness
+                const bad = this.badness(shortfall, shortfall > 0 ? lineStretch + emergencyStretch : lineShrink);
+                // Check feasibility
+                if (ratio < -1) {
+                    toDeactivate.push(a);
+                    continue;
+                }
+                if (pi !== EJECT_PENALTY && bad > threshold) {
+                    continue;
+                }
+                // Calculate demerits
+                let demerits = context.linePenalty + bad;
+                if (Math.abs(demerits) >= 10000) {
+                    demerits = 100000000;
+                }
+                else {
+                    demerits = demerits * demerits;
+                }
+                if (pi > 0) {
+                    demerits += pi * pi;
+                }
+                else if (pi > EJECT_PENALTY) {
+                    demerits -= pi * pi;
+                }
+                if (flagged && a.hyphenated) {
+                    demerits += context.doubleHyphenDemerits;
+                }
+                const fitness = this.fitnessClass(ratio);
+                if (Math.abs(fitness - a.fitness) > 1) {
+                    demerits += context.adjDemerits;
+                }
+                const totalDemerits = a.totalDemerits + demerits;
+                if (totalDemerits < bestDemerits[fitness]) {
+                    bestDemerits[fitness] = totalDemerits;
+                    bestNode[fitness] = {
+                        position: i,
+                        line: a.line + 1,
+                        fitness,
+                        totalDemerits,
+                        previous: a,
+                        hyphenated: flagged,
+                        active: true,
+                        activeIndex: -1,
+                        cumWidth: cumWidth,
+                        cumStretch: cumStretch,
+                        cumShrink: cumShrink
+                    };
+                }
+            }
+            // Deactivate nodes
+            for (const node of toDeactivate) {
+                activeNodes.deactivate(node);
+            }
+            // Insert best nodes
+            for (let f = 0; f < 4; f++) {
+                if (bestNode[f]) {
+                    activeNodes.insert(bestNode[f]);
+                }
+            }
+            if (activeNodes.size() === 0 && pi !== EJECT_PENALTY) {
+                return null;
+            }
+            // Accumulate width after evaluating this breakpoint
+            if (item.type === ItemType.BOX) {
+                cumWidth += item.width;
+            }
+            else if (item.type === ItemType.GLUE) {
+                const glue = item;
+                cumWidth += glue.width;
+                cumStretch += glue.stretch;
+                cumShrink += glue.shrink;
+            }
+            else if (item.type === ItemType.DISCRETIONARY) {
+                cumWidth += item.width;
+            }
+        }
+        // Find best solution
+        let best = null;
+        let bestTotal = Infinity;
+        for (const node of activeNodes.getActive()) {
+            if (node.totalDemerits < bestTotal) {
+                bestTotal = node.totalDemerits;
+                best = node;
+            }
+        }
+        return best;
+    }
+    // Main entry point for line breaking
+    // Implements the multi-pass approach similar to TeX's line_break (tex.web lines 16054-17067)
+    // 1. First pass without hyphenation (pretolerance)
+    // 2. Second pass with hyphenation (tolerance)
+    // 3. Emergency stretch passes with increasing stretchability
+    static breakText(options) {
+        if (!options.text || options.text.length === 0) {
+            return [];
+        }
+        perfLogger.start('LineBreak.breakText', {
+            textLength: options.text.length,
+            width: options.width,
+            align: options.align || 'left',
+            hyphenate: options.hyphenate || false
+        });
+        const { text, width, align = 'left', direction = 'ltr', hyphenate = false, language = 'en-us', respectExistingBreaks = true, measureText, measureTextWidths, hyphenationPatterns, unitsPerEm, letterSpacing = 0, tolerance = DEFAULT_TOLERANCE, pretolerance = DEFAULT_PRETOLERANCE, emergencyStretch = DEFAULT_EMERGENCY_STRETCH, autoEmergencyStretch, lefthyphenmin = DEFAULT_LEFT_HYPHEN_MIN, righthyphenmin = DEFAULT_RIGHT_HYPHEN_MIN, linepenalty = DEFAULT_LINE_PENALTY, adjdemerits = DEFAULT_FITNESS_DIFF_DEMERITS, hyphenpenalty = DEFAULT_HYPHEN_PENALTY, exhyphenpenalty = DEFAULT_EX_HYPHEN_PENALTY, doublehyphendemerits = DEFAULT_DOUBLE_HYPHEN_DEMERITS, finalhyphendemerits = DEFAULT_FINAL_HYPHEN_DEMERITS } = options;
+        // Handle multiple paragraphs
+        if (respectExistingBreaks && text.includes('\n')) {
+            const paragraphs = text.split('\n');
+            const allLines = [];
+            let currentOriginOffset = 0;
+            for (const paragraph of paragraphs) {
+                if (paragraph.length === 0) {
+                    allLines.push({
+                        text: '',
+                        originalStart: currentOriginOffset,
+                        originalEnd: currentOriginOffset,
+                        xOffset: 0,
+                        isLastLine: true,
+                        naturalWidth: 0,
+                        endedWithHyphen: false
+                    });
+                }
+                else {
+                    const paragraphLines = this.breakText({
+                        ...options,
+                        text: paragraph,
+                        respectExistingBreaks: false
+                    });
+                    paragraphLines.forEach((line) => {
+                        line.originalStart += currentOriginOffset;
+                        line.originalEnd += currentOriginOffset;
+                    });
+                    allLines.push(...paragraphLines);
+                }
+                currentOriginOffset += paragraph.length + 1;
+            }
+            perfLogger.end('LineBreak.breakText');
+            return allLines;
+        }
+        let useHyphenation = hyphenate;
+        if (useHyphenation &&
+            (!hyphenationPatterns || !hyphenationPatterns[language])) {
+            logger.warn(`Hyphenation patterns for ${language} not available`);
+            useHyphenation = false;
+        }
+        let initialEmergencyStretch = emergencyStretch;
+        if (autoEmergencyStretch !== undefined && width) {
+            initialEmergencyStretch = width * autoEmergencyStretch;
+        }
+        const context = {
+            linePenalty: linepenalty,
+            adjDemerits: adjdemerits,
+            doubleHyphenDemerits: doublehyphendemerits,
+            finalHyphenDemerits: finalhyphendemerits,
+            hyphenPenalty: hyphenpenalty,
+            exHyphenPenalty: exhyphenpenalty,
+            currentAlign: align,
+            unitsPerEm,
+            letterSpacingFU: unitsPerEm ? letterSpacing * unitsPerEm : 0
+        };
+        if (!width || width === Infinity) {
+            const measuredWidth = measureText(text);
+            perfLogger.end('LineBreak.breakText');
+            return [
+                {
+                    text,
+                    originalStart: 0,
+                    originalEnd: text.length - 1,
+                    xOffset: 0,
+                    isLastLine: true,
+                    naturalWidth: measuredWidth,
+                    endedWithHyphen: false
+                }
+            ];
+        }
+        // First pass: without hyphenation
+        let items = this.itemizeText(text, measureText, measureTextWidths, false, language, hyphenationPatterns, lefthyphenmin, righthyphenmin, context, width);
+        let best = this.lineBreak(items, width, pretolerance, 0, context);
+        // Second pass: with hyphenation
+        if (!best && useHyphenation) {
+            items = this.itemizeText(text, measureText, measureTextWidths, true, language, hyphenationPatterns, lefthyphenmin, righthyphenmin, context, width);
+            best = this.lineBreak(items, width, tolerance, 0, context);
+        }
+        // Third pass: with emergency stretch, retry with increasing amounts
+        if (!best) {
+            const MAX_EMERGENCY_ITERATIONS = 5;
+            for (let i = 0; i < MAX_EMERGENCY_ITERATIONS && !best; i++) {
+                const currentStretch = initialEmergencyStretch + i * width * EMERGENCY_STRETCH_INCREMENT;
+                best = this.lineBreak(items, width, tolerance, currentStretch, context);
+                // Fourth pass: high threshold with current stretch
+                if (!best) {
+                    best = this.lineBreak(items, width, INF_BAD, currentStretch, context);
+                }
+            }
+        }
+        if (best) {
+            const breakpoints = [];
+            let node = best;
+            while (node && node.position > 0) {
+                breakpoints.unshift(node.position);
+                node = node.previous;
+            }
+            perfLogger.end('LineBreak.breakText');
+            return this.postLineBreak(text, items, breakpoints, width, align, direction, context);
+        }
+        perfLogger.end('LineBreak.breakText');
+        return [
+            {
+                text,
+                originalStart: 0,
+                originalEnd: text.length - 1,
+                xOffset: 0,
+                adjustmentRatio: 0,
+                isLastLine: true,
+                naturalWidth: measureText(text),
+                endedWithHyphen: false
+            }
+        ];
+    }
+    // TeX: post_line_break (tex.web lines 17260-17448)
+    // Creates the actual lines from the computed breakpoints
+    static postLineBreak(text, items, breakpoints, lineWidth, align, direction, context) {
+        if (breakpoints.length === 0) {
+            return [
+                {
+                    text,
+                    originalStart: 0,
+                    originalEnd: text.length - 1,
+                    xOffset: 0
+                }
+            ];
+        }
+        const lines = [];
+        let lineStart = 0;
+        for (let i = 0; i < breakpoints.length; i++) {
+            const breakpoint = breakpoints[i];
+            const willHaveFinalLine = breakpoints[breakpoints.length - 1] + 1 < items.length - 1;
+            const isLastLine = willHaveFinalLine
+                ? false
+                : i === breakpoints.length - 1;
+            const lineTextParts = [];
+            let originalStart = -1;
+            let originalEnd = -1;
+            let naturalWidth = 0;
+            let totalStretch = 0;
+            let totalShrink = 0;
+            for (let j = lineStart; j < breakpoint; j++) {
+                const item = items[j];
+                if ((item.type === ItemType.PENALTY && !item.text) ||
+                    (item.type === ItemType.DISCRETIONARY &&
+                        !item.noBreak)) {
+                    continue;
+                }
+                if (item.originIndex !== undefined) {
+                    if (originalStart === -1 || item.originIndex < originalStart)
+                        originalStart = item.originIndex;
+                    const textLength = item.text ? item.text.length : 0;
+                    const itemEnd = item.originIndex + textLength - 1;
+                    if (itemEnd > originalEnd)
+                        originalEnd = itemEnd;
+                }
+                if (item.text) {
+                    lineTextParts.push(item.text);
+                }
+                else if (item.type === ItemType.DISCRETIONARY) {
+                    const disc = item;
+                    if (disc.noBreak)
+                        lineTextParts.push(disc.noBreak);
+                }
+                naturalWidth += item.width;
+                if (item.type === ItemType.GLUE) {
+                    totalStretch += item.stretch;
+                    totalShrink += item.shrink;
+                }
+            }
+            const breakItem = items[breakpoint];
+            let endedWithHyphen = false;
+            if (breakpoint < items.length) {
+                if (breakItem.type === ItemType.PENALTY &&
+                    breakItem.flagged) {
+                    lineTextParts.push('-');
+                    naturalWidth += breakItem.width;
+                    endedWithHyphen = true;
+                    if (breakItem.originIndex !== undefined)
+                        originalEnd = breakItem.originIndex - 1;
+                }
+                else if (breakItem.type === ItemType.DISCRETIONARY) {
+                    const disc = breakItem;
+                    if (disc.preBreak) {
+                        lineTextParts.push(disc.preBreak);
+                        naturalWidth += disc.preBreakWidth;
+                        endedWithHyphen = disc.flagged || false;
+                        if (breakItem.originIndex !== undefined)
+                            originalEnd = breakItem.originIndex - 1;
+                    }
+                }
+            }
+            const lineText = lineTextParts.join('');
+            if (context?.letterSpacingFU && naturalWidth !== 0) {
+                naturalWidth -= context.letterSpacingFU;
+            }
+            let xOffset = 0;
+            let adjustmentRatio = 0;
+            let effectiveAlign = align;
+            if (align === 'justify' && isLastLine) {
+                effectiveAlign = direction === 'rtl' ? 'right' : 'left';
+            }
+            if (effectiveAlign === 'center') {
+                xOffset = (lineWidth - naturalWidth) / 2;
+            }
+            else if (effectiveAlign === 'right') {
+                xOffset = lineWidth - naturalWidth;
+            }
+            else if (effectiveAlign === 'justify' && !isLastLine) {
+                const shortfall = lineWidth - naturalWidth;
+                if (shortfall > 0 && totalStretch > 0) {
+                    adjustmentRatio = shortfall / totalStretch;
+                }
+                else if (shortfall < 0 && totalShrink > 0) {
+                    adjustmentRatio = shortfall / totalShrink;
+                }
+            }
+            lines.push({
+                text: lineText,
+                originalStart,
+                originalEnd,
+                xOffset,
+                adjustmentRatio,
+                isLastLine: false,
+                naturalWidth,
+                endedWithHyphen
+            });
+            lineStart = breakpoint + 1;
+        }
+        // Handle remaining content
+        if (lineStart < items.length - 1) {
+            const finalLineTextParts = [];
+            let finalOriginalStart = -1;
+            let finalOriginalEnd = -1;
+            let finalNaturalWidth = 0;
+            for (let j = lineStart; j < items.length - 1; j++) {
+                const item = items[j];
+                if (item.type === ItemType.PENALTY)
+                    continue;
+                if (item.originIndex !== undefined) {
+                    if (finalOriginalStart === -1 ||
+                        item.originIndex < finalOriginalStart) {
+                        finalOriginalStart = item.originIndex;
+                    }
+                    if (item.originIndex > finalOriginalEnd) {
+                        finalOriginalEnd = item.originIndex;
+                    }
+                }
+                if (item.text)
+                    finalLineTextParts.push(item.text);
+                finalNaturalWidth += item.width;
+            }
+            if (context?.letterSpacingFU && finalNaturalWidth !== 0) {
+                finalNaturalWidth -= context.letterSpacingFU;
+            }
+            let finalXOffset = 0;
+            let finalEffectiveAlign = align;
+            if (align === 'justify') {
+                finalEffectiveAlign = direction === 'rtl' ? 'right' : 'left';
+            }
+            if (finalEffectiveAlign === 'center') {
+                finalXOffset = (lineWidth - finalNaturalWidth) / 2;
+            }
+            else if (finalEffectiveAlign === 'right') {
+                finalXOffset = lineWidth - finalNaturalWidth;
+            }
+            lines.push({
+                text: finalLineTextParts.join(''),
+                originalStart: finalOriginalStart,
+                originalEnd: finalOriginalEnd,
+                xOffset: finalXOffset,
+                adjustmentRatio: 0,
+                isLastLine: true,
+                naturalWidth: finalNaturalWidth,
+                endedWithHyphen: false
+            });
+            if (lines.length > 1)
+                lines[lines.length - 2].isLastLine = false;
+            lines[lines.length - 1].isLastLine = true;
+        }
+        else if (lines.length > 0) {
+            lines[lines.length - 1].isLastLine = true;
+        }
+        return lines;
+    }
+}
+
+// Memoize conversion per feature-object identity to avoid rebuilding the same
+// comma-separated string on every HarfBuzz shape call
+const featureStringCache = new WeakMap();
+// Convert feature objects to HarfBuzz comma-separated format
+function convertFontFeaturesToString(features) {
+    if (!features || Object.keys(features).length === 0) {
+        return undefined;
+    }
+    const cached = featureStringCache.get(features);
+    if (cached !== undefined) {
+        return cached ?? undefined;
+    }
+    const featureStrings = [];
+    // Preserve insertion order of the input object
+    // (The public API/tests expect this to be stable and predictable)
+    for (const [tag, value] of Object.entries(features)) {
+        if (!/^[a-zA-Z0-9]{4}$/.test(tag)) {
+            logger.warn(`Invalid OpenType feature tag: "${tag}". Tags must be exactly 4 alphanumeric characters.`);
+            continue;
+        }
+        if (value === false || value === 0) {
+            featureStrings.push(`${tag}=0`);
+        }
+        else if (value === true || value === 1) {
+            featureStrings.push(tag);
+        }
+        else if (typeof value === 'number' && value > 1) {
+            featureStrings.push(`${tag}=${Math.floor(value)}`);
+        }
+        else {
+            logger.warn(`Invalid value for feature "${tag}": ${value}. Expected boolean or positive number.`);
+        }
+    }
+    const result = featureStrings.length > 0 ? featureStrings.join(',') : undefined;
+    featureStringCache.set(features, result ?? null);
+    return result;
+}
+
+class TextMeasurer {
+    // Shape once and return per-codepoint widths aligned with Array.from(text)
+    // Groups glyph advances by HarfBuzz cluster (cl)
+    // Includes trailing per-glyph letter spacing like measureTextWidth
+    static measureTextWidths(loadedFont, text, letterSpacing = 0) {
+        const chars = Array.from(text);
+        if (chars.length === 0)
+            return [];
+        // HarfBuzz clusters are UTF-16 code unit indices
+        const startToCharIndex = new Map();
+        let codeUnitIndex = 0;
+        for (let i = 0; i < chars.length; i++) {
+            startToCharIndex.set(codeUnitIndex, i);
+            codeUnitIndex += chars[i].length;
+        }
+        const widths = new Array(chars.length).fill(0);
+        const buffer = loadedFont.hb.createBuffer();
+        try {
+            buffer.addText(text);
+            buffer.guessSegmentProperties();
+            const featuresString = convertFontFeaturesToString(loadedFont.fontFeatures);
+            loadedFont.hb.shape(loadedFont.font, buffer, featuresString);
+            const glyphInfos = buffer.json(loadedFont.font);
+            const letterSpacingInFontUnits = letterSpacing * loadedFont.upem;
+            for (let i = 0; i < glyphInfos.length; i++) {
+                const glyph = glyphInfos[i];
+                const cl = glyph.cl ?? 0;
+                let charIndex = startToCharIndex.get(cl);
+                // Fallback if cl lands mid-codepoint
+                if (charIndex === undefined) {
+                    // Find the closest start <= cl
+                    for (let back = cl; back >= 0; back--) {
+                        const candidate = startToCharIndex.get(back);
+                        if (candidate !== undefined) {
+                            charIndex = candidate;
+                            break;
+                        }
+                    }
+                }
+                if (charIndex === undefined)
+                    continue;
+                widths[charIndex] += glyph.ax;
+                if (letterSpacingInFontUnits !== 0) {
+                    widths[charIndex] += letterSpacingInFontUnits;
+                }
+            }
+            return widths;
+        }
+        finally {
+            buffer.destroy();
+        }
+    }
+    static measureTextWidth(loadedFont, text, letterSpacing = 0) {
+        const buffer = loadedFont.hb.createBuffer();
+        buffer.addText(text);
+        buffer.guessSegmentProperties();
+        const featuresString = convertFontFeaturesToString(loadedFont.fontFeatures);
+        loadedFont.hb.shape(loadedFont.font, buffer, featuresString);
+        const glyphInfos = buffer.json(loadedFont.font);
+        const letterSpacingInFontUnits = letterSpacing * loadedFont.upem;
+        let totalWidth = 0;
+        glyphInfos.forEach((glyph) => {
+            totalWidth += glyph.ax;
+            if (letterSpacingInFontUnits !== 0) {
+                totalWidth += letterSpacingInFontUnits;
+            }
+        });
+        buffer.destroy();
+        return totalWidth;
+    }
+}
+
+class TextLayout {
+    constructor(loadedFont) {
+        this.loadedFont = loadedFont;
+    }
+    computeLines(options) {
+        const { text, width, align, direction, hyphenate, language, respectExistingBreaks, tolerance, pretolerance, emergencyStretch, autoEmergencyStretch, hyphenationPatterns, lefthyphenmin, righthyphenmin, linepenalty, adjdemerits, hyphenpenalty, exhyphenpenalty, doublehyphendemerits, letterSpacing } = options;
+        let lines;
+        if (width) {
+            // Line breaking uses a measureText function that already includes letterSpacing,
+            // so widths passed into LineBreak.breakText account for tracking
+            lines = LineBreak.breakText({
+                text,
+                width,
+                align,
+                direction,
+                hyphenate,
+                language,
+                respectExistingBreaks,
+                tolerance,
+                pretolerance,
+                emergencyStretch,
+                autoEmergencyStretch,
+                hyphenationPatterns,
+                lefthyphenmin,
+                righthyphenmin,
+                linepenalty,
+                adjdemerits,
+                hyphenpenalty,
+                exhyphenpenalty,
+                doublehyphendemerits,
+                unitsPerEm: this.loadedFont.upem,
+                letterSpacing,
+                measureText: (textToMeasure) => TextMeasurer.measureTextWidth(this.loadedFont, textToMeasure, letterSpacing // Letter spacing included in width measurements
+                ),
+                measureTextWidths: (textToMeasure) => TextMeasurer.measureTextWidths(this.loadedFont, textToMeasure, letterSpacing)
+            });
+        }
+        else {
+            // No width specified, just split on newlines
+            const linesArray = text.split('\n');
+            lines = [];
+            let currentIndex = 0;
+            for (const line of linesArray) {
+                const originalEnd = line.length === 0 ? currentIndex : currentIndex + line.length - 1;
+                lines.push({
+                    text: line,
+                    originalStart: currentIndex,
+                    originalEnd,
+                    xOffset: 0
+                });
+                currentIndex += line.length + 1;
+            }
+        }
+        return { lines };
+    }
+    applyAlignment(vertices, options) {
+        const { offset, adjustedBounds } = this.computeAlignmentOffset(options);
+        if (offset !== 0) {
+            for (let i = 0; i < vertices.length; i += 3) {
+                vertices[i] += offset;
+            }
+        }
+        return { offset, adjustedBounds };
+    }
+    computeAlignmentOffset(options) {
+        const { width, align, planeBounds } = options;
+        let offset = 0;
+        const adjustedBounds = {
+            min: { ...planeBounds.min },
+            max: { ...planeBounds.max }
+        };
+        if (width && (align === 'center' || align === 'right')) {
+            const lineWidth = planeBounds.max.x - planeBounds.min.x;
+            if (align === 'center') {
+                offset = (width - lineWidth) / 2 - planeBounds.min.x;
+            }
+            else {
+                offset = width - planeBounds.max.x;
+            }
+        }
+        if (offset !== 0) {
+            adjustedBounds.min.x += offset;
+            adjustedBounds.max.x += offset;
+        }
+        return { offset, adjustedBounds };
+    }
+}
+
+// Font file signature constants
+const FONT_SIGNATURE_TRUE_TYPE = 0x00010000;
+const FONT_SIGNATURE_OPEN_TYPE_CFF = 0x4f54544f; // 'OTTO'
+const FONT_SIGNATURE_WOFF = 0x774f4646; // 'wOFF'
+const FONT_SIGNATURE_WOFF2 = 0x774f4632; // 'wOF2'
+// Table Tags
+const TABLE_TAG_HEAD = 0x68656164; // 'head'
+const TABLE_TAG_HHEA = 0x68686561; // 'hhea'
+const TABLE_TAG_OS2 = 0x4f532f32; // 'OS/2'
+const TABLE_TAG_FVAR = 0x66766172; // 'fvar'
+const TABLE_TAG_STAT = 0x53544154; // 'STAT'
+const TABLE_TAG_NAME = 0x6e616d65; // 'name'
+const TABLE_TAG_CFF = 0x43464620; // 'CFF '
+const TABLE_TAG_CFF2 = 0x43464632; // 'CFF2'
+const TABLE_TAG_GSUB = 0x47535542; // 'GSUB'
+const TABLE_TAG_GPOS = 0x47504f53; // 'GPOS'
+
+// SFNT table directory
+function parseTableDirectory(view) {
+    const numTables = view.getUint16(4);
+    const tableRecordsStart = 12;
+    const tables = new Map();
+    for (let i = 0; i < numTables; i++) {
+        const recordOffset = tableRecordsStart + i * 16;
+        // Guard against corrupt buffers that report more tables than exist
+        if (recordOffset + 16 > view.byteLength) {
+            break;
+        }
+        const tag = view.getUint32(recordOffset);
+        const checksum = view.getUint32(recordOffset + 4);
+        const offset = view.getUint32(recordOffset + 8);
+        const length = view.getUint32(recordOffset + 12);
+        tables.set(tag, { tag, checksum, offset, length });
+    }
+    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) {
+            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/WOFF/WOFF2, got signature: 0x${sfntVersion.toString(16)}`);
+        }
+        const tableDirectory = parseTableDirectory(view);
+        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 nameTableOffset = tableDirectory.get(TABLE_TAG_NAME)?.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)
+            };
+        }
+        // Extract axis names only for variable fonts (fvar table present) with STAT table
+        let axisNames = null;
+        if (fvarTableOffset && statTableOffset && nameTableOffset) {
+            axisNames = this.extractAxisNames(view, statTableOffset, nameTableOffset);
+        }
+        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 extractFeatureTags(fontBuffer) {
+        const view = new DataView(fontBuffer);
+        const tableDirectory = parseTableDirectory(view);
+        const gsubTableOffset = tableDirectory.get(TABLE_TAG_GSUB)?.offset ?? 0;
+        const gposTableOffset = tableDirectory.get(TABLE_TAG_GPOS)?.offset ?? 0;
+        const nameTableOffset = tableDirectory.get(TABLE_TAG_NAME)?.offset ?? 0;
+        const features = new Set();
+        const featureNames = {};
+        try {
+            if (gsubTableOffset) {
+                const gsubData = this.extractFeatureDataFromTable(view, gsubTableOffset, nameTableOffset);
+                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));
+                Object.assign(featureNames, gposData.names);
+            }
+        }
+        catch (e) {
+            return undefined;
+        }
+        const featureArray = Array.from(features).sort();
+        if (featureArray.length === 0)
+            return undefined;
+        return {
+            tags: featureArray,
+            names: Object.keys(featureNames).length > 0 ? featureNames : {}
+        };
+    }
+    static extractFeatureDataFromTable(view, tableOffset, nameTableOffset) {
+        const featureListOffset = view.getUint16(tableOffset + 6);
+        const featureListStart = tableOffset + featureListOffset;
+        const featureCount = view.getUint16(featureListStart);
+        const features = [];
+        const names = {};
+        for (let i = 0; i < featureCount; i++) {
+            const recordOffset = featureListStart + 2 + i * 6;
+            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
+            if (/^(ss\d{2}|cv\d{2})$/.test(tag) && nameTableOffset) {
+                const featureOffset = view.getUint16(recordOffset + 4);
+                const featureTableStart = featureListStart + featureOffset;
+                // Feature table structure:
+                // uint16 FeatureParams offset
+                // uint16 LookupCount
+                // uint16[LookupCount] LookupListIndex
+                const featureParamsOffset = view.getUint16(featureTableStart);
+                // FeatureParams for ss features:
+                // uint16 Version (should be 0)
+                // uint16 UINameID
+                if (featureParamsOffset !== 0) {
+                    const paramsStart = featureTableStart + featureParamsOffset;
+                    const version = view.getUint16(paramsStart);
+                    if (version === 0) {
+                        const nameID = view.getUint16(paramsStart + 2);
+                        const name = this.getNameFromNameTable(view, nameTableOffset, nameID);
+                        if (name) {
+                            names[tag] = name;
+                        }
+                    }
+                }
+            }
+        }
+        return { features, names };
+    }
+    static extractAxisNames(view, statOffset, nameOffset) {
+        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 = {};
+            // Read each design axis record (size specified by designAxisSize)
+            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.getNameFromNameTable(view, nameOffset, axisNameID);
+                if (name) {
+                    axisNames[axisTag] = name;
+                }
+            }
+            return Object.keys(axisNames).length > 0 ? axisNames : null;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    static getNameFromNameTable(view, nameOffset, nameID) {
+        try {
+            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 recordNameID = view.getUint16(recordOffset + 6);
+                const length = view.getUint16(recordOffset + 8);
+                const offset = view.getUint16(recordOffset + 10);
+                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;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    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/WOFF/WOFF2, 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 {
+                ascender: metrics.typoAscender,
+                descender: metrics.typoDescender,
+                lineGap: 0
+            };
+        }
+        if (metrics.hheaAscender !== null && metrics.hheaDescender !== null) {
+            return {
+                ascender: metrics.hheaAscender,
+                descender: metrics.hheaDescender,
+                lineGap: 0
+            };
+        }
+        if (metrics.winAscent !== null && metrics.winDescent !== null) {
+            return {
+                ascender: metrics.winAscent,
+                descender: -metrics.winDescent, // winDescent is typically positive
+                lineGap: 0
+            };
+        }
+        // Last resort - default based on UPM
+        return {
+            ascender: Math.round(metrics.unitsPerEm * 0.8),
+            descender: -Math.round(metrics.unitsPerEm * 0.2),
+            lineGap: 0
+        };
+    }
+    static getFontMetrics(metrics) {
+        const verticalMetrics = FontMetadataExtractor.getVerticalMetrics(metrics);
+        return {
+            ascender: verticalMetrics.ascender,
+            descender: verticalMetrics.descender,
+            lineGap: verticalMetrics.lineGap,
+            unitsPerEm: metrics.unitsPerEm,
+            naturalLineHeight: verticalMetrics.ascender - verticalMetrics.descender
+        };
+    }
+}
+
+let woff2Decoder = null;
+function setWoff2Decoder(decoder) {
+    woff2Decoder = decoder;
+}
+// Uses DecompressionStream to decompress WOFF (WOFF is just zlib compressed TTF/OTF so we can use deflate)
+class WoffConverter {
+    static detectFormat(buffer) {
+        if (buffer.byteLength < 4) {
+            return 'ttf/otf';
+        }
+        const view = new DataView(buffer);
+        const signature = view.getUint32(0);
+        if (signature === FONT_SIGNATURE_WOFF) {
+            return 'woff';
+        }
+        if (signature === FONT_SIGNATURE_WOFF2) {
+            return 'woff2';
+        }
+        return 'ttf/otf';
+    }
+    static async decompressWoff(woffBuffer) {
+        const view = new DataView(woffBuffer);
+        const data = new Uint8Array(woffBuffer);
+        // WOFF Header structure:
+        // Offset  Size  Description
+        // 0       4     signature (0x774F4646 'wOFF')
+        // 4       4     flavor (TTF = 0x00010000, CFF = 0x4F54544F)
+        // 8       4     length (total size)
+        // 12      2     numTables
+        // 14      2     reserved
+        // 16      4     totalSfntSize (size of uncompressed font)
+        // 20      2     majorVersion
+        // 22      2     minorVersion
+        // 24      4     metaOffset
+        // 28      4     metaLength
+        // 32      4     metaOrigLength
+        // 36      4     privOffset
+        // 40      4     privLength
+        const signature = view.getUint32(0);
+        if (signature !== FONT_SIGNATURE_WOFF) {
+            throw new Error('Not a valid WOFF font');
+        }
+        const flavor = view.getUint32(4);
+        const numTables = view.getUint16(12);
+        const totalSfntSize = view.getUint32(16);
+        // Check for DecompressionStream support
+        if (typeof DecompressionStream === 'undefined') {
+            throw new Error('WOFF fonts require DecompressionStream API (Chrome 80+, Firefox 113+, Safari 16.4+). ' +
+                'Please use TTF/OTF fonts or upgrade your browser.');
+        }
+        // Create the output buffer for the TTF/OTF font
+        const sfntData = new Uint8Array(totalSfntSize);
+        const sfntView = new DataView(sfntData.buffer);
+        // Write SFNT header. The flavor (0x00010000 for TrueType, 0x4F54544F for CFF)
+        // determines glyph winding order and will be detected by FontMetadataExtractor.
+        sfntView.setUint32(0, flavor);
+        sfntView.setUint16(4, numTables); // numTables
+        const searchRange = 2 ** Math.floor(Math.log2(numTables)) * 16;
+        sfntView.setUint16(6, searchRange);
+        sfntView.setUint16(8, Math.floor(Math.log2(numTables)));
+        sfntView.setUint16(10, numTables * 16 - searchRange);
+        let sfntOffset = 12 + numTables * 16; // Start of table data
+        const tableDirectory = [];
+        // Read WOFF table directory
+        for (let i = 0; i < numTables; i++) {
+            const tableOffset = 44 + i * 20;
+            tableDirectory.push({
+                tag: view.getUint32(tableOffset),
+                offset: view.getUint32(tableOffset + 4),
+                length: view.getUint32(tableOffset + 8), // compressed length
+                origLength: view.getUint32(tableOffset + 12),
+                checksum: view.getUint32(tableOffset + 16)
+            });
+        }
+        // Sort tables by tag (required for SFNT)
+        tableDirectory.sort((a, b) => a.tag - b.tag);
+        // 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;
+            sfntView.setUint32(dirOffset, table.tag);
+            sfntView.setUint32(dirOffset + 4, table.checksum);
+            sfntView.setUint32(dirOffset + 8, sfntOffset);
+            sfntView.setUint32(dirOffset + 12, table.origLength);
+            sfntData.set(decompressedTables[i], sfntOffset);
+            // Add padding to 4-byte boundary
+            sfntOffset += table.origLength;
+            const padding = (4 - (table.origLength % 4)) % 4;
+            sfntOffset += padding;
+        }
+        logger.log('WOFF font decompressed successfully');
+        return sfntData.buffer.slice(0, sfntOffset);
+    }
+    static async decompressWoff2(woff2Buffer) {
+        const view = new DataView(woff2Buffer);
+        const signature = view.getUint32(0);
+        if (signature !== FONT_SIGNATURE_WOFF2) {
+            throw new Error('Not a valid WOFF2 font');
+        }
+        if (!woff2Decoder) {
+            throw new Error('WOFF2 fonts require enabling the decoder. Add to your code:\n' +
+                "  import { woff2Decode } from 'woff-lib/woff2/decode';\n" +
+                '  Text.enableWoff2(woff2Decode);');
+        }
+        const decoded = await woff2Decoder(woff2Buffer);
+        logger.log('WOFF2 font decompressed successfully');
+        return decoded.buffer;
+    }
+    static async decompressZlib(compressedData) {
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(compressedData);
+                controller.close();
+            }
+        }).pipeThrough(new DecompressionStream('deflate'));
+        const response = new Response(stream);
+        return response.arrayBuffer();
+    }
+}
+
+class FontLoader {
+    constructor(getHarfBuzzInstance) {
+        this.getHarfBuzzInstance = getHarfBuzzInstance;
+    }
+    async loadFont(fontBuffer, fontVariations) {
+        perfLogger.start('FontLoader.loadFont', {
+            bufferSize: fontBuffer.byteLength
+        });
+        if (!fontBuffer || fontBuffer.byteLength < 12) {
+            throw new Error('Invalid font buffer: too small to be a valid font file');
+        }
+        // Check if this is a WOFF font and decompress if needed
+        const format = WoffConverter.detectFormat(fontBuffer);
+        if (format === 'woff') {
+            logger.log('WOFF font detected, decompressing...');
+            fontBuffer = await WoffConverter.decompressWoff(fontBuffer);
+        }
+        else if (format === 'woff2') {
+            logger.log('WOFF2 font detected, decompressing...');
+            fontBuffer = await WoffConverter.decompressWoff2(fontBuffer);
+        }
+        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/WOFF/WOFF2, got signature: 0x${sfntVersion.toString(16)}`);
+        }
+        const { hb, module } = await this.getHarfBuzzInstance();
+        try {
+            const fontBlob = hb.createBlob(new Uint8Array(fontBuffer));
+            const face = hb.createFace(fontBlob, 0);
+            const font = hb.createFont(face);
+            if (fontVariations) {
+                font.setVariations(fontVariations);
+            }
+            const axisInfos = face.getAxisInfos();
+            const isVariable = Object.keys(axisInfos).length > 0;
+            const { metrics, features: featureData } = FontMetadataExtractor.extractAll(fontBuffer);
+            // Merge axis names from STAT table with HarfBuzz axis info
+            let variationAxes = undefined;
+            if (isVariable && axisInfos) {
+                variationAxes = {};
+                for (const [tag, info] of Object.entries(axisInfos)) {
+                    variationAxes[tag] = {
+                        ...info,
+                        name: metrics.axisNames?.[tag] || null
+                    };
+                }
+            }
+            return {
+                hb,
+                fontBlob,
+                face,
+                font,
+                module,
+                upem: metrics.unitsPerEm,
+                metrics,
+                fontVariations,
+                isVariable,
+                variationAxes,
+                availableFeatures: featureData?.tags,
+                featureNames: featureData?.names,
+                _buffer: fontBuffer // For stable font ID generation
+            };
+        }
+        catch (error) {
+            logger.error('Failed to load font:', error);
+            throw error;
+        }
+        finally {
+            perfLogger.end('FontLoader.loadFont');
+        }
+    }
+    static destroyFont(loadedFont) {
+        try {
+            if (loadedFont.font && typeof loadedFont.font.destroy === 'function') {
+                loadedFont.font.destroy();
+            }
+            if (loadedFont.face && typeof loadedFont.face.destroy === 'function') {
+                loadedFont.face.destroy();
+            }
+            if (loadedFont.fontBlob &&
+                typeof loadedFont.fontBlob.destroy === 'function') {
+                loadedFont.fontBlob.destroy();
+            }
+        }
+        catch (error) {
+            logger.error('Error destroying font resources:', error);
+        }
+    }
+}
+
+const SAFE_LANGUAGE_RE = /^[a-z]{2,3}(?:-[a-z0-9]{2,16})*$/i;
+// Built-in patterns shipped with three-text (matches files in src/hyphenation/*)
+// Note: GPL-licensed patterns (cs, id, mk, sr-cyrl) are excluded for MIT compatibility
+const BUILTIN_PATTERN_LANGUAGES = new Set([
+    'af',
+    'as',
+    'be',
+    'bg',
+    'bn',
+    'ca',
+    'cy',
+    'da',
+    'de-1996',
+    'el-monoton',
+    'el-polyton',
+    'en-gb',
+    'en-us',
+    'eo',
+    'es',
+    'et',
+    'eu',
+    'fi',
+    'fr',
+    'fur',
+    'ga',
+    'gl',
+    'gu',
+    'hi',
+    'hr',
+    'hsb',
+    'hu',
+    'hy',
+    'ia',
+    'is',
+    'it',
+    'ka',
+    'kmr',
+    'kn',
+    'la',
+    'lt',
+    'lv',
+    'ml',
+    'mn-cyrl',
+    'mr',
+    'mul-ethi',
+    'nb',
+    'nl',
+    'nn',
+    'oc',
+    'or',
+    'pa',
+    'pl',
+    'pms',
+    'pt',
+    'rm',
+    'ro',
+    'ru',
+    'sa',
+    'sh-cyrl',
+    'sh-latn',
+    'sk',
+    'sl',
+    'sq',
+    'sv',
+    'ta',
+    'te',
+    'th',
+    'tk',
+    'tr',
+    'uk',
+    'zh-latn-pinyin'
+]);
+async function loadPattern(language, patternsPath) {
+    if (!SAFE_LANGUAGE_RE.test(language)) {
+        throw new Error(`Invalid hyphenation language code "${language}". Expected e.g. "en-us".`);
+    }
+    // When no patternsPath is provided, we only allow the built-in set shipped with
+    // three-text to avoid accidental arbitrary imports / path traversal
+    if (!patternsPath && !BUILTIN_PATTERN_LANGUAGES.has(language)) {
+        throw new Error(`Unsupported hyphenation language "${language}". ` +
+            `Use a built-in language (e.g. "en-us") or register patterns via Text.registerPattern("${language}", pattern).`);
+    }
+    if (__UMD__) {
+        const safeLangName = language.replace(/-/g, '_');
+        const globalName = `ThreeTextPatterns_${safeLangName}`;
+        // Check if pattern is already loaded as a global
+        if (window[globalName]) {
+            return window[globalName];
+        }
+        // Use provided path or default
+        const patternBasePath = patternsPath || '/patterns/';
+        // Dynamically load pattern via script tag
+        return new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = `${patternBasePath}${language}.umd.js`;
+            script.async = true;
+            script.onload = () => {
+                if (window[globalName]) {
+                    resolve(window[globalName]);
+                }
+                else {
+                    reject(new Error(`Pattern script loaded, but global ${globalName} not found.`));
+                }
+            };
+            script.onerror = () => {
+                reject(new Error(`Failed to load hyphenation pattern from ${script.src}. Did you copy the pattern files to your public directory?`));
+            };
+            document.head.appendChild(script);
+        });
+    }
+    else {
+        // In ESM build, use dynamic imports
+        try {
+            if (patternsPath) {
+                const module = await import(
+                /* @vite-ignore */ `${patternsPath}${language}.js`);
+                return module.default;
+            }
+            else if (typeof import.meta?.url === 'string') {
+                // Use import.meta.url to resolve relative to this module's location
+                const baseUrl = new URL('.', import.meta.url).href;
+                const patternUrl = new URL(`./patterns/${language}.js`, baseUrl).href;
+                const module = await import(/* @vite-ignore */ patternUrl);
+                return module.default;
+            }
+            else {
+                // Fallback for environments without import.meta.url
+                const module = await import(
+                /* @vite-ignore */ `./patterns/${language}.js`);
+                return module.default;
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to load hyphenation patterns for ${language}. Consider using static imports: import pattern from 'three-text/patterns/${language}'; Text.registerPattern('${language}', pattern);`);
+        }
+    }
+}
 
 // 2D Vector
 class Vec2 {
@@ -9,73 +2249,1476 @@ class Vec2 {
         this.x = x;
         this.y = y;
     }
-    set(x, y) {
-        this.x = x;
-        this.y = y;
-        return this;
+    set(x, y) {
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+    clone() {
+        return new Vec2(this.x, this.y);
+    }
+    copy(v) {
+        this.x = v.x;
+        this.y = v.y;
+        return this;
+    }
+    add(v) {
+        this.x += v.x;
+        this.y += v.y;
+        return this;
+    }
+    sub(v) {
+        this.x -= v.x;
+        this.y -= v.y;
+        return this;
+    }
+    multiply(scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+        return this;
+    }
+    divide(scalar) {
+        this.x /= scalar;
+        this.y /= scalar;
+        return this;
+    }
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    }
+    lengthSq() {
+        return this.x * this.x + this.y * this.y;
+    }
+    normalize() {
+        const len = this.length();
+        if (len > 0) {
+            this.divide(len);
+        }
+        return this;
+    }
+    dot(v) {
+        return this.x * v.x + this.y * v.y;
+    }
+    distanceTo(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    distanceToSquared(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        return dx * dx + dy * dy;
+    }
+    equals(v) {
+        return this.x === v.x && this.y === v.y;
+    }
+    angle() {
+        return Math.atan2(this.y, this.x);
+    }
+}
+// 3D Vector
+class Vec3 {
+    constructor(x = 0, y = 0, z = 0) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    set(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+    clone() {
+        return new Vec3(this.x, this.y, this.z);
+    }
+    copy(v) {
+        this.x = v.x;
+        this.y = v.y;
+        this.z = v.z;
+        return this;
+    }
+    add(v) {
+        this.x += v.x;
+        this.y += v.y;
+        this.z += v.z;
+        return this;
+    }
+    sub(v) {
+        this.x -= v.x;
+        this.y -= v.y;
+        this.z -= v.z;
+        return this;
+    }
+    multiply(scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+        this.z *= scalar;
+        return this;
+    }
+    divide(scalar) {
+        this.x /= scalar;
+        this.y /= scalar;
+        this.z /= scalar;
+        return this;
+    }
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+    }
+    lengthSq() {
+        return this.x * this.x + this.y * this.y + this.z * this.z;
+    }
+    normalize() {
+        const len = this.length();
+        if (len > 0) {
+            this.divide(len);
+        }
+        return this;
+    }
+    dot(v) {
+        return this.x * v.x + this.y * v.y + this.z * v.z;
+    }
+    cross(v) {
+        const x = this.y * v.z - this.z * v.y;
+        const y = this.z * v.x - this.x * v.z;
+        const z = this.x * v.y - this.y * v.x;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+    distanceTo(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        const dz = this.z - v.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+    distanceToSquared(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        const dz = this.z - v.z;
+        return dx * dx + dy * dy + dz * dz;
+    }
+    equals(v) {
+        return this.x === v.x && this.y === v.y && this.z === v.z;
+    }
+}
+
+class TextShaper {
+    constructor(loadedFont) {
+        this.cachedSpaceWidth = new Map();
+        this.loadedFont = loadedFont;
+    }
+    shapeLines(lineInfos, scaledLineHeight, letterSpacing, align, direction, color, originalText) {
+        perfLogger.start('TextShaper.shapeLines', {
+            lineCount: lineInfos.length
+        });
+        try {
+            const clustersByLine = [];
+            lineInfos.forEach((lineInfo, lineIndex) => {
+                const clusters = this.shapeLineIntoClusters(lineInfo, lineIndex, scaledLineHeight, letterSpacing, align, direction);
+                clustersByLine.push(clusters);
+            });
+            return clustersByLine;
+        }
+        finally {
+            perfLogger.end('TextShaper.shapeLines');
+        }
+    }
+    shapeLineIntoClusters(lineInfo, lineIndex, scaledLineHeight, letterSpacing, align, direction) {
+        const buffer = this.loadedFont.hb.createBuffer();
+        if (direction === 'rtl') {
+            buffer.setDirection('rtl');
+        }
+        buffer.addText(lineInfo.text);
+        buffer.guessSegmentProperties();
+        const featuresString = convertFontFeaturesToString(this.loadedFont.fontFeatures);
+        this.loadedFont.hb.shape(this.loadedFont.font, buffer, featuresString);
+        const glyphInfos = buffer.json(this.loadedFont.font);
+        buffer.destroy();
+        const clusters = [];
+        let currentClusterGlyphs = [];
+        let clusterTextChars = [];
+        let clusterStartX = 0;
+        let clusterStartY = 0;
+        let cursorX = lineInfo.xOffset;
+        let cursorY = -lineIndex * scaledLineHeight;
+        const cursorZ = 0;
+        // Apply letter spacing after each glyph to match width measurements used during line breaking
+        const letterSpacingFU = letterSpacing * this.loadedFont.upem;
+        const spaceAdjustment = this.calculateSpaceAdjustment(lineInfo, align, letterSpacing);
+        const cjkAdjustment = this.calculateCJKAdjustment(lineInfo, align);
+        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 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 &&
+                charIndex === lineTextLength - 1 &&
+                char === '-') {
+                glyph.absoluteTextIndex = lineInfo.originalEnd;
+            }
+            else {
+                glyph.absoluteTextIndex = lineInfo.originalStart + charIndex;
+            }
+            glyph.lineIndex = lineIndex;
+            // Cluster boundaries are based on whitespace only.
+            // Coloring is applied later via vertex colors and must never affect shaping/kerning.
+            if (isWhitespace) {
+                if (currentClusterGlyphs.length > 0) {
+                    clusters.push({
+                        text: clusterTextChars.join(''),
+                        glyphs: currentClusterGlyphs,
+                        position: new Vec3(clusterStartX, clusterStartY, cursorZ)
+                    });
+                    currentClusterGlyphs = [];
+                    clusterTextChars = [];
+                }
+            }
+            const absoluteGlyphX = cursorX + glyph.dx;
+            const absoluteGlyphY = cursorY + glyph.dy;
+            if (!isWhitespace) {
+                if (currentClusterGlyphs.length === 0) {
+                    clusterStartX = absoluteGlyphX;
+                    clusterStartY = absoluteGlyphY;
+                }
+                glyph.x = absoluteGlyphX - clusterStartX;
+                glyph.y = absoluteGlyphY - clusterStartY;
+                currentClusterGlyphs.push(glyph);
+                clusterTextChars.push(char);
+            }
+            cursorX += glyph.ax;
+            cursorY += glyph.ay;
+            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 < glyphCount - 1 && !isWhitespace) {
+                const nextGlyph = glyphInfos[i + 1];
+                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(char)) {
+                        shouldApply = false;
+                    }
+                    if (LineBreak.isCJPunctuation(char) &&
+                        LineBreak.isCJPunctuation(nextChar)) {
+                        shouldApply = false;
+                    }
+                    if (shouldApply) {
+                        cursorX += cjkAdjustment;
+                    }
+                }
+            }
+            else {
+                nextCharIsCJK = undefined;
+            }
+        }
+        if (currentClusterGlyphs.length > 0) {
+            clusters.push({
+                text: clusterTextChars.join(''),
+                glyphs: currentClusterGlyphs,
+                position: new Vec3(clusterStartX, clusterStartY, cursorZ)
+            });
+        }
+        return clusters;
+    }
+    calculateSpaceAdjustment(lineInfo, align, letterSpacing) {
+        let spaceAdjustment = 0;
+        if (lineInfo.adjustmentRatio !== undefined &&
+            align === 'justify' &&
+            !lineInfo.isLastLine) {
+            let naturalSpaceWidth = this.cachedSpaceWidth.get(letterSpacing);
+            if (naturalSpaceWidth === undefined) {
+                naturalSpaceWidth = TextMeasurer.measureTextWidth(this.loadedFont, ' ', letterSpacing);
+                this.cachedSpaceWidth.set(letterSpacing, naturalSpaceWidth);
+            }
+            const width = naturalSpaceWidth;
+            const stretchFactor = SPACE_STRETCH_RATIO;
+            const shrinkFactor = SPACE_SHRINK_RATIO;
+            if (lineInfo.adjustmentRatio > 0) {
+                spaceAdjustment = lineInfo.adjustmentRatio * width * stretchFactor;
+            }
+            else if (lineInfo.adjustmentRatio < 0) {
+                spaceAdjustment = lineInfo.adjustmentRatio * width * shrinkFactor;
+            }
+        }
+        return spaceAdjustment;
+    }
+    calculateCJKAdjustment(lineInfo, align) {
+        if (lineInfo.adjustmentRatio === undefined ||
+            align !== 'justify' ||
+            lineInfo.isLastLine) {
+            return 0;
+        }
+        const baseCharWidth = this.loadedFont.upem;
+        const glueStretch = baseCharWidth * 0.04;
+        const glueShrink = baseCharWidth * 0.04;
+        if (lineInfo.adjustmentRatio > 0) {
+            return lineInfo.adjustmentRatio * glueStretch;
+        }
+        else if (lineInfo.adjustmentRatio < 0) {
+            return lineInfo.adjustmentRatio * glueShrink;
+        }
+        return 0;
+    }
+}
+
+// Fetch with fs fallback for Electron file:// and Node.js environments
+async function loadBinary(filePath) {
+    try {
+        const res = await fetch(filePath);
+        if (!res.ok) {
+            throw new Error(`HTTP ${res.status}`);
+        }
+        return await res.arrayBuffer();
+    }
+    catch (fetchError) {
+        const req = globalThis.require;
+        if (typeof req !== 'function') {
+            throw new Error(`Failed to fetch ${filePath}: ${fetchError}`);
+        }
+        try {
+            const fs = req('fs');
+            const nodePath = req('path');
+            // file:// URLs need path resolution relative to the HTML document
+            let resolvedPath = filePath;
+            if (typeof window !== 'undefined' &&
+                window.location?.protocol === 'file:') {
+                const dir = nodePath.dirname(window.location.pathname);
+                resolvedPath = nodePath.join(dir, filePath);
+            }
+            const buffer = fs.readFileSync(resolvedPath);
+            if (buffer instanceof ArrayBuffer)
+                return buffer;
+            return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+        }
+        catch (fsError) {
+            throw new Error(`Failed to load ${filePath}: fetch failed (${fetchError}), fs.readFileSync failed (${fsError})`);
+        }
+    }
+}
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var hb = {exports: {}};
+
+(function (module, exports) {
+	var createHarfBuzz=(()=>{var _scriptName=typeof document!="undefined"?document.currentScript?.src:undefined;return async function(moduleArg={}){var moduleRtn;var Module=moduleArg;var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof WorkerGlobalScope!="undefined";var ENVIRONMENT_IS_NODE=typeof process=="object"&&process.versions?.node&&process.type!="renderer";var quit_=(status,toThrow)=>{throw toThrow};if(typeof __filename!="undefined"){_scriptName=__filename;}else if(ENVIRONMENT_IS_WORKER){_scriptName=self.location.href;}var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require$$0;scriptDirectory=__dirname+"/";readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(process.argv.length>1){process.argv[1].replace(/\\/g,"/");}process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow};}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href;}catch{}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)};}readAsync=async url=>{if(isFileURI(url)){return new Promise((resolve,reject)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){resolve(xhr.response);return}reject(xhr.status);};xhr.onerror=reject;xhr.send(null);})}var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)};}}else;console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var EXITSTATUS;var isFileURI=filename=>filename.startsWith("file://");var readyPromiseResolve,readyPromiseReject;var wasmMemory;var HEAPU8;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;Module["HEAP8"]=new Int8Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAP32"]=new Int32Array(b);Module["HEAPU32"]=new Uint32Array(b);Module["HEAPF32"]=new Float32Array(b);new BigInt64Array(b);new BigUint64Array(b);}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift());}}callRuntimeCallbacks(onPreRuns);}function initRuntime(){runtimeInitialized=true;wasmExports["__wasm_call_ctors"]();}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift());}}callRuntimeCallbacks(onPostRuns);}var runDependencies=0;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;Module["monitorRunDependencies"]?.(runDependencies);}function removeRunDependency(id){runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback();}}}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){return locateFile("hb.wasm")}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw "both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason);}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&!isFileURI(binaryFile)&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation");}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){return {env:wasmImports,wasi_snapshot_preview1:wasmImports}}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;Module["wasmExports"]=wasmExports;wasmMemory=wasmExports["memory"];Module["wasmMemory"]=wasmMemory;updateMemoryViews();wasmTable=wasmExports["__indirect_function_table"];assignWasmExports(wasmExports);removeRunDependency();return wasmExports}addRunDependency();function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(mod,inst)=>{resolve(receiveInstance(mod));});})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status;}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module);}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var noExitRuntime=true;var __abort_js=()=>abort("");var runtimeKeepaliveCounter=0;var __emscripten_runtime_keepalive_clear=()=>{noExitRuntime=false;runtimeKeepaliveCounter=0;};var timers={};var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e);};var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var _proc_exit=code=>{EXITSTATUS=code;if(!keepRuntimeAlive()){Module["onExit"]?.(code);ABORT=true;}quit_(code,new ExitStatus(code));};var exitJS=(status,implicit)=>{EXITSTATUS=status;_proc_exit(status);};var _exit=exitJS;var maybeExit=()=>{if(!keepRuntimeAlive()){try{_exit(EXITSTATUS);}catch(e){handleException(e);}}};var callUserCallback=func=>{if(ABORT){return}try{func();maybeExit();}catch(e){handleException(e);}};var _emscripten_get_now=()=>performance.now();var __setitimer_js=(which,timeout_ms)=>{if(timers[which]){clearTimeout(timers[which].id);delete timers[which];}if(!timeout_ms)return 0;var id=setTimeout(()=>{delete timers[which];callUserCallback(()=>__emscripten_timeout(which,_emscripten_get_now()));},timeout_ms);timers[which]={id,timeout_ms};return 0};var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var uleb128EncodeWithLen=arr=>{const n=arr.length;return [n%128|128,n>>7,...arr]};var wasmTypeCodes={i:127,p:127,j:126,f:125,d:124,e:111};var generateTypePack=types=>uleb128EncodeWithLen(Array.from(types,type=>{var code=wasmTypeCodes[type];return code}));var convertJsFunctionToWasm=(func,sig)=>{var bytes=Uint8Array.of(0,97,115,109,1,0,0,0,1,...uleb128EncodeWithLen([1,96,...generateTypePack(sig.slice(1)),...generateTypePack(sig[0]==="v"?"":sig[0])]),2,7,1,1,101,1,102,0,0,7,5,1,1,102,0,0);var module=new WebAssembly.Module(bytes);var instance=new WebAssembly.Instance(module,{e:{f:func}});var wrappedFunc=instance.exports["f"];return wrappedFunc};var wasmTable;var getWasmTableEntry=funcPtr=>wasmTable.get(funcPtr);var updateTableMap=(offset,count)=>{if(functionsInTableMap){for(var i=offset;i<offset+count;i++){var item=getWasmTableEntry(i);if(item){functionsInTableMap.set(item,i);}}}};var functionsInTableMap;var getFunctionAddress=func=>{if(!functionsInTableMap){functionsInTableMap=new WeakMap;updateTableMap(0,wasmTable.length);}return functionsInTableMap.get(func)||0};var freeTableIndexes=[];var getEmptyTableSlot=()=>{if(freeTableIndexes.length){return freeTableIndexes.pop()}return wasmTable["grow"](1)};var setWasmTableEntry=(idx,func)=>wasmTable.set(idx,func);var addFunction=(func,sig)=>{var rtn=getFunctionAddress(func);if(rtn){return rtn}var ret=getEmptyTableSlot();try{setWasmTableEntry(ret,func);}catch(err){if(!(err instanceof TypeError)){throw err}var wrapped=convertJsFunctionToWasm(func,sig);setWasmTableEntry(ret,wrapped);}functionsInTableMap.set(func,ret);return ret};var removeFunction=index=>{functionsInTableMap.delete(getWasmTableEntry(index));setWasmTableEntry(index,null);freeTableIndexes.push(index);};{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])Module["arguments"];if(Module["thisProgram"])Module["thisProgram"];}Module["wasmMemory"]=wasmMemory;Module["wasmExports"]=wasmExports;Module["addFunction"]=addFunction;Module["removeFunction"]=removeFunction;var __emscripten_timeout;function assignWasmExports(wasmExports){Module["_hb_blob_create"]=wasmExports["hb_blob_create"];Module["_hb_blob_destroy"]=wasmExports["hb_blob_destroy"];Module["_hb_blob_get_length"]=wasmExports["hb_blob_get_length"];Module["_hb_blob_get_data"]=wasmExports["hb_blob_get_data"];Module["_hb_buffer_serialize_glyphs"]=wasmExports["hb_buffer_serialize_glyphs"];Module["_hb_buffer_create"]=wasmExports["hb_buffer_create"];Module["_hb_buffer_destroy"]=wasmExports["hb_buffer_destroy"];Module["_hb_buffer_get_content_type"]=wasmExports["hb_buffer_get_content_type"];Module["_hb_buffer_set_direction"]=wasmExports["hb_buffer_set_direction"];Module["_hb_buffer_set_script"]=wasmExports["hb_buffer_set_script"];Module["_hb_buffer_set_language"]=wasmExports["hb_buffer_set_language"];Module["_hb_buffer_set_flags"]=wasmExports["hb_buffer_set_flags"];Module["_hb_buffer_set_cluster_level"]=wasmExports["hb_buffer_set_cluster_level"];Module["_hb_buffer_get_length"]=wasmExports["hb_buffer_get_length"];Module["_hb_buffer_get_glyph_infos"]=wasmExports["hb_buffer_get_glyph_infos"];Module["_hb_buffer_get_glyph_positions"]=wasmExports["hb_buffer_get_glyph_positions"];Module["_hb_glyph_info_get_glyph_flags"]=wasmExports["hb_glyph_info_get_glyph_flags"];Module["_hb_buffer_guess_segment_properties"]=wasmExports["hb_buffer_guess_segment_properties"];Module["_hb_buffer_add_utf8"]=wasmExports["hb_buffer_add_utf8"];Module["_hb_buffer_add_utf16"]=wasmExports["hb_buffer_add_utf16"];Module["_hb_buffer_set_message_func"]=wasmExports["hb_buffer_set_message_func"];Module["_hb_language_from_string"]=wasmExports["hb_language_from_string"];Module["_hb_script_from_string"]=wasmExports["hb_script_from_string"];Module["_hb_version"]=wasmExports["hb_version"];Module["_hb_version_string"]=wasmExports["hb_version_string"];Module["_hb_feature_from_string"]=wasmExports["hb_feature_from_string"];Module["_malloc"]=wasmExports["malloc"];Module["_free"]=wasmExports["free"];Module["_hb_draw_funcs_set_move_to_func"]=wasmExports["hb_draw_funcs_set_move_to_func"];Module["_hb_draw_funcs_set_line_to_func"]=wasmExports["hb_draw_funcs_set_line_to_func"];Module["_hb_draw_funcs_set_quadratic_to_func"]=wasmExports["hb_draw_funcs_set_quadratic_to_func"];Module["_hb_draw_funcs_set_cubic_to_func"]=wasmExports["hb_draw_funcs_set_cubic_to_func"];Module["_hb_draw_funcs_set_close_path_func"]=wasmExports["hb_draw_funcs_set_close_path_func"];Module["_hb_draw_funcs_create"]=wasmExports["hb_draw_funcs_create"];Module["_hb_draw_funcs_destroy"]=wasmExports["hb_draw_funcs_destroy"];Module["_hb_face_create"]=wasmExports["hb_face_create"];Module["_hb_face_destroy"]=wasmExports["hb_face_destroy"];Module["_hb_face_reference_table"]=wasmExports["hb_face_reference_table"];Module["_hb_face_get_upem"]=wasmExports["hb_face_get_upem"];Module["_hb_face_collect_unicodes"]=wasmExports["hb_face_collect_unicodes"];Module["_hb_font_draw_glyph"]=wasmExports["hb_font_draw_glyph"];Module["_hb_font_glyph_to_string"]=wasmExports["hb_font_glyph_to_string"];Module["_hb_font_create"]=wasmExports["hb_font_create"];Module["_hb_font_set_variations"]=wasmExports["hb_font_set_variations"];Module["_hb_font_destroy"]=wasmExports["hb_font_destroy"];Module["_hb_font_set_scale"]=wasmExports["hb_font_set_scale"];Module["_hb_set_create"]=wasmExports["hb_set_create"];Module["_hb_set_destroy"]=wasmExports["hb_set_destroy"];Module["_hb_ot_var_get_axis_infos"]=wasmExports["hb_ot_var_get_axis_infos"];Module["_hb_set_get_population"]=wasmExports["hb_set_get_population"];Module["_hb_set_next_many"]=wasmExports["hb_set_next_many"];Module["_hb_shape"]=wasmExports["hb_shape"];__emscripten_timeout=wasmExports["_emscripten_timeout"];}var wasmImports={_abort_js:__abort_js,_emscripten_runtime_keepalive_clear:__emscripten_runtime_keepalive_clear,_setitimer_js:__setitimer_js,emscripten_resize_heap:_emscripten_resize_heap,proc_exit:_proc_exit};var wasmExports=await createWasm();function run(){if(runDependencies>0){dependenciesFulfilled=run;return}preRun();if(runDependencies>0){dependenciesFulfilled=run;return}function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();postRun();}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun();},1);}else {doRun();}}function preInit(){if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()();}}}preInit();run();if(runtimeInitialized){moduleRtn=Module;}else {moduleRtn=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject;});}
+return moduleRtn}})();{module.exports=createHarfBuzz;module.exports.default=createHarfBuzz;} 
+} (hb));
+
+var hbExports = hb.exports;
+var createHarfBuzz = /*@__PURE__*/getDefaultExportFromCjs(hbExports);
+
+var hbjs$2 = {exports: {}};
+
+function hbjs(Module) {
+
+  var exports = Module.wasmExports;
+  var utf8Decoder = new TextDecoder("utf8");
+  let addFunction = Module.addFunction;
+  let removeFunction = Module.removeFunction;
+
+  var freeFuncPtr = addFunction(function (ptr) { exports.free(ptr); }, 'vi');
+
+  var HB_MEMORY_MODE_WRITABLE = 2;
+  var HB_SET_VALUE_INVALID = -1;
+  var HB_BUFFER_CONTENT_TYPE_GLYPHS = 2;
+  var DONT_STOP = 0;
+  var GSUB_PHASE = 1;
+  var GPOS_PHASE = 2;
+
+  function hb_tag(s) {
+    return (
+      (s.charCodeAt(0) & 0xFF) << 24 |
+      (s.charCodeAt(1) & 0xFF) << 16 |
+      (s.charCodeAt(2) & 0xFF) <<  8 |
+      (s.charCodeAt(3) & 0xFF) <<  0
+    );
+  }
+
+  var HB_BUFFER_SERIALIZE_FORMAT_JSON	= hb_tag('JSON');
+  var HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES	= 4;
+
+  function _hb_untag(tag) {
+    return [
+      String.fromCharCode((tag >> 24) & 0xFF),
+      String.fromCharCode((tag >> 16) & 0xFF),
+      String.fromCharCode((tag >>  8) & 0xFF),
+      String.fromCharCode((tag >>  0) & 0xFF)
+    ].join('');
+  }
+
+  function _buffer_flag(s) {
+    if (s == "BOT") { return 0x1; }
+    if (s == "EOT") { return 0x2; }
+    if (s == "PRESERVE_DEFAULT_IGNORABLES") { return 0x4; }
+    if (s == "REMOVE_DEFAULT_IGNORABLES") { return 0x8; }
+    if (s == "DO_NOT_INSERT_DOTTED_CIRCLE") { return 0x10; }
+    if (s == "PRODUCE_UNSAFE_TO_CONCAT") { return 0x40; }
+    return 0x0;
+  }
+
+  /**
+  * Create an object representing a Harfbuzz blob.
+  * @param {string} blob A blob of binary data (usually the contents of a font file).
+  **/
+  function createBlob(blob) {
+    var blobPtr = exports.malloc(blob.byteLength);
+    Module.HEAPU8.set(new Uint8Array(blob), blobPtr);
+    var ptr = exports.hb_blob_create(blobPtr, blob.byteLength, HB_MEMORY_MODE_WRITABLE, blobPtr, freeFuncPtr);
+    return {
+      ptr: ptr,
+      /**
+      * Free the object.
+      */
+      destroy: function () { exports.hb_blob_destroy(ptr); }
+    };
+  }
+
+  /**
+   * Return the typed array of HarfBuzz set contents.
+   * @param {number} setPtr Pointer of set
+   * @returns {Uint32Array} Typed array instance
+   */
+  function typedArrayFromSet(setPtr) {
+    const setCount = exports.hb_set_get_population(setPtr);
+    const arrayPtr = exports.malloc(setCount << 2);
+    const arrayOffset = arrayPtr >> 2;
+    const array = Module.HEAPU32.subarray(arrayOffset, arrayOffset + setCount);
+    Module.HEAPU32.set(array, arrayOffset);
+    exports.hb_set_next_many(setPtr, HB_SET_VALUE_INVALID, arrayPtr, setCount);
+    return array;
+  }
+
+  /**
+  * Create an object representing a Harfbuzz face.
+  * @param {object} blob An object returned from `createBlob`.
+  * @param {number} index The index of the font in the blob. (0 for most files,
+  *  or a 0-indexed font number if the `blob` came form a TTC/OTC file.)
+  **/
+  function createFace(blob, index) {
+    var ptr = exports.hb_face_create(blob.ptr, index);
+    const upem = exports.hb_face_get_upem(ptr);
+    return {
+      ptr: ptr,
+      upem,
+      /**
+       * Return the binary contents of an OpenType table.
+       * @param {string} table Table name
+       */
+      reference_table: function(table) {
+        var blob = exports.hb_face_reference_table(ptr, hb_tag(table));
+        var length = exports.hb_blob_get_length(blob);
+        if (!length) { return; }
+        var blobptr = exports.hb_blob_get_data(blob, null);
+        var table_string = Module.HEAPU8.subarray(blobptr, blobptr+length);
+        return table_string;
+      },
+      /**
+       * Return variation axis infos
+       */
+      getAxisInfos: function() {
+        var axis = exports.malloc(64 * 32);
+        var c = exports.malloc(4);
+        Module.HEAPU32[c / 4] = 64;
+        exports.hb_ot_var_get_axis_infos(ptr, 0, c, axis);
+        var result = {};
+        Array.from({ length: Module.HEAPU32[c / 4] }).forEach(function (_, i) {
+          result[_hb_untag(Module.HEAPU32[axis / 4 + i * 8 + 1])] = {
+            min: Module.HEAPF32[axis / 4 + i * 8 + 4],
+            default: Module.HEAPF32[axis / 4 + i * 8 + 5],
+            max: Module.HEAPF32[axis / 4 + i * 8 + 6]
+          };
+        });
+        exports.free(c);
+        exports.free(axis);
+        return result;
+      },
+      /**
+       * Return unicodes the face supports
+       */
+      collectUnicodes: function() {
+        var unicodeSetPtr = exports.hb_set_create();
+        exports.hb_face_collect_unicodes(ptr, unicodeSetPtr);
+        var result = typedArrayFromSet(unicodeSetPtr);
+        exports.hb_set_destroy(unicodeSetPtr);
+        return result;
+      },
+      /**
+       * Free the object.
+       */
+      destroy: function () {
+        exports.hb_face_destroy(ptr);
+      },
+    };
+  }
+
+  var pathBuffer = "";
+
+  var nameBufferSize = 256; // should be enough for most glyphs
+  var nameBuffer = exports.malloc(nameBufferSize); // permanently allocated
+
+  /**
+  * Create an object representing a Harfbuzz font.
+  * @param {object} blob An object returned from `createFace`.
+  **/
+  function createFont(face) {
+    var ptr = exports.hb_font_create(face.ptr);
+    var drawFuncsPtr = null;
+    var moveToPtr = null;
+    var lineToPtr = null;
+    var cubicToPtr = null;
+    var quadToPtr = null;
+    var closePathPtr = null;
+
+    /**
+    * Return a glyph as an SVG path string.
+    * @param {number} glyphId ID of the requested glyph in the font.
+    **/
+    function glyphToPath(glyphId) {
+      if (!drawFuncsPtr) {
+        var moveTo = function (dfuncs, draw_data, draw_state, to_x, to_y, user_data) {
+          pathBuffer += `M${to_x},${to_y}`;
+        };
+        var lineTo = function (dfuncs, draw_data, draw_state, to_x, to_y, user_data) {
+          pathBuffer += `L${to_x},${to_y}`;
+        };
+        var cubicTo = function (dfuncs, draw_data, draw_state, c1_x, c1_y, c2_x, c2_y, to_x, to_y, user_data) {
+          pathBuffer += `C${c1_x},${c1_y} ${c2_x},${c2_y} ${to_x},${to_y}`;
+        };
+        var quadTo = function (dfuncs, draw_data, draw_state, c_x, c_y, to_x, to_y, user_data) {
+          pathBuffer += `Q${c_x},${c_y} ${to_x},${to_y}`;
+        };
+        var closePath = function (dfuncs, draw_data, draw_state, user_data) {
+          pathBuffer += 'Z';
+        };
+
+        moveToPtr = addFunction(moveTo, 'viiiffi');
+        lineToPtr = addFunction(lineTo, 'viiiffi');
+        cubicToPtr = addFunction(cubicTo, 'viiiffffffi');
+        quadToPtr = addFunction(quadTo, 'viiiffffi');
+        closePathPtr = addFunction(closePath, 'viiii');
+        drawFuncsPtr = exports.hb_draw_funcs_create();
+        exports.hb_draw_funcs_set_move_to_func(drawFuncsPtr, moveToPtr, 0, 0);
+        exports.hb_draw_funcs_set_line_to_func(drawFuncsPtr, lineToPtr, 0, 0);
+        exports.hb_draw_funcs_set_cubic_to_func(drawFuncsPtr, cubicToPtr, 0, 0);
+        exports.hb_draw_funcs_set_quadratic_to_func(drawFuncsPtr, quadToPtr, 0, 0);
+        exports.hb_draw_funcs_set_close_path_func(drawFuncsPtr, closePathPtr, 0, 0);
+      }
+
+      pathBuffer = "";
+      exports.hb_font_draw_glyph(ptr, glyphId, drawFuncsPtr, 0);
+      return pathBuffer;
+    }
+
+    /**
+     * Return glyph name.
+     * @param {number} glyphId ID of the requested glyph in the font.
+     **/
+    function glyphName(glyphId) {
+      exports.hb_font_glyph_to_string(
+        ptr,
+        glyphId,
+        nameBuffer,
+        nameBufferSize
+      );
+      var array = Module.HEAPU8.subarray(nameBuffer, nameBuffer + nameBufferSize);
+      return utf8Decoder.decode(array.slice(0, array.indexOf(0)));
+    }
+
+    return {
+      ptr: ptr,
+      glyphName: glyphName,
+      glyphToPath: glyphToPath,
+      /**
+      * Return a glyph as a JSON path string
+      * based on format described on https://svgwg.org/specs/paths/#InterfaceSVGPathSegment
+      * @param {number} glyphId ID of the requested glyph in the font.
+      **/
+      glyphToJson: function (glyphId) {
+        var path = glyphToPath(glyphId);
+        return path.replace(/([MLQCZ])/g, '|$1 ').split('|').filter(function (x) { return x.length; }).map(function (x) {
+          var row = x.split(/[ ,]/g);
+          return { type: row[0], values: row.slice(1).filter(function (x) { return x.length; }).map(function (x) { return +x; }) };
+        });
+      },
+      /**
+      * Set the font's scale factor, affecting the position values returned from
+      * shaping.
+      * @param {number} xScale Units to scale in the X dimension.
+      * @param {number} yScale Units to scale in the Y dimension.
+      **/
+      setScale: function (xScale, yScale) {
+        exports.hb_font_set_scale(ptr, xScale, yScale);
+      },
+      /**
+       * Set the font's variations.
+       * @param {object} variations Dictionary of variations to set
+       **/
+      setVariations: function (variations) {
+        var entries = Object.entries(variations);
+        var vars = exports.malloc(8 * entries.length);
+        entries.forEach(function (entry, i) {
+          Module.HEAPU32[vars / 4 + i * 2 + 0] = hb_tag(entry[0]);
+          Module.HEAPF32[vars / 4 + i * 2 + 1] = entry[1];
+        });
+        exports.hb_font_set_variations(ptr, vars, entries.length);
+        exports.free(vars);
+      },
+      /**
+      * Free the object.
+      */
+      destroy: function () {
+        exports.hb_font_destroy(ptr);
+        if (drawFuncsPtr) {
+          exports.hb_draw_funcs_destroy(drawFuncsPtr);
+          drawFuncsPtr = null;
+          removeFunction(moveToPtr);
+          removeFunction(lineToPtr);
+          removeFunction(cubicToPtr);
+          removeFunction(quadToPtr);
+          removeFunction(closePathPtr);
+        }
+      }
+    };
+  }
+
+  /**
+  * Use when you know the input range should be ASCII.
+  * Faster than encoding to UTF-8
+  **/
+  function createAsciiString(text) {
+    var ptr = exports.malloc(text.length + 1);
+    for (let i = 0; i < text.length; ++i) {
+      const char = text.charCodeAt(i);
+      if (char > 127) throw new Error('Expected ASCII text');
+      Module.HEAPU8[ptr + i] = char;
+    }
+    Module.HEAPU8[ptr + text.length] = 0;
+    return {
+      ptr: ptr,
+      length: text.length,
+      free: function () { exports.free(ptr); }
+    };
+  }
+
+  function createJsString(text) {
+    const ptr = exports.malloc(text.length * 2);
+    const words = new Uint16Array(Module.wasmMemory.buffer, ptr, text.length);
+    for (let i = 0; i < words.length; ++i) words[i] = text.charCodeAt(i);
+    return {
+      ptr: ptr,
+      length: words.length,
+      free: function () { exports.free(ptr); }
+    };
+  }
+
+  /**
+  * Create an object representing a Harfbuzz buffer.
+  **/
+  function createBuffer() {
+    var ptr = exports.hb_buffer_create();
+    return {
+      ptr: ptr,
+      /**
+      * Add text to the buffer.
+      * @param {string} text Text to be added to the buffer.
+      **/
+      addText: function (text) {
+        const str = createJsString(text);
+        exports.hb_buffer_add_utf16(ptr, str.ptr, str.length, 0, str.length);
+        str.free();
+      },
+      /**
+      * Set buffer script, language and direction.
+      *
+      * This needs to be done before shaping.
+      **/
+      guessSegmentProperties: function () {
+        return exports.hb_buffer_guess_segment_properties(ptr);
+      },
+      /**
+      * Set buffer direction explicitly.
+      * @param {string} direction: One of "ltr", "rtl", "ttb" or "btt"
+      */
+      setDirection: function (dir) {
+        exports.hb_buffer_set_direction(ptr, {
+          ltr: 4,
+          rtl: 5,
+          ttb: 6,
+          btt: 7
+        }[dir] || 0);
+      },
+      /**
+      * Set buffer flags explicitly.
+      * @param {string[]} flags: A list of strings which may be either:
+      * "BOT"
+      * "EOT"
+      * "PRESERVE_DEFAULT_IGNORABLES"
+      * "REMOVE_DEFAULT_IGNORABLES"
+      * "DO_NOT_INSERT_DOTTED_CIRCLE"
+      * "PRODUCE_UNSAFE_TO_CONCAT"
+      */
+      setFlags: function (flags) {
+        var flagValue = 0;
+        flags.forEach(function (s) {
+          flagValue |= _buffer_flag(s);
+        });
+
+        exports.hb_buffer_set_flags(ptr,flagValue);
+      },
+      /**
+      * Set buffer language explicitly.
+      * @param {string} language: The buffer language
+      */
+      setLanguage: function (language) {
+        var str = createAsciiString(language);
+        exports.hb_buffer_set_language(ptr, exports.hb_language_from_string(str.ptr,-1));
+        str.free();
+      },
+      /**
+      * Set buffer script explicitly.
+      * @param {string} script: The buffer script
+      */
+      setScript: function (script) {
+        var str = createAsciiString(script);
+        exports.hb_buffer_set_script(ptr, exports.hb_script_from_string(str.ptr,-1));
+        str.free();
+      },
+
+      /**
+      * Set the Harfbuzz clustering level.
+      *
+      * Affects the cluster values returned from shaping.
+      * @param {number} level: Clustering level. See the Harfbuzz manual chapter
+      * on Clusters.
+      **/
+      setClusterLevel: function (level) {
+        exports.hb_buffer_set_cluster_level(ptr, level);
+      },
+      /**
+      * Return the buffer contents as a JSON object.
+      *
+      * After shaping, this function will return an array of glyph information
+      * objects. Each object will have the following attributes:
+      *
+      *   - g: The glyph ID
+      *   - cl: The cluster ID
+      *   - ax: Advance width (width to advance after this glyph is painted)
+      *   - ay: Advance height (height to advance after this glyph is painted)
+      *   - dx: X displacement (adjustment in X dimension when painting this glyph)
+      *   - dy: Y displacement (adjustment in Y dimension when painting this glyph)
+      *   - flags: Glyph flags like `HB_GLYPH_FLAG_UNSAFE_TO_BREAK` (0x1)
+      **/
+      json: function () {
+        var length = exports.hb_buffer_get_length(ptr);
+        var result = [];
+        var infosPtr = exports.hb_buffer_get_glyph_infos(ptr, 0);
+        var infosPtr32 = infosPtr / 4;
+        var positionsPtr32 = exports.hb_buffer_get_glyph_positions(ptr, 0) / 4;
+        var infos = Module.HEAPU32.subarray(infosPtr32, infosPtr32 + 5 * length);
+        var positions = Module.HEAP32.subarray(positionsPtr32, positionsPtr32 + 5 * length);
+        for (var i = 0; i < length; ++i) {
+          result.push({
+            g: infos[i * 5 + 0],
+            cl: infos[i * 5 + 2],
+            ax: positions[i * 5 + 0],
+            ay: positions[i * 5 + 1],
+            dx: positions[i * 5 + 2],
+            dy: positions[i * 5 + 3],
+            flags: exports.hb_glyph_info_get_glyph_flags(infosPtr + i * 20)
+          });
+        }
+        return result;
+      },
+      /**
+      * Free the object.
+      */
+      destroy: function () { exports.hb_buffer_destroy(ptr); }
+    };
+  }
+
+  /**
+  * Shape a buffer with a given font.
+  *
+  * This returns nothing, but modifies the buffer.
+  *
+  * @param {object} font: A font returned from `createFont`
+  * @param {object} buffer: A buffer returned from `createBuffer` and suitably
+  *   prepared.
+  * @param {object} features: A string of comma-separated OpenType features to apply.
+  */
+  function shape(font, buffer, features) {
+    var featuresPtr = 0;
+    var featuresLen = 0;
+    if (features) {
+      features = features.split(",");
+      featuresPtr = exports.malloc(16 * features.length);
+      features.forEach(function (feature, i) {
+        var str = createAsciiString(feature);
+        if (exports.hb_feature_from_string(str.ptr, -1, featuresPtr + featuresLen * 16))
+          featuresLen++;
+        str.free();
+      });
+    }
+
+    exports.hb_shape(font.ptr, buffer.ptr, featuresPtr, featuresLen);
+    if (featuresPtr)
+      exports.free(featuresPtr);
+  }
+
+  /**
+  * Shape a buffer with a given font, returning a JSON trace of the shaping process.
+  *
+  * This function supports "partial shaping", where the shaping process is
+  * terminated after a given lookup ID is reached. If the user requests the function
+  * to terminate shaping after an ID in the GSUB phase, GPOS table lookups will be
+  * processed as normal.
+  *
+  * @param {object} font: A font returned from `createFont`
+  * @param {object} buffer: A buffer returned from `createBuffer` and suitably
+  *   prepared.
+  * @param {object} features: A string of comma-separated OpenType features to apply.
+  * @param {number} stop_at: A lookup ID at which to terminate shaping.
+  * @param {number} stop_phase: Either 0 (don't terminate shaping), 1 (`stop_at`
+      refers to a lookup ID in the GSUB table), 2 (`stop_at` refers to a lookup
+      ID in the GPOS table).
+  */
+  function shapeWithTrace(font, buffer, features, stop_at, stop_phase) {
+    var trace = [];
+    var currentPhase = DONT_STOP;
+    var stopping = false;
+
+    var traceBufLen = 1024 * 1024;
+    var traceBufPtr = exports.malloc(traceBufLen);
+
+    var traceFunc = function (bufferPtr, fontPtr, messagePtr, user_data) {
+      var message = utf8Decoder.decode(Module.HEAPU8.subarray(messagePtr, Module.HEAPU8.indexOf(0, messagePtr)));
+      if (message.startsWith("start table GSUB"))
+        currentPhase = GSUB_PHASE;
+      else if (message.startsWith("start table GPOS"))
+        currentPhase = GPOS_PHASE;
+
+      if (currentPhase != stop_phase)
+        stopping = false;
+
+      if (stop_phase != DONT_STOP && currentPhase == stop_phase && message.startsWith("end lookup " + stop_at))
+        stopping = true;
+
+      if (stopping)
+        return 0;
+
+      exports.hb_buffer_serialize_glyphs(
+        bufferPtr,
+        0, exports.hb_buffer_get_length(bufferPtr),
+        traceBufPtr, traceBufLen, 0,
+        fontPtr,
+        HB_BUFFER_SERIALIZE_FORMAT_JSON,
+        HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES);
+
+      trace.push({
+        m: message,
+        t: JSON.parse(utf8Decoder.decode(Module.HEAPU8.subarray(traceBufPtr, Module.HEAPU8.indexOf(0, traceBufPtr)))),
+        glyphs: exports.hb_buffer_get_content_type(bufferPtr) == HB_BUFFER_CONTENT_TYPE_GLYPHS,
+      });
+
+      return 1;
+    };
+
+    var traceFuncPtr = addFunction(traceFunc, 'iiiii');
+    exports.hb_buffer_set_message_func(buffer.ptr, traceFuncPtr, 0, 0);
+    shape(font, buffer, features);
+    exports.free(traceBufPtr);
+    removeFunction(traceFuncPtr);
+
+    return trace;
+  }
+
+  function version() {
+    var versionPtr = exports.malloc(12);
+    exports.hb_version(versionPtr, versionPtr + 4, versionPtr + 8);
+    var version = {
+      major: Module.HEAPU32[versionPtr / 4],
+      minor: Module.HEAPU32[(versionPtr + 4) / 4],
+      micro: Module.HEAPU32[(versionPtr + 8) / 4],
+    };
+    exports.free(versionPtr);
+    return version;
+  }
+
+  function version_string() {
+    var versionPtr = exports.hb_version_string();
+    var version = utf8Decoder.decode(Module.HEAPU8.subarray(versionPtr, Module.HEAPU8.indexOf(0, versionPtr)));
+    return version;
+  }
+
+  return {
+    createBlob: createBlob,
+    createFace: createFace,
+    createFont: createFont,
+    createBuffer: createBuffer,
+    shape: shape,
+    shapeWithTrace: shapeWithTrace,
+    version: version,
+    version_string: version_string,
+  };
+}
+
+// Should be replaced with something more reliable
+try {
+  hbjs$2.exports = hbjs;
+} catch (e) {}
+
+var hbjsExports = hbjs$2.exports;
+var hbjs$1 = /*@__PURE__*/getDefaultExportFromCjs(hbjsExports);
+
+let harfbuzzPromise = null;
+let wasmPath = null;
+let wasmBuffer = null;
+const HarfBuzzLoader = {
+    setWasmPath(path) {
+        wasmPath = path;
+        wasmBuffer = null; // Clear buffer if path is set
+        harfbuzzPromise = null;
+    },
+    setWasmBuffer(buffer) {
+        wasmBuffer = buffer;
+        wasmPath = null; // Clear path if buffer is set
+        harfbuzzPromise = null;
+    },
+    async getHarfBuzz() {
+        if (harfbuzzPromise) {
+            return harfbuzzPromise;
+        }
+        harfbuzzPromise = new Promise(async (resolve, reject) => {
+            try {
+                const moduleConfig = {};
+                if (wasmBuffer) {
+                    moduleConfig.wasmBinary = wasmBuffer;
+                }
+                else if (wasmPath) {
+                    moduleConfig.wasmBinary = await loadBinary(wasmPath);
+                }
+                else {
+                    throw new Error('HarfBuzz WASM path or buffer must be set before initialization.');
+                }
+                const hbModule = await createHarfBuzz(moduleConfig);
+                const hb = hbjs$1(hbModule);
+                const module = {
+                    addFunction: hbModule.addFunction,
+                    exports: hbModule.wasmExports,
+                    removeFunction: hbModule.removeFunction
+                };
+                resolve({ hb, module });
+            }
+            catch (error) {
+                reject(new Error(`Failed to initialize HarfBuzz: ${error}`));
+            }
+        });
+        return harfbuzzPromise;
+    }
+};
+
+const DEFAULT_MAX_TEXT_LENGTH = 100000;
+const DEFAULT_FONT_SIZE = 72;
+let Text$1 = class Text {
+    static { this.patternCache = new Map(); }
+    static { this.hbInitPromise = null; }
+    static { this.fontCache = new Map(); }
+    static { this.fontLoadPromises = new Map(); }
+    static { this.fontRefCounts = new Map(); }
+    static { this.fontCacheMemoryBytes = 0; }
+    static { this.maxFontCacheMemoryBytes = Infinity; }
+    static { this.fontIdCounter = 0; }
+    static enableWoff2(decoder) {
+        setWoff2Decoder(decoder);
+    }
+    static stableStringify(obj) {
+        const keys = Object.keys(obj).sort();
+        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 = '';
+        if (!Text.hbInitPromise) {
+            Text.hbInitPromise = HarfBuzzLoader.getHarfBuzz();
+        }
+        this.fontLoader = new FontLoader(() => Text.hbInitPromise);
+    }
+    static setHarfBuzzPath(path) {
+        HarfBuzzLoader.setWasmPath(path);
+        Text.hbInitPromise = null;
+    }
+    static setHarfBuzzBuffer(wasmBuffer) {
+        HarfBuzzLoader.setWasmBuffer(wasmBuffer);
+        Text.hbInitPromise = null;
+    }
+    static init() {
+        if (!Text.hbInitPromise) {
+            Text.hbInitPromise = HarfBuzzLoader.getHarfBuzz();
+        }
+        return Text.hbInitPromise;
+    }
+    static async create(options) {
+        if (!options.font) {
+            throw new Error('Font is required. Specify options.font as a URL string or ArrayBuffer.');
+        }
+        if (!Text.hbInitPromise) {
+            Text.hbInitPromise = HarfBuzzLoader.getHarfBuzz();
+        }
+        const { loadedFont, fontKey } = await Text.resolveFont(options);
+        const text = new Text();
+        text.setLoadedFont(loadedFont, fontKey);
+        const result = await text.createLayout(options);
+        const update = async (newOptions) => {
+            const mergedOptions = { ...options };
+            for (const key in newOptions) {
+                const value = newOptions[key];
+                if (value !== undefined) {
+                    mergedOptions[key] = value;
+                }
+            }
+            if (newOptions.font !== undefined ||
+                newOptions.fontVariations !== undefined ||
+                newOptions.fontFeatures !== undefined) {
+                const { loadedFont: newLoadedFont, fontKey: newFontKey } = await Text.resolveFont(mergedOptions);
+                text.setLoadedFont(newLoadedFont, newFontKey);
+                text.resetHelpers();
+            }
+            options = mergedOptions;
+            const newResult = await text.createLayout(options);
+            return {
+                ...newResult,
+                getLoadedFont: () => text.getLoadedFont(),
+                measureTextWidth: (textString, letterSpacing) => text.measureTextWidth(textString, letterSpacing),
+                update,
+                dispose: () => text.destroy()
+            };
+        };
+        return {
+            ...result,
+            getLoadedFont: () => text.getLoadedFont(),
+            measureTextWidth: (textString, letterSpacing) => text.measureTextWidth(textString, letterSpacing),
+            update,
+            dispose: () => text.destroy()
+        };
+    }
+    static retainFont(fontKey) {
+        Text.fontRefCounts.set(fontKey, (Text.fontRefCounts.get(fontKey) ?? 0) + 1);
+    }
+    static releaseFont(fontKey, loadedFont) {
+        const nextCount = (Text.fontRefCounts.get(fontKey) ?? 0) - 1;
+        if (nextCount > 0) {
+            Text.fontRefCounts.set(fontKey, nextCount);
+            return;
+        }
+        Text.fontRefCounts.delete(fontKey);
+        // Cached fonts stay alive while present in the cache. If a font has been
+        // evicted, destroy it once the last live handle releases it.
+        if (!Text.fontCache.has(fontKey)) {
+            FontLoader.destroyFont(loadedFont);
+        }
+    }
+    static async resolveFont(options) {
+        const baseFontKey = typeof options.font === 'string'
+            ? options.font
+            : `buffer-${Text.generateFontContentHash(options.font)}`;
+        let fontKey = baseFontKey;
+        if (options.fontVariations) {
+            fontKey += `_var_${Text.stableStringify(options.fontVariations)}`;
+        }
+        if (options.fontFeatures) {
+            fontKey += `_feat_${Text.stableStringify(options.fontFeatures)}`;
+        }
+        let loadedFont = Text.fontCache.get(fontKey);
+        if (!loadedFont) {
+            let loadPromise = Text.fontLoadPromises.get(fontKey);
+            if (!loadPromise) {
+                loadPromise = Text.loadAndCacheFont(fontKey, options.font, options.fontVariations, options.fontFeatures).finally(() => {
+                    Text.fontLoadPromises.delete(fontKey);
+                });
+                Text.fontLoadPromises.set(fontKey, loadPromise);
+            }
+            loadedFont = await loadPromise;
+        }
+        Text.retainFont(fontKey);
+        return { loadedFont, fontKey };
+    }
+    static async loadAndCacheFont(fontKey, font, fontVariations, fontFeatures) {
+        const tempText = new Text();
+        await tempText.loadFont(font, fontVariations, fontFeatures);
+        const loadedFont = tempText.getLoadedFont();
+        Text.fontCache.set(fontKey, loadedFont);
+        Text.trackFontCacheAdd(loadedFont);
+        Text.enforceFontCacheMemoryLimit();
+        return loadedFont;
+    }
+    static trackFontCacheAdd(loadedFont) {
+        const size = loadedFont._buffer?.byteLength ?? 0;
+        Text.fontCacheMemoryBytes += size;
+    }
+    static trackFontCacheRemove(fontKey) {
+        const font = Text.fontCache.get(fontKey);
+        if (!font)
+            return;
+        const size = font._buffer?.byteLength ?? 0;
+        Text.fontCacheMemoryBytes -= size;
+        if (Text.fontCacheMemoryBytes < 0)
+            Text.fontCacheMemoryBytes = 0;
+    }
+    static enforceFontCacheMemoryLimit() {
+        if (Text.maxFontCacheMemoryBytes === Infinity)
+            return;
+        while (Text.fontCacheMemoryBytes > Text.maxFontCacheMemoryBytes &&
+            Text.fontCache.size > 0) {
+            const firstKey = Text.fontCache.keys().next().value;
+            if (firstKey === undefined)
+                break;
+            const font = Text.fontCache.get(firstKey);
+            Text.trackFontCacheRemove(firstKey);
+            Text.fontCache.delete(firstKey);
+            if ((Text.fontRefCounts.get(firstKey) ?? 0) <= 0 && font) {
+                FontLoader.destroyFont(font);
+            }
+        }
     }
-    clone() {
-        return new Vec2(this.x, this.y);
+    static generateFontContentHash(buffer) {
+        if (buffer) {
+            const view = new Uint8Array(buffer);
+            let hash = 2166136261;
+            const samplePoints = Math.min(32, view.length);
+            const step = Math.floor(view.length / samplePoints);
+            for (let i = 0; i < samplePoints; i++) {
+                const index = i * step;
+                hash ^= view[index];
+                hash = Math.imul(hash, 16777619);
+            }
+            hash ^= view.length;
+            hash = Math.imul(hash, 16777619);
+            return (hash >>> 0).toString(36);
+        }
+        else {
+            return `c${++Text.fontIdCounter}`;
+        }
     }
-    copy(v) {
-        this.x = v.x;
-        this.y = v.y;
-        return this;
+    setLoadedFont(loadedFont, fontKey) {
+        if (this.loadedFont && this.loadedFont !== loadedFont) {
+            this.releaseCurrentFont();
+        }
+        this.loadedFont = loadedFont;
+        this.currentFontCacheKey = fontKey;
+        const contentHash = Text.generateFontContentHash(loadedFont._buffer);
+        this.currentFontId = `font_${contentHash}`;
+        if (loadedFont.fontVariations) {
+            this.currentFontId += `_var_${Text.stableStringify(loadedFont.fontVariations)}`;
+        }
+        if (loadedFont.fontFeatures) {
+            this.currentFontId += `_feat_${Text.stableStringify(loadedFont.fontFeatures)}`;
+        }
     }
-    add(v) {
-        this.x += v.x;
-        this.y += v.y;
-        return this;
+    releaseCurrentFont() {
+        if (!this.loadedFont)
+            return;
+        const currentFont = this.loadedFont;
+        const currentFontKey = this.currentFontCacheKey;
+        try {
+            if (currentFontKey) {
+                Text.releaseFont(currentFontKey, currentFont);
+            }
+            else {
+                FontLoader.destroyFont(currentFont);
+            }
+        }
+        catch (error) {
+            logger.warn('Error destroying HarfBuzz objects:', error);
+        }
+        finally {
+            this.loadedFont = undefined;
+            this.currentFontCacheKey = undefined;
+            this.textLayout = undefined;
+            this.textShaper = undefined;
+        }
     }
-    sub(v) {
-        this.x -= v.x;
-        this.y -= v.y;
-        return this;
+    async loadFont(fontSrc, fontVariations, fontFeatures) {
+        perfLogger.start('Text.loadFont', {
+            fontSrc: typeof fontSrc === 'string' ? fontSrc : `buffer(${fontSrc.byteLength})`
+        });
+        if (!Text.hbInitPromise) {
+            Text.hbInitPromise = HarfBuzzLoader.getHarfBuzz();
+        }
+        await Text.hbInitPromise;
+        const fontBuffer = typeof fontSrc === 'string' ? await loadBinary(fontSrc) : fontSrc;
+        try {
+            if (this.loadedFont) {
+                this.destroy();
+            }
+            this.loadedFont = await this.fontLoader.loadFont(fontBuffer, fontVariations);
+            if (fontFeatures) {
+                this.loadedFont.fontFeatures = fontFeatures;
+            }
+            const contentHash = Text.generateFontContentHash(fontBuffer);
+            this.currentFontId = `font_${contentHash}`;
+            if (fontVariations) {
+                this.currentFontId += `_var_${Text.stableStringify(fontVariations)}`;
+            }
+            if (fontFeatures) {
+                this.currentFontId += `_feat_${Text.stableStringify(fontFeatures)}`;
+            }
+        }
+        catch (error) {
+            logger.error('Failed to load font:', error);
+            throw error;
+        }
+        finally {
+            perfLogger.end('Text.loadFont');
+        }
     }
-    multiply(scalar) {
-        this.x *= scalar;
-        this.y *= scalar;
-        return this;
+    async createLayout(options) {
+        perfLogger.start('Text.createLayout', {
+            textLength: options.text.length,
+            size: options.size || DEFAULT_FONT_SIZE,
+            hasLayout: !!options.layout
+        });
+        try {
+            if (!this.loadedFont) {
+                throw new Error('Font not loaded. Use Text.create() with a font option.');
+            }
+            const updatedOptions = await this.prepareHyphenation(options);
+            this.validateOptions(updatedOptions);
+            options = updatedOptions;
+            this.updateFontVariations(options);
+            this.loadedFont.font.setScale(this.loadedFont.upem, this.loadedFont.upem);
+            if (!this.textShaper) {
+                this.textShaper = new TextShaper(this.loadedFont);
+            }
+            const layoutData = this.prepareLayout(options);
+            const clustersByLine = this.textShaper.shapeLines(layoutData.lines, layoutData.scaledLineHeight, layoutData.letterSpacing, layoutData.align, layoutData.direction, options.color, options.text);
+            return {
+                clustersByLine,
+                layoutData,
+                options,
+                loadedFont: this.loadedFont,
+                fontId: this.currentFontId
+            };
+        }
+        finally {
+            perfLogger.end('Text.createLayout');
+        }
     }
-    divide(scalar) {
-        this.x /= scalar;
-        this.y /= scalar;
-        return this;
+    async prepareHyphenation(options) {
+        if (options.layout?.hyphenate !== false && options.layout?.width) {
+            const language = options.layout?.language || 'en-us';
+            if (!options.layout?.hyphenationPatterns?.[language]) {
+                try {
+                    if (!Text.patternCache.has(language)) {
+                        const pattern = await loadPattern(language, options.layout?.patternsPath);
+                        Text.patternCache.set(language, pattern);
+                    }
+                    return {
+                        ...options,
+                        layout: {
+                            ...options.layout,
+                            hyphenationPatterns: {
+                                ...options.layout?.hyphenationPatterns,
+                                [language]: Text.patternCache.get(language)
+                            }
+                        }
+                    };
+                }
+                catch (error) {
+                    logger.warn(`Failed to load patterns for ${language}: ${error}`);
+                    return {
+                        ...options,
+                        layout: {
+                            ...options.layout,
+                            hyphenate: false
+                        }
+                    };
+                }
+            }
+        }
+        return options;
     }
-    length() {
-        return Math.sqrt(this.x * this.x + this.y * this.y);
+    validateOptions(options) {
+        if (!options.text) {
+            throw new Error('Text content is required');
+        }
+        const maxLength = options.maxTextLength ?? DEFAULT_MAX_TEXT_LENGTH;
+        if (options.text.length > maxLength) {
+            throw new Error(`Text exceeds ${maxLength} character limit`);
+        }
     }
-    lengthSq() {
-        return this.x * this.x + this.y * this.y;
+    updateFontVariations(options) {
+        if (options.fontVariations && this.loadedFont) {
+            if (Text.stableStringify(options.fontVariations) !==
+                Text.stableStringify(this.loadedFont.fontVariations || {})) {
+                this.loadedFont.font.setVariations(options.fontVariations);
+                this.loadedFont.fontVariations = options.fontVariations;
+            }
+        }
     }
-    normalize() {
-        const len = this.length();
-        if (len > 0) {
-            this.divide(len);
+    prepareLayout(options) {
+        if (!this.loadedFont) {
+            throw new Error('Font not loaded. Use Text.create() with a font option');
         }
-        return this;
+        const { text, size = DEFAULT_FONT_SIZE, depth = 0, lineHeight = 1.0, letterSpacing = 0, layout = {} } = options;
+        const { width, direction = 'ltr', align = direction === 'rtl' ? 'right' : 'left', respectExistingBreaks = true, hyphenate = true, language = 'en-us', tolerance = DEFAULT_TOLERANCE, pretolerance = DEFAULT_PRETOLERANCE, emergencyStretch = DEFAULT_EMERGENCY_STRETCH, autoEmergencyStretch, hyphenationPatterns, lefthyphenmin, righthyphenmin, linepenalty, adjdemerits, hyphenpenalty, exhyphenpenalty, doublehyphendemerits } = layout;
+        const fontUnitsPerPixel = this.loadedFont.upem / size;
+        let widthInFontUnits;
+        if (width !== undefined) {
+            widthInFontUnits = width * fontUnitsPerPixel;
+        }
+        const rawDepthInFontUnits = depth * fontUnitsPerPixel;
+        const minExtrudeDepth = this.loadedFont.upem * 0.000025;
+        const depthInFontUnits = rawDepthInFontUnits <= 0
+            ? 0
+            : Math.max(rawDepthInFontUnits, minExtrudeDepth);
+        if (!this.textLayout) {
+            this.textLayout = new TextLayout(this.loadedFont);
+        }
+        const layoutResult = this.textLayout.computeLines({
+            text,
+            width: widthInFontUnits,
+            align,
+            direction,
+            hyphenate,
+            language,
+            respectExistingBreaks,
+            tolerance,
+            pretolerance,
+            emergencyStretch,
+            autoEmergencyStretch,
+            hyphenationPatterns,
+            lefthyphenmin,
+            righthyphenmin,
+            linepenalty,
+            adjdemerits,
+            hyphenpenalty,
+            exhyphenpenalty,
+            doublehyphendemerits,
+            letterSpacing
+        });
+        const metrics = FontMetadataExtractor.getVerticalMetrics(this.loadedFont.metrics);
+        const fontLineHeight = metrics.ascender - metrics.descender;
+        const scaledLineHeight = fontLineHeight * lineHeight;
+        return {
+            lines: layoutResult.lines,
+            scaledLineHeight,
+            letterSpacing,
+            align,
+            direction,
+            depth: depthInFontUnits,
+            size,
+            pixelsPerFontUnit: 1 / fontUnitsPerPixel
+        };
     }
-    dot(v) {
-        return this.x * v.x + this.y * v.y;
+    getFontMetrics() {
+        if (!this.loadedFont) {
+            throw new Error('Font not loaded. Call loadFont() first');
+        }
+        return FontMetadataExtractor.getFontMetrics(this.loadedFont.metrics);
     }
-    distanceTo(v) {
-        const dx = this.x - v.x;
-        const dy = this.y - v.y;
-        return Math.sqrt(dx * dx + dy * dy);
+    static async preloadPatterns(languages, patternsPath) {
+        await Promise.all(languages.map(async (language) => {
+            if (!Text.patternCache.has(language)) {
+                try {
+                    const pattern = await loadPattern(language, patternsPath);
+                    Text.patternCache.set(language, pattern);
+                }
+                catch (error) {
+                    logger.warn(`Failed to pre-load patterns for ${language}: ${error}`);
+                }
+            }
+        }));
     }
-    distanceToSquared(v) {
-        const dx = this.x - v.x;
-        const dy = this.y - v.y;
-        return dx * dx + dy * dy;
+    static registerPattern(language, pattern) {
+        Text.patternCache.set(language, pattern);
     }
-    equals(v) {
-        return this.x === v.x && this.y === v.y;
+    static setMaxFontCacheMemoryMB(limitMB) {
+        Text.maxFontCacheMemoryBytes =
+            limitMB === Infinity
+                ? Infinity
+                : Math.max(1, Math.floor(limitMB)) * 1024 * 1024;
+        Text.enforceFontCacheMemoryLimit();
     }
-    angle() {
-        return Math.atan2(this.y, this.x);
+    getLoadedFont() {
+        return this.loadedFont;
+    }
+    measureTextWidth(text, letterSpacing = 0) {
+        if (!this.loadedFont) {
+            throw new Error('Font not loaded. Call loadFont() first');
+        }
+        return TextMeasurer.measureTextWidth(this.loadedFont, text, letterSpacing);
+    }
+    resetHelpers() {
+        this.textShaper = undefined;
+        this.textLayout = undefined;
+    }
+    destroy() {
+        if (!this.loadedFont) {
+            return;
+        }
+        this.releaseCurrentFont();
+    }
+};
+
+// Map-based cache with no eviction policy
+class Cache {
+    constructor() {
+        this.cache = new Map();
+    }
+    get(key) {
+        return this.cache.get(key);
+    }
+    has(key) {
+        return this.cache.has(key);
+    }
+    set(key, value) {
+        this.cache.set(key, value);
+    }
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    get size() {
+        return this.cache.size;
+    }
+    keys() {
+        return Array.from(this.cache.keys());
+    }
+    getStats() {
+        return {
+            size: this.cache.size
+        };
     }
 }
 
+const globalOutlineCache = new Cache();
+
 class GlyphOutlineCollector {
     constructor() {
         this.currentGlyphId = 0;
@@ -249,6 +3892,122 @@ class GlyphOutlineCollector {
     }
 }
 
+class DrawCallbackHandler {
+    constructor() {
+        this.moveTo_func = null;
+        this.lineTo_func = null;
+        this.quadTo_func = null;
+        this.cubicTo_func = null;
+        this.closePath_func = null;
+        this.drawFuncsPtr = 0;
+        this.position = { x: 0, y: 0 };
+    }
+    setPosition(x, y) {
+        this.position.x = x;
+        this.position.y = y;
+        if (this.collector) {
+            this.collector.setPosition(x, y);
+        }
+    }
+    updatePosition(dx, dy) {
+        this.position.x += dx;
+        this.position.y += dy;
+        if (this.collector) {
+            this.collector.updatePosition(dx, dy);
+        }
+    }
+    setCollector(collector) {
+        this.collector = collector;
+    }
+    createDrawFuncs(font, collector) {
+        if (!font || !font.module || !font.hb) {
+            throw new Error('Invalid font object');
+        }
+        this.collector = collector;
+        if (this.drawFuncsPtr) {
+            return;
+        }
+        const module = font.module;
+        // Collect contours at origin - position applied during instancing
+        this.moveTo_func = module.addFunction((_dfuncs, _draw_data, _draw_state, to_x, to_y) => {
+            this.collector?.onMoveTo(to_x, to_y);
+        }, 'viiiffi');
+        this.lineTo_func = module.addFunction((_dfuncs, _draw_data, _draw_state, to_x, to_y) => {
+            this.collector?.onLineTo(to_x, to_y);
+        }, 'viiiffi');
+        this.quadTo_func = module.addFunction((_dfuncs, _draw_data, _draw_state, c_x, c_y, to_x, to_y) => {
+            this.collector?.onQuadTo(c_x, c_y, to_x, to_y);
+        }, 'viiiffffi');
+        this.cubicTo_func = module.addFunction((_dfuncs, _draw_data, _draw_state, c1_x, c1_y, c2_x, c2_y, to_x, to_y) => {
+            this.collector?.onCubicTo(c1_x, c1_y, c2_x, c2_y, to_x, to_y);
+        }, 'viiiffffffi');
+        this.closePath_func = module.addFunction((_dfuncs, _draw_data, _draw_state) => {
+            this.collector?.onClosePath();
+        }, 'viiii');
+        // Create HarfBuzz draw functions object using the module exports
+        this.drawFuncsPtr = module.exports.hb_draw_funcs_create();
+        module.exports.hb_draw_funcs_set_move_to_func(this.drawFuncsPtr, this.moveTo_func, 0, 0);
+        module.exports.hb_draw_funcs_set_line_to_func(this.drawFuncsPtr, this.lineTo_func, 0, 0);
+        module.exports.hb_draw_funcs_set_quadratic_to_func(this.drawFuncsPtr, this.quadTo_func, 0, 0);
+        module.exports.hb_draw_funcs_set_cubic_to_func(this.drawFuncsPtr, this.cubicTo_func, 0, 0);
+        module.exports.hb_draw_funcs_set_close_path_func(this.drawFuncsPtr, this.closePath_func, 0, 0);
+    }
+    getDrawFuncsPtr() {
+        if (!this.drawFuncsPtr) {
+            throw new Error('Draw functions not initialized');
+        }
+        return this.drawFuncsPtr;
+    }
+    destroy(font) {
+        if (!font || !font.module || !font.hb) {
+            return;
+        }
+        const module = font.module;
+        try {
+            if (this.drawFuncsPtr) {
+                module.exports.hb_draw_funcs_destroy(this.drawFuncsPtr);
+                this.drawFuncsPtr = 0;
+            }
+            if (this.moveTo_func !== null) {
+                module.removeFunction(this.moveTo_func);
+                this.moveTo_func = null;
+            }
+            if (this.lineTo_func !== null) {
+                module.removeFunction(this.lineTo_func);
+                this.lineTo_func = null;
+            }
+            if (this.quadTo_func !== null) {
+                module.removeFunction(this.quadTo_func);
+                this.quadTo_func = null;
+            }
+            if (this.cubicTo_func !== null) {
+                module.removeFunction(this.cubicTo_func);
+                this.cubicTo_func = null;
+            }
+            if (this.closePath_func !== null) {
+                module.removeFunction(this.closePath_func);
+                this.closePath_func = null;
+            }
+        }
+        catch (error) {
+            logger.warn('Error destroying draw callbacks:', error);
+        }
+        this.collector = undefined;
+    }
+}
+// Share a single DrawCallbackHandler per HarfBuzz module to avoid leaking
+// wasm function pointers when users create many Text instances
+const sharedDrawCallbackHandlers = new WeakMap();
+function getSharedDrawCallbackHandler(font) {
+    const key = font.module;
+    const existing = sharedDrawCallbackHandlers.get(key);
+    if (existing)
+        return existing;
+    const handler = new DrawCallbackHandler();
+    sharedDrawCallbackHandlers.set(key, handler);
+    return handler;
+}
+
 function ceilDiv(a, b) {
     return Math.floor((a + b - 1) / b);
 }
@@ -257,7 +4016,7 @@ function createPackedTexture(texelCount, width) {
     return { width, height, data: new Float32Array(width * height * 4) };
 }
 // All cubic-to-quadratic work uses scalar x/y to avoid per-recursion
-// Vec2 allocations. Only the final emitted QuadSegs create Vec2s
+// Vec2 allocations. Only the final emitted QuadSegs create Vec2s.
 function cubicToQuadraticsAdaptive(contourId, p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y, tol2, depth, out) {
     // Approximate quad control points
     const c0x = p0x + 0.75 * (p1x - p0x);
@@ -461,14 +4220,7 @@ class GlyphVectorGeometryBuilder {
                     const bounds = glyphBoundsByGlyph.get(g.g);
                     const px = (cluster.position.x + (g.x ?? 0)) * scale;
                     const py = (cluster.position.y + (g.y ?? 0)) * scale;
-                    loopBlinnGlyphs.push({
-                        offsetX: px,
-                        offsetY: py,
-                        segments,
-                        bounds,
-                        lineIndex: g.lineIndex,
-                        baselineY: (cluster.position.y + (g.y ?? 0)) * scale
-                    });
+                    loopBlinnGlyphs.push({ offsetX: px, offsetY: py, segments, bounds });
                     glyphInfos.push({
                         textIndex: g.absoluteTextIndex,
                         lineIndex: g.lineIndex,
@@ -490,6 +4242,47 @@ class GlyphVectorGeometryBuilder {
             glyphs: glyphInfos
         };
     }
+    collectForSlug(clustersByLine, scale) {
+        const uniqueGlyphIds = this.collectUniqueGlyphIds(clustersByLine);
+        const outlinesByGlyph = new Map();
+        for (const glyphId of uniqueGlyphIds) {
+            outlinesByGlyph.set(glyphId, this.getOutlineForGlyph(glyphId));
+        }
+        const outlines = [];
+        const positions = [];
+        const glyphInfos = [];
+        for (const line of clustersByLine) {
+            for (const cluster of line) {
+                for (const g of cluster.glyphs) {
+                    const outline = outlinesByGlyph.get(g.g);
+                    if (!outline || outline.segments.length === 0)
+                        continue;
+                    const px = (cluster.position.x + (g.x ?? 0)) * scale;
+                    const py = (cluster.position.y + (g.y ?? 0)) * scale;
+                    outlines.push(outline);
+                    positions.push({ x: px, y: py });
+                    const bMinX = outline.bounds.min.x * scale;
+                    const bMinY = outline.bounds.min.y * scale;
+                    const bMaxX = outline.bounds.max.x * scale;
+                    const bMaxY = outline.bounds.max.y * scale;
+                    glyphInfos.push({
+                        textIndex: g.absoluteTextIndex,
+                        lineIndex: g.lineIndex,
+                        vertexStart: 0,
+                        vertexCount: 0,
+                        segmentStart: 0,
+                        segmentCount: outline.segments.length,
+                        bounds: {
+                            min: { x: px + bMinX, y: py + bMinY, z: 0 },
+                            max: { x: px + bMaxX, y: py + bMaxY, z: 0 }
+                        }
+                    });
+                }
+            }
+        }
+        const planeBounds = this.computePlaneBounds(glyphInfos);
+        return { outlines, positions, glyphs: glyphInfos, planeBounds };
+    }
     getOutlineForGlyph(glyphId) {
         if (this.emptyGlyphs.has(glyphId)) {
             return {
@@ -575,6 +4368,7 @@ class GlyphVectorGeometryBuilder {
             1, -1, 1, 0
         ]);
         const quadIndices = new Uint16Array([0, 1, 2, 0, 2, 3]);
+        // Collect unique glyph IDs so we pack segment data once per glyph
         const uniqueGlyphIds = [];
         const seen = new Set();
         for (const line of clustersByLine) {
@@ -950,6 +4744,7 @@ class GlyphVectorGeometryBuilder {
                 }
             }
         }
+        // Count instances (glyph occurrences) with non-empty outlines
         let glyphInstanceCount = 0;
         for (const line of clustersByLine) {
             for (const cluster of line) {
@@ -1021,6 +4816,7 @@ class GlyphVectorGeometryBuilder {
                         }
                     };
                     glyphInfos.push(glyphInfo);
+                    // Update plane bounds
                     if (glyphInfo.bounds.min.x < planeBounds.min.x)
                         planeBounds.min.x = glyphInfo.bounds.min.x;
                     if (glyphInfo.bounds.min.y < planeBounds.min.y)
@@ -1068,186 +4864,565 @@ class GlyphVectorGeometryBuilder {
     }
 }
 
-const CONTOUR_EPSILON = 0.001;
-const CURVE_LINEARITY_EPSILON = 1e-5;
-function nearlyEqual(a, b, epsilon) {
-    return Math.abs(a - b) < epsilon;
+/**
+ * CPU-side data packer for the Slug algorithm.
+ * Faithful to Eric Lengyel's reference layout (MIT License, 2017).
+ *
+ * Takes generic quadratic Bezier shapes (not text-specific) and produces
+ * GPU-ready packed textures + vertex attribute buffers.
+ */
+const TEX_WIDTH = 4096;
+const LOG_TEX_WIDTH = 12;
+// Float ↔ Uint32 reinterpretation helpers
+const _f32 = new Float32Array(1);
+const _u32 = new Uint32Array(_f32.buffer);
+function uintAsFloat(u) {
+    _u32[0] = u;
+    return _f32[0];
 }
-function extractContours(segments) {
-    const contours = [];
-    let contourVertices = [];
-    let contourSegments = [];
-    const pushCurrentContour = () => {
-        if (contourVertices.length < 3) {
-            contourVertices = [];
-            contourSegments = [];
-            return;
-        }
-        const first = contourVertices[0];
-        const last = contourVertices[contourVertices.length - 1];
-        if (nearlyEqual(first.x, last.x, CONTOUR_EPSILON) &&
-            nearlyEqual(first.y, last.y, CONTOUR_EPSILON)) {
-            contourVertices.pop();
-        }
-        if (contourVertices.length >= 3) {
-            contours.push({
-                vertices: contourVertices,
-                segments: contourSegments
+/**
+ * Pack an array of shapes into Slug's GPU data layout.
+ *
+ * Each shape is a closed region defined by quadratic Bezier curves.
+ * Returns textures + vertex buffers ready for GPU upload.
+ */
+function packSlugData(shapes, options) {
+    const bandCount = options?.bandCount ?? 16;
+    const evenOdd = options?.evenOdd ?? false;
+    // Phase 1: Pack all curves into curveTexture
+    const allCurves = [];
+    // Estimate max texels needed
+    let totalCurves = 0;
+    for (const shape of shapes) {
+        totalCurves += shape.curves.length;
+    }
+    const curveTexHeight = Math.ceil((totalCurves * 2) / TEX_WIDTH) + 1;
+    const curveData = new Float32Array(TEX_WIDTH * curveTexHeight * 4);
+    let curveX = 0;
+    let curveY = 0;
+    for (const shape of shapes) {
+        const entries = [];
+        for (const curve of shape.curves) {
+            // Don't let a curve span across row boundary (needs 2 consecutive texels)
+            if (curveX >= TEX_WIDTH - 1) {
+                curveX = 0;
+                curveY++;
+            }
+            const base = (curveY * TEX_WIDTH + curveX) * 4;
+            curveData[base + 0] = curve.p1[0];
+            curveData[base + 1] = curve.p1[1];
+            curveData[base + 2] = curve.p2[0];
+            curveData[base + 3] = curve.p2[1];
+            const base2 = base + 4;
+            curveData[base2 + 0] = curve.p3[0];
+            curveData[base2 + 1] = curve.p3[1];
+            const minX = Math.min(curve.p1[0], curve.p2[0], curve.p3[0]);
+            const minY = Math.min(curve.p1[1], curve.p2[1], curve.p3[1]);
+            const maxX = Math.max(curve.p1[0], curve.p2[0], curve.p3[0]);
+            const maxY = Math.max(curve.p1[1], curve.p2[1], curve.p3[1]);
+            entries.push({
+                p1x: curve.p1[0], p1y: curve.p1[1],
+                p2x: curve.p2[0], p2y: curve.p2[1],
+                p3x: curve.p3[0], p3y: curve.p3[1],
+                minX, minY, maxX, maxY,
+                curveTexX: curveX,
+                curveTexY: curveY
             });
+            curveX += 2;
         }
-        contourVertices = [];
-        contourSegments = [];
-    };
-    for (const segment of segments) {
-        if (contourVertices.length === 0) {
-            contourVertices.push({ x: segment.p0x, y: segment.p0y }, { x: segment.p2x, y: segment.p2y });
-            contourSegments.push(segment);
+        allCurves.push(entries);
+    }
+    const actualCurveTexHeight = curveY + 1;
+    // Phase 2: Build band data for each shape and pack into bandTexture
+    // Layout per shape in bandTexture (relative to glyphLoc):
+    //   [0 .. hBandMax]                          : h-band headers
+    //   [hBandMax+1 .. hBandMax+1+vBandMax]      : v-band headers
+    //   [hBandMax+vBandMax+2 .. ]                : curve index lists
+    // First pass: compute total band texels needed
+    const shapeBandData = [];
+    let totalBandTexels = 0;
+    for (let si = 0; si < shapes.length; si++) {
+        const shape = shapes[si];
+        const curves = allCurves[si];
+        if (curves.length === 0) {
+            shapeBandData.push({
+                hBands: [], vBands: [], hLists: [], vLists: [],
+                totalTexels: 0, bandMaxX: 0, bandMaxY: 0
+            });
             continue;
         }
-        const previousEnd = contourVertices[contourVertices.length - 1];
-        if (nearlyEqual(segment.p0x, previousEnd.x, CONTOUR_EPSILON) &&
-            nearlyEqual(segment.p0y, previousEnd.y, CONTOUR_EPSILON)) {
-            contourVertices.push({ x: segment.p2x, y: segment.p2y });
-            contourSegments.push(segment);
-            continue;
+        const [bMinX, bMinY, bMaxX, bMaxY] = shape.bounds;
+        const w = bMaxX - bMinX;
+        const h = bMaxY - bMinY;
+        const hBandCount = Math.min(bandCount, 255); // max 255 (fits in 8 bits)
+        const vBandCount = Math.min(bandCount, 255);
+        const bandMaxY = hBandCount - 1;
+        const bandMaxX = vBandCount - 1;
+        // Build horizontal bands (partition y-axis)
+        const hBands = [];
+        const hLists = [];
+        const bandH = h / hBandCount;
+        for (let bi = 0; bi < hBandCount; bi++) {
+            const bandMinY = bMinY + bi * bandH;
+            const bandMaxYCoord = bandMinY + bandH;
+            // Collect curves whose y-range overlaps this band
+            const list = [];
+            for (const c of curves) {
+                if (c.maxY >= bandMinY && c.minY <= bandMaxYCoord) {
+                    list.push({ curve: c, sortKey: c.maxX });
+                }
+            }
+            // Sort by descending max-x for early exit
+            list.sort((a, b) => b.sortKey - a.sortKey);
+            const flatList = [];
+            for (const item of list) {
+                flatList.push(item.curve.curveTexX, item.curve.curveTexY);
+            }
+            hBands.push({ curveCount: list.length, listOffset: 0 });
+            hLists.push(flatList);
+        }
+        // Build vertical bands (partition x-axis)
+        const vBands = [];
+        const vLists = [];
+        const bandW = w / vBandCount;
+        for (let bi = 0; bi < vBandCount; bi++) {
+            const bandMinX = bMinX + bi * bandW;
+            const bandMaxXCoord = bandMinX + bandW;
+            const list = [];
+            for (const c of curves) {
+                if (c.maxX >= bandMinX && c.minX <= bandMaxXCoord) {
+                    list.push({ curve: c, sortKey: c.maxY });
+                }
+            }
+            // Sort by descending max-y for early exit
+            list.sort((a, b) => b.sortKey - a.sortKey);
+            const flatList = [];
+            for (const item of list) {
+                flatList.push(item.curve.curveTexX, item.curve.curveTexY);
+            }
+            vBands.push({ curveCount: list.length, listOffset: 0 });
+            vLists.push(flatList);
         }
-        pushCurrentContour();
-        contourVertices.push({ x: segment.p0x, y: segment.p0y }, { x: segment.p2x, y: segment.p2y });
-        contourSegments.push(segment);
+        // Total texels for this shape: band headers + curve lists
+        const headerTexels = hBandCount + vBandCount;
+        let listTexels = 0;
+        for (const l of hLists)
+            listTexels += l.length / 2;
+        for (const l of vLists)
+            listTexels += l.length / 2;
+        const total = headerTexels + listTexels;
+        shapeBandData.push({
+            hBands, vBands, hLists, vLists,
+            totalTexels: total, bandMaxX, bandMaxY
+        });
+        totalBandTexels += total;
     }
-    pushCurrentContour();
-    return contours;
-}
-function triangulateContourFan(vertices, offsetX, offsetY, positions, indices) {
-    const baseIndex = positions.length / 3;
-    for (const vertex of vertices) {
-        positions.push(vertex.x + offsetX, vertex.y + offsetY, 0);
+    // Allocate bandTexture (extra rows for row-alignment padding of curve lists)
+    const bandTexHeight = Math.max(1, Math.ceil(totalBandTexels / TEX_WIDTH) + shapes.length * 2);
+    const bandData = new Uint32Array(TEX_WIDTH * bandTexHeight * 4);
+    // Pack band data per shape
+    let bandX = 0;
+    let bandY = 0;
+    const glyphLocs = [];
+    for (let si = 0; si < shapes.length; si++) {
+        const sd = shapeBandData[si];
+        if (sd.totalTexels === 0) {
+            glyphLocs.push({ x: 0, y: 0 });
+            continue;
+        }
+        // Ensure glyph data doesn't start too close to row end
+        // (need at least headerTexels contiguous... actually wrapping is handled by CalcBandLoc)
+        // But the initial band header reads don't use CalcBandLoc, so glyphLoc.x + bandMax.y + 1 + bandMaxX
+        // must be reachable. CalcBandLoc handles wrapping for curve lists.
+        // To be safe, start each glyph at the beginning of a row if remaining space is tight.
+        const minContiguous = sd.hBands.length + sd.vBands.length;
+        if (bandX + minContiguous > TEX_WIDTH) {
+            bandX = 0;
+            bandY++;
+        }
+        const glyphLocX = bandX;
+        const glyphLocY = bandY;
+        glyphLocs.push({ x: glyphLocX, y: glyphLocY });
+        // Curve lists start after all headers
+        let listStartOffset = sd.hBands.length + sd.vBands.length;
+        // The shader reads curve list entries at (hbandLoc.x + curveIndex, hbandLoc.y)
+        // with NO row wrapping. Each list must fit entirely within a single texture row.
+        // Pad the offset to the next row start when a list would cross a row boundary.
+        const ensureListFits = (listLen) => {
+            if (listLen === 0)
+                return;
+            const startX = (glyphLocX + listStartOffset) & ((1 << LOG_TEX_WIDTH) - 1);
+            if (startX + listLen > TEX_WIDTH) {
+                listStartOffset += (TEX_WIDTH - startX);
+            }
+        };
+        // Assign list offsets for h-bands
+        for (let bi = 0; bi < sd.hBands.length; bi++) {
+            const listLen = sd.hLists[bi].length / 2;
+            ensureListFits(listLen);
+            sd.hBands[bi].listOffset = listStartOffset;
+            listStartOffset += listLen;
+        }
+        // Assign list offsets for v-bands
+        for (let bi = 0; bi < sd.vBands.length; bi++) {
+            const listLen = sd.vLists[bi].length / 2;
+            ensureListFits(listLen);
+            sd.vBands[bi].listOffset = listStartOffset;
+            listStartOffset += listLen;
+        }
+        // Write h-band headers
+        for (let bi = 0; bi < sd.hBands.length; bi++) {
+            const tx = glyphLocX + bi;
+            const ty = glyphLocY;
+            const idx = (ty * TEX_WIDTH + tx) * 4;
+            bandData[idx + 0] = sd.hBands[bi].curveCount;
+            bandData[idx + 1] = sd.hBands[bi].listOffset;
+            bandData[idx + 2] = 0;
+            bandData[idx + 3] = 0;
+        }
+        // Write v-band headers (after h-bands)
+        const vBandStart = glyphLocX + sd.hBands.length;
+        for (let bi = 0; bi < sd.vBands.length; bi++) {
+            const tx = vBandStart + bi;
+            const ty = glyphLocY;
+            const idx = (ty * TEX_WIDTH + tx) * 4;
+            bandData[idx + 0] = sd.vBands[bi].curveCount;
+            bandData[idx + 1] = sd.vBands[bi].listOffset;
+            bandData[idx + 2] = 0;
+            bandData[idx + 3] = 0;
+        }
+        // Write curve lists using CalcBandLoc-style wrapping
+        const writeBandLoc = (offset) => {
+            let bx = glyphLocX + offset;
+            let by = glyphLocY;
+            by += bx >> LOG_TEX_WIDTH;
+            bx &= (1 << LOG_TEX_WIDTH) - 1;
+            return { x: bx, y: by };
+        };
+        // Write h-band curve lists
+        for (let bi = 0; bi < sd.hBands.length; bi++) {
+            const list = sd.hLists[bi];
+            const baseOffset = sd.hBands[bi].listOffset;
+            for (let ci = 0; ci < list.length; ci += 2) {
+                const loc = writeBandLoc(baseOffset + ci / 2);
+                const idx = (loc.y * TEX_WIDTH + loc.x) * 4;
+                bandData[idx + 0] = list[ci]; // curveTexX
+                bandData[idx + 1] = list[ci + 1]; // curveTexY
+                bandData[idx + 2] = 0;
+                bandData[idx + 3] = 0;
+            }
+        }
+        // Write v-band curve lists
+        for (let bi = 0; bi < sd.vBands.length; bi++) {
+            const list = sd.vLists[bi];
+            const baseOffset = sd.vBands[bi].listOffset;
+            for (let ci = 0; ci < list.length; ci += 2) {
+                const loc = writeBandLoc(baseOffset + ci / 2);
+                const idx = (loc.y * TEX_WIDTH + loc.x) * 4;
+                bandData[idx + 0] = list[ci];
+                bandData[idx + 1] = list[ci + 1];
+                bandData[idx + 2] = 0;
+                bandData[idx + 3] = 0;
+            }
+        }
+        // Advance band cursor past this shape's data
+        const totalForShape = listStartOffset;
+        const endLoc = writeBandLoc(totalForShape);
+        bandX = endLoc.x;
+        bandY = endLoc.y;
     }
-    if (vertices.length < 3)
-        return 0;
-    for (let index = 1; index < vertices.length - 1; index++) {
-        indices.push(baseIndex, baseIndex + index, baseIndex + index + 1);
+    const actualBandTexHeight = bandY + 1;
+    // Phase 3: Build vertex attributes
+    // 5 attribs x 4 floats x 4 vertices per shape = 80 floats per shape
+    const FLOATS_PER_VERTEX = 20; // 5 attribs * 4 components
+    const VERTS_PER_SHAPE = 4;
+    const vertices = new Float32Array(shapes.length * VERTS_PER_SHAPE * FLOATS_PER_VERTEX);
+    const indices = new Uint16Array(shapes.length * 6);
+    // Corner normals (outward-pointing, un-normalized — SlugDilate normalizes)
+    const cornerNormals = [
+        [-1, -1], // bottom-left
+        [1, -1], // bottom-right
+        [1, 1], // top-right
+        [-1, 1], // top-left
+    ];
+    for (let si = 0; si < shapes.length; si++) {
+        const shape = shapes[si];
+        const sd = shapeBandData[si];
+        const glyph = glyphLocs[si];
+        const [bMinX, bMinY, bMaxX, bMaxY] = shape.bounds;
+        const w = bMaxX - bMinX;
+        const h = bMaxY - bMinY;
+        // Corner positions in object-space
+        const corners = [
+            [bMinX, bMinY],
+            [bMaxX, bMinY],
+            [bMaxX, bMaxY],
+            [bMinX, bMaxY],
+        ];
+        // Em-space sample coords at corners (same as object-space for 1:1 mapping)
+        const emCorners = [
+            [bMinX, bMinY],
+            [bMaxX, bMinY],
+            [bMaxX, bMaxY],
+            [bMinX, bMaxY],
+        ];
+        // Pack tex.z: glyph location in band texture
+        const texZ = uintAsFloat((glyph.x & 0xFFFF) | ((glyph.y & 0xFFFF) << 16));
+        // Pack tex.w: band max + flags
+        let texWBits = (sd.bandMaxX & 0xFF) | ((sd.bandMaxY & 0xFF) << 16);
+        if (evenOdd)
+            texWBits |= 0x10000000; // E flag at bit 28
+        const texW = uintAsFloat(texWBits);
+        // Band transform: scale and offset to map em-coords to band indices
+        const bandScaleX = w > 0 ? sd.vBands.length / w : 0;
+        const bandScaleY = h > 0 ? sd.hBands.length / h : 0;
+        const bandOffsetX = -bMinX * bandScaleX;
+        const bandOffsetY = -bMinY * bandScaleY;
+        for (let vi = 0; vi < 4; vi++) {
+            const base = (si * 4 + vi) * FLOATS_PER_VERTEX;
+            // pos: .xy = position, .zw = normal
+            vertices[base + 0] = corners[vi][0];
+            vertices[base + 1] = corners[vi][1];
+            vertices[base + 2] = cornerNormals[vi][0];
+            vertices[base + 3] = cornerNormals[vi][1];
+            // tex: .xy = em-space coords, .z = packed glyph loc, .w = packed band max
+            vertices[base + 4] = emCorners[vi][0];
+            vertices[base + 5] = emCorners[vi][1];
+            vertices[base + 6] = texZ;
+            vertices[base + 7] = texW;
+            // jac: identity Jacobian (em-space = object-space)
+            vertices[base + 8] = 1.0;
+            vertices[base + 9] = 0.0;
+            vertices[base + 10] = 0.0;
+            vertices[base + 11] = 1.0;
+            // bnd: band scale and offset
+            vertices[base + 12] = bandScaleX;
+            vertices[base + 13] = bandScaleY;
+            vertices[base + 14] = bandOffsetX;
+            vertices[base + 15] = bandOffsetY;
+            // col: white with full alpha (caller overrides via uniform or attribute)
+            vertices[base + 16] = 1.0;
+            vertices[base + 17] = 1.0;
+            vertices[base + 18] = 1.0;
+            vertices[base + 19] = 1.0;
+        }
+        // Indices: two triangles per quad
+        const vBase = si * 4;
+        const iBase = si * 6;
+        indices[iBase + 0] = vBase + 0;
+        indices[iBase + 1] = vBase + 1;
+        indices[iBase + 2] = vBase + 2;
+        indices[iBase + 3] = vBase + 0;
+        indices[iBase + 4] = vBase + 2;
+        indices[iBase + 5] = vBase + 3;
     }
-    return vertices.length - 2;
+    return {
+        curveTexture: {
+            data: curveData.subarray(0, TEX_WIDTH * actualCurveTexHeight * 4),
+            width: TEX_WIDTH,
+            height: actualCurveTexHeight
+        },
+        bandTexture: {
+            data: bandData.subarray(0, TEX_WIDTH * actualBandTexHeight * 4),
+            width: TEX_WIDTH,
+            height: actualBandTexHeight
+        },
+        vertices,
+        indices,
+        shapeCount: shapes.length
+    };
 }
-function shouldSkipCurveSegment(segment) {
-    const dx = segment.p2x - segment.p0x;
-    const dy = segment.p2y - segment.p0y;
-    const lenSq = dx * dx + dy * dy;
-    if (lenSq <= 0)
-        return true;
-    const cross = (segment.p1x - segment.p0x) * dy - (segment.p1y - segment.p0y) * dx;
-    return Math.abs(cross) < CURVE_LINEARITY_EPSILON * lenSq;
+
+const DEFAULT_MAX_ERROR = 0.01;
+const DEFAULT_MAX_DEPTH = 8;
+function cloneVec2(p) {
+    return [p[0], p[1]];
 }
-function fillGlyphAttrs(center, idx, progress, lineIdx, baselineY, vertCount, gc, gi, gp, gl, gb) {
-    for (let v = 0; v < vertCount; v++) {
-        gc.push(center[0], center[1], center[2]);
-        gi.push(idx);
-        gp.push(progress);
-        gl.push(lineIdx);
-        gb.push(baselineY);
-    }
+function lineToQuadratic(p0, p1) {
+    const mx = (p0[0] + p1[0]) * 0.5;
+    const my = (p0[1] + p1[1]) * 0.5;
+    return { p1: cloneVec2(p0), p2: [mx, my], p3: cloneVec2(p1) };
 }
-function packAttrs(gc, gi, gp, gl, gb) {
-    return {
-        glyphCenter: new Float32Array(gc),
-        glyphIndex: new Float32Array(gi),
-        glyphProgress: new Float32Array(gp),
-        glyphLineIndex: new Float32Array(gl),
-        glyphBaselineY: new Float32Array(gb)
+function cubicToQuadratics(p0, p1, p2, p3, options) {
+    const maxError = options?.maxError ?? DEFAULT_MAX_ERROR;
+    const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const recurse = (rp0, rp1, rp2, rp3, depth) => {
+        // Error bound for best-fit quadratic approximation of this cubic:
+        // |P3 - 3*P2 + 3*P1 - P0| / 6
+        const dx = rp3[0] - 3 * rp2[0] + 3 * rp1[0] - rp0[0];
+        const dy = rp3[1] - 3 * rp2[1] + 3 * rp1[1] - rp0[1];
+        const err = dx * dx + dy * dy;
+        const threshold = maxError * maxError * 36;
+        if (err <= threshold || depth >= maxDepth) {
+            const qx = (3 * (rp1[0] + rp2[0]) - rp0[0] - rp3[0]) * 0.25;
+            const qy = (3 * (rp1[1] + rp2[1]) - rp0[1] - rp3[1]) * 0.25;
+            return [{ p1: cloneVec2(rp0), p2: [qx, qy], p3: cloneVec2(rp3) }];
+        }
+        const m01x = (rp0[0] + rp1[0]) * 0.5, m01y = (rp0[1] + rp1[1]) * 0.5;
+        const m12x = (rp1[0] + rp2[0]) * 0.5, m12y = (rp1[1] + rp2[1]) * 0.5;
+        const m23x = (rp2[0] + rp3[0]) * 0.5, m23y = (rp2[1] + rp3[1]) * 0.5;
+        const m012x = (m01x + m12x) * 0.5, m012y = (m01y + m12y) * 0.5;
+        const m123x = (m12x + m23x) * 0.5, m123y = (m12y + m23y) * 0.5;
+        const midx = (m012x + m123x) * 0.5, midy = (m012y + m123y) * 0.5;
+        const left = recurse(rp0, [m01x, m01y], [m012x, m012y], [midx, midy], depth + 1);
+        const right = recurse([midx, midy], [m123x, m123y], [m23x, m23y], rp3, depth + 1);
+        return left.concat(right);
     };
+    return recurse(p0, p1, p2, p3, 0);
 }
-function buildVectorGeometry(input) {
-    const interiorPositions = [];
-    const interiorIndices = [];
-    const curvePositions = [];
-    const iGC = [], iGI = [], iGP = [], iGL = [], iGB = [];
-    const cGC = [], cGI = [], cGP = [], cGL = [], cGB = [];
-    const fGC = [], fGI = [], fGP = [], fGL = [], fGB = [];
-    const glyphCount = input.glyphs.length;
-    let contourCount = 0;
-    let interiorTriangleCount = 0;
-    let curveTriangleCount = 0;
-    const glyphRanges = [];
-    const fillPositions = new Float32Array(glyphCount * 12);
-    const fillIndices = new Uint32Array(glyphCount * 6);
-    for (let i = 0; i < glyphCount; i++) {
-        const glyph = input.glyphs[i];
-        const { minX, minY, maxX, maxY } = glyph.bounds;
-        const cx = glyph.offsetX + (minX + maxX) * 0.5;
-        const cy = glyph.offsetY + (minY + maxY) * 0.5;
-        const center = [cx, cy, 0];
-        const progress = glyphCount > 1 ? i / (glyphCount - 1) : 0;
-        const intIdxStart = interiorIndices.length;
-        const curveVertStart = curvePositions.length / 3;
-        const contours = extractContours(glyph.segments);
-        contourCount += contours.length;
-        for (const contour of contours) {
-            const intVertsBefore = interiorPositions.length / 3;
-            interiorTriangleCount += triangulateContourFan(contour.vertices, glyph.offsetX, glyph.offsetY, interiorPositions, interiorIndices);
-            const intVertsAfter = interiorPositions.length / 3;
-            fillGlyphAttrs(center, i, progress, glyph.lineIndex, glyph.baselineY, intVertsAfter - intVertsBefore, iGC, iGI, iGP, iGL, iGB);
-            for (const segment of contour.segments) {
-                if (shouldSkipCurveSegment(segment))
-                    continue;
-                curvePositions.push(glyph.offsetX + segment.p0x, glyph.offsetY + segment.p0y, 0, glyph.offsetX + segment.p1x, glyph.offsetY + segment.p1y, 0, glyph.offsetX + segment.p2x, glyph.offsetY + segment.p2y, 0);
-                curveTriangleCount++;
-                fillGlyphAttrs(center, i, progress, glyph.lineIndex, glyph.baselineY, 3, cGC, cGI, cGP, cGL, cGB);
+
+/**
+ * Bridges three-text's glyph outline pipeline to the Slug packer.
+ *
+ * Takes GlyphOutline[] (raw bezier segments from HarfBuzz) and produces
+ * SlugGPUData ready for WebGL2/WebGPU upload.
+ */
+function segmentToQuadCurves(seg) {
+    switch (seg.type) {
+        case 0:
+            return [lineToQuadratic([seg.p0.x, seg.p0.y], [seg.p1.x, seg.p1.y])];
+        case 1:
+            return [{
+                    p1: [seg.p0.x, seg.p0.y],
+                    p2: [seg.p1.x, seg.p1.y],
+                    p3: [seg.p2.x, seg.p2.y]
+                }];
+        case 2:
+            return cubicToQuadratics([seg.p0.x, seg.p0.y], [seg.p1.x, seg.p1.y], [seg.p2.x, seg.p2.y], [seg.p3.x, seg.p3.y]);
+        default:
+            return [];
+    }
+}
+function buildSlugData(outlines, positions, scale, options) {
+    const shapes = [];
+    const glyphMeta = [];
+    for (let i = 0; i < outlines.length; i++) {
+        const outline = outlines[i];
+        if (outline.segments.length === 0)
+            continue;
+        const pos = positions[i] || { x: 0, y: 0 };
+        const curves = [];
+        for (const seg of outline.segments) {
+            const quads = segmentToQuadCurves(seg);
+            for (const q of quads) {
+                curves.push({
+                    p1: [q.p1[0] * scale + pos.x, q.p1[1] * scale + pos.y],
+                    p2: [q.p2[0] * scale + pos.x, q.p2[1] * scale + pos.y],
+                    p3: [q.p3[0] * scale + pos.x, q.p3[1] * scale + pos.y]
+                });
             }
         }
-        glyphRanges.push({
-            interiorIndexStart: intIdxStart,
-            interiorIndexCount: interiorIndices.length - intIdxStart,
-            curveVertexStart: curveVertStart,
-            curveVertexCount: (curvePositions.length / 3) - curveVertStart
+        const bounds = [
+            outline.bounds.min.x * scale + pos.x,
+            outline.bounds.min.y * scale + pos.y,
+            outline.bounds.max.x * scale + pos.x,
+            outline.bounds.max.y * scale + pos.y
+        ];
+        glyphMeta.push({
+            glyphId: outline.glyphId,
+            textIndex: outline.textIndex,
+            shapeIndex: shapes.length,
+            bounds
         });
-        const fp = i * 12;
-        fillPositions[fp] = glyph.offsetX + minX;
-        fillPositions[fp + 1] = glyph.offsetY + minY;
-        fillPositions[fp + 2] = 0;
-        fillPositions[fp + 3] = glyph.offsetX + maxX;
-        fillPositions[fp + 4] = glyph.offsetY + minY;
-        fillPositions[fp + 5] = 0;
-        fillPositions[fp + 6] = glyph.offsetX + maxX;
-        fillPositions[fp + 7] = glyph.offsetY + maxY;
-        fillPositions[fp + 8] = 0;
-        fillPositions[fp + 9] = glyph.offsetX + minX;
-        fillPositions[fp + 10] = glyph.offsetY + maxY;
-        fillPositions[fp + 11] = 0;
-        fillGlyphAttrs(center, i, progress, glyph.lineIndex, glyph.baselineY, 4, fGC, fGI, fGP, fGL, fGB);
-        const fi = i * 6;
-        const fv = i * 4;
-        fillIndices[fi] = fv;
-        fillIndices[fi + 1] = fv + 1;
-        fillIndices[fi + 2] = fv + 2;
-        fillIndices[fi + 3] = fv;
-        fillIndices[fi + 4] = fv + 2;
-        fillIndices[fi + 5] = fv + 3;
+        shapes.push({ curves, bounds });
     }
-    return {
-        interiorPositions: new Float32Array(interiorPositions),
-        interiorIndices: new Uint32Array(interiorIndices),
-        curvePositions: new Float32Array(curvePositions),
-        fillPositions,
-        fillIndices,
-        glyphRanges,
-        interiorGlyphAttrs: packAttrs(iGC, iGI, iGP, iGL, iGB),
-        curveGlyphAttrs: packAttrs(cGC, cGI, cGP, cGL, cGB),
-        fillGlyphAttrs: packAttrs(fGC, fGI, fGP, fGL, fGB),
-        planeBounds: input.planeBounds,
-        stats: {
-            glyphCount,
-            contourCount,
-            interiorTriangleCount,
-            curveTriangleCount
+    const gpuData = packSlugData(shapes, options);
+    return { gpuData, glyphMeta };
+}
+
+class TextRangeQuery {
+    constructor(text, glyphs) {
+        this.text = text;
+        this.glyphsByTextIndex = new Map();
+        glyphs.forEach((g) => {
+            const existing = this.glyphsByTextIndex.get(g.textIndex) || [];
+            existing.push(g);
+            this.glyphsByTextIndex.set(g.textIndex, existing);
+        });
+    }
+    execute(options) {
+        const ranges = [];
+        if (options.byText) {
+            ranges.push(...this.findByText(options.byText));
         }
-    };
+        if (options.byCharRange) {
+            ranges.push(...this.findByCharRange(options.byCharRange));
+        }
+        return ranges;
+    }
+    findByText(patterns) {
+        const ranges = [];
+        for (const pattern of patterns) {
+            let index = 0;
+            while ((index = this.text.indexOf(pattern, index)) !== -1) {
+                ranges.push(this.createTextRange(index, index + pattern.length, pattern));
+                index += pattern.length;
+            }
+        }
+        return ranges;
+    }
+    findByCharRange(ranges) {
+        return ranges.map((range) => {
+            const text = this.text.slice(range.start, range.end);
+            return this.createTextRange(range.start, range.end, text);
+        });
+    }
+    createTextRange(start, end, originalText) {
+        const relevantGlyphs = [];
+        const lineGroups = new Map();
+        for (let i = start; i < end; i++) {
+            const glyphs = this.glyphsByTextIndex.get(i);
+            if (glyphs) {
+                for (const glyph of glyphs) {
+                    relevantGlyphs.push(glyph);
+                    const lineGlyphs = lineGroups.get(glyph.lineIndex) || [];
+                    lineGlyphs.push(glyph);
+                    lineGroups.set(glyph.lineIndex, lineGlyphs);
+                }
+            }
+        }
+        const bounds = Array.from(lineGroups.values()).map((lineGlyphs) => this.calculateBounds(lineGlyphs));
+        return {
+            start,
+            end,
+            originalText,
+            bounds,
+            glyphs: relevantGlyphs,
+            lineIndices: Array.from(lineGroups.keys()).sort((a, b) => a - b)
+        };
+    }
+    calculateBounds(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 }
+        };
+    }
 }
 
-function buildVectorResult(layoutHandle, vectorBuilder, options) {
+function buildCoreResult(layoutHandle, vectorBuilder, options) {
     const scale = layoutHandle.layoutData.pixelsPerFontUnit;
-    const { loopBlinnInput, glyphs } = vectorBuilder.buildForLoopBlinn(layoutHandle.clustersByLine, scale);
-    const geometryData = buildVectorGeometry(loopBlinnInput);
     let cachedQuery = null;
     const update = async (newOptions) => {
         const mergedOptions = { ...options };
@@ -1265,16 +5440,19 @@ function buildVectorResult(layoutHandle, vectorBuilder, options) {
             newBuilder.setFontId(newLayout.fontId);
             layoutHandle = newLayout;
             options = mergedOptions;
-            return buildVectorResult(layoutHandle, newBuilder, options);
+            return buildCoreResult(layoutHandle, newBuilder, options);
         }
         const newLayout = await layoutHandle.update(mergedOptions);
         layoutHandle = newLayout;
         options = mergedOptions;
-        return buildVectorResult(layoutHandle, vectorBuilder, options);
+        return buildCoreResult(layoutHandle, vectorBuilder, options);
     };
+    const { outlines, positions, glyphs, planeBounds } = vectorBuilder.collectForSlug(layoutHandle.clustersByLine, scale);
+    const { gpuData } = buildSlugData(outlines, positions, scale);
     return {
+        gpuData,
         glyphs,
-        geometryData,
+        planeBounds,
         query: (queryOptions) => {
             if (!cachedQuery) {
                 cachedQuery = new TextRangeQuery(options.text, glyphs);
@@ -1284,7 +5462,9 @@ function buildVectorResult(layoutHandle, vectorBuilder, options) {
         getLoadedFont: () => layoutHandle.getLoadedFont(),
         measureTextWidth: (text, letterSpacing) => layoutHandle.measureTextWidth(text, letterSpacing),
         update,
-        dispose: () => layoutHandle.dispose()
+        dispose: () => {
+            layoutHandle.dispose();
+        }
     };
 }
 class Text {
@@ -1299,8 +5479,8 @@ class Text {
         const layoutHandle = await Text$1.create(options);
         const vectorBuilder = new GlyphVectorGeometryBuilder(layoutHandle.loadedFont, globalOutlineCache);
         vectorBuilder.setFontId(layoutHandle.fontId);
-        return buildVectorResult(layoutHandle, vectorBuilder, options);
+        return buildCoreResult(layoutHandle, vectorBuilder, options);
     }
 }
 
-export { Text, buildVectorGeometry, extractContours };
+export { Text };