three-text 0.5.2 → 0.6.0

package/dist/vector/core/index.js

@@ -0,0 +1,854 @@
+import { Text as Text$1 } from '../../index.js';
+import { globalOutlineCache } from '../../index.js';
+import { getSharedDrawCallbackHandler } from '../../index.js';
+import { TextRangeQuery } from '../../index.js';
+
+// 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);
+    }
+}
+
+// CPU-side data packer for the Slug algorithm
+// Faithful to Eric Lengyel's reference layout (MIT License, 2017)
+//
+// Takes generic quadratic Bezier shapes (not text-specific) and produces
+// GPU-ready packed textures + vertex attribute buffers
+const TEX_WIDTH = 4096;
+const LOG_TEX_WIDTH = 12;
+// Float/Uint32 reinterpretation helpers
+const _f32 = new Float32Array(1);
+const _u32 = new Uint32Array(_f32.buffer);
+function uintAsFloat(u) {
+    _u32[0] = u;
+    return _f32[0];
+}
+// Pack an array of shapes into Slug's GPU data layout
+// Each shape is a closed region defined by quadratic Bezier curves
+function packSlugData(shapes, options) {
+    const bandCount = options?.bandCount ?? 16;
+    const evenOdd = options?.evenOdd ?? false;
+    // Pack all curves into curveTexture
+    const allCurves = [];
+    // Estimate max texels needed
+    let totalCurves = 0;
+    for (const shape of shapes) {
+        totalCurves += shape.curves.length;
+    }
+    const curveTexHeight = Math.ceil((totalCurves * 2) / TEX_WIDTH) + 1;
+    const curveData = new Float32Array(TEX_WIDTH * curveTexHeight * 4);
+    let curveX = 0;
+    let curveY = 0;
+    for (const shape of shapes) {
+        const entries = [];
+        for (const curve of shape.curves) {
+            // Don't let a curve span across row boundary (needs 2 consecutive texels)
+            if (curveX >= TEX_WIDTH - 1) {
+                curveX = 0;
+                curveY++;
+            }
+            const base = (curveY * TEX_WIDTH + curveX) * 4;
+            curveData[base + 0] = curve.p1[0];
+            curveData[base + 1] = curve.p1[1];
+            curveData[base + 2] = curve.p2[0];
+            curveData[base + 3] = curve.p2[1];
+            const base2 = base + 4;
+            curveData[base2 + 0] = curve.p3[0];
+            curveData[base2 + 1] = curve.p3[1];
+            const minX = Math.min(curve.p1[0], curve.p2[0], curve.p3[0]);
+            const minY = Math.min(curve.p1[1], curve.p2[1], curve.p3[1]);
+            const maxX = Math.max(curve.p1[0], curve.p2[0], curve.p3[0]);
+            const maxY = Math.max(curve.p1[1], curve.p2[1], curve.p3[1]);
+            entries.push({
+                p1x: curve.p1[0], p1y: curve.p1[1],
+                p2x: curve.p2[0], p2y: curve.p2[1],
+                p3x: curve.p3[0], p3y: curve.p3[1],
+                minX, minY, maxX, maxY,
+                curveTexX: curveX,
+                curveTexY: curveY
+            });
+            curveX += 2;
+        }
+        allCurves.push(entries);
+    }
+    const actualCurveTexHeight = curveY + 1;
+    // Build band data for each shape and pack into bandTexture
+    // Layout per shape in bandTexture (relative to glyphLoc):
+    //   [0 .. hBandMax]                          : h-band headers
+    //   [hBandMax+1 .. hBandMax+1+vBandMax]      : v-band headers
+    //   [hBandMax+vBandMax+2 .. ]                : curve index lists
+    // First pass: compute total band texels needed
+    const shapeBandData = [];
+    let totalBandTexels = 0;
+    for (let si = 0; si < shapes.length; si++) {
+        const shape = shapes[si];
+        const curves = allCurves[si];
+        if (curves.length === 0) {
+            shapeBandData.push({
+                hBands: [], vBands: [], hLists: [], vLists: [],
+                totalTexels: 0, bandMaxX: 0, bandMaxY: 0
+            });
+            continue;
+        }
+        const [bMinX, bMinY, bMaxX, bMaxY] = shape.bounds;
+        const w = bMaxX - bMinX;
+        const h = bMaxY - bMinY;
+        const hBandCount = Math.min(bandCount, 255); // max 255 (fits in 8 bits)
+        const vBandCount = Math.min(bandCount, 255);
+        const bandMaxY = hBandCount - 1;
+        const bandMaxX = vBandCount - 1;
+        // Build horizontal bands (partition y-axis)
+        const hBands = [];
+        const hLists = [];
+        const bandH = h / hBandCount;
+        for (let bi = 0; bi < hBandCount; bi++) {
+            const bandMinY = bMinY + bi * bandH;
+            const bandMaxYCoord = bandMinY + bandH;
+            // Collect curves whose y-range overlaps this band
+            const list = [];
+            for (const c of curves) {
+                if (c.maxY >= bandMinY && c.minY <= bandMaxYCoord) {
+                    list.push({ curve: c, sortKey: c.maxX });
+                }
+            }
+            // Sort by descending max-x for early exit
+            list.sort((a, b) => b.sortKey - a.sortKey);
+            const flatList = [];
+            for (const item of list) {
+                flatList.push(item.curve.curveTexX, item.curve.curveTexY);
+            }
+            hBands.push({ curveCount: list.length, listOffset: 0 });
+            hLists.push(flatList);
+        }
+        // Build vertical bands (partition x-axis)
+        const vBands = [];
+        const vLists = [];
+        const bandW = w / vBandCount;
+        for (let bi = 0; bi < vBandCount; bi++) {
+            const bandMinX = bMinX + bi * bandW;
+            const bandMaxXCoord = bandMinX + bandW;
+            const list = [];
+            for (const c of curves) {
+                if (c.maxX >= bandMinX && c.minX <= bandMaxXCoord) {
+                    list.push({ curve: c, sortKey: c.maxY });
+                }
+            }
+            // Sort by descending max-y for early exit
+            list.sort((a, b) => b.sortKey - a.sortKey);
+            const flatList = [];
+            for (const item of list) {
+                flatList.push(item.curve.curveTexX, item.curve.curveTexY);
+            }
+            vBands.push({ curveCount: list.length, listOffset: 0 });
+            vLists.push(flatList);
+        }
+        // Total texels for this shape: band headers + curve lists
+        const headerTexels = hBandCount + vBandCount;
+        let listTexels = 0;
+        for (const l of hLists)
+            listTexels += l.length / 2;
+        for (const l of vLists)
+            listTexels += l.length / 2;
+        const total = headerTexels + listTexels;
+        shapeBandData.push({
+            hBands, vBands, hLists, vLists,
+            totalTexels: total, bandMaxX, bandMaxY
+        });
+        totalBandTexels += total;
+    }
+    // Allocate bandTexture (extra rows for row-alignment padding of curve lists)
+    const bandTexHeight = Math.max(1, Math.ceil(totalBandTexels / TEX_WIDTH) + shapes.length * 2);
+    const bandData = new Uint32Array(TEX_WIDTH * bandTexHeight * 4);
+    // Pack band data per shape
+    let bandX = 0;
+    let bandY = 0;
+    const glyphLocs = [];
+    for (let si = 0; si < shapes.length; si++) {
+        const sd = shapeBandData[si];
+        if (sd.totalTexels === 0) {
+            glyphLocs.push({ x: 0, y: 0 });
+            continue;
+        }
+        // Ensure glyph data doesn't start too close to row end
+        // (need at least headerTexels contiguous... actually wrapping is handled by CalcBandLoc)
+        // But the initial band header reads don't use CalcBandLoc, so glyphLoc.x + bandMax.y + 1 + bandMaxX
+        // must be reachable. CalcBandLoc handles wrapping for curve lists.
+        // To be safe, start each glyph at the beginning of a row if remaining space is tight.
+        const minContiguous = sd.hBands.length + sd.vBands.length;
+        if (bandX + minContiguous > TEX_WIDTH) {
+            bandX = 0;
+            bandY++;
+        }
+        const glyphLocX = bandX;
+        const glyphLocY = bandY;
+        glyphLocs.push({ x: glyphLocX, y: glyphLocY });
+        // Curve lists start after all headers
+        let listStartOffset = sd.hBands.length + sd.vBands.length;
+        // The shader reads curve list entries at (hbandLoc.x + curveIndex, hbandLoc.y)
+        // with NO row wrapping. Each list must fit entirely within a single texture row.
+        // Pad the offset to the next row start when a list would cross a row boundary.
+        const ensureListFits = (listLen) => {
+            if (listLen === 0)
+                return;
+            const startX = (glyphLocX + listStartOffset) & ((1 << LOG_TEX_WIDTH) - 1);
+            if (startX + listLen > TEX_WIDTH) {
+                listStartOffset += (TEX_WIDTH - startX);
+            }
+        };
+        // Assign list offsets for h-bands
+        for (let bi = 0; bi < sd.hBands.length; bi++) {
+            const listLen = sd.hLists[bi].length / 2;
+            ensureListFits(listLen);
+            sd.hBands[bi].listOffset = listStartOffset;
+            listStartOffset += listLen;
+        }
+        // Assign list offsets for v-bands
+        for (let bi = 0; bi < sd.vBands.length; bi++) {
+            const listLen = sd.vLists[bi].length / 2;
+            ensureListFits(listLen);
+            sd.vBands[bi].listOffset = listStartOffset;
+            listStartOffset += listLen;
+        }
+        // Write h-band headers
+        for (let bi = 0; bi < sd.hBands.length; bi++) {
+            const tx = glyphLocX + bi;
+            const ty = glyphLocY;
+            const idx = (ty * TEX_WIDTH + tx) * 4;
+            bandData[idx + 0] = sd.hBands[bi].curveCount;
+            bandData[idx + 1] = sd.hBands[bi].listOffset;
+            bandData[idx + 2] = 0;
+            bandData[idx + 3] = 0;
+        }
+        // Write v-band headers (after h-bands)
+        const vBandStart = glyphLocX + sd.hBands.length;
+        for (let bi = 0; bi < sd.vBands.length; bi++) {
+            const tx = vBandStart + bi;
+            const ty = glyphLocY;
+            const idx = (ty * TEX_WIDTH + tx) * 4;
+            bandData[idx + 0] = sd.vBands[bi].curveCount;
+            bandData[idx + 1] = sd.vBands[bi].listOffset;
+            bandData[idx + 2] = 0;
+            bandData[idx + 3] = 0;
+        }
+        // Write curve lists using CalcBandLoc-style wrapping
+        const texWidthMask = (1 << LOG_TEX_WIDTH) - 1;
+        // Write h-band curve lists
+        for (let bi = 0; bi < sd.hBands.length; bi++) {
+            const list = sd.hLists[bi];
+            const baseOffset = sd.hBands[bi].listOffset;
+            for (let ci = 0; ci < list.length; ci += 2) {
+                let bx = glyphLocX + baseOffset + (ci >> 1);
+                const by = glyphLocY + (bx >> LOG_TEX_WIDTH);
+                bx &= texWidthMask;
+                const idx = (by * TEX_WIDTH + bx) * 4;
+                bandData[idx + 0] = list[ci]; // curveTexX
+                bandData[idx + 1] = list[ci + 1]; // curveTexY
+                bandData[idx + 2] = 0;
+                bandData[idx + 3] = 0;
+            }
+        }
+        // Write v-band curve lists
+        for (let bi = 0; bi < sd.vBands.length; bi++) {
+            const list = sd.vLists[bi];
+            const baseOffset = sd.vBands[bi].listOffset;
+            for (let ci = 0; ci < list.length; ci += 2) {
+                let bx = glyphLocX + baseOffset + (ci >> 1);
+                const by = glyphLocY + (bx >> LOG_TEX_WIDTH);
+                bx &= texWidthMask;
+                const idx = (by * TEX_WIDTH + bx) * 4;
+                bandData[idx + 0] = list[ci];
+                bandData[idx + 1] = list[ci + 1];
+                bandData[idx + 2] = 0;
+                bandData[idx + 3] = 0;
+            }
+        }
+        // Advance band cursor past this shape's data
+        let endBx = glyphLocX + listStartOffset;
+        bandY = glyphLocY + (endBx >> LOG_TEX_WIDTH);
+        bandX = endBx & texWidthMask;
+    }
+    const actualBandTexHeight = bandY + 1;
+    // Build vertex attributes
+    // 5 attribs x 4 floats x 4 vertices per shape = 80 floats per shape
+    const FLOATS_PER_VERTEX = 20; // 5 attribs * 4 components
+    const VERTS_PER_SHAPE = 4;
+    const vertices = new Float32Array(shapes.length * VERTS_PER_SHAPE * FLOATS_PER_VERTEX);
+    const indices = new Uint16Array(shapes.length * 6);
+    // Corner normals (outward-pointing, un-normalized; SlugDilate normalizes)
+    const cornerNormals = [
+        [-1, -1], // bottom-left
+        [1, -1], // bottom-right
+        [1, 1], // top-right
+        [-1, 1], // top-left
+    ];
+    for (let si = 0; si < shapes.length; si++) {
+        const shape = shapes[si];
+        const sd = shapeBandData[si];
+        const glyph = glyphLocs[si];
+        const [bMinX, bMinY, bMaxX, bMaxY] = shape.bounds;
+        const w = bMaxX - bMinX;
+        const h = bMaxY - bMinY;
+        // Corner positions in object-space
+        const corners = [
+            [bMinX, bMinY],
+            [bMaxX, bMinY],
+            [bMaxX, bMaxY],
+            [bMinX, bMaxY],
+        ];
+        // Em-space sample coords at corners (same as object-space for 1:1 mapping)
+        const emCorners = [
+            [bMinX, bMinY],
+            [bMaxX, bMinY],
+            [bMaxX, bMaxY],
+            [bMinX, bMaxY],
+        ];
+        // Pack tex.z: glyph location in band texture
+        const texZ = uintAsFloat((glyph.x & 0xFFFF) | ((glyph.y & 0xFFFF) << 16));
+        // Pack tex.w: band max + flags
+        let texWBits = (sd.bandMaxX & 0xFF) | ((sd.bandMaxY & 0xFF) << 16);
+        if (evenOdd)
+            texWBits |= 0x10000000; // E flag at bit 28
+        const texW = uintAsFloat(texWBits);
+        // Band transform: scale and offset to map em-coords to band indices
+        const bandScaleX = w > 0 ? sd.vBands.length / w : 0;
+        const bandScaleY = h > 0 ? sd.hBands.length / h : 0;
+        const bandOffsetX = -bMinX * bandScaleX;
+        const bandOffsetY = -bMinY * bandScaleY;
+        for (let vi = 0; vi < 4; vi++) {
+            const base = (si * 4 + vi) * FLOATS_PER_VERTEX;
+            // pos: .xy = position, .zw = normal
+            vertices[base + 0] = corners[vi][0];
+            vertices[base + 1] = corners[vi][1];
+            vertices[base + 2] = cornerNormals[vi][0];
+            vertices[base + 3] = cornerNormals[vi][1];
+            // tex: .xy = em-space coords, .z = packed glyph loc, .w = packed band max
+            vertices[base + 4] = emCorners[vi][0];
+            vertices[base + 5] = emCorners[vi][1];
+            vertices[base + 6] = texZ;
+            vertices[base + 7] = texW;
+            // jac: identity Jacobian (em-space = object-space)
+            vertices[base + 8] = 1.0;
+            vertices[base + 9] = 0.0;
+            vertices[base + 10] = 0.0;
+            vertices[base + 11] = 1.0;
+            // bnd: band scale and offset
+            vertices[base + 12] = bandScaleX;
+            vertices[base + 13] = bandScaleY;
+            vertices[base + 14] = bandOffsetX;
+            vertices[base + 15] = bandOffsetY;
+            // col: white with full alpha (caller overrides via uniform or attribute)
+            vertices[base + 16] = 1.0;
+            vertices[base + 17] = 1.0;
+            vertices[base + 18] = 1.0;
+            vertices[base + 19] = 1.0;
+        }
+        // Indices: two triangles per quad
+        const vBase = si * 4;
+        const iBase = si * 6;
+        indices[iBase + 0] = vBase + 0;
+        indices[iBase + 1] = vBase + 1;
+        indices[iBase + 2] = vBase + 2;
+        indices[iBase + 3] = vBase + 0;
+        indices[iBase + 4] = vBase + 2;
+        indices[iBase + 5] = vBase + 3;
+    }
+    return {
+        curveTexture: {
+            data: curveData.slice(0, TEX_WIDTH * actualCurveTexHeight * 4),
+            width: TEX_WIDTH,
+            height: actualCurveTexHeight
+        },
+        bandTexture: {
+            data: bandData.slice(0, TEX_WIDTH * actualBandTexHeight * 4),
+            width: TEX_WIDTH,
+            height: actualBandTexHeight
+        },
+        vertices,
+        indices,
+        shapeCount: shapes.length
+    };
+}
+
+const DEFAULT_MAX_ERROR = 0.01;
+const DEFAULT_MAX_DEPTH = 8;
+function cloneVec2(p) {
+    return [p[0], p[1]];
+}
+function cubicToQuadratics(p0, p1, p2, p3, options) {
+    const maxError = options?.maxError ?? DEFAULT_MAX_ERROR;
+    const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const out = [];
+    const recurse = (rp0, rp1, rp2, rp3, depth) => {
+        // Error bound for best-fit quadratic approximation of this cubic:
+        // |P3 - 3*P2 + 3*P1 - P0| / 6
+        const dx = rp3[0] - 3 * rp2[0] + 3 * rp1[0] - rp0[0];
+        const dy = rp3[1] - 3 * rp2[1] + 3 * rp1[1] - rp0[1];
+        const err = dx * dx + dy * dy;
+        const threshold = maxError * maxError * 36;
+        if (err <= threshold || depth >= maxDepth) {
+            const qx = (3 * (rp1[0] + rp2[0]) - rp0[0] - rp3[0]) * 0.25;
+            const qy = (3 * (rp1[1] + rp2[1]) - rp0[1] - rp3[1]) * 0.25;
+            out.push({ p1: cloneVec2(rp0), p2: [qx, qy], p3: cloneVec2(rp3) });
+            return;
+        }
+        const m01x = (rp0[0] + rp1[0]) * 0.5, m01y = (rp0[1] + rp1[1]) * 0.5;
+        const m12x = (rp1[0] + rp2[0]) * 0.5, m12y = (rp1[1] + rp2[1]) * 0.5;
+        const m23x = (rp2[0] + rp3[0]) * 0.5, m23y = (rp2[1] + rp3[1]) * 0.5;
+        const m012x = (m01x + m12x) * 0.5, m012y = (m01y + m12y) * 0.5;
+        const m123x = (m12x + m23x) * 0.5, m123y = (m12y + m23y) * 0.5;
+        const midx = (m012x + m123x) * 0.5, midy = (m012y + m123y) * 0.5;
+        recurse(rp0, [m01x, m01y], [m012x, m012y], [midx, midy], depth + 1);
+        recurse([midx, midy], [m123x, m123y], [m23x, m23y], rp3, depth + 1);
+    };
+    recurse(p0, p1, p2, p3, 0);
+    return out;
+}
+
+function createOutlineContext(loadedFont, fontId, cache = globalOutlineCache) {
+    const collector = new GlyphOutlineCollector();
+    const drawCallbacks = getSharedDrawCallbackHandler(loadedFont);
+    drawCallbacks.createDrawFuncs(loadedFont, collector);
+    return {
+        loadedFont,
+        outlineCache: cache,
+        drawCallbacks,
+        collector,
+        cacheKeyPrefix: `${fontId}__outline`,
+        emptyGlyphs: new Set(),
+    };
+}
+function getOutlineForGlyph(ctx, glyphId) {
+    if (ctx.emptyGlyphs.has(glyphId)) {
+        return {
+            glyphId,
+            textIndex: 0,
+            segments: [],
+            bounds: { min: { x: 0, y: 0 }, max: { x: 0, y: 0 } }
+        };
+    }
+    const key = `${ctx.cacheKeyPrefix}_${glyphId}`;
+    const cached = ctx.outlineCache.get(key);
+    if (cached)
+        return cached;
+    ctx.drawCallbacks.setCollector(ctx.collector);
+    ctx.collector.reset();
+    ctx.collector.beginGlyph(glyphId, 0);
+    ctx.loadedFont.module.exports.hb_font_draw_glyph(ctx.loadedFont.font.ptr, glyphId, ctx.drawCallbacks.getDrawFuncsPtr(), 0);
+    ctx.collector.finishGlyph();
+    const collected = ctx.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) {
+        ctx.emptyGlyphs.add(glyphId);
+    }
+    ctx.outlineCache.set(key, outline);
+    return outline;
+}
+function collectForSlug(ctx, clustersByLine, scale) {
+    const seen = new Set();
+    const outlinesByGlyph = new Map();
+    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);
+                    outlinesByGlyph.set(g.g, getOutlineForGlyph(ctx, g.g));
+                }
+            }
+        }
+    }
+    const shapes = [];
+    const glyphInfos = [];
+    for (const line of clustersByLine) {
+        for (const cluster of line) {
+            for (const g of cluster.glyphs) {
+                const outline = outlinesByGlyph.get(g.g);
+                if (!outline || outline.segments.length === 0)
+                    continue;
+                const px = (cluster.position.x + (g.x ?? 0)) * scale;
+                const py = (cluster.position.y + (g.y ?? 0)) * scale;
+                const curves = [];
+                for (const seg of outline.segments) {
+                    switch (seg.type) {
+                        // line to quadratic
+                        case 0: {
+                            const x0 = seg.p0.x * scale + px, y0 = seg.p0.y * scale + py;
+                            const x1 = seg.p1.x * scale + px, y1 = seg.p1.y * scale + py;
+                            curves.push({
+                                p1: [x0, y0],
+                                p2: [(x0 + x1) * 0.5, (y0 + y1) * 0.5],
+                                p3: [x1, y1],
+                            });
+                            break;
+                        }
+                        // quadratic
+                        case 1:
+                            curves.push({
+                                p1: [seg.p0.x * scale + px, seg.p0.y * scale + py],
+                                p2: [seg.p1.x * scale + px, seg.p1.y * scale + py],
+                                p3: [seg.p2.x * scale + px, seg.p2.y * scale + py],
+                            });
+                            break;
+                        // cubic to quadratic
+                        case 2: {
+                            const quads = cubicToQuadratics([seg.p0.x, seg.p0.y], [seg.p1.x, seg.p1.y], [seg.p2.x, seg.p2.y], [seg.p3.x, seg.p3.y]);
+                            for (const q of quads) {
+                                curves.push({
+                                    p1: [q.p1[0] * scale + px, q.p1[1] * scale + py],
+                                    p2: [q.p2[0] * scale + px, q.p2[1] * scale + py],
+                                    p3: [q.p3[0] * scale + px, q.p3[1] * scale + py],
+                                });
+                            }
+                            break;
+                        }
+                    }
+                }
+                const bounds = [
+                    outline.bounds.min.x * scale + px,
+                    outline.bounds.min.y * scale + py,
+                    outline.bounds.max.x * scale + px,
+                    outline.bounds.max.y * scale + py,
+                ];
+                glyphInfos.push({
+                    textIndex: g.absoluteTextIndex,
+                    lineIndex: g.lineIndex,
+                    vertexStart: 0,
+                    vertexCount: 0,
+                    segmentStart: 0,
+                    segmentCount: outline.segments.length,
+                    bounds: {
+                        min: { x: bounds[0], y: bounds[1], z: 0 },
+                        max: { x: bounds[2], y: bounds[3], z: 0 },
+                    },
+                });
+                shapes.push({ curves, bounds });
+            }
+        }
+    }
+    const gpuData = packSlugData(shapes);
+    const planeBounds = computePlaneBounds(glyphInfos);
+    return { gpuData, glyphs: glyphInfos, planeBounds };
+}
+function 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 } };
+}
+// Public API
+function buildVectorResult(layoutHandle, ctx, options) {
+    const scale = layoutHandle.layoutData.pixelsPerFontUnit;
+    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 newCtx = createOutlineContext(newLayout.loadedFont, newLayout.fontId, globalOutlineCache);
+            layoutHandle = newLayout;
+            options = mergedOptions;
+            return buildVectorResult(layoutHandle, newCtx, options);
+        }
+        const newLayout = await layoutHandle.update(mergedOptions);
+        layoutHandle = newLayout;
+        options = mergedOptions;
+        return buildVectorResult(layoutHandle, ctx, options);
+    };
+    const { gpuData, glyphs, planeBounds } = collectForSlug(ctx, layoutHandle.clustersByLine, scale);
+    return {
+        gpuData,
+        glyphs,
+        planeBounds,
+        query: (queryOptions) => {
+            if (!cachedQuery) {
+                cachedQuery = new 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.setHarfBuzzPath; }
+    static { this.setHarfBuzzBuffer = Text$1.setHarfBuzzBuffer; }
+    static { this.init = Text$1.init; }
+    static { this.registerPattern = Text$1.registerPattern; }
+    static { this.preloadPatterns = Text$1.preloadPatterns; }
+    static { this.setMaxFontCacheMemoryMB = Text$1.setMaxFontCacheMemoryMB; }
+    static { this.enableWoff2 = Text$1.enableWoff2; }
+    static async create(options) {
+        const layoutHandle = await Text$1.create(options);
+        const ctx = createOutlineContext(layoutHandle.loadedFont, layoutHandle.fontId, globalOutlineCache);
+        return buildVectorResult(layoutHandle, ctx, options);
+    }
+}
+
+export { Text };