three-text 0.5.0 → 0.5.2

package/dist/vector/index.cjs

@@ -1,1095 +1,7 @@
 'use strict';
 
-var Text$1 = require('../index.cjs');
-var sharedCaches = require('../index.cjs');
-var DrawCallbacks = require('../index.cjs');
-var TextRangeQuery = require('../index.cjs');
-var THREE = require('three');
-var tsl = require('three/tsl');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var THREE__namespace = /*#__PURE__*/_interopNamespaceDefault(THREE);
-
-// 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
-        };
-    }
-}
+var core = require('./core.cjs');
+var loopBlinnTSL = require('./loopBlinnTSL.cjs');
 
 const CONTOUR_EPSILON = 0.001;
 const CURVE_LINEARITY_EPSILON = 1e-5;
@@ -1267,192 +179,56 @@ function buildVectorGeometry(input) {
     };
 }
 
-// Loop-Blinn TSL adapter for Three.js WebGPURenderer.
-// Creates meshes with TSL node materials for Loop-Blinn curve evaluation
-// and Kokojima stencil fill. Works on WebGL (r170+) and WebGPU (r182+).
-// Requires peer dependencies: three, three/tsl
-// @ts-ignore - three is a peer dependency
-// TSL fragment node: evaluates u^2 - v = 0 per fragment with
-// screen-space derivative antialiasing. Discards outside fragments.
-// UV convention per triangle: p0=(0,0), p1=(0.5,0), p2=(1,1)
-const loopBlinnFragment = tsl.Fn(() => {
-    const curveUV = tsl.uv();
-    const px = tsl.dFdx(curveUV);
-    const py = tsl.dFdy(curveUV);
-    const fx = tsl.float(2.0).mul(curveUV.x).mul(px.x).sub(px.y);
-    const fy = tsl.float(2.0).mul(curveUV.x).mul(py.x).sub(py.y);
-    const denom = tsl.sqrt(fx.mul(fx).add(fy.mul(fy)));
-    const f = curveUV.x.mul(curveUV.x).sub(curveUV.y);
-    const sd = f.div(denom.max(1e-6));
-    const alpha = tsl.clamp(tsl.float(0.5).sub(sd), 0.0, 1.0);
-    tsl.Discard(alpha.lessThanEqual(0.0));
-    return tsl.vec4(1.0, 1.0, 1.0, alpha);
-});
-function setGlyphAttrsOnGeometry(geo, attrs, offsetX = 0, offsetY = 0) {
-    if (!attrs)
-        return;
-    const glyphCenter = new Float32Array(attrs.glyphCenter);
-    if (offsetX !== 0 || offsetY !== 0) {
-        for (let i = 0; i < glyphCenter.length; i += 3) {
-            glyphCenter[i] += offsetX;
-            glyphCenter[i + 1] += offsetY;
-        }
-    }
-    geo.setAttribute('glyphCenter', new THREE__namespace.Float32BufferAttribute(glyphCenter, 3));
-    geo.setAttribute('glyphIndex', new THREE__namespace.Float32BufferAttribute(attrs.glyphIndex, 1));
-    geo.setAttribute('glyphProgress', new THREE__namespace.Float32BufferAttribute(attrs.glyphProgress, 1));
-    geo.setAttribute('glyphLineIndex', new THREE__namespace.Float32BufferAttribute(attrs.glyphLineIndex, 1));
-    geo.setAttribute('glyphBaselineY', new THREE__namespace.Float32BufferAttribute(attrs.glyphBaselineY, 1));
-}
-function applyStencilXOR(mat) {
-    mat.depthTest = false;
-    mat.depthWrite = false;
-    mat.side = THREE__namespace.DoubleSide;
-    mat.stencilWrite = true;
-    mat.stencilFunc = THREE__namespace.AlwaysStencilFunc;
-    mat.stencilRef = 0;
-    mat.stencilFuncMask = 0xFF;
-    mat.stencilWriteMask = 0xFF;
-    mat.stencilFail = THREE__namespace.KeepStencilOp;
-    mat.stencilZFail = THREE__namespace.KeepStencilOp;
-    mat.stencilZPass = THREE__namespace.InvertStencilOp;
-}
-// Three meshes that must render in order (via renderOrder or sequential draws):
-//   1. interiorMesh - stencil XOR (fan triangulated interiors, no color output)
-//   2. curveMesh    - stencil XOR (Loop-Blinn curve eval, alpha-to-coverage)
-//   3. fillMesh     - color where stencil != 0, then zeros stencil
-function createVectorMeshes(data, color) {
-    const interiorGeo = new THREE__namespace.BufferGeometry();
-    interiorGeo.setAttribute('position', new THREE__namespace.Float32BufferAttribute(data.interiorPositions, 3));
-    interiorGeo.setIndex(new THREE__namespace.BufferAttribute(data.interiorIndices, 1));
-    setGlyphAttrsOnGeometry(interiorGeo, data.interiorGlyphAttrs);
-    const curveGeo = new THREE__namespace.BufferGeometry();
-    curveGeo.setAttribute('position', new THREE__namespace.Float32BufferAttribute(data.curvePositions, 3));
-    const curveVertCount = data.curvePositions.length / 3;
-    const curveUVs = new Float32Array(curveVertCount * 2);
-    for (let i = 0; i < curveVertCount; i += 3) {
-        curveUVs[i * 2] = 0;
-        curveUVs[i * 2 + 1] = 0; // p0
-        curveUVs[i * 2 + 2] = 0.5;
-        curveUVs[i * 2 + 3] = 0; // p1
-        curveUVs[i * 2 + 4] = 1;
-        curveUVs[i * 2 + 5] = 1; // p2
-    }
-    curveGeo.setAttribute('uv', new THREE__namespace.Float32BufferAttribute(curveUVs, 2));
-    setGlyphAttrsOnGeometry(curveGeo, data.curveGlyphAttrs);
-    const fillGeo = new THREE__namespace.BufferGeometry();
-    fillGeo.setAttribute('position', new THREE__namespace.Float32BufferAttribute(data.fillPositions, 3));
-    fillGeo.setIndex(new THREE__namespace.BufferAttribute(data.fillIndices, 1));
-    setGlyphAttrsOnGeometry(fillGeo, data.fillGlyphAttrs);
-    // 1) Interior stencil material - no color output
-    const stencilInteriorMat = new THREE__namespace.MeshBasicNodeMaterial();
-    applyStencilXOR(stencilInteriorMat);
-    stencilInteriorMat.colorWrite = false;
-    // 2) Curve stencil material - Loop-Blinn fragment evaluation
-    const stencilCurveMat = new THREE__namespace.MeshBasicNodeMaterial();
-    applyStencilXOR(stencilCurveMat);
-    stencilCurveMat.colorWrite = false;
-    stencilCurveMat.alphaToCoverage = true;
-    stencilCurveMat.fragmentNode = loopBlinnFragment();
-    // 3) Color fill material - renders where stencil != 0
-    const colorMat = new THREE__namespace.MeshBasicNodeMaterial();
-    colorMat.depthTest = false;
-    colorMat.depthWrite = false;
-    colorMat.side = THREE__namespace.DoubleSide;
-    colorMat.stencilWrite = true;
-    colorMat.stencilFunc = THREE__namespace.NotEqualStencilFunc;
-    colorMat.stencilRef = 0;
-    colorMat.stencilFuncMask = 0xFF;
-    colorMat.stencilWriteMask = 0xFF;
-    colorMat.stencilFail = THREE__namespace.KeepStencilOp;
-    colorMat.stencilZFail = THREE__namespace.KeepStencilOp;
-    colorMat.stencilZPass = THREE__namespace.ZeroStencilOp;
-    if (color !== undefined) {
-        colorMat.color = new THREE__namespace.Color(color);
-    }
-    const interiorMesh = new THREE__namespace.Mesh(interiorGeo, stencilInteriorMat);
-    const curveMesh = new THREE__namespace.Mesh(curveGeo, stencilCurveMat);
-    const fillMesh = new THREE__namespace.Mesh(fillGeo, colorMat);
+function wrapResult(coreResult, opts) {
+    const meshes = loopBlinnTSL.createVectorMeshes(coreResult.geometryData, {
+        color: opts.color,
+        positionNode: opts.positionNode,
+        colorNode: opts.colorNode,
+        center: opts.center,
+    });
     return {
-        interiorMesh,
-        curveMesh,
-        fillMesh,
-        setOffset(x, y, z = 0) {
-            interiorMesh.position.set(x, y, z);
-            curveMesh.position.set(x, y, z);
-            fillMesh.position.set(x, y, z);
+        glyphs: coreResult.glyphs,
+        geometryData: coreResult.geometryData,
+        group: meshes.group,
+        interiorGeometry: meshes.interiorGeometry,
+        curveGeometry: meshes.curveGeometry,
+        fillGeometry: meshes.fillGeometry,
+        query: coreResult.query,
+        getLoadedFont: coreResult.getLoadedFont,
+        measureTextWidth: coreResult.measureTextWidth,
+        updateMaterials: meshes.updateMaterials,
+        async update(newOptions) {
+            const newCore = await coreResult.update(newOptions);
+            return wrapResult(newCore, { ...opts, ...newOptions });
         },
         dispose() {
-            interiorGeo.dispose();
-            curveGeo.dispose();
-            fillGeo.dispose();
-            stencilInteriorMat.dispose();
-            stencilCurveMat.dispose();
-            colorMat.dispose();
+            meshes.dispose();
+            coreResult.dispose();
         }
     };
 }
-
-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 { this.setHarfBuzzPath = core.Text.setHarfBuzzPath; }
+    static { this.setHarfBuzzBuffer = core.Text.setHarfBuzzBuffer; }
+    static { this.init = core.Text.init; }
+    static { this.registerPattern = core.Text.registerPattern; }
+    static { this.preloadPatterns = core.Text.preloadPatterns; }
+    static { this.setMaxFontCacheMemoryMB = core.Text.setMaxFontCacheMemoryMB; }
+    static { this.enableWoff2 = core.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);
+        const coreResult = await core.Text.create(options);
+        return wrapResult(coreResult, options);
     }
 }
 
+Object.defineProperty(exports, 'createVectorMeshes', {
+    enumerable: true,
+    get: function () { return loopBlinnTSL.createVectorMeshes; }
+});
+Object.defineProperty(exports, 'loopBlinnFragment', {
+    enumerable: true,
+    get: function () { return loopBlinnTSL.loopBlinnFragment; }
+});
 exports.Text = Text;
 exports.buildVectorGeometry = buildVectorGeometry;
-exports.createVectorMeshes = createVectorMeshes;
 exports.extractContours = extractContours;