@codexo/exojs 0.6.8 → 0.6.10

package/dist/exo.esm.js

@@ -706,7 +706,7 @@ const trimRotation = (degrees) => {
 const degreesToRadians = (degree) => degree * radiansPerDegree;
 const radiansToDegrees = (radian) => radian * degreesPerRadian;
 const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
-const sign$1 = (value) => (value && (value < 0 ? -1 : 1));
+const sign = (value) => (value && (value < 0 ? -1 : 1));
 const lerp = (startValue, endValue, ratio) => (((1 - ratio) * startValue) + (ratio * endValue));
 const isPowerOfTwo = (value) => ((value !== 0) && ((value & (value - 1)) === 0));
 const inRange = (value, min, max) => (value >= Math.min(min, max) && value <= Math.max(min, max));
@@ -6211,19 +6211,6 @@ const createCanvas = (options = {}) => {
     context.fillRect(0, 0, newCanvas.width, newCanvas.height);
     return newCanvas;
 };
-const heightCache = new Map();
-const determineFontHeight = (font) => {
-    if (!heightCache.has(font)) {
-        const body = document.body;
-        const dummy = document.createElement('div');
-        dummy.appendChild(document.createTextNode('M'));
-        dummy.setAttribute('style', `font: ${font};position:absolute;top:0;left:0`);
-        body.appendChild(dummy);
-        heightCache.set(font, dummy.offsetHeight);
-        body.removeChild(dummy);
-    }
-    return heightCache.get(font);
-};
 
 class Texture {
     static _black = null;
@@ -15465,636 +15452,166 @@ class Input {
     }
 }
 
-function earcut(data, holeIndices, dim = 2) {
-
-    const hasHoles = holeIndices && holeIndices.length;
-    const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
-    let outerNode = linkedList(data, 0, outerLen, dim, true);
-    const triangles = [];
-
-    if (!outerNode || outerNode.next === outerNode.prev) return triangles;
-
-    let minX, minY, invSize;
-
-    if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
-
-    // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
-    if (data.length > 80 * dim) {
-        minX = data[0];
-        minY = data[1];
-        let maxX = minX;
-        let maxY = minY;
-
-        for (let i = dim; i < outerLen; i += dim) {
-            const x = data[i];
-            const y = data[i + 1];
-            if (x < minX) minX = x;
-            if (y < minY) minY = y;
-            if (x > maxX) maxX = x;
-            if (y > maxY) maxY = y;
-        }
-
-        // minX, minY and invSize are later used to transform coords into integers for z-order calculation
-        invSize = Math.max(maxX - minX, maxY - minY);
-        invSize = invSize !== 0 ? 32767 / invSize : 0;
-    }
-
-    earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
-
-    return triangles;
-}
-
-// create a circular doubly linked list from polygon points in the specified winding order
-function linkedList(data, start, end, dim, clockwise) {
-    let last;
-
-    if (clockwise === (signedArea(data, start, end, dim) > 0)) {
-        for (let i = start; i < end; i += dim) last = insertNode(i / dim | 0, data[i], data[i + 1], last);
-    } else {
-        for (let i = end - dim; i >= start; i -= dim) last = insertNode(i / dim | 0, data[i], data[i + 1], last);
-    }
-
-    if (last && equals(last, last.next)) {
-        removeNode(last);
-        last = last.next;
-    }
-
-    return last;
-}
-
-// eliminate colinear or duplicate points
-function filterPoints(start, end) {
-    if (!start) return start;
-    if (!end) end = start;
-
-    let p = start,
-        again;
-    do {
-        again = false;
-
-        if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
-            removeNode(p);
-            p = end = p.prev;
-            if (p === p.next) break;
-            again = true;
-
-        } else {
-            p = p.next;
-        }
-    } while (again || p !== end);
-
-    return end;
-}
-
-// main ear slicing loop which triangulates a polygon (given as a linked list)
-function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
-    if (!ear) return;
-
-    // interlink polygon nodes in z-order
-    if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
-
-    let stop = ear;
-
-    // iterate through ears, slicing them one by one
-    while (ear.prev !== ear.next) {
-        const prev = ear.prev;
-        const next = ear.next;
-
-        if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
-            triangles.push(prev.i, ear.i, next.i); // cut off the triangle
-
-            removeNode(ear);
-
-            // skipping the next vertex leads to less sliver triangles
-            ear = next.next;
-            stop = next.next;
-
-            continue;
-        }
-
-        ear = next;
-
-        // if we looped through the whole remaining polygon and can't find any more ears
-        if (ear === stop) {
-            // try filtering points and slicing again
-            if (!pass) {
-                earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
-
-            // if this didn't work, try curing all small self-intersections locally
-            } else if (pass === 1) {
-                ear = cureLocalIntersections(filterPoints(ear), triangles);
-                earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
-
-            // as a last resort, try splitting the remaining polygon into two
-            } else if (pass === 2) {
-                splitEarcut(ear, triangles, dim, minX, minY, invSize);
+/**
+ * Triangulate a simple 2D polygon by ear-clipping.
+ *
+ * Input: `vertices` is a flat sequence of (x, y) pairs (length must be even,
+ * minimum 6 = 3 vertices). Polygon may be CW or CCW; the algorithm normalises
+ * to CCW internally.
+ *
+ * Output: a `Uint32Array` of indices in groups of 3 (per triangle), referencing
+ * vertex positions (the i-th vertex spans `vertices[2*i], vertices[2*i + 1]`).
+ *
+ * Polygons that are degenerate (all collinear), zero-area, or self-intersecting
+ * may produce incomplete output but must not throw or hang.
+ *
+ * @param vertices flat (x, y) pairs
+ * @returns triangle index list (length is multiple of 3)
+ */
+function triangulate(vertices) {
+    const n = vertices.length >> 1;
+    if (n < 3) {
+        return new Uint32Array(0);
+    }
+    if (n === 3) {
+        // Return in CCW order; swap if input triangle is CW.
+        const ax = vertices[0], ay = vertices[1];
+        const bx = vertices[2], by = vertices[3];
+        const cx = vertices[4], cy = vertices[5];
+        return isCcwTriangle(ax, ay, bx, by, cx, cy)
+            ? new Uint32Array([0, 1, 2])
+            : new Uint32Array([2, 1, 0]);
+    }
+    // Build doubly-linked list of vertex indices.
+    const prev = new Uint32Array(n);
+    const next = new Uint32Array(n);
+    for (let i = 0; i < n; i++) {
+        prev[i] = (i + n - 1) % n;
+        next[i] = (i + 1) % n;
+    }
+    // Normalise to CCW: compute signed area; if negative (CW), reverse the list.
+    if (signedArea(vertices) < 0) {
+        for (let i = 0; i < n; i++) {
+            const tmp = prev[i];
+            prev[i] = next[i];
+            next[i] = tmp;
+        }
+    }
+    const maxTriangles = n - 2;
+    const out = new Uint32Array(maxTriangles * 3);
+    let outIdx = 0;
+    let remaining = n;
+    let current = 0;
+    // Ear-clipping: at most O(n^2) iterations; bail after one full pass finds no ear.
+    while (remaining > 3) {
+        // Try each remaining vertex as a potential ear, one full pass at a time.
+        let earFound = false;
+        const passStart = current;
+        do {
+            const p = prev[current];
+            const nx = next[current];
+            const v = current;
+            const ax = vertices[p * 2], ay = vertices[p * 2 + 1];
+            const bx = vertices[v * 2], by = vertices[v * 2 + 1];
+            const cx = vertices[nx * 2], cy = vertices[nx * 2 + 1];
+            if (isCcwTriangle(ax, ay, bx, by, cx, cy) && isEar(vertices, prev, next, p, v, nx)) {
+                // Emit triangle (prev, v, next).
+                out[outIdx++] = p;
+                out[outIdx++] = v;
+                out[outIdx++] = nx;
+                // Remove v from the list.
+                next[p] = nx;
+                prev[nx] = p;
+                remaining--;
+                earFound = true;
+                current = nx;
+                break;
             }
-
+            current = next[current];
+        } while (current !== passStart);
+        if (!earFound) {
+            // Degenerate polygon: no ear found in a full pass; bail out.
             break;
         }
     }
-}
-
-// check whether a polygon node forms a valid ear with adjacent nodes
-function isEar(ear) {
-    const a = ear.prev,
-        b = ear,
-        c = ear.next;
-
-    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
-
-    // now make sure we don't have other points inside the potential ear
-    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
-
-    // triangle bbox
-    const x0 = Math.min(ax, bx, cx),
-        y0 = Math.min(ay, by, cy),
-        x1 = Math.max(ax, bx, cx),
-        y1 = Math.max(ay, by, cy);
-
-    let p = c.next;
-    while (p !== a) {
-        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 &&
-            pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) &&
-            area(p.prev, p, p.next) >= 0) return false;
-        p = p.next;
-    }
-
-    return true;
-}
-
-function isEarHashed(ear, minX, minY, invSize) {
-    const a = ear.prev,
-        b = ear,
-        c = ear.next;
-
-    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
-
-    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
-
-    // triangle bbox
-    const x0 = Math.min(ax, bx, cx),
-        y0 = Math.min(ay, by, cy),
-        x1 = Math.max(ax, bx, cx),
-        y1 = Math.max(ay, by, cy);
-
-    // z-order range for the current triangle bbox;
-    const minZ = zOrder(x0, y0, minX, minY, invSize),
-        maxZ = zOrder(x1, y1, minX, minY, invSize);
-
-    let p = ear.prevZ,
-        n = ear.nextZ;
-
-    // look for points inside the triangle in both directions
-    while (p && p.z >= minZ && n && n.z <= maxZ) {
-        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
-            pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
-        p = p.prevZ;
-
-        if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
-            pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
-        n = n.nextZ;
-    }
-
-    // look for remaining points in decreasing z-order
-    while (p && p.z >= minZ) {
-        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
-            pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
-        p = p.prevZ;
-    }
-
-    // look for remaining points in increasing z-order
-    while (n && n.z <= maxZ) {
-        if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
-            pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
-        n = n.nextZ;
-    }
-
-    return true;
-}
-
-// go through all polygon nodes and cure small local self-intersections
-function cureLocalIntersections(start, triangles) {
-    let p = start;
-    do {
-        const a = p.prev,
-            b = p.next.next;
-
-        if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
-
-            triangles.push(a.i, p.i, b.i);
-
-            // remove two nodes involved
-            removeNode(p);
-            removeNode(p.next);
-
-            p = start = b;
+    // Emit the final triangle if exactly 3 vertices remain.
+    // Emit in CCW order (the linked-list direction may be CW after prior clips on concave polygons).
+    if (remaining === 3) {
+        const pa = prev[current];
+        const nc = next[current];
+        const ax = vertices[pa * 2], ay = vertices[pa * 2 + 1];
+        const bx = vertices[current * 2], by = vertices[current * 2 + 1];
+        const cx = vertices[nc * 2], cy = vertices[nc * 2 + 1];
+        if (isCcwTriangle(ax, ay, bx, by, cx, cy)) {
+            out[outIdx++] = pa;
+            out[outIdx++] = current;
+            out[outIdx++] = nc;
         }
-        p = p.next;
-    } while (p !== start);
-
-    return filterPoints(p);
-}
-
-// try splitting polygon into two and triangulate them independently
-function splitEarcut(start, triangles, dim, minX, minY, invSize) {
-    // look for a valid diagonal that divides the polygon into two
-    let a = start;
-    do {
-        let b = a.next.next;
-        while (b !== a.prev) {
-            if (a.i !== b.i && isValidDiagonal(a, b)) {
-                // split the polygon in two by the diagonal
-                let c = splitPolygon(a, b);
-
-                // filter colinear points around the cuts
-                a = filterPoints(a, a.next);
-                c = filterPoints(c, c.next);
-
-                // run earcut on each half
-                earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
-                earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
-                return;
-            }
-            b = b.next;
-        }
-        a = a.next;
-    } while (a !== start);
-}
-
-// link every hole into the outer loop, producing a single-ring polygon without holes
-function eliminateHoles(data, holeIndices, outerNode, dim) {
-    const queue = [];
-
-    for (let i = 0, len = holeIndices.length; i < len; i++) {
-        const start = holeIndices[i] * dim;
-        const end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-        const list = linkedList(data, start, end, dim, false);
-        if (list === list.next) list.steiner = true;
-        queue.push(getLeftmost(list));
-    }
-
-    queue.sort(compareXYSlope);
-
-    // process holes from left to right
-    for (let i = 0; i < queue.length; i++) {
-        outerNode = eliminateHole(queue[i], outerNode);
-    }
-
-    return outerNode;
-}
-
-function compareXYSlope(a, b) {
-    let result = a.x - b.x;
-    // when the left-most point of 2 holes meet at a vertex, sort the holes counterclockwise so that when we find
-    // the bridge to the outer shell is always the point that they meet at.
-    if (result === 0) {
-        result = a.y - b.y;
-        if (result === 0) {
-            const aSlope = (a.next.y - a.y) / (a.next.x - a.x);
-            const bSlope = (b.next.y - b.y) / (b.next.x - b.x);
-            result = aSlope - bSlope;
+        else {
+            out[outIdx++] = nc;
+            out[outIdx++] = current;
+            out[outIdx++] = pa;
         }
     }
-    return result;
+    return out.subarray(0, outIdx);
 }
-
-// find a bridge between vertices that connects hole with an outer ring and link it
-function eliminateHole(hole, outerNode) {
-    const bridge = findHoleBridge(hole, outerNode);
-    if (!bridge) {
-        return outerNode;
-    }
-
-    const bridgeReverse = splitPolygon(bridge, hole);
-
-    // filter collinear points around the cuts
-    filterPoints(bridgeReverse, bridgeReverse.next);
-    return filterPoints(bridge, bridge.next);
+/** Shoelace signed area. Positive = CCW (mathematical orientation), negative = CW. */
+function signedArea(vertices) {
+    const n = vertices.length >> 1;
+    let area = 0;
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        const x0 = vertices[i * 2];
+        const y0 = vertices[i * 2 + 1];
+        const x1 = vertices[j * 2];
+        const y1 = vertices[j * 2 + 1];
+        area += (x0 * y1) - (x1 * y0);
+    }
+    return area; // Positive = CCW, negative = CW.
 }
-
-// David Eberly's algorithm for finding a bridge between hole and outer polygon
-function findHoleBridge(hole, outerNode) {
-    let p = outerNode;
-    const hx = hole.x;
-    const hy = hole.y;
-    let qx = -Infinity;
-    let m;
-
-    // find a segment intersected by a ray from the hole's leftmost point to the left;
-    // segment's endpoint with lesser x will be potential connection point
-    // unless they intersect at a vertex, then choose the vertex
-    if (equals(hole, p)) return p;
-    do {
-        if (equals(hole, p.next)) return p.next;
-        else if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
-            const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
-            if (x <= hx && x > qx) {
-                qx = x;
-                m = p.x < p.next.x ? p : p.next;
-                if (x === hx) return m; // hole touches outer segment; pick leftmost endpoint
-            }
-        }
-        p = p.next;
-    } while (p !== outerNode);
-
-    if (!m) return null;
-
-    // look for points inside the triangle of hole point, segment intersection and endpoint;
-    // if there are no points found, we have a valid connection;
-    // otherwise choose the point of the minimum angle with the ray as connection point
-
-    const stop = m;
-    const mx = m.x;
-    const my = m.y;
-    let tanMin = Infinity;
-
-    p = m;
-
-    do {
-        if (hx >= p.x && p.x >= mx && hx !== p.x &&
-                pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
-
-            const tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
-
-            if (locallyInside(p, hole) &&
-                (tan < tanMin || (tan === tanMin && (p.x > m.x || (p.x === m.x && sectorContainsSector(m, p)))))) {
-                m = p;
-                tanMin = tan;
-            }
-        }
-
-        p = p.next;
-    } while (p !== stop);
-
-    return m;
-}
-
-// whether sector in vertex m contains sector in vertex p in the same coordinates
-function sectorContainsSector(m, p) {
-    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+/**
+ * Returns true if the triangle (a, b, c) has a counter-clockwise (CCW) winding.
+ * Uses the cross product of (b-a) × (c-a); positive = CCW.
+ */
+function isCcwTriangle(ax, ay, bx, by, cx, cy) {
+    return ((bx - ax) * (cy - ay) - (by - ay) * (cx - ax)) > 0;
 }
-
-// interlink polygon nodes in z-order
-function indexCurve(start, minX, minY, invSize) {
-    let p = start;
-    do {
-        if (p.z === 0) p.z = zOrder(p.x, p.y, minX, minY, invSize);
-        p.prevZ = p.prev;
-        p.nextZ = p.next;
-        p = p.next;
-    } while (p !== start);
-
-    p.prevZ.nextZ = null;
-    p.prevZ = null;
-
-    sortLinked(p);
+/**
+ * Returns true if point (px, py) lies strictly inside triangle (a, b, c).
+ * Uses sign-of-cross-products. Boundary points (including corners) return false.
+ */
+function pointInTriangle(px, py, ax, ay, bx, by, cx, cy) {
+    const d1 = (px - bx) * (ay - by) - (ax - bx) * (py - by);
+    const d2 = (px - cx) * (by - cy) - (bx - cx) * (py - cy);
+    const d3 = (px - ax) * (cy - ay) - (cx - ax) * (py - ay);
+    const hasNeg = (d1 < 0) || (d2 < 0) || (d3 < 0);
+    const hasPos = (d1 > 0) || (d2 > 0) || (d3 > 0);
+    // Strictly inside: all same sign and none are exactly zero (exclude boundary).
+    return !(hasNeg && hasPos) && (d1 !== 0) && (d2 !== 0) && (d3 !== 0);
 }
-
-// Simon Tatham's linked list merge sort algorithm
-// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
-function sortLinked(list) {
-    let numMerges;
-    let inSize = 1;
-
-    do {
-        let p = list;
-        let e;
-        list = null;
-        let tail = null;
-        numMerges = 0;
-
-        while (p) {
-            numMerges++;
-            let q = p;
-            let pSize = 0;
-            for (let i = 0; i < inSize; i++) {
-                pSize++;
-                q = q.nextZ;
-                if (!q) break;
-            }
-            let qSize = inSize;
-
-            while (pSize > 0 || (qSize > 0 && q)) {
-
-                if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
-                    e = p;
-                    p = p.nextZ;
-                    pSize--;
-                } else {
-                    e = q;
-                    q = q.nextZ;
-                    qSize--;
-                }
-
-                if (tail) tail.nextZ = e;
-                else list = e;
-
-                e.prevZ = tail;
-                tail = e;
+/**
+ * Returns true if vertex v is an ear: the triangle (prevIdx, v, nextIdx) contains
+ * no other polygon vertex strictly inside it.
+ */
+function isEar(vertices, prev, next, prevIdx, v, nextIdx) {
+    const ax = vertices[prevIdx * 2], ay = vertices[prevIdx * 2 + 1];
+    const bx = vertices[v * 2], by = vertices[v * 2 + 1];
+    const cx = vertices[nextIdx * 2], cy = vertices[nextIdx * 2 + 1];
+    // Walk all remaining vertices and check if any lie strictly inside the ear triangle.
+    // Skip the three ear vertices themselves — they can never be "inside" by strict test,
+    // but we exclude them explicitly for clarity and to avoid floating-point edge cases.
+    let node = next[nextIdx];
+    while (node !== prevIdx) {
+        if (node !== v) {
+            const px = vertices[node * 2];
+            const py = vertices[node * 2 + 1];
+            if (pointInTriangle(px, py, ax, ay, bx, by, cx, cy)) {
+                return false;
             }
-
-            p = q;
         }
-
-        tail.nextZ = null;
-        inSize *= 2;
-
-    } while (numMerges > 1);
-
-    return list;
-}
-
-// z-order of a point given coords and inverse of the longer side of data bbox
-function zOrder(x, y, minX, minY, invSize) {
-    // coords are transformed into non-negative 15-bit integer range
-    x = (x - minX) * invSize | 0;
-    y = (y - minY) * invSize | 0;
-
-    x = (x | (x << 8)) & 0x00FF00FF;
-    x = (x | (x << 4)) & 0x0F0F0F0F;
-    x = (x | (x << 2)) & 0x33333333;
-    x = (x | (x << 1)) & 0x55555555;
-
-    y = (y | (y << 8)) & 0x00FF00FF;
-    y = (y | (y << 4)) & 0x0F0F0F0F;
-    y = (y | (y << 2)) & 0x33333333;
-    y = (y | (y << 1)) & 0x55555555;
-
-    return x | (y << 1);
-}
-
-// find the leftmost node of a polygon ring
-function getLeftmost(start) {
-    let p = start,
-        leftmost = start;
-    do {
-        if (p.x < leftmost.x || (p.x === leftmost.x && p.y < leftmost.y)) leftmost = p;
-        p = p.next;
-    } while (p !== start);
-
-    return leftmost;
-}
-
-// check if a point lies within a convex triangle
-function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
-    return (cx - px) * (ay - py) >= (ax - px) * (cy - py) &&
-           (ax - px) * (by - py) >= (bx - px) * (ay - py) &&
-           (bx - px) * (cy - py) >= (cx - px) * (by - py);
-}
-
-// check if a point lies within a convex triangle but false if its equal to the first point of the triangle
-function pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, px, py) {
-    return !(ax === px && ay === py) && pointInTriangle(ax, ay, bx, by, cx, cy, px, py);
-}
-
-// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
-function isValidDiagonal(a, b) {
-    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // doesn't intersect other edges
-           (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
-            (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
-            equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0); // special zero-length case
-}
-
-// signed area of a triangle
-function area(p, q, r) {
-    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
-}
-
-// check if two points are equal
-function equals(p1, p2) {
-    return p1.x === p2.x && p1.y === p2.y;
-}
-
-// check if two segments intersect
-function intersects(p1, q1, p2, q2) {
-    const o1 = sign(area(p1, q1, p2));
-    const o2 = sign(area(p1, q1, q2));
-    const o3 = sign(area(p2, q2, p1));
-    const o4 = sign(area(p2, q2, q1));
-
-    if (o1 !== o2 && o3 !== o4) return true; // general case
-
-    if (o1 === 0 && onSegment(p1, p2, q1)) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
-    if (o2 === 0 && onSegment(p1, q2, q1)) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
-    if (o3 === 0 && onSegment(p2, p1, q2)) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
-    if (o4 === 0 && onSegment(p2, q1, q2)) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2
-
-    return false;
-}
-
-// for collinear points p, q, r, check if point q lies on segment pr
-function onSegment(p, q, r) {
-    return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
-}
-
-function sign(num) {
-    return num > 0 ? 1 : num < 0 ? -1 : 0;
-}
-
-// check if a polygon diagonal intersects any polygon segments
-function intersectsPolygon(a, b) {
-    let p = a;
-    do {
-        if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
-                intersects(p, p.next, a, b)) return true;
-        p = p.next;
-    } while (p !== a);
-
-    return false;
-}
-
-// check if a polygon diagonal is locally inside the polygon
-function locallyInside(a, b) {
-    return area(a.prev, a, a.next) < 0 ?
-        area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :
-        area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
-}
-
-// check if the middle point of a polygon diagonal is inside the polygon
-function middleInside(a, b) {
-    let p = a;
-    let inside = false;
-    const px = (a.x + b.x) / 2;
-    const py = (a.y + b.y) / 2;
-    do {
-        if (((p.y > py) !== (p.next.y > py)) && p.next.y !== p.y &&
-                (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x))
-            inside = !inside;
-        p = p.next;
-    } while (p !== a);
-
-    return inside;
-}
-
-// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
-// if one belongs to the outer ring and another to a hole, it merges it into a single ring
-function splitPolygon(a, b) {
-    const a2 = createNode(a.i, a.x, a.y),
-        b2 = createNode(b.i, b.x, b.y),
-        an = a.next,
-        bp = b.prev;
-
-    a.next = b;
-    b.prev = a;
-
-    a2.next = an;
-    an.prev = a2;
-
-    b2.next = a2;
-    a2.prev = b2;
-
-    bp.next = b2;
-    b2.prev = bp;
-
-    return b2;
-}
-
-// create a node and optionally link it with previous one (in a circular doubly linked list)
-function insertNode(i, x, y, last) {
-    const p = createNode(i, x, y);
-
-    if (!last) {
-        p.prev = p;
-        p.next = p;
-
-    } else {
-        p.next = last.next;
-        p.prev = last;
-        last.next.prev = p;
-        last.next = p;
-    }
-    return p;
-}
-
-function removeNode(p) {
-    p.next.prev = p.prev;
-    p.prev.next = p.next;
-
-    if (p.prevZ) p.prevZ.nextZ = p.nextZ;
-    if (p.nextZ) p.nextZ.prevZ = p.prevZ;
-}
-
-function createNode(i, x, y) {
-    return {
-        i, // vertex index in coordinates array
-        x, y, // vertex coordinates
-        prev: null, // previous and next vertex nodes in a polygon ring
-        next: null,
-        z: 0, // z-order curve value
-        prevZ: null, // previous and next nodes in z-order
-        nextZ: null,
-        steiner: false // indicates whether this is a steiner point
-    };
-}
-
-function signedArea(data, start, end, dim) {
-    let sum = 0;
-    for (let i = start, j = end - dim; i < end; i += dim) {
-        sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
-        j = i;
+        node = next[node];
     }
-    return sum;
+    return true;
 }
 
 const buildLine = (startX, startY, endX, endY, width) => {
@@ -16298,13 +15815,13 @@ const buildPolygon = (points) => {
         throw new Error('At least three X/Y pairs are required to build a polygon.');
     }
     const length = points.length / 2;
-    const triangles = earcut(points, [], 2);
+    const triangles = triangulate(points);
     const vertices = new Float32Array(points.length);
     for (let i = 0; i < length; i++) {
         vertices[i * 2] = points[i * 2];
         vertices[(i * 2) + 1] = points[(i * 2) + 1];
     }
-    const indices = triangles ? new Uint16Array(triangles) : new Uint16Array(0);
+    const indices = new Uint16Array(triangles);
     return { vertices, indices, points };
 };
 const buildRectangle = (x, y, width, height) => {
@@ -17629,14 +17146,227 @@ class AnimatedSprite extends Sprite {
     }
 }
 
+const glyphPadding = 2;
+class ShelfPacker {
+    _shelves = [];
+    _width;
+    _height;
+    constructor(width, height) {
+        this._width = width;
+        this._height = height;
+    }
+    insert(width, height) {
+        // Try existing shelves in order (ascending y)
+        for (const shelf of this._shelves) {
+            if (shelf.height >= height && shelf.cursorX + width <= this._width) {
+                const x = shelf.cursorX;
+                shelf.cursorX += width;
+                return { x, y: shelf.y };
+            }
+        }
+        // Create a new shelf at the bottom
+        const last = this._shelves[this._shelves.length - 1];
+        const bottomY = last === undefined ? 0 : last.y + last.height;
+        if (bottomY + height > this._height) {
+            throw new Error(`GlyphAtlas full — clear() and re-render, or instantiate with larger dims`);
+        }
+        this._shelves.push({ y: bottomY, height, cursorX: width });
+        return { x: 0, y: bottomY };
+    }
+    reset() {
+        this._shelves.length = 0;
+    }
+}
+/**
+ * A shared atlas that rasterizes glyphs on demand into an offscreen canvas
+ * and wraps it as a Texture for use by the Mesh-based Text renderer.
+ *
+ * Glyphs are always rasterized in white so that runtime tinting via
+ * `Mesh.tint` applies the fill color without requiring re-rasterization.
+ *
+ * Use `getDefaultGlyphAtlas()` from `atlas-singleton.ts` rather than
+ * constructing directly.
+ */
+class DynamicGlyphAtlas {
+    texture;
+    _canvas;
+    _ctx;
+    _packer;
+    _cache = new Map();
+    _width;
+    _height;
+    constructor(width = 1024, height = 1024) {
+        this._width = width;
+        this._height = height;
+        // Use OffscreenCanvas when available, fall back to HTMLCanvasElement.
+        // In jsdom / Node the global may be absent; createCanvas falls through
+        // to document.createElement which jsdom provides.
+        const canvas = typeof OffscreenCanvas !== 'undefined'
+            ? new OffscreenCanvas(width, height)
+            : document.createElement('canvas');
+        if ('width' in canvas) {
+            canvas.width = width;
+            canvas.height = height;
+        }
+        this._canvas = canvas;
+        const ctx = canvas.getContext('2d');
+        if (ctx === null) {
+            throw new Error('DynamicGlyphAtlas: could not obtain a 2D context.');
+        }
+        this._ctx = ctx;
+        this._packer = new ShelfPacker(width, height);
+        this.texture = new Texture(canvas);
+        this.texture.setSize(width, height);
+    }
+    /**
+     * Returns the cached GlyphInfo for the given character + font parameters,
+     * rasterizing it into the atlas if not already present.
+     */
+    getGlyph(char, family, size, weight, style) {
+        const key = `${char}:${family}:${size}:${weight}:${style}`;
+        const cached = this._cache.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const info = this._rasterize(char, family, size, weight, style, key);
+        this._cache.set(key, info);
+        // Bump texture version so GPU backends re-upload the canvas data.
+        this.texture.updateSource();
+        return info;
+    }
+    /**
+     * Clears all cached glyphs and resets the atlas packer.
+     * The underlying canvas pixels are also cleared.
+     */
+    clear() {
+        this._cache.clear();
+        this._packer.reset();
+        this._ctx.clearRect(0, 0, this._width, this._height);
+        this.texture.updateSource();
+    }
+    // -----------------------------------------------------------------------
+    _rasterize(char, family, size, weight, fontStyle, _key) {
+        const ctx = this._ctx;
+        const padding = glyphPadding;
+        ctx.font = `${fontStyle} ${weight} ${size}px ${family}`;
+        ctx.textBaseline = 'alphabetic';
+        ctx.fillStyle = '#ffffff';
+        const metrics = ctx.measureText(char);
+        const ascent = Math.ceil(metrics.fontBoundingBoxAscent
+            ?? metrics.actualBoundingBoxAscent
+            ?? size * 0.8);
+        const descent = Math.ceil(metrics.fontBoundingBoxDescent
+            ?? metrics.actualBoundingBoxDescent
+            ?? size * 0.2);
+        const advance = metrics.width;
+        const glyphWidth = Math.max(1, Math.ceil((metrics.actualBoundingBoxLeft ?? 0) + (metrics.actualBoundingBoxRight ?? 0)) || Math.ceil(advance));
+        const glyphHeight = Math.max(1, ascent + descent);
+        const slotW = glyphWidth + padding * 2;
+        const slotH = glyphHeight + padding * 2;
+        const slot = this._packer.insert(slotW, slotH);
+        // Draw the glyph white into the atlas slot
+        ctx.fillText(char, slot.x + padding + (metrics.actualBoundingBoxLeft ?? 0), slot.y + padding + ascent);
+        const info = {
+            x: slot.x,
+            y: slot.y,
+            width: glyphWidth,
+            height: glyphHeight,
+            advance,
+            ascent,
+            uvLeft: slot.x / this._width,
+            uvTop: slot.y / this._height,
+            uvRight: (slot.x + slotW) / this._width,
+            uvBottom: (slot.y + slotH) / this._height,
+        };
+        return info;
+    }
+}
+
+let _defaultAtlas = null;
+/**
+ * Returns the shared process-wide glyph atlas, creating it lazily on first
+ * call.  All `Text` instances share this atlas so that identical glyph shapes
+ * (same char + family + size + weight + style) are rasterized only once.
+ */
+function getDefaultGlyphAtlas() {
+    if (_defaultAtlas === null) {
+        _defaultAtlas = new DynamicGlyphAtlas();
+    }
+    return _defaultAtlas;
+}
+
+/**
+ * Computes per-glyph quad placements for the given text and style.
+ *
+ * Handles `\n` line breaks and left/center/right alignment. No word-wrap,
+ * no RTL, no ligature shaping — Unicode/diacritics are delegated to the
+ * browser's font engine via canvas `fillText`.
+ *
+ * Returns an empty array for empty text.
+ */
+function layoutText(text, style, atlas) {
+    if (text.length === 0) {
+        return [];
+    }
+    const { fontSize, fontFamily, fontWeight, fontStyle, lineHeight, align } = style;
+    const computedLineHeight = fontSize * lineHeight;
+    const lines = text.split('\n');
+    // Pass 1: gather glyph info per line, track line widths
+    const linePlacements = [];
+    let maxLineWidth = 0;
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex];
+        const y = lineIndex * computedLineHeight;
+        let cursorX = 0;
+        const placements = [];
+        for (const char of line) {
+            const info = atlas.getGlyph(char, fontFamily, fontSize, fontWeight, fontStyle);
+            placements.push({ info, x: cursorX, y });
+            cursorX += info.advance;
+        }
+        const lineWidth = cursorX;
+        if (lineWidth > maxLineWidth) {
+            maxLineWidth = lineWidth;
+        }
+        linePlacements.push({ placements, width: lineWidth });
+    }
+    // Pass 2: apply alignment and build final GlyphPlacement array
+    const result = [];
+    for (const line of linePlacements) {
+        let offsetX = 0;
+        if (align === 'right') {
+            offsetX = maxLineWidth - line.width;
+        }
+        else if (align === 'center') {
+            offsetX = (maxLineWidth - line.width) / 2;
+        }
+        for (const { info, x, y } of line.placements) {
+            result.push({
+                x: x + offsetX,
+                y,
+                width: info.width,
+                height: info.height,
+                uvLeft: info.uvLeft,
+                uvTop: info.uvTop,
+                uvRight: info.uvRight,
+                uvBottom: info.uvBottom,
+            });
+        }
+    }
+    return result;
+}
+
 class TextStyle {
     _align;
     _fill;
+    _fillColor;
+    _lineHeight;
     _stroke;
     _strokeThickness;
     _fontSize;
     _fontWeight;
     _fontFamily;
+    _fontStyle;
     _wordWrap;
     _wordWrapWidth;
     _baseline;
@@ -17647,11 +17377,14 @@ class TextStyle {
     constructor(options = {}) {
         this._align = options.align ?? 'left';
         this._fill = options.fill ?? 'black';
+        this._fillColor = options.fillColor ?? Color.white.clone();
+        this._lineHeight = options.lineHeight ?? 1.2;
         this._stroke = options.stroke ?? 'black';
         this._strokeThickness = options.strokeThickness ?? 1;
         this._fontSize = options.fontSize ?? 20;
         this._fontWeight = options.fontWeight ?? 'bold';
         this._fontFamily = options.fontFamily ?? 'Arial';
+        this._fontStyle = options.fontStyle ?? 'normal';
         this._wordWrap = options.wordWrap ?? false;
         this._wordWrapWidth = options.wordWrapWidth ?? 100;
         this._baseline = options.baseline ?? 'alphabetic';
@@ -17677,6 +17410,31 @@ class TextStyle {
             this._dirty = true;
         }
     }
+    /**
+     * Runtime fill color applied via `Mesh.tint`. Glyphs are always
+     * rasterized white; this color multiplies them at draw time so that
+     * changing the color never requires re-rasterizing cached glyphs.
+     */
+    get fillColor() {
+        return this._fillColor;
+    }
+    set fillColor(color) {
+        this._fillColor = color;
+        this._dirty = true;
+    }
+    /**
+     * Line-height multiplier applied to `fontSize` when computing vertical
+     * spacing between lines. Defaults to 1.2.
+     */
+    get lineHeight() {
+        return this._lineHeight;
+    }
+    set lineHeight(lineHeight) {
+        if (this._lineHeight !== lineHeight) {
+            this._lineHeight = lineHeight;
+            this._dirty = true;
+        }
+    }
     get stroke() {
         return this._stroke;
     }
@@ -17722,6 +17480,15 @@ class TextStyle {
             this._dirty = true;
         }
     }
+    get fontStyle() {
+        return this._fontStyle;
+    }
+    set fontStyle(fontStyle) {
+        if (this._fontStyle !== fontStyle) {
+            this._fontStyle = fontStyle;
+            this._dirty = true;
+        }
+    }
     get wordWrap() {
         return this._wordWrap;
     }
@@ -17799,11 +17566,14 @@ class TextStyle {
         if (style !== this) {
             this.align = style.align;
             this.fill = style.fill;
+            this._fillColor = style.fillColor.clone();
+            this.lineHeight = style.lineHeight;
             this.stroke = style.stroke;
             this.strokeThickness = style.strokeThickness;
             this.fontSize = style.fontSize;
             this.fontWeight = style.fontWeight;
             this.fontFamily = style.fontFamily;
+            this.fontStyle = style.fontStyle;
             this.wordWrap = style.wordWrap;
             this.wordWrapWidth = style.wordWrapWidth;
             this.baseline = style.baseline;
@@ -17819,26 +17589,81 @@ class TextStyle {
     }
 }
 
-const newLinePattern = /(?:\r\n|\r|\n)/;
-class Text extends Sprite {
+function buildMesh(placements, style) {
+    const n = placements.length;
+    const vertices = new Float32Array(n * 4 * 2);
+    const uvs = new Float32Array(n * 4 * 2);
+    const indices = new Uint16Array(n * 6);
+    for (let i = 0; i < n; i++) {
+        const p = placements[i];
+        const v = i * 8;
+        const u = i * 8;
+        const idx = i * 6;
+        const baseV = i * 4;
+        // Vertices: TL, TR, BR, BL
+        vertices[v + 0] = p.x;
+        vertices[v + 1] = p.y;
+        vertices[v + 2] = p.x + p.width;
+        vertices[v + 3] = p.y;
+        vertices[v + 4] = p.x + p.width;
+        vertices[v + 5] = p.y + p.height;
+        vertices[v + 6] = p.x;
+        vertices[v + 7] = p.y + p.height;
+        // UVs: TL, TR, BR, BL
+        uvs[u + 0] = p.uvLeft;
+        uvs[u + 1] = p.uvTop;
+        uvs[u + 2] = p.uvRight;
+        uvs[u + 3] = p.uvTop;
+        uvs[u + 4] = p.uvRight;
+        uvs[u + 5] = p.uvBottom;
+        uvs[u + 6] = p.uvLeft;
+        uvs[u + 7] = p.uvBottom;
+        // Indices: [TL, TR, BR, TL, BR, BL]
+        indices[idx + 0] = baseV + 0;
+        indices[idx + 1] = baseV + 1;
+        indices[idx + 2] = baseV + 2;
+        indices[idx + 3] = baseV + 0;
+        indices[idx + 4] = baseV + 2;
+        indices[idx + 5] = baseV + 3;
+    }
+    const atlas = getDefaultGlyphAtlas();
+    const mesh = new Mesh({
+        vertices,
+        uvs,
+        indices,
+        texture: atlas.texture,
+    });
+    mesh.tint = style.fillColor;
+    return mesh;
+}
+/**
+ * GPU-accelerated text node that rasterizes individual glyphs into a shared
+ * atlas ({@link DynamicGlyphAtlas}) and renders them as a single quad-per-
+ * glyph {@link Mesh} (one draw call per Text instance).
+ *
+ * Glyphs are always rasterized in white and tinted at runtime via
+ * `Mesh.tint`; changing `style.fillColor` only updates the mesh tint —
+ * no atlas re-rasterization is needed.
+ *
+ * The internal {@link Mesh} is the sole child of this {@link Container}.
+ * All transform properties (position, rotation, scale, origin) are
+ * inherited from {@link Container} → {@link RenderNode}.
+ */
+class Text extends Container {
     _text;
     _style;
-    _canvas;
-    _context;
-    _dirty = true;
-    constructor(text, style, samplerOptions, canvas = document.createElement('canvas')) {
-        super(new Texture(canvas, samplerOptions));
+    _mesh = null;
+    constructor(text, style) {
+        super();
         this._text = text;
         this._style = (style && style instanceof TextStyle) ? style : new TextStyle(style);
-        this._canvas = canvas;
-        this._context = canvas.getContext('2d');
-        this.updateTexture();
+        this._rebuild();
     }
     get text() {
         return this._text;
     }
-    set text(text) {
-        this.setText(text);
+    set text(value) {
+        this.setText(value);
     }
     get style() {
         return this._style;
@@ -17846,98 +17671,43 @@ class Text extends Sprite {
     set style(style) {
         this.setStyle(style);
     }
-    get canvas() {
-        return this._canvas;
-    }
-    set canvas(canvas) {
-        this.setCanvas(canvas);
-    }
     setText(text) {
         if (this._text !== text) {
             this._text = text;
-            this._dirty = true;
+            this._rebuild();
         }
         return this;
     }
     setStyle(style) {
         this._style = (style instanceof TextStyle) ? style : new TextStyle(style);
-        this._dirty = true;
-        return this;
-    }
-    setCanvas(canvas) {
-        if (this._canvas !== canvas) {
-            this._canvas = canvas;
-            this._context = this._getContext(canvas);
-            this._dirty = true;
-            this.texture.setSource.call(this.texture, canvas);
-            this.setTextureFrame(Rectangle.temp.set(0, 0, canvas.width, canvas.height));
-        }
-        return this;
-    }
-    updateTexture() {
-        if (this._style && (this._dirty || this._style.dirty)) {
-            const canvas = this._canvas, context = this._context, style = this._style.apply(context), text = style.wordWrap ? this.getWordWrappedText() : this._text, lineHeight = determineFontHeight(context.font) + style.strokeThickness, lines = text.split(newLinePattern), lineMetrics = lines.map((line) => context.measureText(line)), maxLineWidth = lineMetrics.reduce((max, measure) => Math.max(max, measure.width), 0), canvasWidth = Math.ceil((maxLineWidth + style.strokeThickness) + (style.padding * 2)), canvasHeight = Math.ceil((lineHeight * lines.length) + (style.padding * 2));
-            if (canvasWidth !== canvas.width || canvasHeight !== canvas.height) {
-                canvas.width = canvasWidth;
-                canvas.height = canvasHeight;
-                this.setTextureFrame(Rectangle.temp.set(0, 0, canvasWidth, canvasHeight));
-            }
-            else {
-                context.clearRect(0, 0, canvasWidth, canvasHeight);
-            }
-            style.apply(context);
-            for (let i = 0; i < lines.length; i++) {
-                const metrics = lineMetrics[i], lineWidth = (maxLineWidth - metrics.width), offset = (style.align === 'right') ? lineWidth : lineWidth / 2, padding = style.padding + (style.strokeThickness / 2), lineX = metrics.actualBoundingBoxLeft + (style.align === 'left' ? 0 : offset) + padding, lineY = metrics.actualBoundingBoxAscent + (lineHeight * i) + padding;
-                if (style.stroke && style.strokeThickness) {
-                    context.strokeText(lines[i], lineX, lineY);
-                }
-                if (style.fill) {
-                    context.fillText(lines[i], lineX, lineY);
-                }
-            }
-            this.texture.updateSource();
-            this._dirty = false;
-            this._style.dirty = false;
-        }
+        this._rebuild();
         return this;
     }
-    getWordWrappedText() {
-        const context = this._context, wrapWidth = this._style.wordWrapWidth, lines = this._text.split('\n'), spaceWidth = context.measureText(' ').width;
-        let spaceLeft = wrapWidth, result = '';
-        for (let y = 0; y < lines.length; y++) {
-            const words = lines[y].split(' ');
-            if (y > 0) {
-                result += '\n';
-            }
-            for (let x = 0; x < words.length; x++) {
-                const word = words[x], wordWidth = context.measureText(word).width, pairWidth = wordWidth + spaceWidth;
-                if (pairWidth > spaceLeft) {
-                    if (x > 0) {
-                        result += '\n';
-                    }
-                    spaceLeft = wrapWidth;
-                }
-                else {
-                    spaceLeft -= pairWidth;
-                }
-                result += `${word} `;
-            }
+    destroy() {
+        if (this._mesh !== null) {
+            this._mesh.destroy();
+            this._mesh = null;
         }
-        return result;
+        super.destroy();
     }
-    render(backend) {
-        if (this.visible) {
-            this.updateTexture();
-            super.render(backend);
+    // -----------------------------------------------------------------------
+    _rebuild() {
+        // Remove and discard the old mesh (if any).
+        if (this._mesh !== null) {
+            this.removeChild(this._mesh);
+            this._mesh.destroy();
+            this._mesh = null;
+        }
+        if (this._text.length === 0) {
+            return;
         }
-        return this;
-    }
-    _getContext(canvas) {
-        const context = canvas.getContext('2d');
-        if (context === null) {
-            throw new Error('Could not create a 2D canvas context.');
+        const atlas = getDefaultGlyphAtlas();
+        const placements = layoutText(this._text, this._style, atlas);
+        if (placements.length === 0) {
+            return;
         }
-        return context;
+        this._mesh = buildMesh(placements, this._style);
+        this.addChild(this._mesh);
     }
 }
 
@@ -18519,5 +18289,5 @@ class IndexedDbStore {
     }
 }
 
-export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Capabilities, ChannelOffset, ChannelSize, Circle, Clock, CollisionType, Color, ColorAffector, ColorFilter, Container, Drawable, Ellipse, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadChannel, GamepadControl, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Graphics, ImageFactory, IndexedDbDatabase, IndexedDbStore, Input, InputManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, Particle, ParticleOptions, ParticleSystem, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuSpriteRenderer, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRenderStats, createWebGl2ShaderProgram, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, lerp, matchesIds, maxPointers, milliseconds, minutes, noop$1 as noop, normalizeIds, onAudioContextReady, parseGamepadDescriptor, pointerSlotSize, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign$1 as sign, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
+export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Capabilities, ChannelOffset, ChannelSize, Circle, Clock, CollisionType, Color, ColorAffector, ColorFilter, Container, Drawable, DynamicGlyphAtlas, Ellipse, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadChannel, GamepadControl, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Graphics, ImageFactory, IndexedDbDatabase, IndexedDbStore, Input, InputManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, Particle, ParticleOptions, ParticleSystem, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuSpriteRenderer, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRenderStats, createWebGl2ShaderProgram, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, layoutText, lerp, matchesIds, maxPointers, milliseconds, minutes, noop$1 as noop, normalizeIds, onAudioContextReady, parseGamepadDescriptor, pointerSlotSize, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
 //# sourceMappingURL=exo.esm.js.map