three-text 0.5.0 → 0.5.2

package/dist/vector/core.cjs

@@ -0,0 +1,1310 @@
+'use strict';
+
+var Text$1 = require('../index.cjs');
+var sharedCaches = require('../index.cjs');
+var DrawCallbacks = require('../index.cjs');
+var TextRangeQuery = require('../index.cjs');
+
+// 2D Vector
+class Vec2 {
+    constructor(x = 0, y = 0) {
+        this.x = x;
+        this.y = y;
+    }
+    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);
+    }
+}
+
+class GlyphOutlineCollector {
+    constructor() {
+        this.currentGlyphId = 0;
+        this.currentTextIndex = 0;
+        this.inGlyph = false;
+        this.currentSegments = [];
+        this.currentPoint = null;
+        this.contourStartPoint = null;
+        this.contourId = 0;
+        this.currentGlyphBounds = {
+            min: new Vec2(Infinity, Infinity),
+            max: new Vec2(-Infinity, -Infinity)
+        };
+        this.collectedGlyphs = [];
+        this.currentPosition = new Vec2(0, 0);
+    }
+    setPosition(x, y) {
+        this.currentPosition.set(x, y);
+    }
+    updatePosition(dx, dy) {
+        this.currentPosition.x += dx;
+        this.currentPosition.y += dy;
+    }
+    beginGlyph(glyphId, textIndex) {
+        if (this.currentSegments.length > 0) {
+            this.finishGlyph();
+        }
+        this.currentGlyphId = glyphId;
+        this.currentTextIndex = textIndex;
+        this.inGlyph = true;
+        this.currentSegments = [];
+        this.currentPoint = null;
+        this.contourStartPoint = null;
+        this.contourId = 0;
+        this.currentGlyphBounds.min.set(Infinity, Infinity);
+        this.currentGlyphBounds.max.set(-Infinity, -Infinity);
+    }
+    finishGlyph() {
+        if (this.currentSegments.length > 0) {
+            this.collectedGlyphs.push({
+                glyphId: this.currentGlyphId,
+                textIndex: this.currentTextIndex,
+                segments: this.currentSegments,
+                bounds: {
+                    min: {
+                        x: this.currentGlyphBounds.min.x,
+                        y: this.currentGlyphBounds.min.y
+                    },
+                    max: {
+                        x: this.currentGlyphBounds.max.x,
+                        y: this.currentGlyphBounds.max.y
+                    }
+                }
+            });
+        }
+        else {
+            this.collectedGlyphs.push({
+                glyphId: this.currentGlyphId,
+                textIndex: this.currentTextIndex,
+                segments: [],
+                bounds: {
+                    min: { x: 0, y: 0 },
+                    max: { x: 0, y: 0 }
+                }
+            });
+        }
+        this.currentSegments = [];
+        this.currentPoint = null;
+        this.contourStartPoint = null;
+        this.inGlyph = false;
+        this.currentGlyphId = 0;
+        this.currentTextIndex = 0;
+    }
+    onMoveTo(x, y) {
+        const p = new Vec2(x, y);
+        this.updateBounds(p);
+        this.currentPoint = p;
+        this.contourStartPoint = p;
+        this.contourId++;
+    }
+    onLineTo(x, y) {
+        if (!this.currentPoint)
+            return;
+        const p1 = new Vec2(x, y);
+        const p0 = this.currentPoint;
+        this.updateBounds(p1);
+        this.currentSegments.push({
+            type: 0,
+            contourId: this.contourId,
+            p0,
+            p1
+        });
+        this.currentPoint = p1;
+    }
+    onQuadTo(cx, cy, x, y) {
+        if (!this.currentPoint)
+            return;
+        const p0 = this.currentPoint;
+        const p1 = new Vec2(cx, cy);
+        const p2 = new Vec2(x, y);
+        this.updateBounds(p1);
+        this.updateBounds(p2);
+        this.currentSegments.push({
+            type: 1,
+            contourId: this.contourId,
+            p0,
+            p1,
+            p2
+        });
+        this.currentPoint = p2;
+    }
+    onCubicTo(c1x, c1y, c2x, c2y, x, y) {
+        if (!this.currentPoint)
+            return;
+        const p0 = this.currentPoint;
+        const p1 = new Vec2(c1x, c1y);
+        const p2 = new Vec2(c2x, c2y);
+        const p3 = new Vec2(x, y);
+        this.updateBounds(p1);
+        this.updateBounds(p2);
+        this.updateBounds(p3);
+        this.currentSegments.push({
+            type: 2,
+            contourId: this.contourId,
+            p0,
+            p1,
+            p2,
+            p3
+        });
+        this.currentPoint = p3;
+    }
+    onClosePath() {
+        if (!this.currentPoint || !this.contourStartPoint)
+            return;
+        const p0 = this.currentPoint;
+        const p1 = this.contourStartPoint;
+        if (p0.x !== p1.x || p0.y !== p1.y) {
+            this.currentSegments.push({
+                type: 0,
+                contourId: this.contourId,
+                p0,
+                p1
+            });
+        }
+        this.currentPoint = p1;
+        this.contourStartPoint = null;
+    }
+    getCollectedGlyphs() {
+        if (this.inGlyph) {
+            this.finishGlyph();
+        }
+        return this.collectedGlyphs;
+    }
+    reset() {
+        this.collectedGlyphs = [];
+        this.currentGlyphId = 0;
+        this.currentTextIndex = 0;
+        this.currentSegments = [];
+        this.currentPoint = null;
+        this.contourStartPoint = null;
+        this.contourId = 0;
+        this.currentPosition.set(0, 0);
+        this.currentGlyphBounds.min.set(Infinity, Infinity);
+        this.currentGlyphBounds.max.set(-Infinity, -Infinity);
+    }
+    updateBounds(p) {
+        this.currentGlyphBounds.min.x = Math.min(this.currentGlyphBounds.min.x, p.x);
+        this.currentGlyphBounds.min.y = Math.min(this.currentGlyphBounds.min.y, p.y);
+        this.currentGlyphBounds.max.x = Math.max(this.currentGlyphBounds.max.x, p.x);
+        this.currentGlyphBounds.max.y = Math.max(this.currentGlyphBounds.max.y, p.y);
+    }
+}
+
+function ceilDiv(a, b) {
+    return Math.floor((a + b - 1) / b);
+}
+function createPackedTexture(texelCount, width) {
+    const height = Math.max(1, ceilDiv(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
+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);
+    const c0y = p0y + 0.75 * (p1y - p0y);
+    const c1x = p3x + 0.75 * (p2x - p3x);
+    const c1y = p3y + 0.75 * (p2y - p3y);
+    const mx = (c0x + c1x) * 0.5;
+    const my = (c0y + c1y) * 0.5;
+    // Error: sample cubic vs piecewise quads at t=0.25, 0.5, 0.75
+    let maxErr2 = 0;
+    for (let si = 0; si < 3; si++) {
+        const t = 0.25 + si * 0.25;
+        const u = 1 - t;
+        const uu = u * u;
+        const uuu = uu * u;
+        const tt = t * t;
+        const ttt = tt * t;
+        const cx = uuu * p0x + 3 * uu * t * p1x + 3 * u * tt * p2x + ttt * p3x;
+        const cy = uuu * p0y + 3 * uu * t * p1y + 3 * u * tt * p2y + ttt * p3y;
+        let qx, qy;
+        if (t < 0.5) {
+            const qt = t * 2;
+            const qu = 1 - qt;
+            qx = qu * qu * p0x + 2 * qu * qt * c0x + qt * qt * mx;
+            qy = qu * qu * p0y + 2 * qu * qt * c0y + qt * qt * my;
+        }
+        else {
+            const qt = (t - 0.5) * 2;
+            const qu = 1 - qt;
+            qx = qu * qu * mx + 2 * qu * qt * c1x + qt * qt * p3x;
+            qy = qu * qu * my + 2 * qu * qt * c1y + qt * qt * p3y;
+        }
+        const dx = cx - qx, dy = cy - qy;
+        const e2 = dx * dx + dy * dy;
+        if (e2 > maxErr2)
+            maxErr2 = e2;
+    }
+    if (maxErr2 <= tol2 || depth <= 0) {
+        out.push({ type: 1, contourId, p0: new Vec2(p0x, p0y), p1: new Vec2(c0x, c0y), p2: new Vec2(mx, my) }, { type: 1, contourId, p0: new Vec2(mx, my), p1: new Vec2(c1x, c1y), p2: new Vec2(p3x, p3y) });
+        return;
+    }
+    // De Casteljau split at t=0.5, pure scalar
+    const p01x = (p0x + p1x) * 0.5;
+    const p01y = (p0y + p1y) * 0.5;
+    const p12x = (p1x + p2x) * 0.5;
+    const p12y = (p1y + p2y) * 0.5;
+    const p23x = (p2x + p3x) * 0.5;
+    const p23y = (p2y + p3y) * 0.5;
+    const p012x = (p01x + p12x) * 0.5;
+    const p012y = (p01y + p12y) * 0.5;
+    const p123x = (p12x + p23x) * 0.5;
+    const p123y = (p12y + p23y) * 0.5;
+    const p0123x = (p012x + p123x) * 0.5;
+    const p0123y = (p012y + p123y) * 0.5;
+    cubicToQuadraticsAdaptive(contourId, p0x, p0y, p01x, p01y, p012x, p012y, p0123x, p0123y, tol2, depth - 1, out);
+    cubicToQuadraticsAdaptive(contourId, p0123x, p0123y, p123x, p123y, p23x, p23y, p3x, p3y, tol2, depth - 1, out);
+}
+function toQuadratics(segments) {
+    const out = [];
+    // tol=0.25 font units; pre-squared for the scalar subdivision
+    const tol2 = 0.25 * 0.25;
+    const maxDepth = 4;
+    for (let i = 0; i < segments.length; i++) {
+        const s = segments[i];
+        const type = s.type;
+        if (type === 0) {
+            const p0 = s.p0;
+            const p2 = s.p1;
+            out.push({
+                type: 1,
+                contourId: s.contourId,
+                p0,
+                p1: new Vec2((p0.x + p2.x) * 0.5, (p0.y + p2.y) * 0.5),
+                p2
+            });
+            continue;
+        }
+        if (type === 1) {
+            out.push({
+                type: 1,
+                contourId: s.contourId,
+                p0: s.p0,
+                p1: s.p1,
+                p2: s.p2
+            });
+            continue;
+        }
+        cubicToQuadraticsAdaptive(s.contourId, s.p0.x, s.p0.y, s.p1.x, s.p1.y, s.p2.x, s.p2.y, s.p3.x, s.p3.y, tol2, maxDepth, out);
+    }
+    return out;
+}
+// Packs glyph outlines into GPU-friendly textures and instance
+// attributes for vector rendering without tessellation
+class GlyphVectorGeometryBuilder {
+    constructor(loadedFont, cache = sharedCaches.globalOutlineCache) {
+        this.fontId = 'default';
+        this.cacheKeyPrefix = 'default';
+        this.emptyGlyphs = new Set();
+        this.loadedFont = loadedFont;
+        this.outlineCache = cache;
+        this.collector = new GlyphOutlineCollector();
+        this.drawCallbacks = DrawCallbacks.getSharedDrawCallbackHandler(this.loadedFont);
+        this.drawCallbacks.createDrawFuncs(this.loadedFont, this.collector);
+    }
+    setFontId(fontId) {
+        this.fontId = fontId;
+        this.cacheKeyPrefix = `${this.fontId}__outline`;
+    }
+    clearCache() {
+        this.outlineCache.clear();
+        this.emptyGlyphs.clear();
+    }
+    getCacheStats() {
+        return this.outlineCache.getStats();
+    }
+    collectUniqueGlyphIds(clustersByLine) {
+        const ids = [];
+        const seen = new Set();
+        for (const line of clustersByLine) {
+            for (const cluster of line) {
+                for (const g of cluster.glyphs) {
+                    if (!seen.has(g.g)) {
+                        seen.add(g.g);
+                        ids.push(g.g);
+                    }
+                }
+            }
+        }
+        return ids;
+    }
+    computePlaneBounds(glyphInfos) {
+        if (glyphInfos.length === 0) {
+            return { min: { x: 0, y: 0, z: 0 }, max: { x: 0, y: 0, z: 0 } };
+        }
+        let minX = Infinity, minY = Infinity;
+        let maxX = -Infinity, maxY = -Infinity;
+        for (const g of glyphInfos) {
+            if (g.bounds.min.x < minX)
+                minX = g.bounds.min.x;
+            if (g.bounds.min.y < minY)
+                minY = g.bounds.min.y;
+            if (g.bounds.max.x > maxX)
+                maxX = g.bounds.max.x;
+            if (g.bounds.max.y > maxY)
+                maxY = g.bounds.max.y;
+        }
+        return { min: { x: minX, y: minY, z: 0 }, max: { x: maxX, y: maxY, z: 0 } };
+    }
+    buildForLoopBlinn(clustersByLine, scale) {
+        const uniqueGlyphIds = this.collectUniqueGlyphIds(clustersByLine);
+        const scaledSegsByGlyph = new Map();
+        const glyphBoundsByGlyph = new Map();
+        for (const glyphId of uniqueGlyphIds) {
+            const outline = this.getOutlineForGlyph(glyphId);
+            const quadSegs = toQuadratics(outline.segments);
+            const scaledSegs = [];
+            let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+            for (const seg of quadSegs) {
+                const p0x = seg.p0.x * scale, p0y = seg.p0.y * scale;
+                const p1x = seg.p1.x * scale, p1y = seg.p1.y * scale;
+                const p2x = seg.p2.x * scale, p2y = seg.p2.y * scale;
+                scaledSegs.push({ p0x, p0y, p1x, p1y, p2x, p2y });
+                if (p0x < minX)
+                    minX = p0x;
+                if (p0y < minY)
+                    minY = p0y;
+                if (p0x > maxX)
+                    maxX = p0x;
+                if (p0y > maxY)
+                    maxY = p0y;
+                if (p1x < minX)
+                    minX = p1x;
+                if (p1y < minY)
+                    minY = p1y;
+                if (p1x > maxX)
+                    maxX = p1x;
+                if (p1y > maxY)
+                    maxY = p1y;
+                if (p2x < minX)
+                    minX = p2x;
+                if (p2y < minY)
+                    minY = p2y;
+                if (p2x > maxX)
+                    maxX = p2x;
+                if (p2y > maxY)
+                    maxY = p2y;
+            }
+            scaledSegsByGlyph.set(glyphId, scaledSegs);
+            glyphBoundsByGlyph.set(glyphId, scaledSegs.length > 0
+                ? { minX, minY, maxX, maxY }
+                : { minX: 0, minY: 0, maxX: 0, maxY: 0 });
+        }
+        const loopBlinnGlyphs = [];
+        const glyphInfos = [];
+        for (const line of clustersByLine) {
+            for (const cluster of line) {
+                for (const g of cluster.glyphs) {
+                    const segments = scaledSegsByGlyph.get(g.g);
+                    if (!segments || segments.length === 0)
+                        continue;
+                    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
+                    });
+                    glyphInfos.push({
+                        textIndex: g.absoluteTextIndex,
+                        lineIndex: g.lineIndex,
+                        vertexStart: 0,
+                        vertexCount: 0,
+                        segmentStart: 0,
+                        segmentCount: segments.length,
+                        bounds: {
+                            min: { x: px + bounds.minX, y: py + bounds.minY, z: 0 },
+                            max: { x: px + bounds.maxX, y: py + bounds.maxY, z: 0 }
+                        }
+                    });
+                }
+            }
+        }
+        const planeBounds = this.computePlaneBounds(glyphInfos);
+        return {
+            loopBlinnInput: { glyphs: loopBlinnGlyphs, planeBounds },
+            glyphs: glyphInfos
+        };
+    }
+    getOutlineForGlyph(glyphId) {
+        if (this.emptyGlyphs.has(glyphId)) {
+            return {
+                glyphId,
+                textIndex: 0,
+                segments: [],
+                bounds: { min: { x: 0, y: 0 }, max: { x: 0, y: 0 } }
+            };
+        }
+        const key = `${this.cacheKeyPrefix}_${glyphId}`;
+        const cached = this.outlineCache.get(key);
+        if (cached)
+            return cached;
+        this.drawCallbacks.setCollector(this.collector);
+        this.collector.reset();
+        this.collector.beginGlyph(glyphId, 0);
+        this.loadedFont.module.exports.hb_font_draw_glyph(this.loadedFont.font.ptr, glyphId, this.drawCallbacks.getDrawFuncsPtr(), 0);
+        this.collector.finishGlyph();
+        const collected = this.collector.getCollectedGlyphs()[0];
+        const outline = collected ?? {
+            glyphId,
+            textIndex: 0,
+            segments: [],
+            bounds: { min: { x: 0, y: 0 }, max: { x: 0, y: 0 } }
+        };
+        if (outline.segments.length === 0) {
+            this.emptyGlyphs.add(glyphId);
+        }
+        this.outlineCache.set(key, outline);
+        return outline;
+    }
+    writeSegmentToTexture(tex, texelIndex, a, b, c, d) {
+        const i = texelIndex * 4;
+        tex.data[i] = a;
+        tex.data[i + 1] = b;
+        tex.data[i + 2] = c;
+        tex.data[i + 3] = d;
+    }
+    segmentAABB(seg) {
+        let minX = seg.p0.x;
+        let minY = seg.p0.y;
+        let maxX = seg.p0.x;
+        let maxY = seg.p0.y;
+        const p1 = seg.p1;
+        if (p1.x < minX)
+            minX = p1.x;
+        if (p1.y < minY)
+            minY = p1.y;
+        if (p1.x > maxX)
+            maxX = p1.x;
+        if (p1.y > maxY)
+            maxY = p1.y;
+        const p2 = seg.p2;
+        if (p2) {
+            if (p2.x < minX)
+                minX = p2.x;
+            if (p2.y < minY)
+                minY = p2.y;
+            if (p2.x > maxX)
+                maxX = p2.x;
+            if (p2.y > maxY)
+                maxY = p2.y;
+        }
+        const p3 = seg.p3;
+        if (p3) {
+            if (p3.x < minX)
+                minX = p3.x;
+            if (p3.y < minY)
+                minY = p3.y;
+            if (p3.x > maxX)
+                maxX = p3.x;
+            if (p3.y > maxY)
+                maxY = p3.y;
+        }
+        return { minX, minY, maxX, maxY };
+    }
+    buildVectorGeometry(clustersByLine, scale, segmentTextureWidth = 1024, bandCount = 0, tileCountX = 0, tileCountY = 0) {
+        // Base quad: positions in [-1,1] with UV in [0,1]
+        const quadVertices = new Float32Array([
+            -1, -1, 0, 0,
+            -1, 1, 0, 1,
+            1, 1, 1, 1,
+            1, -1, 1, 0
+        ]);
+        const quadIndices = new Uint16Array([0, 1, 2, 0, 2, 3]);
+        const uniqueGlyphIds = [];
+        const seen = new Set();
+        for (const line of clustersByLine) {
+            for (const cluster of line) {
+                for (const g of cluster.glyphs) {
+                    if (!seen.has(g.g)) {
+                        seen.add(g.g);
+                        uniqueGlyphIds.push(g.g);
+                    }
+                }
+            }
+        }
+        const outlinesByGlyph = new Map();
+        const rangesByGlyph = new Map();
+        const glyphDataIndexByGlyphId = new Map();
+        const quadSegsByGlyph = new Map();
+        let totalSegments = 0;
+        for (let gi = 0; gi < uniqueGlyphIds.length; gi++) {
+            const glyphId = uniqueGlyphIds[gi];
+            const outline = this.getOutlineForGlyph(glyphId);
+            outlinesByGlyph.set(glyphId, outline);
+            glyphDataIndexByGlyphId.set(glyphId, gi);
+            const quadSegs = toQuadratics(outline.segments);
+            quadSegsByGlyph.set(glyphId, quadSegs);
+            totalSegments += quadSegs.length;
+        }
+        // Pack segments into RGBA32F texels: 3 texels per segment (12 floats)
+        const segmentTexelsPerSegment = 3;
+        const segmentTexelCount = totalSegments * segmentTexelsPerSegment;
+        const segmentsTex = createPackedTexture(segmentTexelCount, segmentTextureWidth);
+        // Segment bounds: 1 texel per segment (minX,minY,maxX,maxY), conservative hull AABB
+        const boundsTex = createPackedTexture(totalSegments, segmentTextureWidth);
+        // Keep bounds in CPU arrays for banding/tiling calculations (scaled, local coords)
+        const segMinX = new Float32Array(totalSegments);
+        const segMaxX = new Float32Array(totalSegments);
+        const segMinY = new Float32Array(totalSegments);
+        const segMaxY = new Float32Array(totalSegments);
+        let segmentCursor = 0;
+        for (const glyphId of uniqueGlyphIds) {
+            outlinesByGlyph.get(glyphId);
+            const start = segmentCursor;
+            const quadSegs = quadSegsByGlyph.get(glyphId);
+            const count = quadSegs.length;
+            rangesByGlyph.set(glyphId, { start, count });
+            for (let i = 0; i < count; i++) {
+                const seg = quadSegs[i];
+                // texel base for this segment
+                const tBase = (segmentCursor + i) * segmentTexelsPerSegment;
+                // Scale to match the mesh pipeline's output units
+                const p0x = seg.p0.x * scale;
+                const p0y = seg.p0.y * scale;
+                const p1x = seg.p1.x * scale;
+                const p1y = seg.p1.y * scale;
+                const p2x = seg.p2.x * scale;
+                const p2y = seg.p2.y * scale;
+                const p3x = 0;
+                const p3y = 0;
+                // Texel 0: p0.xy, p1.xy
+                this.writeSegmentToTexture(segmentsTex, tBase + 0, p0x, p0y, p1x, p1y);
+                // Texel 1: p2.xy, p3.xy
+                this.writeSegmentToTexture(segmentsTex, tBase + 1, p2x, p2y, p3x, p3y);
+                // Texel 2: type, contourId, reserved, reserved
+                this.writeSegmentToTexture(segmentsTex, tBase + 2, 1, // quadratic-only
+                seg.contourId, 0, 0);
+                // Bounds texel (conservative AABB from control points, scaled)
+                const aabb = this.segmentAABB(seg);
+                const sMinX = aabb.minX * scale;
+                const sMaxX = aabb.maxX * scale;
+                const sMinY = aabb.minY * scale;
+                const sMaxY = aabb.maxY * scale;
+                this.writeSegmentToTexture(boundsTex, segmentCursor + i, sMinX, sMinY, sMaxX, sMaxY);
+                segMinX[segmentCursor + i] = sMinX;
+                segMaxX[segmentCursor + i] = sMaxX;
+                segMinY[segmentCursor + i] = sMinY;
+                segMaxY[segmentCursor + i] = sMaxY;
+            }
+            segmentCursor += count;
+        }
+        // Per-glyph bounds from the packed segments, not the original outline,
+        // since cubic->quadratic approximation can slightly overshoot
+        const glyphMinX = new Float32Array(uniqueGlyphIds.length);
+        const glyphMinY = new Float32Array(uniqueGlyphIds.length);
+        const glyphMaxX = new Float32Array(uniqueGlyphIds.length);
+        const glyphMaxY = new Float32Array(uniqueGlyphIds.length);
+        for (let gi = 0; gi < uniqueGlyphIds.length; gi++) {
+            const glyphId = uniqueGlyphIds[gi];
+            const range = rangesByGlyph.get(glyphId);
+            if (range.count === 0) {
+                glyphMinX[gi] = 0;
+                glyphMinY[gi] = 0;
+                glyphMaxX[gi] = 0;
+                glyphMaxY[gi] = 0;
+                continue;
+            }
+            let minX = Infinity;
+            let minY = Infinity;
+            let maxX = -Infinity;
+            let maxY = -Infinity;
+            for (let si = 0; si < range.count; si++) {
+                const segIndex = range.start + si;
+                const x0 = segMinX[segIndex];
+                const x1 = segMaxX[segIndex];
+                const y0 = segMinY[segIndex];
+                const y1 = segMaxY[segIndex];
+                if (x0 < minX)
+                    minX = x0;
+                if (y0 < minY)
+                    minY = y0;
+                if (x1 > maxX)
+                    maxX = x1;
+                if (y1 > maxY)
+                    maxY = y1;
+            }
+            glyphMinX[gi] = minX;
+            glyphMinY[gi] = minY;
+            glyphMaxX[gi] = maxX;
+            glyphMaxY[gi] = maxY;
+        }
+        // Y-bands: partition each glyph into horizontal bands so the shader
+        // only tests segments overlapping the current fragment's Y range
+        const useBands = bandCount > 0;
+        const bandRangesTex = useBands
+            ? createPackedTexture(uniqueGlyphIds.length * bandCount, segmentTextureWidth)
+            : undefined;
+        let bandIndexRefsTotal = 0;
+        let bandListsByGlyph = [];
+        if (useBands) {
+            bandListsByGlyph = new Array(uniqueGlyphIds.length);
+            for (let gi = 0; gi < uniqueGlyphIds.length; gi++) {
+                const glyphId = uniqueGlyphIds[gi];
+                const range = rangesByGlyph.get(glyphId);
+                const gMinY = glyphMinY[gi];
+                const gMaxY = glyphMaxY[gi];
+                const height = gMaxY - gMinY;
+                const invBandH = height > 1e-8 ? bandCount / height : 0;
+                const bands = new Array(bandCount);
+                for (let bi = 0; bi < bandCount; bi++)
+                    bands[bi] = [];
+                for (let si = 0; si < range.count; si++) {
+                    const segIndex = range.start + si;
+                    const s0 = segMinY[segIndex];
+                    const s1 = segMaxY[segIndex];
+                    let b0 = 0;
+                    let b1 = bandCount - 1;
+                    if (invBandH > 0) {
+                        b0 = Math.floor((s0 - gMinY) * invBandH);
+                        b1 = Math.floor((s1 - gMinY) * invBandH);
+                        if (b0 < 0)
+                            b0 = 0;
+                        if (b1 < 0)
+                            b1 = 0;
+                        if (b0 >= bandCount)
+                            b0 = bandCount - 1;
+                        if (b1 >= bandCount)
+                            b1 = bandCount - 1;
+                    }
+                    if (b1 < b0) {
+                        const tmp = b0;
+                        b0 = b1;
+                        b1 = tmp;
+                    }
+                    for (let bi = b0; bi <= b1; bi++) {
+                        bands[bi].push(segIndex);
+                    }
+                }
+                // Sort by maxX descending so the shader can early-exit leftward
+                for (let bi = 0; bi < bandCount; bi++) {
+                    bands[bi].sort((a, b) => segMaxX[b] - segMaxX[a]);
+                }
+                bandListsByGlyph[gi] = bands;
+                for (let bi = 0; bi < bandCount; bi++) {
+                    bandIndexRefsTotal += bands[bi].length;
+                }
+            }
+        }
+        const bandIndicesTex = useBands
+            ? createPackedTexture(bandIndexRefsTotal, segmentTextureWidth)
+            : undefined;
+        if (useBands && bandRangesTex && bandIndicesTex) {
+            let bandIndexCursor = 0;
+            for (let gi = 0; gi < uniqueGlyphIds.length; gi++) {
+                const bands = bandListsByGlyph[gi];
+                for (let bi = 0; bi < bandCount; bi++) {
+                    const list = bands[bi];
+                    const start = bandIndexCursor;
+                    const count = list.length;
+                    // bandRanges texel: (start, count, 0, 0)
+                    this.writeSegmentToTexture(bandRangesTex, gi * bandCount + bi, start, count, 0, 0);
+                    for (let k = 0; k < count; k++) {
+                        const segIndex = list[k];
+                        // bandIndices texel.x = segIndex
+                        this.writeSegmentToTexture(bandIndicesTex, bandIndexCursor++, segIndex, 0, 0, 0);
+                    }
+                }
+            }
+        }
+        // X-bands: same idea along the horizontal axis for vertical ray tests
+        const xBandCount = bandCount; // Use same count for both axes
+        const xBandRangesTex = useBands
+            ? createPackedTexture(uniqueGlyphIds.length * xBandCount, segmentTextureWidth)
+            : undefined;
+        let xBandIndexRefsTotal = 0;
+        let xBandListsByGlyph = [];
+        if (useBands) {
+            xBandListsByGlyph = new Array(uniqueGlyphIds.length);
+            for (let gi = 0; gi < uniqueGlyphIds.length; gi++) {
+                const glyphId = uniqueGlyphIds[gi];
+                const range = rangesByGlyph.get(glyphId);
+                const gMinX = glyphMinX[gi];
+                const gMaxX = glyphMaxX[gi];
+                const width = gMaxX - gMinX;
+                const invBandW = width > 1e-8 ? xBandCount / width : 0;
+                const bands = new Array(xBandCount);
+                for (let bi = 0; bi < xBandCount; bi++)
+                    bands[bi] = [];
+                for (let si = 0; si < range.count; si++) {
+                    const segIndex = range.start + si;
+                    const s0 = segMinX[segIndex];
+                    const s1 = segMaxX[segIndex];
+                    let b0 = 0;
+                    let b1 = xBandCount - 1;
+                    if (invBandW > 0) {
+                        b0 = Math.floor((s0 - gMinX) * invBandW);
+                        b1 = Math.floor((s1 - gMinX) * invBandW);
+                        if (b0 < 0)
+                            b0 = 0;
+                        if (b1 < 0)
+                            b1 = 0;
+                        if (b0 >= xBandCount)
+                            b0 = xBandCount - 1;
+                        if (b1 >= xBandCount)
+                            b1 = xBandCount - 1;
+                    }
+                    if (b1 < b0) {
+                        const tmp = b0;
+                        b0 = b1;
+                        b1 = tmp;
+                    }
+                    for (let bi = b0; bi <= b1; bi++) {
+                        bands[bi].push(segIndex);
+                    }
+                }
+                // Sort by maxY descending so the shader can early-exit downward
+                for (let bi = 0; bi < xBandCount; bi++) {
+                    bands[bi].sort((a, b) => segMaxY[b] - segMaxY[a]);
+                }
+                xBandListsByGlyph[gi] = bands;
+                for (let bi = 0; bi < xBandCount; bi++) {
+                    xBandIndexRefsTotal += bands[bi].length;
+                }
+            }
+        }
+        const xBandIndicesTex = useBands
+            ? createPackedTexture(xBandIndexRefsTotal, segmentTextureWidth)
+            : undefined;
+        if (useBands && xBandRangesTex && xBandIndicesTex) {
+            let xBandIndexCursor = 0;
+            for (let gi = 0; gi < uniqueGlyphIds.length; gi++) {
+                const bands = xBandListsByGlyph[gi];
+                for (let bi = 0; bi < xBandCount; bi++) {
+                    const list = bands[bi];
+                    const start = xBandIndexCursor;
+                    const count = list.length;
+                    // xBandRanges texel: (start, count, 0, 0)
+                    this.writeSegmentToTexture(xBandRangesTex, gi * xBandCount + bi, start, count, 0, 0);
+                    for (let k = 0; k < count; k++) {
+                        const segIndex = list[k];
+                        // xBandIndices texel.x = segIndex
+                        this.writeSegmentToTexture(xBandIndicesTex, xBandIndexCursor++, segIndex, 0, 0, 0);
+                    }
+                }
+            }
+        }
+        // Build 2D tile grid (optional acceleration, Pathfinder-style)
+        const useTiles = tileCountX > 0 && tileCountY > 0;
+        const tileCount = useTiles ? tileCountX * tileCountY : 0;
+        const tileRangesTex = useTiles
+            ? createPackedTexture(uniqueGlyphIds.length * tileCount, segmentTextureWidth)
+            : undefined;
+        let tileIndexRefsTotal = 0;
+        let tileListsByGlyph = [];
+        if (useTiles) {
+            tileListsByGlyph = new Array(uniqueGlyphIds.length);
+            for (let gi = 0; gi < uniqueGlyphIds.length; gi++) {
+                const glyphId = uniqueGlyphIds[gi];
+                const range = rangesByGlyph.get(glyphId);
+                const gMinX = glyphMinX[gi];
+                const gMaxX = glyphMaxX[gi];
+                const gMinY = glyphMinY[gi];
+                const gMaxY = glyphMaxY[gi];
+                const width = gMaxX - gMinX;
+                const height = gMaxY - gMinY;
+                const invTileW = width > 1e-8 ? tileCountX / width : 0;
+                const invTileH = height > 1e-8 ? tileCountY / height : 0;
+                const tiles = new Array(tileCount);
+                for (let ti = 0; ti < tileCount; ti++)
+                    tiles[ti] = [];
+                for (let si = 0; si < range.count; si++) {
+                    const segIndex = range.start + si;
+                    const x0 = segMinX[segIndex];
+                    const x1 = segMaxX[segIndex];
+                    const y0 = segMinY[segIndex];
+                    const y1 = segMaxY[segIndex];
+                    let tx0 = 0;
+                    let tx1 = tileCountX - 1;
+                    let ty0 = 0;
+                    let ty1 = tileCountY - 1;
+                    if (invTileW > 0) {
+                        tx0 = Math.floor((x0 - gMinX) * invTileW);
+                        tx1 = Math.floor((x1 - gMinX) * invTileW);
+                        if (tx0 < 0)
+                            tx0 = 0;
+                        if (tx1 < 0)
+                            tx1 = 0;
+                        if (tx0 >= tileCountX)
+                            tx0 = tileCountX - 1;
+                        if (tx1 >= tileCountX)
+                            tx1 = tileCountX - 1;
+                    }
+                    if (invTileH > 0) {
+                        ty0 = Math.floor((y0 - gMinY) * invTileH);
+                        ty1 = Math.floor((y1 - gMinY) * invTileH);
+                        if (ty0 < 0)
+                            ty0 = 0;
+                        if (ty1 < 0)
+                            ty1 = 0;
+                        if (ty0 >= tileCountY)
+                            ty0 = tileCountY - 1;
+                        if (ty1 >= tileCountY)
+                            ty1 = tileCountY - 1;
+                    }
+                    if (tx1 < tx0) {
+                        const t = tx0;
+                        tx0 = tx1;
+                        tx1 = t;
+                    }
+                    if (ty1 < ty0) {
+                        const t = ty0;
+                        ty0 = ty1;
+                        ty1 = t;
+                    }
+                    for (let ty = ty0; ty <= ty1; ty++) {
+                        const rowBase = ty * tileCountX;
+                        for (let tx = tx0; tx <= tx1; tx++) {
+                            tiles[rowBase + tx].push(segIndex);
+                        }
+                    }
+                }
+                tileListsByGlyph[gi] = tiles;
+                for (let ti = 0; ti < tileCount; ti++) {
+                    tileIndexRefsTotal += tiles[ti].length;
+                }
+            }
+        }
+        const tileIndicesTex = useTiles
+            ? createPackedTexture(tileIndexRefsTotal, segmentTextureWidth)
+            : undefined;
+        if (useTiles && tileRangesTex && tileIndicesTex) {
+            let tileIndexCursor = 0;
+            for (let gi = 0; gi < uniqueGlyphIds.length; gi++) {
+                const tiles = tileListsByGlyph[gi];
+                for (let ti = 0; ti < tileCount; ti++) {
+                    const list = tiles[ti];
+                    const start = tileIndexCursor;
+                    const count = list.length;
+                    // tileRanges texel: (start, count, 0, 0)
+                    this.writeSegmentToTexture(tileRangesTex, gi * tileCount + ti, start, count, 0, 0);
+                    for (let k = 0; k < count; k++) {
+                        const segIndex = list[k];
+                        // tileIndices texel.x = segIndex
+                        this.writeSegmentToTexture(tileIndicesTex, tileIndexCursor++, segIndex, 0, 0, 0);
+                    }
+                }
+            }
+        }
+        let glyphInstanceCount = 0;
+        for (const line of clustersByLine) {
+            for (const cluster of line) {
+                for (const g of cluster.glyphs) {
+                    const range = rangesByGlyph.get(g.g);
+                    if (range && range.count > 0)
+                        glyphInstanceCount++;
+                }
+            }
+        }
+        const instances = {
+            position: new Float32Array(glyphInstanceCount * 3),
+            bounds: new Float32Array(glyphInstanceCount * 4),
+            segmentRange: new Uint32Array(glyphInstanceCount * 2),
+            glyphDataIndex: new Uint32Array(glyphInstanceCount),
+            glyphIndex: new Uint32Array(glyphInstanceCount),
+            textIndex: new Uint32Array(glyphInstanceCount),
+            lineIndex: new Uint32Array(glyphInstanceCount)
+        };
+        const glyphInfos = [];
+        const planeBounds = {
+            min: { x: Infinity, y: Infinity, z: 0 },
+            max: { x: -Infinity, y: -Infinity, z: 0 }
+        };
+        let instanceCursor = 0;
+        for (const line of clustersByLine) {
+            for (const cluster of line) {
+                const clusterX = cluster.position.x;
+                const clusterY = cluster.position.y;
+                const clusterZ = cluster.position.z;
+                for (const g of cluster.glyphs) {
+                    const range = rangesByGlyph.get(g.g);
+                    if (!range || range.count === 0)
+                        continue;
+                    const px = (clusterX + (g.x ?? 0)) * scale;
+                    const py = (clusterY + (g.y ?? 0)) * scale;
+                    const pz = clusterZ * scale;
+                    const gi = glyphDataIndexByGlyphId.get(g.g) ?? 0;
+                    const bMinX = glyphMinX[gi];
+                    const bMinY = glyphMinY[gi];
+                    const bMaxX = glyphMaxX[gi];
+                    const bMaxY = glyphMaxY[gi];
+                    // Instance attributes
+                    instances.position[instanceCursor * 3 + 0] = px;
+                    instances.position[instanceCursor * 3 + 1] = py;
+                    instances.position[instanceCursor * 3 + 2] = pz;
+                    instances.bounds[instanceCursor * 4 + 0] = bMinX;
+                    instances.bounds[instanceCursor * 4 + 1] = bMinY;
+                    instances.bounds[instanceCursor * 4 + 2] = bMaxX;
+                    instances.bounds[instanceCursor * 4 + 3] = bMaxY;
+                    instances.segmentRange[instanceCursor * 2 + 0] = range.start;
+                    instances.segmentRange[instanceCursor * 2 + 1] = range.count;
+                    instances.glyphDataIndex[instanceCursor] =
+                        glyphDataIndexByGlyphId.get(g.g) ?? 0;
+                    instances.glyphIndex[instanceCursor] = g.g;
+                    instances.textIndex[instanceCursor] = g.absoluteTextIndex;
+                    instances.lineIndex[instanceCursor] = g.lineIndex;
+                    // Glyph info for querying/selection (world bounds)
+                    const glyphInfo = {
+                        textIndex: g.absoluteTextIndex,
+                        lineIndex: g.lineIndex,
+                        vertexStart: 0,
+                        vertexCount: 0,
+                        segmentStart: range.start,
+                        segmentCount: range.count,
+                        bounds: {
+                            min: { x: px + bMinX, y: py + bMinY, z: pz },
+                            max: { x: px + bMaxX, y: py + bMaxY, z: pz }
+                        }
+                    };
+                    glyphInfos.push(glyphInfo);
+                    if (glyphInfo.bounds.min.x < planeBounds.min.x)
+                        planeBounds.min.x = glyphInfo.bounds.min.x;
+                    if (glyphInfo.bounds.min.y < planeBounds.min.y)
+                        planeBounds.min.y = glyphInfo.bounds.min.y;
+                    if (glyphInfo.bounds.min.z < planeBounds.min.z)
+                        planeBounds.min.z = glyphInfo.bounds.min.z;
+                    if (glyphInfo.bounds.max.x > planeBounds.max.x)
+                        planeBounds.max.x = glyphInfo.bounds.max.x;
+                    if (glyphInfo.bounds.max.y > planeBounds.max.y)
+                        planeBounds.max.y = glyphInfo.bounds.max.y;
+                    if (glyphInfo.bounds.max.z > planeBounds.max.z)
+                        planeBounds.max.z = glyphInfo.bounds.max.z;
+                    instanceCursor++;
+                }
+            }
+        }
+        if (glyphInfos.length === 0) {
+            planeBounds.min.x = 0;
+            planeBounds.min.y = 0;
+            planeBounds.min.z = 0;
+            planeBounds.max.x = 0;
+            planeBounds.max.y = 0;
+            planeBounds.max.z = 0;
+        }
+        return {
+            quadVertices,
+            quadIndices,
+            instances,
+            segmentTexelsPerSegment,
+            segments: segmentsTex,
+            segmentBounds: boundsTex,
+            bandCount: useBands ? bandCount : undefined,
+            bandRanges: bandRangesTex,
+            bandIndices: bandIndicesTex,
+            xBandCount: useBands ? xBandCount : undefined,
+            xBandRanges: xBandRangesTex,
+            xBandIndices: xBandIndicesTex,
+            tileCountX: useTiles ? tileCountX : undefined,
+            tileCountY: useTiles ? tileCountY : undefined,
+            tileRanges: tileRangesTex,
+            tileIndices: tileIndicesTex,
+            glyphs: glyphInfos,
+            planeBounds
+        };
+    }
+}
+
+const CONTOUR_EPSILON = 0.001;
+const CURVE_LINEARITY_EPSILON = 1e-5;
+function nearlyEqual(a, b, epsilon) {
+    return Math.abs(a - b) < epsilon;
+}
+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
+            });
+        }
+        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);
+            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;
+        }
+        pushCurrentContour();
+        contourVertices.push({ x: segment.p0x, y: segment.p0y }, { x: segment.p2x, y: segment.p2y });
+        contourSegments.push(segment);
+    }
+    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);
+    }
+    if (vertices.length < 3)
+        return 0;
+    for (let index = 1; index < vertices.length - 1; index++) {
+        indices.push(baseIndex, baseIndex + index, baseIndex + index + 1);
+    }
+    return vertices.length - 2;
+}
+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;
+}
+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 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 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);
+            }
+        }
+        glyphRanges.push({
+            interiorIndexStart: intIdxStart,
+            interiorIndexCount: interiorIndices.length - intIdxStart,
+            curveVertexStart: curveVertStart,
+            curveVertexCount: (curvePositions.length / 3) - curveVertStart
+        });
+        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;
+    }
+    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
+        }
+    };
+}
+
+function buildVectorResult(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 };
+        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 newLayout = await layoutHandle.update(mergedOptions);
+            const newBuilder = new GlyphVectorGeometryBuilder(newLayout.loadedFont, sharedCaches.globalOutlineCache);
+            newBuilder.setFontId(newLayout.fontId);
+            layoutHandle = newLayout;
+            options = mergedOptions;
+            return buildVectorResult(layoutHandle, newBuilder, options);
+        }
+        const newLayout = await layoutHandle.update(mergedOptions);
+        layoutHandle = newLayout;
+        options = mergedOptions;
+        return buildVectorResult(layoutHandle, vectorBuilder, options);
+    };
+    return {
+        glyphs,
+        geometryData,
+        query: (queryOptions) => {
+            if (!cachedQuery) {
+                cachedQuery = new TextRangeQuery.TextRangeQuery(options.text, glyphs);
+            }
+            return cachedQuery.execute(queryOptions);
+        },
+        getLoadedFont: () => layoutHandle.getLoadedFont(),
+        measureTextWidth: (text, letterSpacing) => layoutHandle.measureTextWidth(text, letterSpacing),
+        update,
+        dispose: () => layoutHandle.dispose()
+    };
+}
+class Text {
+    static { this.setHarfBuzzPath = Text$1.Text.setHarfBuzzPath; }
+    static { this.setHarfBuzzBuffer = Text$1.Text.setHarfBuzzBuffer; }
+    static { this.init = Text$1.Text.init; }
+    static { this.registerPattern = Text$1.Text.registerPattern; }
+    static { this.preloadPatterns = Text$1.Text.preloadPatterns; }
+    static { this.setMaxFontCacheMemoryMB = Text$1.Text.setMaxFontCacheMemoryMB; }
+    static { this.enableWoff2 = Text$1.Text.enableWoff2; }
+    static async create(options) {
+        const layoutHandle = await Text$1.Text.create(options);
+        const vectorBuilder = new GlyphVectorGeometryBuilder(layoutHandle.loadedFont, sharedCaches.globalOutlineCache);
+        vectorBuilder.setFontId(layoutHandle.fontId);
+        return buildVectorResult(layoutHandle, vectorBuilder, options);
+    }
+}
+
+exports.Text = Text;
+exports.buildVectorGeometry = buildVectorGeometry;
+exports.extractContours = extractContours;