@haiyue/extensions 0.1.0

package/dist/chunks/Animation2DStateMachine-9IonguNa.js

@@ -0,0 +1,3245 @@
+import { HYA_STATE_MACHINE_EXTENSION_ID, AnimationFormatError, ANIMATION_VECTOR_SHAPE_EXTENSION_ID } from '@haiyue/animation-spec';
+import { Geometry2D, Component, Entity, Transform2D } from '@haiyue/engine';
+import { createRect2D } from '@haiyue/engine/geometry';
+import { UniqueCheckType } from '@haiyue/engine/ecs';
+import { ParticleEmitter2D } from '@haiyue/engine/components';
+import { A as Animation3DStateMachineController, c as compileAnimationStateMachineDefinition } from './AnimationStateMachineController-BIcAh-sT.js';
+
+/**
+ * A vertex in a circular doubly linked list representing a polygon ring.
+ * `prev`/`next` are always linked (set immediately after {@link createNode}), so they're typed
+ * non-null; `prevZ`/`nextZ` are the z-order list links and are null at the ends.
+ *
+ * @typedef {object} Node
+ * @property {number} i vertex index in the coordinates array
+ * @property {number} x vertex x coordinate
+ * @property {number} y vertex y coordinate
+ * @property {Node} prev previous vertex node in the polygon ring
+ * @property {Node} next next vertex node in the polygon ring
+ * @property {number} z z-order curve value; doubles as the owning block index during eliminateHoles
+ * @property {Node | null} prevZ previous node in z-order
+ * @property {Node | null} nextZ next node in z-order
+ */
+
+// single-vertex holes to preserve through filterPoints (steiner points); kept off the Node
+// shape since they're rare — the empty-set fast path means non-steiner inputs pay nothing
+/** @type {Set<Node>} */
+const steiners = new Set();
+
+// set by filterPoints whenever it removes at least one node; read by earcutLinked's stall
+// handler to decide whether another clip pass is worth attempting before the costlier stages
+let filteredOut = false;
+
+/**
+ * Triangulate a polygon given as a flat array of vertex coordinates.
+ *
+ * @param {ArrayLike<number>} data flat array of vertex coordinates
+ * @param {ArrayLike<number> | null} [holeIndices] indices (in vertices, not coordinates) where each hole ring starts
+ * @param {number} [dim=2] number of coordinates per vertex in `data`
+ * @returns {number[]} triangles as triplets of vertex indices into `data`
+ * @example earcut([10,0, 0,50, 60,60, 70,10]); // [1,0,3, 3,2,1]
+ */
+function earcut(data, holeIndices, dim = 2) {
+
+    const hasHoles = holeIndices && holeIndices.length;
+    const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+    if (steiners.size) steiners.clear();
+
+    let outerNode = linkedList(data, 0, outerLen, dim, true);
+    /** @type {number[]} */
+    const triangles = [];
+
+    if (!outerNode || outerNode.next === outerNode.prev) return triangles;
+
+    let minX = 0, minY = 0, invSize = 0;
+
+    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, minX, minY, invSize);
+
+    return triangles;
+}
+
+// create a circular doubly linked list from polygon points in the specified winding order
+/** @param {ArrayLike<number>} data @param {number} start @param {number} end @param {number} dim @param {boolean} clockwise @returns {Node | null} */
+function linkedList(data, start, end, dim, clockwise) {
+    /** @type {Node | null} */
+    let last = null;
+
+    if (clockwise === (signedArea$1(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;
+}
+
+// Remove collinear or coincident points; removability depends only on a node's immediate
+// neighbors, so we sweep forward and re-check the predecessor after each removal. With no `end`
+// we sweep the whole ring, lapping until nothing is removable (the fixpoint the clipper needs).
+// With an explicit `end` we heal only the dirty window around a bridge/diagonal cut, stopping at
+// `end` rather than lapping — O(window) instead of O(ring).
+/** @param {Node} start @param {Node} [end] @returns {Node} */
+function filterPoints(start, end = start) {
+    const full = end === start;
+
+    let p = start, again;
+    do {
+        again = false;
+        if (p !== p.next && (steiners.size === 0 || !steiners.has(p)) &&
+            (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+            if (full || p === end) end = p.prev; // pull the stop bound back past the removal
+            filteredOut = true;
+            removeNode(p);
+            p = p.prev;         // re-check the predecessor
+            again = true;
+        } else if (full || p !== end) {
+            p = p.next;
+            again = !full;      // local heal: keep looping until the sweep reaches end
+        }
+    } while (again || p !== end);
+
+    return end;
+}
+
+// main ear slicing loop which triangulates a polygon (given as a linked list)
+/** @param {Node} ear @param {number[]} triangles @param {number} minX @param {number} minY @param {number} invSize */
+function earcutLinked(ear, triangles, minX, minY, invSize) {
+    // interlink polygon nodes in z-order
+    if (invSize) indexCurve(ear, minX, minY, invSize);
+
+    let stop = ear, cured = false;
+
+    // iterate through ears, slicing them one by one
+    while (ear.prev !== ear.next) {
+        const prev = ear.prev;
+        /** @type {Node} */
+        const next = ear.next;
+
+        if (area(prev, ear, next) < 0 && (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear))) {
+            triangles.push(prev.i, ear.i, next.i); // cut off the triangle
+
+            removeNode(ear);
+            ear = next;
+            stop = next;
+            continue;
+        }
+
+        ear = next;
+
+        // if we looped through the whole remaining polygon and can't find any more ears
+        if (ear === stop) {
+            // try filtering collinear/coincident points and slicing again — repeat as long as
+            // filtering actually removes nodes, since each removal can expose new ears
+            filteredOut = false;
+            ear = filterPoints(ear);
+            if (filteredOut) { stop = ear; continue; }
+
+            // filtering is exhausted: cure small local self-intersections once, then retry
+            if (!cured) {
+                ear = cureLocalIntersections(ear, triangles);
+                stop = ear;
+                cured = true;
+                continue;
+            }
+
+            // as a last resort, try splitting the remaining polygon into two
+            splitEarcut(ear, triangles, minX, minY, invSize);
+            break;
+        }
+    }
+}
+
+// check whether a polygon node forms a valid ear with adjacent nodes
+/** @param {Node} ear @returns {boolean} */
+function isEar(ear) {
+    // reflex check (area(a, b, c) >= 0) is hoisted into the earcutLinked caller to avoid non-inlined call here
+    const a = ear.prev, b = ear, c = ear.next,
+        ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y,
+        x0 = Math.min(ax, bx, cx), // triangle bbox
+        y0 = Math.min(ay, by, cy),
+        x1 = Math.max(ax, bx, cx),
+        y1 = Math.max(ay, by, cy);
+
+    // make sure we don't have other points inside the potential ear
+    let p = c.next;
+    while (p !== a) {
+        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && !(ax === p.x && ay === p.y) &&
+            pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+        p = p.next;
+    }
+    return true;
+}
+
+/** @param {Node} ear @param {number} minX @param {number} minY @param {number} invSize @returns {boolean} */
+function isEarHashed(ear, minX, minY, invSize) {
+    // reflex check is hoisted into the earcutLinked caller (see isEar)
+    const a = ear.prev, b = ear, c = ear.next,
+        ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y,
+        x0 = Math.min(ax, bx, cx), // triangle bbox
+        y0 = Math.min(ay, by, cy),
+        x1 = Math.max(ax, bx, cx),
+        y1 = Math.max(ay, by, cy),
+        minZ = zOrder(x0, y0, minX, minY, invSize), // z-order range for the current triangle bbox;
+        maxZ = zOrder(x1, y1, minX, minY, invSize);
+
+    let p = ear.prevZ;
+    while (p && p.z >= minZ) { // look for points inside the triangle in decreasing z-order
+        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== c && !(ax === p.x && ay === p.y) &&
+            pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+        p = p.prevZ;
+    }
+    let n = ear.nextZ;
+    while (n && n.z <= maxZ) { // look for points in increasing z-order
+        if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== c && !(ax === n.x && ay === n.y) &&
+            pointInTriangle(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
+/** @param {Node} start @param {number[]} triangles @returns {Node} */
+function cureLocalIntersections(start, triangles) {
+    let p = start;
+    let cured = false;
+    do {
+        const a = p.prev,
+            b = p.next.next;
+
+        if (intersects(a, p, p.next, b, false) && 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;
+            cured = true;
+        }
+        p = p.next;
+    } while (p !== start);
+
+    return cured ? filterPoints(p) : p;
+}
+
+// try splitting polygon into two and triangulate them independently
+/** @param {Node} start @param {number[]} triangles @param {number} minX @param {number} minY @param {number} invSize */
+function splitEarcut(start, triangles, 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, minX, minY, invSize);
+                earcutLinked(c, triangles, minX, minY, invSize);
+                return;
+            }
+            b = b.next;
+        }
+        a = a.next;
+    } while (a !== start);
+}
+
+// true only while eliminateHoles merges holes, so removeNode keeps the block index live (growBlock)
+let indexActive = false;
+
+// link every hole into the outer loop, producing a single-ring polygon without holes
+/** @param {ArrayLike<number>} data @param {ArrayLike<number>} holeIndices @param {Node} outerNode @param {number} dim @returns {Node} */
+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 = /** @type {Node} */ (linkedList(data, start, end, dim, false));
+        if (list === list.next) steiners.add(list);
+        queue.push(getLeftmost(list));
+    }
+
+    queue.sort(compareXYSlope);
+
+    // block-bbox index for findHoleBridge, grown append-only as holes merge (see notes
+    // above buildBlockIndex). Seed it with the outer ring, then append each merged hole.
+    buildBlockIndex(data.length / dim, holeIndices.length);
+    indexSegment(outerNode, outerNode);
+
+    // process holes from left to right; indexActive lets removeNode keep block bboxes live as
+    // filterPoints heals edges during merges (see growBlock)
+    indexActive = true;
+    for (let i = 0; i < queue.length; i++) {
+        outerNode = eliminateHole(queue[i], outerNode);
+    }
+    indexActive = false;
+
+    // collapse collinear/coincident points across the whole merged ring once before clipping
+    return filterPoints(outerNode);
+}
+
+/** @param {Node} a @param {Node} b @returns {number} */
+function compareXYSlope(a, b) {
+    // 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.
+    return a.x - b.x || a.y - b.y ||
+        (a.next.y - a.y) / (a.next.x - a.x) -
+        (b.next.y - b.y) / (b.next.x - b.x);
+}
+
+// find a bridge between vertices that connects hole with an outer ring and link it
+/** @param {Node} hole @param {Node} outerNode @returns {Node} */
+function eliminateHole(hole, outerNode) {
+    const bridge = findHoleBridge(hole, outerNode);
+    if (!bridge) {
+        return outerNode;
+    }
+
+    const bridgeReverse = splitPolygon(bridge, hole);
+
+    // index the merged-in segment before filtering: in ring order the splice runs
+    // bridge -> hole -> bridgeReverse -> bridge2 -> (bridge's old next), covering the
+    // hole's edges and both new slit edges. filterPoints below only drops collinear /
+    // coincident points, so these bboxes stay valid (conservative) supersets.
+    const bridge2 = bridgeReverse.next;
+    indexSegment(bridge, bridge2.next);
+
+    // heal collinear/coincident points around the two new slit edges
+    filterPoints(bridgeReverse, bridgeReverse.next);
+    return filterPoints(bridge, bridge.next);
+}
+
+// Block-bbox index for findHoleBridge (issue #183): one [minX,minY,maxX,maxY] bbox per K
+// consecutive ring edges, in a flat Float64Array, so the leftward-ray scan can skip whole
+// blocks in O(1) instead of walking the entire merged ring. Grown append-only — the outer
+// ring seeds it, then each merged hole appends a segment (head node, stop node, K-blocks
+// over head..stop); independent segments, not a ring tiling, since splices land mid-ring.
+// Buffers are sized once from the input upper bound and reused across calls.
+//
+// filterPoints only drops collinear/coincident points, so a stale bbox stays a conservative
+// superset of its live edges (never a false skip); the scan skips dead nodes (p.prev.next !==
+// p) and lazily advances a dead stop. Blocks are scanned in append (not ring) order, so the
+// chosen bridge can differ from the un-indexed code — a different but equally valid result.
+const K = 16; // edges per block
+
+let blockBBox = new Float64Array(0); // [minX,minY,maxX,maxY] per block
+let numBlocks = 0;
+/** @type {Node[]} */
+const blockHead = []; // first node of each block's segment
+/** @type {Node[]} */
+const blockStop = []; // node just past each block's segment (exclusive walk bound)
+
+/** @param {number} maxNodes @param {number} numHoles */
+function buildBlockIndex(maxNodes, numHoles) {
+    // upper bound: every input node indexed once, +2 bridge nodes per hole, plus a partial
+    // trailing block per appended segment (outer ring + one per hole)
+    const maxBlocks = Math.ceil((maxNodes + 2 * numHoles) / K) + numHoles + 2;
+    if (blockBBox.length < maxBlocks * 4) blockBBox = new Float64Array(maxBlocks * 4);
+    numBlocks = 0;
+}
+
+// index the ring run head..stop (exclusive) as ceil(len / K) blocks; head === stop means
+// the whole ring. each block's bbox covers both endpoints of every edge it owns.
+/** @param {Node} head @param {Node} stop */
+function indexSegment(head, stop) {
+    let p = head;
+    do {
+        const b = numBlocks++;
+        blockHead[b] = p;
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        let k = 0;
+        do {
+            const c = p.next; // edge p->c; bbox must bound both endpoints
+            p.z = b; // reuse z as the owning block during eliminateHoles (see growBlock)
+            if (p.x < minX) minX = p.x; if (p.x > maxX) maxX = p.x;
+            if (p.y < minY) minY = p.y; if (p.y > maxY) maxY = p.y;
+            if (c.x < minX) minX = c.x; if (c.x > maxX) maxX = c.x;
+            if (c.y < minY) minY = c.y; if (c.y > maxY) maxY = c.y;
+            p = c;
+        } while (++k < K && p !== stop);
+        blockStop[b] = p;
+        const g = b * 4;
+        blockBBox[g] = minX; blockBBox[g + 1] = minY; blockBBox[g + 2] = maxX; blockBBox[g + 3] = maxY;
+    } while (p !== stop);
+}
+
+// when filterPoints heals an edge head->tail (removing the collinear node between them), the
+// healed edge can extend past head's frozen block bbox if its old far endpoint lived in another
+// block; grow head's block bbox to cover tail so the leftward-ray prune can't false-skip it.
+/** @param {Node} head @param {Node} tail */
+function growBlock(head, tail) {
+    const g = head.z * 4;
+    if (tail.x < blockBBox[g]) blockBBox[g] = tail.x;
+    if (tail.y < blockBBox[g + 1]) blockBBox[g + 1] = tail.y;
+    if (tail.x > blockBBox[g + 2]) blockBBox[g + 2] = tail.x;
+    if (tail.y > blockBBox[g + 3]) blockBBox[g + 3] = tail.y;
+}
+
+/** @param {number} b @returns {Node} */
+function liveBlockStop(b) {
+    let stop = blockStop[b];
+    while (stop.prev.next !== stop) stop = stop.next;
+    blockStop[b] = stop;
+    return stop;
+}
+
+// the block's head node can be removed by filterPoints during merges; advance it to the next
+// live node so the walk doesn't start on (and immediately terminate at) a dead node. For the
+// single full-ring seed block (head === stop) the same forward advance keeps them equal, so the
+// do-while still laps the whole ring instead of collapsing to an empty walk.
+/** @param {number} b @returns {Node} */
+function liveBlockHead(b) {
+    let head = blockHead[b];
+    while (head.prev.next !== head) head = head.next;
+    blockHead[b] = head;
+    return head;
+}
+
+// David Eberly's algorithm for finding a bridge between hole and outer polygon
+/** @param {Node} hole @param {Node} outerNode @returns {Node | null} */
+function findHoleBridge(hole, outerNode) {
+    let p = outerNode;
+    const hx = hole.x;
+    const hy = hole.y;
+    let qx = -Infinity;
+    /** @type {Node | undefined} */
+    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;
+
+    // scan blocks; skip any whose bbox can't hold a crossing that beats qx and lies left
+    // of hx (the prune Morton order can't express — explicit per-axis [minY,maxY]/[minX,maxX])
+    for (let b = 0, g = 0; b < numBlocks; b++, g += 4) {
+        if (hy < blockBBox[g + 1] || hy > blockBBox[g + 3] || blockBBox[g] > hx || blockBBox[g + 2] <= qx) continue;
+
+        // ensure the walk's exclusive bound is live so we don't overrun into other blocks
+        const stop = liveBlockStop(b);
+
+        p = liveBlockHead(b);
+        do {
+            if (p.prev.next === p) { // skip nodes removed by filterPoints (stale in the index)
+                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 !== stop);
+    }
+
+    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 mx = m.x;
+    const my = m.y;
+    const tminY = Math.min(hy, my); // the triangle's y span; x span is [mx, hx]
+    const tmaxY = Math.max(hy, my);
+    let tanMin = Infinity;
+
+    // scan the same blocks; skip any whose bbox can't overlap the triangle's [mx,hx]×[tminY,tmaxY] box
+    for (let b = 0, g = 0; b < numBlocks; b++, g += 4) {
+        if (blockBBox[g + 2] < mx || blockBBox[g] > hx || blockBBox[g + 3] < tminY || blockBBox[g + 1] > tmaxY) continue;
+
+        const stop = liveBlockStop(b);
+
+        p = liveBlockHead(b);
+        do {
+            if (p.prev.next === p && hx >= p.x && p.x >= mx && hx !== p.x && // skip dead nodes
+                    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 hole point sits on p's horizontal edge (T-junction touch): the bridge runs
+                // along that edge — locallyInside rejects it as collinear, but it's valid
+                if ((locallyInside(p, hole) || (p.y === hy && p.next.y === hy && p.next.x > hx)) &&
+                    (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
+/** @param {Node} m @param {Node} p @returns {boolean} */
+function sectorContainsSector(m, p) {
+    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+}
+
+// scratch buffers reused across calls and grown on demand: two node-ref arrays that
+// ping-pong during the radix passes, plus parallel z-value arrays so the passes read
+// z from contiguous memory instead of dereferencing each node. 256-entry histogram for
+// 8-bit digits; the small histogram keeps per-call setup cheap (most rings are short)
+/** @type {Node[]} */
+const sortArr = [];
+/** @type {Node[]} */
+let sortBuf = [];
+let zArr = new Uint32Array(0);
+let zBuf = new Uint32Array(0);
+const counts = new Uint32Array(256);
+
+// interlink polygon nodes in z-order: collect into an array, sort by z, relink
+/** @param {Node} start @param {number} minX @param {number} minY @param {number} invSize */
+function indexCurve(start, minX, minY, invSize) {
+    let p = start;
+    let n = 0;
+    do {
+        // always (re)compute: z may still hold a block index left over from eliminateHoles
+        p.z = zOrder(p.x, p.y, minX, minY, invSize);
+        sortArr[n++] = p;
+        p = p.next;
+    } while (p !== start);
+
+    sortNodes(n);
+
+    /** @type {Node | null} */
+    let prev = null;
+    for (let i = 0; i < n; i++) {
+        const node = sortArr[i];
+        node.prevZ = prev;
+        if (prev) prev.nextZ = node;
+        prev = node;
+    }
+    /** @type {Node} */ (prev).nextZ = null;
+}
+
+// sort the first n nodes of sortArr by z, in place: insertion sort for small n (cheaper
+// than histogram setup), else LSD radix in four 8-bit passes (covering z's 30 bits)
+/** @param {number} n */
+function sortNodes(n) {
+    if (n <= 32) {
+        for (let i = 1; i < n; i++) {
+            const node = sortArr[i], z = node.z;
+            let j = i - 1;
+            while (j >= 0 && sortArr[j].z > z) { sortArr[j + 1] = sortArr[j]; j--; }
+            sortArr[j + 1] = node;
+        }
+        return;
+    }
+
+    if (zArr.length < n) {
+        zArr = new Uint32Array(n);
+        zBuf = new Uint32Array(n);
+        sortBuf = new Array(n);
+    }
+    for (let i = 0; i < n; i++) zArr[i] = sortArr[i].z;
+
+    // even pass count lands the sorted result back in sortArr
+    radixPass(n, sortArr, zArr, sortBuf, zBuf, 0);
+    radixPass(n, sortBuf, zBuf, sortArr, zArr, 8);
+    radixPass(n, sortArr, zArr, sortBuf, zBuf, 16);
+    radixPass(n, sortBuf, zBuf, sortArr, zArr, 24);
+}
+
+// one LSD radix pass: stably scatter the first n nodes (and their z) from src to dst,
+// bucketed by the 8-bit digit of z at the given bit shift
+/** @param {number} n @param {Node[]} src @param {Uint32Array} srcZ @param {Node[]} dst @param {Uint32Array} dstZ @param {number} shift */
+function radixPass(n, src, srcZ, dst, dstZ, shift) {
+    counts.fill(0);
+    for (let i = 0; i < n; i++) counts[(srcZ[i] >>> shift) & 0xff]++;
+    // turn per-bucket counts into start offsets (prefix sum)
+    let sum = 0;
+    for (let b = 0; b < 256; b++) { const c = counts[b]; counts[b] = sum; sum += c; }
+    for (let i = 0; i < n; i++) {
+        const z = srcZ[i];
+        const pos = counts[(z >>> shift) & 0xff]++;
+        dst[pos] = src[i];
+        dstZ[pos] = z;
+    }
+}
+
+// z-order of a point given coords and inverse of the longer side of data bbox
+/** @param {number} x @param {number} y @param {number} minX @param {number} minY @param {number} invSize @returns {number} */
+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
+/** @param {Node} start @returns {Node} */
+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
+/** @param {number} ax @param {number} ay @param {number} bx @param {number} by @param {number} cx @param {number} cy @param {number} px @param {number} py @returns {boolean} */
+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 diagonal between two polygon nodes is valid (lies in polygon interior)
+/** @param {Node} a @param {Node} b @returns {boolean} true when the diagonal is valid */
+function isValidDiagonal(a, b) {
+    const zeroLength = equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0; // degenerate case
+    return a.next.i !== b.i && (zeroLength || locallyInside(a, b) && locallyInside(b, a) && // // locally visible
+        (area(a.prev, a, b.prev) !== 0 || area(a, b.prev, b) !== 0)) && // no opposite-facing sectors
+        !intersectsPolygon(a, b) && (zeroLength || middleInside(a, b)); // doesn't intersect other edges, diagonal inside polygon
+}
+
+// signed area of a triangle
+/** @param {Node} p @param {Node} q @param {Node} r @returns {number} */
+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
+/** @param {Node} p1 @param {Node} p2 @returns {boolean} */
+function equals(p1, p2) {
+    return p1.x === p2.x && p1.y === p2.y;
+}
+
+// check if two segments intersect; by default includes collinear boundary touches
+/** @param {Node} p1 @param {Node} q1 @param {Node} p2 @param {Node} q2 @param {boolean} [includeBoundary] @returns {boolean} */
+function intersects(p1, q1, p2, q2, includeBoundary = true) {
+    const o1 = area(p1, q1, p2);
+    const o2 = area(p1, q1, q2);
+    const o3 = area(p2, q2, p1);
+    const o4 = area(p2, q2, q1);
+
+    if (((o1 > 0 && o2 < 0) || (o1 < 0 && o2 > 0)) && ((o3 > 0 && o4 < 0) || (o3 < 0 && o4 > 0))) return true;
+
+    if (!includeBoundary) return false;
+
+    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
+/** @param {Node} p @param {Node} q @param {Node} r @returns {boolean} */
+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);
+}
+
+// check if a polygon diagonal intersects any polygon segments
+/** @param {Node} a @param {Node} b @returns {boolean} */
+function intersectsPolygon(a, b) {
+    // diagonal bbox; an edge whose bbox can't overlap it can't intersect it, so
+    // skip the orientation test for those (the common case — the diagonal is short)
+    const minX = Math.min(a.x, b.x);
+    const maxX = Math.max(a.x, b.x);
+    const minY = Math.min(a.y, b.y);
+    const maxY = Math.max(a.y, b.y);
+
+    let p = a;
+    do {
+        const n = p.next;
+        if ((p.x > maxX && n.x > maxX) || (p.x < minX && n.x < minX) ||
+            (p.y > maxY && n.y > maxY) || (p.y < minY && n.y < minY)) {
+            p = n;
+            continue;
+        }
+        if (p.i !== a.i && n.i !== a.i && p.i !== b.i && n.i !== b.i &&
+                intersects(p, n, a, b)) return true;
+        p = n;
+    } while (p !== a);
+
+    return false;
+}
+
+// check if a polygon diagonal is locally inside the polygon
+/** @param {Node} a @param {Node} b @returns {boolean} */
+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
+/** @param {Node} a @param {Node} b @returns {boolean} */
+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 {
+        const n = p.next;
+        if (((p.y > py) !== (n.y > py)) && (px < (n.x - p.x) * (py - p.y) / (n.y - p.y) + p.x))
+            inside = !inside;
+        p = n;
+    } 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
+/** @param {Node} a @param {Node} b @returns {Node} */
+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)
+/** @param {number} i @param {number} x @param {number} y @param {Node | null} last @returns {Node} */
+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;
+}
+
+/** @param {Node} 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;
+
+    // keep the hole-bridge index's block bboxes covering the healed prev->next edge
+    if (indexActive) growBlock(p.prev, p.next);
+}
+
+/** @param {number} i @param {number} x @param {number} y @returns {Node} */
+function createNode(i, x, y) {
+    // prev/next are assigned by the caller before any read, so the null init is cast away here
+    return /** @type {Node} */ (/** @type {unknown} */ ({
+        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; doubles as owning block in the hole-bridge index during eliminateHoles
+        prevZ: null, // previous and next nodes in z-order
+        nextZ: null
+    }));
+}
+
+/** @param {ArrayLike<number>} data @param {number} start @param {number} end @param {number} dim @returns {number} */
+function signedArea$1(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;
+    }
+    return sum;
+}
+
+const geometryCache = new WeakMap();
+const strokeGeometryCache = new WeakMap();
+const MAX_FLATTENED_VERTICES = 262_144;
+/** Applies ordered source-neutral modifiers after curve flattening. Empty trim ranges return an empty command stream. */
+function applyVectorPathModifiers(commands, values, tolerance, modifiers, closeOpen) {
+    if (modifiers.length === 0)
+        return { commands, values: new Float32Array(values) };
+    let paths = flattenStrokePaths({
+        commands, values,
+        tolerance,
+    });
+    for (const modifier of modifiers) {
+        paths = modifier.kind === 'round-corners'
+            ? paths.map(path => roundStrokeSubpath(path, modifier.radius, tolerance))
+            : trimStrokeSubpaths(paths, modifier.start, modifier.end, modifier.offset, modifier.mode);
+    }
+    let resolvedCommands = '';
+    const resolvedValues = [];
+    for (const path of paths) {
+        if (path.points.length < 2 || subpathLength(path) <= 1e-6)
+            continue;
+        resolvedCommands += `M${'L'.repeat(path.points.length - 1)}${path.closed || closeOpen ? 'Z' : ''}`;
+        for (const point of path.points)
+            resolvedValues.push(point.x, point.y);
+    }
+    return { commands: resolvedCommands, values: new Float32Array(resolvedValues) };
+}
+function roundStrokeSubpath(path, radius, tolerance) {
+    if (radius <= 1e-6 || path.points.length < 3)
+        return path;
+    const result = [];
+    const last = path.points.length - 1;
+    for (let index = 0; index <= last; index++) {
+        const current = path.points[index];
+        if (!path.closed && (index === 0 || index === last)) {
+            result.push(current);
+            continue;
+        }
+        const previous = path.points[(index - 1 + path.points.length) % path.points.length];
+        const next = path.points[(index + 1) % path.points.length];
+        const previousLength = distance(previous, current);
+        const nextLength = distance(current, next);
+        if (previousLength <= 1e-6 || nextLength <= 1e-6) {
+            result.push(current);
+            continue;
+        }
+        const incomingX = (current.x - previous.x) / previousLength;
+        const incomingY = (current.y - previous.y) / previousLength;
+        const outgoingX = (next.x - current.x) / nextLength;
+        const outgoingY = (next.y - current.y) / nextLength;
+        if (incomingX * outgoingX + incomingY * outgoingY > 0.995) {
+            result.push(current);
+            continue;
+        }
+        const inset = Math.min(radius, previousLength * 0.5, nextLength * 0.5);
+        const entry = interpolatePoint(current, previous, inset / previousLength);
+        const exit = interpolatePoint(current, next, inset / nextLength);
+        result.push(entry);
+        const steps = Math.max(2, Math.min(16, Math.ceil(Math.sqrt(inset / Math.max(tolerance, 0.05)))));
+        for (let step = 1; step <= steps; step++) {
+            const t = step / steps;
+            const inverse = 1 - t;
+            result.push({
+                x: inverse * inverse * entry.x + 2 * inverse * t * current.x + t * t * exit.x,
+                y: inverse * inverse * entry.y + 2 * inverse * t * current.y + t * t * exit.y,
+            });
+        }
+    }
+    return { points: result, closed: path.closed };
+}
+function trimStrokeSubpaths(paths, start, end, offset, mode) {
+    const span = end - start;
+    if (Math.abs(span) >= 1 - 1e-6)
+        return paths.slice();
+    if (Math.abs(span) <= 1e-6)
+        return [];
+    const normalizedStart = wrapUnit(start + offset);
+    const normalizedEnd = wrapUnit(end + offset);
+    const intervals = normalizedEnd > normalizedStart
+        ? [[normalizedStart, normalizedEnd]]
+        : [[normalizedStart, 1], [0, normalizedEnd]];
+    if (mode === 'individual')
+        return paths.flatMap(path => {
+            const length = subpathLength(path);
+            return intervals.flatMap(([from, to]) => extractSubpathRange(path, from * length, to * length));
+        });
+    const lengths = paths.map(subpathLength);
+    const total = lengths.reduce((sum, length) => sum + length, 0);
+    if (total <= 1e-6)
+        return [];
+    const result = [];
+    let pathStart = 0;
+    for (let index = 0; index < paths.length; index++) {
+        const length = lengths[index];
+        const pathEnd = pathStart + length;
+        for (const [from, to] of intervals) {
+            const globalStart = from * total;
+            const globalEnd = to * total;
+            const overlapStart = Math.max(pathStart, globalStart);
+            const overlapEnd = Math.min(pathEnd, globalEnd);
+            if (overlapEnd > overlapStart + 1e-6) {
+                result.push(...extractSubpathRange(paths[index], overlapStart - pathStart, overlapEnd - pathStart));
+            }
+        }
+        pathStart = pathEnd;
+    }
+    return result;
+}
+function extractSubpathRange(path, from, to) {
+    const length = subpathLength(path);
+    if (length <= 1e-6 || to <= from + 1e-6)
+        return [];
+    if (from <= 1e-6 && to >= length - 1e-6)
+        return [path];
+    const segmentCount = path.closed ? path.points.length : path.points.length - 1;
+    const result = [pointAtSubpathDistance(path, from)];
+    let cursor = 0;
+    for (let segment = 0; segment < segmentCount; segment++) {
+        const next = (segment + 1) % path.points.length;
+        cursor += distance(path.points[segment], path.points[next]);
+        if (cursor > from + 1e-6 && cursor < to - 1e-6)
+            result.push(path.points[next]);
+    }
+    result.push(pointAtSubpathDistance(path, to));
+    return [{ points: result, closed: false }];
+}
+function pointAtSubpathDistance(path, target) {
+    const segmentCount = path.closed ? path.points.length : path.points.length - 1;
+    let cursor = 0;
+    for (let segment = 0; segment < segmentCount; segment++) {
+        const next = (segment + 1) % path.points.length;
+        const segmentLength = distance(path.points[segment], path.points[next]);
+        if (target <= cursor + segmentLength || segment === segmentCount - 1) {
+            return interpolatePoint(path.points[segment], path.points[next], segmentLength <= 1e-8 ? 0 : (target - cursor) / segmentLength);
+        }
+        cursor += segmentLength;
+    }
+    return path.points.at(-1);
+}
+function subpathLength(path) {
+    const segmentCount = path.closed ? path.points.length : path.points.length - 1;
+    let result = 0;
+    for (let index = 0; index < segmentCount; index++) {
+        result += distance(path.points[index], path.points[(index + 1) % path.points.length]);
+    }
+    return result;
+}
+function distance(left, right) {
+    return Math.hypot(right.x - left.x, right.y - left.y);
+}
+function interpolatePoint(from, to, progress) {
+    const t = Math.min(1, Math.max(0, progress));
+    return { x: from.x + (to.x - from.x) * t, y: from.y + (to.y - from.y) * t };
+}
+function wrapUnit(value) {
+    return ((value % 1) + 1) % 1;
+}
+/** Flattens packed quadratic/cubic commands and triangulates contours with hole nesting. */
+function tessellateAnimationPath(component) {
+    const cached = geometryCache.get(component);
+    if (cached)
+        return cached;
+    const contours = flattenPath(component);
+    if (contours.length === 0)
+        throw new RangeError('Animation path contains no drawable closed contour.');
+    classifyContours(contours, component.fillRule ?? 'nonzero');
+    const positions = [];
+    const indices = [];
+    for (let contourIndex = 0; contourIndex < contours.length; contourIndex++) {
+        const outer = contours[contourIndex];
+        if (outer.role !== 'outer')
+            continue;
+        const flat = [];
+        const holes = [];
+        appendContour(flat, outer.points);
+        for (let childIndex = 0; childIndex < contours.length; childIndex++) {
+            const hole = contours[childIndex];
+            if (hole.role !== 'hole' || nearestOuterAncestor(contours, childIndex) !== contourIndex)
+                continue;
+            holes.push(flat.length / 2);
+            appendContour(flat, hole.points);
+        }
+        const vertexOffset = positions.length / 2;
+        positions.push(...flat);
+        for (const index of earcut(flat, holes, 2))
+            indices.push(vertexOffset + index);
+    }
+    if (indices.length === 0)
+        throw new RangeError('Animation path tessellation produced no triangles.');
+    const indexArray = positions.length / 2 > 0xffff ? new Uint32Array(indices) : new Uint16Array(indices);
+    const geometry = new Geometry2D(new Float32Array(positions), indexArray);
+    geometryCache.set(component, geometry);
+    return geometry;
+}
+/** Tessellates the compact Lottie stroke extension without expanding it in the HYA payload. */
+function tessellateVectorStrokePath(component, allowEmpty = false) {
+    const cached = strokeGeometryCache.get(component);
+    if (cached)
+        return cached;
+    const flattened = flattenStrokePaths(component);
+    const subpaths = component.dash?.length
+        ? flattened.flatMap(subpath => dashStrokeSubpath(subpath, component.dash, component.dashOffset ?? 0))
+        : flattened;
+    const contours = subpaths.flatMap(subpath => strokeContours(subpath, component));
+    const positions = [];
+    const indices = [];
+    for (const contour of contours) {
+        if (contour.length < 3)
+            continue;
+        const flat = contour.flatMap(point => [point.x, point.y]);
+        const vertexOffset = positions.length / 2;
+        positions.push(...flat);
+        for (const index of earcut(flat, undefined, 2))
+            indices.push(vertexOffset + index);
+    }
+    if (indices.length === 0 && !allowEmpty)
+        throw new RangeError('Animation stroke tessellation produced no triangles.');
+    const indexArray = indices.length === 0
+        ? new Uint16Array([0, 1, 2])
+        : positions.length / 2 > 0xffff ? new Uint32Array(indices) : new Uint16Array(indices);
+    const geometry = new Geometry2D(indices.length === 0 ? new Float32Array(6) : new Float32Array(positions), indexArray);
+    strokeGeometryCache.set(component, geometry);
+    return geometry;
+}
+function dashStrokeSubpath(subpath, sourcePattern, sourceOffset) {
+    const positive = Array.from(sourcePattern, value => Math.max(0, value)).filter(value => value > 1e-6);
+    if (positive.length === 0)
+        return [subpath];
+    const pattern = positive.length % 2 === 0 ? positive : [...positive, ...positive];
+    const total = pattern.reduce((sum, value) => sum + value, 0);
+    let offset = ((sourceOffset % total) + total) % total;
+    let patternIndex = 0;
+    while (offset >= pattern[patternIndex]) {
+        offset -= pattern[patternIndex];
+        patternIndex = (patternIndex + 1) % pattern.length;
+    }
+    let remaining = pattern[patternIndex] - offset;
+    let drawing = patternIndex % 2 === 0;
+    const result = [];
+    let active = drawing ? [subpath.points[0]] : null;
+    const segmentCount = subpath.closed ? subpath.points.length : subpath.points.length - 1;
+    for (let segment = 0; segment < segmentCount; segment++) {
+        const from = subpath.points[segment];
+        const to = subpath.points[(segment + 1) % subpath.points.length];
+        const length = Math.hypot(to.x - from.x, to.y - from.y);
+        if (length <= 1e-8)
+            continue;
+        let distance = 0;
+        while (distance < length - 1e-8) {
+            const advance = Math.min(remaining, length - distance);
+            const endDistance = distance + advance;
+            const point = {
+                x: from.x + (to.x - from.x) * endDistance / length,
+                y: from.y + (to.y - from.y) * endDistance / length,
+            };
+            if (drawing) {
+                active ??= [{
+                        x: from.x + (to.x - from.x) * distance / length,
+                        y: from.y + (to.y - from.y) * distance / length,
+                    }];
+                active.push(point);
+            }
+            distance = endDistance;
+            remaining -= advance;
+            if (remaining <= 1e-8) {
+                if (drawing && active && active.length >= 2)
+                    result.push({ points: active, closed: false });
+                patternIndex = (patternIndex + 1) % pattern.length;
+                drawing = patternIndex % 2 === 0;
+                remaining = pattern[patternIndex];
+                active = drawing ? [point] : null;
+            }
+        }
+    }
+    if (drawing && active && active.length >= 2)
+        result.push({ points: active, closed: false });
+    return result;
+}
+/** Samples a topology-stable Lottie path morph into the ordinary path tessellator ABI. */
+function sampleVectorPathMorph(component, time) {
+    const values = samplePackedPathMorph(component, time);
+    return {
+        type: 'path2d',
+        commands: component.commands,
+        values,
+        fill: component.fill,
+        fillRule: component.fillRule,
+        ...(component.tolerance === undefined ? {} : { tolerance: component.tolerance }),
+    };
+}
+function samplePackedPathMorph(component, time) {
+    const frameCount = component.times.length;
+    if (frameCount === 0 || component.valueSize <= 0)
+        throw new RangeError('Lottie path morph contains no keyframes.');
+    let frame = 0;
+    while (frame + 1 < frameCount && component.times[frame + 1] <= time)
+        frame++;
+    const nextFrame = Math.min(frame + 1, frameCount - 1);
+    let progress = 0;
+    if (nextFrame !== frame && component.interpolation !== 'step') {
+        const start = component.times[frame];
+        const end = component.times[nextFrame];
+        progress = Math.min(1, Math.max(0, (time - start) / Math.max(1e-8, end - start)));
+        if (component.interpolation === 'cubic-bezier' && component.easings) {
+            const offset = frame * 4;
+            progress = cubicBezierYForX$2(progress, component.easings[offset] ?? 0.333, component.easings[offset + 1] ?? 0.333, component.easings[offset + 2] ?? 0.667, component.easings[offset + 3] ?? 0.667);
+        }
+    }
+    const fromOffset = frame * component.valueSize;
+    const toOffset = nextFrame * component.valueSize;
+    const values = new Float32Array(component.valueSize);
+    for (let offset = 0; offset < values.length; offset++) {
+        const from = component.values[fromOffset + offset] ?? 0;
+        const to = component.values[toOffset + offset] ?? from;
+        values[offset] = from + (to - from) * progress;
+    }
+    return values;
+}
+function cubicBezierYForX$2(x, x1, y1, x2, y2) {
+    let parameter = x;
+    for (let iteration = 0; iteration < 5; iteration++) {
+        const estimate = cubicBezierCoordinate(parameter, x1, x2) - x;
+        const derivative = cubicBezierDerivative(parameter, x1, x2);
+        if (Math.abs(derivative) < 1e-5)
+            break;
+        parameter = Math.min(1, Math.max(0, parameter - estimate / derivative));
+    }
+    return cubicBezierCoordinate(parameter, y1, y2);
+}
+function cubicBezierCoordinate(value, first, second) {
+    const inverse = 1 - value;
+    return 3 * inverse * inverse * value * first + 3 * inverse * value * value * second + value * value * value;
+}
+function cubicBezierDerivative(value, first, second) {
+    const inverse = 1 - value;
+    return 3 * inverse * inverse * first + 6 * inverse * value * (second - first) + 3 * value * value * (1 - second);
+}
+function flattenStrokePaths(component) {
+    const subpaths = [];
+    const values = component.values;
+    if (typeof component.commands !== 'string' || values === undefined) {
+        throw new TypeError('Resolved Lottie stroke extension requires commands and values.');
+    }
+    const toleranceSquared = (component.tolerance ?? 0.35) ** 2;
+    let valueOffset = 0;
+    let current = null;
+    let cursor = { x: 0, y: 0 };
+    let start = cursor;
+    const budget = { count: 0 };
+    const finish = (closed) => {
+        if (!current)
+            return;
+        const compact = [];
+        for (const point of current)
+            if (!compact.length || !samePoint(compact.at(-1), point))
+                compact.push(point);
+        if (closed && compact.length > 1 && samePoint(compact[0], compact.at(-1)))
+            compact.pop();
+        if (compact.length >= 2)
+            subpaths.push({ points: compact, closed });
+        current = null;
+    };
+    for (const command of component.commands) {
+        if (command === 'M') {
+            finish(false);
+            cursor = readPoint(values, valueOffset);
+            valueOffset += 2;
+            start = cursor;
+            current = [];
+            appendPoint(current, cursor, budget);
+        }
+        else if (command === 'L') {
+            cursor = readPoint(values, valueOffset);
+            valueOffset += 2;
+            if (current)
+                appendPoint(current, cursor, budget);
+        }
+        else if (command === 'Q') {
+            const control = readPoint(values, valueOffset);
+            const end = readPoint(values, valueOffset + 2);
+            valueOffset += 4;
+            if (current)
+                flattenQuadratic(cursor, control, end, toleranceSquared, current, budget, 0);
+            cursor = end;
+        }
+        else if (command === 'C') {
+            const control1 = readPoint(values, valueOffset);
+            const control2 = readPoint(values, valueOffset + 2);
+            const end = readPoint(values, valueOffset + 4);
+            valueOffset += 6;
+            if (current)
+                flattenCubic(cursor, control1, control2, end, toleranceSquared, current, budget, 0);
+            cursor = end;
+        }
+        else if (command === 'Z') {
+            cursor = start;
+            finish(true);
+        }
+    }
+    finish(false);
+    return subpaths;
+}
+function strokeContours(subpath, style) {
+    const points = subpath.points;
+    const closed = subpath.closed;
+    const halfWidth = style.width / 2;
+    const contours = [];
+    const segmentCount = closed ? points.length : points.length - 1;
+    for (let segment = 0; segment < segmentCount; segment++) {
+        const from = points[segment];
+        const to = points[(segment + 1) % points.length];
+        const direction = normalizePoint({ x: to.x - from.x, y: to.y - from.y });
+        if (!direction)
+            continue;
+        const normal = { x: -direction.y, y: direction.x };
+        const extendStart = !closed && style.lineCap === 'square' && segment === 0 ? halfWidth : 0;
+        const extendEnd = !closed && style.lineCap === 'square' && segment === segmentCount - 1 ? halfWidth : 0;
+        const start = { x: from.x - direction.x * extendStart, y: from.y - direction.y * extendStart };
+        const end = { x: to.x + direction.x * extendEnd, y: to.y + direction.y * extendEnd };
+        contours.push([
+            { x: start.x + normal.x * halfWidth, y: start.y + normal.y * halfWidth },
+            { x: end.x + normal.x * halfWidth, y: end.y + normal.y * halfWidth },
+            { x: end.x - normal.x * halfWidth, y: end.y - normal.y * halfWidth },
+            { x: start.x - normal.x * halfWidth, y: start.y - normal.y * halfWidth },
+        ]);
+    }
+    const joinStart = closed ? 0 : 1;
+    const joinEnd = closed ? points.length : points.length - 1;
+    for (let index = joinStart; index < joinEnd; index++) {
+        const previous = points[(index - 1 + points.length) % points.length];
+        const vertex = points[index];
+        const next = points[(index + 1) % points.length];
+        const incoming = normalizePoint({ x: vertex.x - previous.x, y: vertex.y - previous.y });
+        const outgoing = normalizePoint({ x: next.x - vertex.x, y: next.y - vertex.y });
+        if (!incoming || !outgoing)
+            continue;
+        if (style.lineJoin === 'round') {
+            contours.push(strokeCircle(vertex, halfWidth));
+            continue;
+        }
+        const cross = incoming.x * outgoing.y - incoming.y * outgoing.x;
+        if (Math.abs(cross) < 1e-6)
+            continue;
+        const side = cross > 0 ? 1 : -1;
+        const incomingNormal = { x: -incoming.y * side, y: incoming.x * side };
+        const outgoingNormal = { x: -outgoing.y * side, y: outgoing.x * side };
+        const outerIncoming = { x: vertex.x + incomingNormal.x * halfWidth, y: vertex.y + incomingNormal.y * halfWidth };
+        const outerOutgoing = { x: vertex.x + outgoingNormal.x * halfWidth, y: vertex.y + outgoingNormal.y * halfWidth };
+        if (style.lineJoin === 'miter') {
+            const bisector = normalizePoint({ x: incomingNormal.x + outgoingNormal.x, y: incomingNormal.y + outgoingNormal.y });
+            const denominator = bisector ? bisector.x * outgoingNormal.x + bisector.y * outgoingNormal.y : 0;
+            const miterLength = Math.abs(denominator) > 1e-6 ? halfWidth / denominator : Infinity;
+            if (bisector && miterLength > 0 && miterLength <= halfWidth * style.miterLimit) {
+                contours.push([outerIncoming, { x: vertex.x + bisector.x * miterLength, y: vertex.y + bisector.y * miterLength }, outerOutgoing]);
+                continue;
+            }
+        }
+        contours.push([outerIncoming, vertex, outerOutgoing]);
+    }
+    if (!closed && style.lineCap === 'round' && points.length > 1) {
+        contours.push(strokeCircle(points[0], halfWidth), strokeCircle(points.at(-1), halfWidth));
+    }
+    return contours;
+}
+function strokeCircle(center, radius) {
+    return Array.from({ length: 16 }, (_, index) => {
+        const angle = index * Math.PI * 2 / 16;
+        return { x: center.x + Math.cos(angle) * radius, y: center.y + Math.sin(angle) * radius };
+    });
+}
+function normalizePoint(point) {
+    const length = Math.hypot(point.x, point.y);
+    return length > 1e-8 ? { x: point.x / length, y: point.y / length } : null;
+}
+function flattenPath(component) {
+    const contours = [];
+    const values = component.values;
+    const toleranceSquared = (component.tolerance ?? 0.35) ** 2;
+    let valueOffset = 0;
+    let current = null;
+    let cursor = { x: 0, y: 0 };
+    let start = cursor;
+    const budget = { count: 0 };
+    for (const command of component.commands) {
+        if (command === 'M') {
+            if (current && current.length >= 3)
+                closeContour(contours, current);
+            cursor = readPoint(values, valueOffset);
+            valueOffset += 2;
+            start = cursor;
+            current = [];
+            appendPoint(current, cursor, budget);
+        }
+        else if (command === 'L') {
+            cursor = readPoint(values, valueOffset);
+            valueOffset += 2;
+            if (current)
+                appendPoint(current, cursor, budget);
+        }
+        else if (command === 'Q') {
+            const control = readPoint(values, valueOffset);
+            const end = readPoint(values, valueOffset + 2);
+            valueOffset += 4;
+            if (current)
+                flattenQuadratic(cursor, control, end, toleranceSquared, current, budget, 0);
+            cursor = end;
+        }
+        else if (command === 'C') {
+            const control1 = readPoint(values, valueOffset);
+            const control2 = readPoint(values, valueOffset + 2);
+            const end = readPoint(values, valueOffset + 4);
+            valueOffset += 6;
+            if (current)
+                flattenCubic(cursor, control1, control2, end, toleranceSquared, current, budget, 0);
+            cursor = end;
+        }
+        else if (command === 'Z' && current) {
+            if (!samePoint(cursor, start))
+                appendPoint(current, start, budget);
+            closeContour(contours, current);
+            current = null;
+            cursor = start;
+        }
+    }
+    return contours;
+}
+function readPoint(values, offset) {
+    return { x: values[offset] ?? 0, y: -(values[offset + 1] ?? 0) };
+}
+function flattenQuadratic(a, b, c, toleranceSquared, out, budget, depth) {
+    if (depth >= 12 || pointLineDistanceSquared(b, a, c) <= toleranceSquared) {
+        appendPoint(out, c, budget);
+        return;
+    }
+    const ab = midpoint(a, b), bc = midpoint(b, c), middle = midpoint(ab, bc);
+    flattenQuadratic(a, ab, middle, toleranceSquared, out, budget, depth + 1);
+    flattenQuadratic(middle, bc, c, toleranceSquared, out, budget, depth + 1);
+}
+function flattenCubic(a, b, c, d, toleranceSquared, out, budget, depth) {
+    if (depth >= 12 || Math.max(pointLineDistanceSquared(b, a, d), pointLineDistanceSquared(c, a, d)) <= toleranceSquared) {
+        appendPoint(out, d, budget);
+        return;
+    }
+    const ab = midpoint(a, b), bc = midpoint(b, c), cd = midpoint(c, d);
+    const abc = midpoint(ab, bc), bcd = midpoint(bc, cd), middle = midpoint(abc, bcd);
+    flattenCubic(a, ab, abc, middle, toleranceSquared, out, budget, depth + 1);
+    flattenCubic(middle, bcd, cd, d, toleranceSquared, out, budget, depth + 1);
+}
+function appendPoint(out, point, budget) {
+    if (++budget.count > MAX_FLATTENED_VERTICES) {
+        throw new RangeError(`Animation path exceeds the ${MAX_FLATTENED_VERTICES} flattened-vertex runtime budget.`);
+    }
+    out.push(point);
+}
+function closeContour(out, points) {
+    const compact = [];
+    for (const point of points)
+        if (!compact.length || !samePoint(compact[compact.length - 1], point))
+            compact.push(point);
+    if (compact.length > 1 && samePoint(compact[0], compact[compact.length - 1]))
+        compact.pop();
+    if (compact.length < 3)
+        return;
+    out.push({ points: compact, area: signedArea(compact), parent: -1, depth: 0, role: 'ignore' });
+}
+function classifyContours(contours, fillRule) {
+    for (let i = 0; i < contours.length; i++) {
+        const contour = contours[i];
+        let parent = -1;
+        let parentArea = Infinity;
+        const point = contour.points[0];
+        for (let candidateIndex = 0; candidateIndex < contours.length; candidateIndex++) {
+            if (candidateIndex === i)
+                continue;
+            const candidate = contours[candidateIndex];
+            const area = Math.abs(candidate.area);
+            if (area <= Math.abs(contour.area) || area >= parentArea || !pointInPolygon(point, candidate.points))
+                continue;
+            parent = candidateIndex;
+            parentArea = area;
+        }
+        contour.parent = parent;
+    }
+    for (const contour of contours) {
+        let depth = 0;
+        let parent = contour.parent;
+        while (parent >= 0) {
+            depth++;
+            parent = contours[parent].parent;
+        }
+        contour.depth = depth;
+        if (fillRule === 'evenodd') {
+            contour.role = (depth & 1) === 0 ? 'outer' : 'hole';
+            continue;
+        }
+        let windingBefore = 0;
+        parent = contour.parent;
+        while (parent >= 0) {
+            windingBefore += Math.sign(contours[parent].area);
+            parent = contours[parent].parent;
+        }
+        const windingAfter = windingBefore + Math.sign(contour.area);
+        contour.role = windingBefore === 0 && windingAfter !== 0
+            ? 'outer'
+            : windingBefore !== 0 && windingAfter === 0 ? 'hole' : 'ignore';
+    }
+}
+function nearestOuterAncestor(contours, contourIndex) {
+    let parent = contours[contourIndex].parent;
+    while (parent >= 0) {
+        if (contours[parent].role === 'outer')
+            return parent;
+        parent = contours[parent].parent;
+    }
+    return -1;
+}
+function appendContour(out, points) {
+    for (const point of points)
+        out.push(point.x, point.y);
+}
+function signedArea(points) {
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+        const a = points[i], b = points[(i + 1) % points.length];
+        area += a.x * b.y - b.x * a.y;
+    }
+    return area * 0.5;
+}
+function pointInPolygon(point, polygon) {
+    let inside = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const a = polygon[i], b = polygon[j];
+        if ((a.y > point.y) !== (b.y > point.y) && point.x < (b.x - a.x) * (point.y - a.y) / (b.y - a.y) + a.x)
+            inside = !inside;
+    }
+    return inside;
+}
+function midpoint(a, b) { return { x: (a.x + b.x) * 0.5, y: (a.y + b.y) * 0.5 }; }
+function samePoint(a, b) { return Math.abs(a.x - b.x) < 1e-6 && Math.abs(a.y - b.y) < 1e-6; }
+function pointLineDistanceSquared(point, a, b) {
+    const dx = b.x - a.x, dy = b.y - a.y;
+    const lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared <= 1e-12)
+        return (point.x - a.x) ** 2 + (point.y - a.y) ** 2;
+    const t = ((point.x - a.x) * dx + (point.y - a.y) * dy) / lengthSquared;
+    const x = a.x - point.x + dx * t, y = a.y - point.y + dy * t;
+    return x * x + y * y;
+}
+
+/** Runtime-private render item consumed by Animation2DRenderSystem. */
+class AnimationVisual2D extends Component {
+    static UniqueCheckType = UniqueCheckType.SYMBOL | UniqueCheckType.REPLACE;
+    static UniqueSymbol = Symbol.for('AnimationVisual2D');
+    geometry;
+    instanceId;
+    nodeId;
+    nodeKey;
+    order;
+    sourceOnly;
+    compositeLayers;
+    compositeKeys;
+    /** Compatibility accessors for single-layer renderer diagnostics. */
+    compositeSource;
+    compositeKey;
+    compositeMode;
+    uvRect;
+    color;
+    texture;
+    textureHandle;
+    textMaterial;
+    requiresTexture;
+    gradient;
+    effects;
+    revision = 0;
+    constructor(options) {
+        super('AnimationVisual2D');
+        this.geometry = options.geometry;
+        this.instanceId = options.instanceId;
+        this.nodeId = options.nodeId;
+        this.nodeKey = `${options.instanceId}:${options.nodeId}`;
+        this.order = options.order;
+        this.sourceOnly = options.sourceOnly ?? false;
+        this.compositeLayers = Object.freeze(options.composite
+            ? ('layers' in options.composite
+                ? options.composite.layers.map(layer => ({ ...layer }))
+                : [{ ...options.composite }])
+            : []);
+        this.compositeKeys = Object.freeze(this.compositeLayers.map(layer => `${options.instanceId}:${layer.source}`));
+        this.compositeSource = this.compositeLayers[0]?.source;
+        this.compositeKey = this.compositeKeys[0];
+        this.compositeMode = this.compositeLayers[0]?.mode;
+        this.uvRect = [...(options.uvRect ?? [0, 0, 1, 1])];
+        this.color = [...options.color];
+        this.texture = options.texture ?? null;
+        this.textureHandle = options.textureHandle ?? null;
+        this.textMaterial = options.textMaterial ?? null;
+        this.requiresTexture = options.requiresTexture ?? false;
+        this.gradient = options.gradient ?? null;
+        this.effects = Object.freeze(options.effects ? [...options.effects] : []);
+    }
+    setTexture(texture) {
+        if (this.texture === texture)
+            return;
+        this.texture = texture;
+        this.revision++;
+    }
+    setTextureHandle(handle) {
+        if (this.textureHandle === handle)
+            return;
+        this.textureHandle = handle;
+        this.revision++;
+    }
+    setUvRect(value) {
+        if (this.uvRect.every((current, index) => current === value[index]))
+            return;
+        this.uvRect[0] = value[0];
+        this.uvRect[1] = value[1];
+        this.uvRect[2] = value[2];
+        this.uvRect[3] = value[3];
+        this.revision++;
+    }
+    setCompositeExpansion(index, value) {
+        const layer = this.compositeLayers[index];
+        if (!layer || layer.expansion === value)
+            return;
+        layer.expansion = value;
+        this.revision++;
+    }
+    resolveTexture() {
+        if (!this.textureHandle)
+            return this.texture;
+        try {
+            return this.textureHandle.value;
+        }
+        catch {
+            return null;
+        }
+    }
+    clone() {
+        return new AnimationVisual2D({
+            geometry: this.geometry,
+            color: this.color,
+            instanceId: this.instanceId,
+            nodeId: this.nodeId,
+            order: this.order,
+            sourceOnly: this.sourceOnly,
+            ...(this.compositeLayers.length === 0 ? {} : { composite: { layers: this.compositeLayers } }),
+            texture: this.texture,
+            textureHandle: this.textureHandle,
+            textMaterial: this.textMaterial,
+            requiresTexture: this.requiresTexture,
+            uvRect: this.uvRect,
+            gradient: this.gradient ? {
+                kind: this.gradient.kind,
+                start: [...this.gradient.start],
+                end: [...this.gradient.end],
+                stops: new Float32Array(this.gradient.stops),
+                opacity: this.gradient.opacity,
+            } : null,
+            effects: this.effects.map(effect => ({ kind: effect.kind, values: new Float32Array(effect.values) })),
+        });
+    }
+}
+
+/** Runtime-private deterministic grapheme shaper and Canvas atlas uploader. */
+class AnimationTextRasterizer {
+    component;
+    texture = null;
+    textureVersion = 0;
+    canvas;
+    time = Number.NaN;
+    dirty = true;
+    updating = false;
+    updateToken = 0;
+    animated;
+    constructor(component) {
+        this.component = component;
+        this.canvas = typeof document === 'undefined' ? null : document.createElement('canvas');
+        this.animated = (component.documents?.length ?? 0) > 1
+            || (component.animators ?? []).some(animator => hasAnimatedAnimator(animator));
+        void this.updateTexture();
+    }
+    setTime(time) {
+        if (!this.animated)
+            return;
+        if (this.time === time && !this.dirty)
+            return;
+        this.time = time;
+        this.dirty = true;
+        void this.updateTexture();
+    }
+    invalidateFont() {
+        this.dirty = true;
+        void this.updateTexture();
+    }
+    destroy() {
+        this.updateToken++;
+        closeTextTexture(this.texture, this.canvas);
+        this.texture = null;
+    }
+    async updateTexture() {
+        if (!this.dirty || this.updating || !this.canvas)
+            return;
+        const token = ++this.updateToken;
+        this.dirty = false;
+        this.updating = true;
+        try {
+            this.draw(this.canvas, Number.isFinite(this.time) ? this.time : 0);
+            this.texture = this.canvas;
+            this.textureVersion++;
+            if (typeof createImageBitmap !== 'function')
+                return;
+            const bitmap = await createImageBitmap(this.canvas, { colorSpaceConversion: 'none' });
+            if (token !== this.updateToken) {
+                bitmap.close();
+                return;
+            }
+            const retired = this.texture;
+            this.texture = bitmap;
+            this.textureVersion++;
+            closeTextTexture(retired, this.canvas);
+        }
+        finally {
+            this.updating = false;
+            if (this.dirty)
+                void this.updateTexture();
+        }
+    }
+    draw(canvas, time) {
+        const component = this.component;
+        const document = resolveDocument(component, time);
+        const dpr = Math.max(1, Math.min(4, component.resolutionScale ?? 2));
+        const width = Math.max(1, Math.ceil(component.size[0]));
+        const height = Math.max(1, Math.ceil(component.size[1]));
+        canvas.width = Math.max(1, Math.ceil(width * dpr));
+        canvas.height = Math.max(1, Math.ceil(height * dpr));
+        const context = canvas.getContext('2d');
+        if (!context)
+            return;
+        context.setTransform(dpr, 0, 0, dpr, 0, 0);
+        context.clearRect(0, 0, width, height);
+        const background = component.backgroundColor;
+        if (background && background[3] > 0) {
+            context.fillStyle = cssColor(background);
+            context.fillRect(0, 0, width, height);
+        }
+        const padding = Math.max(0, component.padding ?? 0);
+        const contentWidth = Math.max(1, width - padding * 2);
+        const contentHeight = Math.max(1, height - padding * 2);
+        context.font = `${document.fontStyle} ${document.fontWeight} ${document.fontSize}px ${quoteFont(document.fontFamily)}`;
+        context.textBaseline = 'alphabetic';
+        context.textAlign = 'left';
+        const lines = document.text.split(/\r?\n/).map(splitGraphemes);
+        const animators = component.animators ?? [];
+        const selectorPlans = animators.map(animator => createSelectorIndexPlan(lines, animator));
+        const lineHeight = Math.max(1, document.lineHeight);
+        const textHeight = lines.length * lineHeight;
+        let top = padding;
+        const vertical = component.verticalAlign ?? 'middle';
+        if (vertical === 'middle')
+            top += Math.max(0, (contentHeight - textHeight) / 2);
+        else if (vertical === 'bottom')
+            top += Math.max(0, contentHeight - textHeight);
+        let globalIndex = 0;
+        for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+            const line = lines[lineIndex];
+            const advances = line.map(glyph => context.measureText(glyph).width);
+            const baseWidth = advances.reduce((sum, advance) => sum + advance, 0) + Math.max(0, line.length - 1) * document.tracking;
+            let x = padding;
+            if (document.textAlign === 'center')
+                x += Math.max(0, (contentWidth - baseWidth) / 2);
+            else if (document.textAlign === 'right')
+                x += Math.max(0, contentWidth - baseWidth);
+            const baseline = top + lineIndex * lineHeight + document.fontSize;
+            for (let glyphIndex = 0; glyphIndex < line.length; glyphIndex++, globalIndex++) {
+                const glyph = line[glyphIndex];
+                const advance = advances[glyphIndex] ?? 0;
+                const state = resolveGlyphState(animators, selectorPlans, time, globalIndex, document.color);
+                const centerX = x + advance / 2 + state.x;
+                context.save();
+                context.translate(centerX, baseline + state.y);
+                context.rotate(state.rotation);
+                context.scale(state.scaleX, state.scaleY);
+                context.globalAlpha = state.opacity;
+                context.fillStyle = cssColor(state.color);
+                context.fillText(glyph, -advance / 2, 0);
+                context.restore();
+                x += advance + document.tracking + state.tracking;
+            }
+        }
+    }
+}
+function resolveDocument(component, time) {
+    let keyframe;
+    for (const candidate of component.documents ?? []) {
+        if (candidate.time > time)
+            break;
+        keyframe = candidate;
+    }
+    return {
+        text: keyframe?.text ?? component.text,
+        fontFamily: keyframe?.fontFamily ?? component.fontFamily ?? 'sans-serif',
+        fontSize: keyframe?.fontSize ?? component.fontSize ?? 28,
+        fontWeight: keyframe?.fontWeight ?? component.fontWeight ?? 400,
+        fontStyle: keyframe?.fontStyle ?? component.fontStyle ?? 'normal',
+        lineHeight: keyframe?.lineHeight ?? component.lineHeight ?? (keyframe?.fontSize ?? component.fontSize ?? 28) * 1.2,
+        tracking: keyframe?.tracking ?? component.tracking ?? 0,
+        textAlign: keyframe?.textAlign ?? component.textAlign ?? 'center',
+        color: keyframe?.color ?? component.color,
+    };
+}
+function resolveGlyphState(animators, selectorPlans, time, index, baseColor) {
+    const state = { x: 0, y: 0, scaleX: 1, scaleY: 1, rotation: 0, opacity: 1, tracking: 0, color: [...baseColor] };
+    for (let animatorIndex = 0; animatorIndex < animators.length; animatorIndex++) {
+        const animator = animators[animatorIndex];
+        const plan = selectorPlans[animatorIndex];
+        const weight = selectorWeight(animator, time, plan.indices[index] ?? 0, plan.count);
+        if (Math.abs(weight) < 1e-6)
+            continue;
+        const position = sampled(animator.positionTrack, time, animator.position ?? [0, 0]);
+        const scale = sampled(animator.scaleTrack, time, animator.scale ?? [1, 1]);
+        const rotation = sampled(animator.rotationTrack, time, [animator.rotation ?? 0])[0] ?? 0;
+        const opacity = sampled(animator.opacityTrack, time, [animator.opacity ?? 1])[0] ?? 1;
+        const tracking = sampled(animator.trackingTrack, time, [animator.tracking ?? 0])[0] ?? 0;
+        const color = sampled(animator.fillColorTrack, time, animator.fillColor ?? state.color);
+        state.x += (position[0] ?? 0) * weight;
+        state.y += (position[1] ?? 0) * weight;
+        state.scaleX *= mix$1(1, scale[0] ?? 1, weight);
+        state.scaleY *= mix$1(1, scale[1] ?? 1, weight);
+        state.rotation += rotation * weight;
+        state.opacity *= mix$1(1, opacity, weight);
+        state.tracking += tracking * weight;
+        for (let channel = 0; channel < 4; channel++)
+            state.color[channel] = mix$1(state.color[channel], color[channel] ?? state.color[channel], weight);
+    }
+    state.opacity = clamp$2(state.opacity, 0, 1);
+    return state;
+}
+function selectorWeight(animator, time, index, count) {
+    const selector = animator.selector;
+    const units = selector.units ?? 'percent';
+    const coordinate = units === 'index' ? index + 0.5 : (index + 0.5) / Math.max(1, count);
+    const start = sampled(selector.startTrack, time, [selector.start])[0] ?? selector.start;
+    const end = sampled(selector.endTrack, time, [selector.end])[0] ?? selector.end;
+    const offset = sampled(selector.offsetTrack, time, [selector.offset ?? 0])[0] ?? selector.offset ?? 0;
+    const amount = sampled(selector.amountTrack, time, [selector.amount ?? 1])[0] ?? selector.amount ?? 1;
+    const low = Math.min(start + offset, end + offset);
+    const high = Math.max(start + offset, end + offset);
+    const span = Math.max(1e-6, high - low);
+    const progress = clamp$2((coordinate - low) / span, 0, 1);
+    let weight = coordinate >= low && coordinate <= high ? 1 : 0;
+    switch (selector.shape ?? 'square') {
+        case 'ramp-up':
+            weight = progress;
+            break;
+        case 'ramp-down':
+            weight = 1 - progress;
+            break;
+        case 'triangle':
+            weight = 1 - Math.abs(progress * 2 - 1);
+            break;
+        case 'round':
+            weight = Math.sqrt(Math.max(0, 1 - (progress * 2 - 1) ** 2));
+            break;
+        case 'smooth':
+            weight = progress * progress * (3 - 2 * progress);
+            break;
+    }
+    if (selector.easing)
+        weight = cubicBezierYForX$1(weight, ...selector.easing);
+    const smoothness = selector.smoothness ?? 1;
+    if (smoothness < 1) {
+        const width = Math.max(0.01, smoothness);
+        const edge = 0.5 - width * 0.5;
+        weight = clamp$2((weight - edge) / width, 0, 1);
+    }
+    return clamp$2(weight * amount, -1, 1);
+}
+function createSelectorIndexPlan(lines, animator) {
+    const basedOn = animator.selector.basedOn ?? 'characters';
+    const indices = [];
+    let group = 0;
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex];
+        for (let glyphIndex = 0; glyphIndex < line.length; glyphIndex++) {
+            const glyph = line[glyphIndex];
+            indices.push(basedOn === 'lines' ? lineIndex : group);
+            if (basedOn === 'characters')
+                group++;
+            else if (basedOn === 'characters-excluding-spaces' && glyph !== ' ')
+                group++;
+            else if (basedOn === 'words' && (glyph === ' ' || glyphIndex === line.length - 1))
+                group++;
+        }
+    }
+    const count = Math.max(1, basedOn === 'lines' ? lines.length : group);
+    const seed = animator.selector.randomSeed;
+    if (seed === undefined || count < 2)
+        return { indices, count };
+    const permutation = Array.from({ length: count }, (_, index) => index);
+    let randomState = seed >>> 0;
+    for (let index = permutation.length - 1; index > 0; index--) {
+        randomState = deterministicRandom(randomState);
+        const swap = randomState % (index + 1);
+        [permutation[index], permutation[swap]] = [permutation[swap], permutation[index]];
+    }
+    return { indices: indices.map(index => permutation[index] ?? index), count };
+}
+function deterministicRandom(state) {
+    let value = state || 0x6d2b79f5;
+    value ^= value << 13;
+    value ^= value >>> 17;
+    value ^= value << 5;
+    return value >>> 0;
+}
+function sampled(track, time, fallback) {
+    if (!track || track.times.length === 0)
+        return fallback;
+    let frame = 0;
+    while (frame + 1 < track.times.length && track.times[frame + 1] <= time)
+        frame++;
+    const next = Math.min(frame + 1, track.times.length - 1);
+    let progress = 0;
+    if (next !== frame && track.interpolation !== 'step') {
+        progress = clamp$2((time - track.times[frame]) / Math.max(1e-8, track.times[next] - track.times[frame]), 0, 1);
+        if (track.interpolation === 'cubic-bezier' && track.easings) {
+            const offset = frame * 4;
+            progress = cubicBezierYForX$1(progress, track.easings[offset], track.easings[offset + 1], track.easings[offset + 2], track.easings[offset + 3]);
+        }
+    }
+    const result = new Array(track.valueSize);
+    for (let index = 0; index < track.valueSize; index++) {
+        const from = track.values[frame * track.valueSize + index] ?? 0;
+        result[index] = mix$1(from, track.values[next * track.valueSize + index] ?? from, progress);
+    }
+    return result;
+}
+function splitGraphemes(text) {
+    const result = [];
+    for (const codePoint of Array.from(text)) {
+        if (codePoint === '\u200D' && result.length > 0) {
+            result[result.length - 1] += codePoint;
+        }
+        else if (result.length > 0 && (/\p{Mark}/u.test(codePoint) || codePoint === '\uFE0F' || result[result.length - 1].endsWith('\u200D'))) {
+            result[result.length - 1] += codePoint;
+        }
+        else
+            result.push(codePoint);
+    }
+    return result;
+}
+function hasAnimatedAnimator(animator) {
+    return animator.positionTrack !== undefined || animator.scaleTrack !== undefined || animator.rotationTrack !== undefined
+        || animator.opacityTrack !== undefined || animator.fillColorTrack !== undefined || animator.trackingTrack !== undefined
+        || animator.selector.startTrack !== undefined || animator.selector.endTrack !== undefined
+        || animator.selector.offsetTrack !== undefined || animator.selector.amountTrack !== undefined;
+}
+function cubicBezierYForX$1(x, x1, y1, x2, y2) {
+    let low = 0;
+    let high = 1;
+    let t = x;
+    for (let iteration = 0; iteration < 10; iteration++) {
+        const estimate = cubic(t, 0, x1, x2, 1);
+        if (estimate < x)
+            low = t;
+        else
+            high = t;
+        t = (low + high) * 0.5;
+    }
+    return cubic(t, 0, y1, y2, 1);
+}
+function cubic(t, a, b, c, d) {
+    const inverse = 1 - t;
+    return inverse ** 3 * a + 3 * inverse ** 2 * t * b + 3 * inverse * t ** 2 * c + t ** 3 * d;
+}
+function cssColor(color) {
+    return `rgba(${Math.round(clamp$2(color[0] ?? 0, 0, 1) * 255)},${Math.round(clamp$2(color[1] ?? 0, 0, 1) * 255)},${Math.round(clamp$2(color[2] ?? 0, 0, 1) * 255)},${clamp$2(color[3] ?? 1, 0, 1)})`;
+}
+function quoteFont(value) { return `"${value.replace(/["\\]/g, '')}"`; }
+function closeTextTexture(texture, canvas) {
+    if (texture && texture !== canvas && typeof texture.close === 'function')
+        texture.close();
+}
+function mix$1(a, b, t) { return a + (b - a) * t; }
+function clamp$2(value, minimum, maximum) { return Math.max(minimum, Math.min(maximum, value)); }
+
+/** HTML media-backed audio clip with composition-time seek and playback-rate synchronization. */
+class AnimationAudioClip {
+    element;
+    nodeStart;
+    nodeEnd;
+    startOffset;
+    baseVolume;
+    clipRate;
+    loop;
+    playPending = false;
+    destroyed = false;
+    stateMachineActive = false;
+    playRequestEpoch = 0;
+    constructor(uri, component, node, animationDuration) {
+        this.nodeStart = node.start ?? 0;
+        this.nodeEnd = this.nodeStart + (node.duration ?? animationDuration - this.nodeStart);
+        this.startOffset = component.startOffset ?? 0;
+        this.baseVolume = component.volume ?? 1;
+        this.clipRate = component.playbackRate ?? 1;
+        this.loop = component.loop ?? false;
+        this.element = typeof Audio === 'undefined' ? null : new Audio(uri);
+        if (this.element) {
+            this.element.preload = 'auto';
+            this.element.loop = this.loop;
+        }
+    }
+    sync(compositionTime, playing, speed, opacity) {
+        const element = this.element;
+        if (!element || this.destroyed)
+            return;
+        const active = compositionTime >= this.nodeStart && compositionTime <= this.nodeEnd;
+        element.volume = clamp$1(this.baseVolume * opacity, 0, 1);
+        element.playbackRate = clamp$1(this.clipRate * speed, 0.0625, 16);
+        if (!active || !playing || speed <= 0) {
+            this._cancelPendingPlay();
+            return;
+        }
+        let target = this.startOffset + (compositionTime - this.nodeStart) * this.clipRate;
+        if (this.loop && Number.isFinite(element.duration) && element.duration > 0)
+            target %= element.duration;
+        if (Number.isFinite(target) && Math.abs(element.currentTime - target) > 0.12) {
+            try {
+                element.currentTime = Math.max(0, target);
+            }
+            catch { /* Metadata may not be loaded yet. */ }
+        }
+        if (element.paused)
+            this._requestPlay();
+    }
+    enterStateMachine(playing, speed, opacity, rejected) {
+        const element = this.element;
+        if (!element || this.destroyed)
+            return;
+        this.stateMachineActive = true;
+        element.volume = clamp$1(this.baseVolume * opacity, 0, 1);
+        element.playbackRate = clamp$1(this.clipRate * Math.max(speed, 0.0625), 0.0625, 16);
+        try {
+            element.currentTime = Math.max(0, this.startOffset);
+        }
+        catch { /* Metadata may not be loaded yet. */ }
+        if (playing && speed > 0)
+            this._requestPlay(rejected);
+        else
+            this._cancelPendingPlay();
+    }
+    restartStateMachine(playing, speed, opacity, rejected) {
+        this.enterStateMachine(playing, speed, opacity, rejected);
+    }
+    setStateMachinePlaying(playing, speed, rejected) {
+        const element = this.element;
+        if (!element || this.destroyed || !this.stateMachineActive)
+            return;
+        element.playbackRate = clamp$1(this.clipRate * Math.max(speed, 0.0625), 0.0625, 16);
+        if (playing && speed > 0)
+            this._requestPlay(rejected);
+        else
+            this._cancelPendingPlay();
+    }
+    updateStateMachineProperties(speed, opacity) {
+        const element = this.element;
+        if (!element || this.destroyed || !this.stateMachineActive)
+            return;
+        element.volume = clamp$1(this.baseVolume * opacity, 0, 1);
+        element.playbackRate = clamp$1(this.clipRate * Math.max(speed, 0.0625), 0.0625, 16);
+    }
+    exitStateMachine() {
+        this.stateMachineActive = false;
+        this._cancelPendingPlay();
+    }
+    pause() { this._cancelPendingPlay(); }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.stateMachineActive = false;
+        const element = this.element;
+        if (!element)
+            return;
+        this._cancelPendingPlay();
+        element.removeAttribute('src');
+        element.load();
+    }
+    _requestPlay(rejected) {
+        const element = this.element;
+        if (!element || this.playPending || this.destroyed)
+            return;
+        const epoch = ++this.playRequestEpoch;
+        const stateMachineRequest = rejected !== undefined;
+        this.playPending = true;
+        void element.play()
+            .then(() => {
+            if (epoch !== this.playRequestEpoch
+                || this.destroyed
+                || (stateMachineRequest && !this.stateMachineActive))
+                element.pause();
+        })
+            .catch(reason => {
+            if (epoch === this.playRequestEpoch)
+                rejected?.(reason);
+        })
+            .finally(() => {
+            if (epoch === this.playRequestEpoch)
+                this.playPending = false;
+        });
+    }
+    _cancelPendingPlay() {
+        this.playRequestEpoch++;
+        this.playPending = false;
+        this.element?.pause();
+    }
+}
+function clamp$1(value, minimum, maximum) {
+    return Math.min(maximum, Math.max(minimum, value));
+}
+
+/** Single runtime mapping from screen-y-down HYA data to the engine's y-up emitter. */
+function particle2DDescriptorToEmitterOptions(component) {
+    return {
+        maxParticles: component.maxParticles,
+        emissionRate: component.emissionRate,
+        burst: component.burst ?? 0,
+        duration: component.duration ?? Number.POSITIVE_INFINITY,
+        loop: component.loop ?? true,
+        seed: component.seed ?? 1,
+        lifetime: component.lifetime,
+        speed: component.speed,
+        angle: [-component.angle[1], -component.angle[0]],
+        gravity: [component.gravity?.[0] ?? 0, -(component.gravity?.[1] ?? 20)],
+        startSize: component.startSize,
+        endSize: component.endSize,
+        startColor: component.startColor,
+        endColor: component.endColor,
+        shape: component.shape ?? 'point',
+        shapeSize: component.shapeSize ?? [0, 0],
+        shapeRadius: component.shapeRadius ?? 0,
+        blendMode: component.blendMode ?? 'normal',
+        radial: component.radial ?? true,
+    };
+}
+function createParticle2DEmitter(component) {
+    return new ParticleEmitter2D(particle2DDescriptorToEmitterOptions(component));
+}
+
+let nextRuntimeInstanceId = 1;
+class Animation2DRuntime {
+    _animation;
+    _assetManager;
+    _root;
+    _nodes = [];
+    _nodesById = new Map();
+    _tracksByNode = new Map();
+    _trackCursors;
+    _trackIndices = new Map();
+    _opacityMemo = new Map();
+    _abortController = new AbortController();
+    _assetHandles = [];
+    _fontLoads = new Map();
+    _fontFaces = [];
+    _instanceId = nextRuntimeInstanceId++;
+    _visualCount = 0;
+    _unsupportedComponentCount = 0;
+    _pendingResourceCount = 0;
+    _failedResourceCount = 0;
+    _textCount = 0;
+    _particleCount = 0;
+    _audioCount = 0;
+    _destroyed = false;
+    _playing = false;
+    _speed = 1;
+    _lastAppliedTime = Number.NaN;
+    get stats() {
+        return Object.freeze({
+            nodeCount: this._nodes.length,
+            visualCount: this._visualCount,
+            unsupportedComponentCount: this._unsupportedComponentCount,
+            pendingResourceCount: this._pendingResourceCount,
+            failedResourceCount: this._failedResourceCount,
+            textCount: this._textCount,
+            particleCount: this._particleCount,
+            audioCount: this._audioCount,
+        });
+    }
+    constructor(owner, _animation, runtimeExtensions, _assetManager) {
+        this._animation = _animation;
+        this._assetManager = _assetManager;
+        for (const id of _animation.extensionsRequired) {
+            if (id === HYA_STATE_MACHINE_EXTENSION_ID)
+                continue;
+            if (!runtimeExtensions?.has(id)) {
+                throw new AnimationFormatError('E_ANIMATION_MISSING_EXTENSION', `Required animation runtime extension "${id}" is not registered.`, '$.extensionsRequired');
+            }
+        }
+        this._root = new Entity(`${_animation.name ?? 'Animation'} runtime`);
+        this._root.addComponent(new Transform2D({ x: -_animation.canvas.width / 2, y: _animation.canvas.height / 2 }));
+        owner.addChild(this._root);
+        const compositeSources = new Set(_animation.nodes.flatMap(node => compositeLayers(node.composite).map(layer => layer.source)));
+        const sourceGroupByNode = resolveSourceGroups(_animation.nodes, compositeSources);
+        const compositeByNode = resolveInheritedComposites(_animation.nodes, sourceGroupByNode);
+        const effectsByNode = resolveInheritedEffects(_animation.nodes, sourceGroupByNode);
+        const sourceNodesById = new Map(_animation.nodes.map(node => [node.id, node]));
+        let renderOrder = 0;
+        for (const node of _animation.nodes) {
+            const transformSource = node.transform;
+            const position = transformSource?.position ?? [0, 0];
+            const scale = transformSource?.scale ?? [1, 1];
+            const transform = new Transform2D({
+                x: position[0],
+                y: -position[1],
+                rotation: -(transformSource?.rotation ?? 0),
+                scaleX: scale[0],
+                scaleY: scale[1],
+            });
+            const entity = new Entity(node.name ?? node.id).addComponent(transform);
+            const anchor = transformSource?.anchor ?? [0, 0];
+            const content = new Entity(`${node.name ?? node.id} anchor`).addComponent(new Transform2D({
+                x: -anchor[0],
+                y: anchor[1],
+            }));
+            entity.addChild(content);
+            const runtimeNode = {
+                source: node,
+                entity,
+                content,
+                transform,
+                visuals: [],
+                deferredVisuals: [],
+                extensions: [],
+                particles: [],
+                audio: [],
+                initialX: transform.x,
+                initialY: transform.y,
+                initialRotation: transform.rotation,
+                initialScaleX: transform.scaleX,
+                initialScaleY: transform.scaleY,
+                initialOpacity: transformSource?.opacity ?? 1,
+                opacity: transformSource?.opacity ?? 1,
+            };
+            const sourceComponents = node.components ?? [];
+            for (let componentIndex = 0; componentIndex < sourceComponents.length; componentIndex++) {
+                const component = sourceComponents[componentIndex];
+                if (isParticle2DComponent(component)) {
+                    // Particle2D is rendered by the engine's independent pass. Do not silently
+                    // bypass animation alpha-composite semantics until both renderers share a graph item protocol.
+                    if (sourceGroupByNode.has(node.id) || compositeByNode.has(node.id)) {
+                        this._unsupportedComponentCount++;
+                        continue;
+                    }
+                    const emitter = createParticle2DEmitter(component);
+                    content.addChild(new Entity(`${entity.name} particles`).addComponent(emitter));
+                    runtimeNode.particles.push(emitter);
+                    this._visualCount++;
+                    this._particleCount++;
+                    if (component.resource)
+                        this._loadTexture(component.resource, handle => { emitter.textureSource = handle; });
+                    continue;
+                }
+                if (isAudioComponent(component)) {
+                    const resource = this._animation.resources.find(candidate => candidate.id === component.resource);
+                    if (!resource || resource.type !== 'audio') {
+                        this._unsupportedComponentCount++;
+                        continue;
+                    }
+                    runtimeNode.audio.push(new AnimationAudioClip(resource.uri, component, node, this._animation.duration));
+                    this._audioCount++;
+                    continue;
+                }
+                if (!isCoreVisualComponent(component)) {
+                    const handler = runtimeExtensions?.get(component.type);
+                    if (!handler) {
+                        this._unsupportedComponentCount++;
+                        continue;
+                    }
+                    try {
+                        const instance = handler.create({ animation: _animation, node, component, parent: content });
+                        if (instance) {
+                            runtimeNode.extensions.push(instance);
+                            this._visualCount++;
+                        }
+                    }
+                    catch (error) {
+                        this._abortController.abort();
+                        for (const handle of this._assetHandles)
+                            handle.release();
+                        this._assetHandles.length = 0;
+                        for (const createdNode of [...this._nodes, runtimeNode]) {
+                            for (const audio of createdNode.audio)
+                                audio.destroy();
+                            for (const instance of createdNode.extensions)
+                                instance.destroy?.();
+                        }
+                        this._root.destroy();
+                        throw error;
+                    }
+                    continue;
+                }
+                const deferred = {
+                    component,
+                    componentIndex,
+                    order: renderOrder++,
+                    sourceGroup: sourceGroupByNode.get(node.id),
+                    composite: compositeByNode.get(node.id),
+                    effects: effectsByNode.get(node.id),
+                };
+                this._visualCount++;
+                if (component.type === 'text2d')
+                    this._textCount++;
+                if (isSourceNodeActiveAt(node, 0, sourceNodesById, _animation.duration)) {
+                    this._materializeCoreVisual(runtimeNode, deferred);
+                }
+                else {
+                    runtimeNode.deferredVisuals.push(deferred);
+                }
+            }
+            this._nodes.push(runtimeNode);
+            this._nodesById.set(node.id, runtimeNode);
+        }
+        for (const node of this._nodes) {
+            const parent = node.source.parent ? this._nodesById.get(node.source.parent)?.content : this._root;
+            (parent ?? this._root).addChild(node.entity);
+        }
+        for (let index = 0; index < _animation.tracks.length; index++) {
+            const track = _animation.tracks[index];
+            let tracks = this._tracksByNode.get(track.node);
+            if (!tracks)
+                this._tracksByNode.set(track.node, tracks = []);
+            tracks.push(track);
+            this._trackIndices.set(track, index);
+        }
+        this._trackCursors = new Int32Array(_animation.tracks.length);
+    }
+    apply(time, playing = this._playing, speed = this._speed, forceParticleSeek = false) {
+        const discontinuity = forceParticleSeek || (!Number.isFinite(this._lastAppliedTime)
+            ? time > 1e-6
+            : time + 1e-6 < this._lastAppliedTime || Math.abs(time - this._lastAppliedTime) > 0.25);
+        this._playing = playing;
+        this._speed = speed;
+        this._opacityMemo.clear();
+        for (const node of this._nodes) {
+            const start = node.source.start ?? 0;
+            const end = start + (node.source.duration ?? this._animation.duration);
+            node.entity.disabled = time < start || time > end;
+            node.transform.setPosition(node.initialX, node.initialY);
+            node.transform.rotation = node.initialRotation;
+            node.transform.setScale(node.initialScaleX, node.initialScaleY);
+            node.opacity = node.initialOpacity;
+            for (const track of this._tracksByNode.get(node.source.id) ?? [])
+                this._applyTrack(node, track, time);
+        }
+        for (const node of this._nodes) {
+            const opacity = this._resolveOpacity(node);
+            if (node.deferredVisuals.length > 0 && isRuntimeNodeActive(node, this._nodesById)) {
+                for (const deferred of node.deferredVisuals.splice(0))
+                    this._materializeCoreVisual(node, deferred);
+            }
+            for (const particle of node.particles) {
+                if (discontinuity)
+                    particle.seek(Math.max(0, time - (node.source.start ?? 0)));
+                particle.opacity = opacity;
+                particle.playing = playing && !node.entity.disabled;
+            }
+            for (const audio of node.audio)
+                audio.sync(time, playing && !node.entity.disabled, speed, opacity);
+            for (const visual of node.visuals) {
+                if (visual.spriteUvRectTrack) {
+                    const frame = findVectorTrackFrame(visual.spriteUvRectTrack, time);
+                    if (frame !== visual.spriteUvRectFrame) {
+                        const offset = frame * 4;
+                        visual.component.setUvRect([
+                            visual.spriteUvRectTrack.values[offset],
+                            visual.spriteUvRectTrack.values[offset + 1],
+                            visual.spriteUvRectTrack.values[offset + 2],
+                            visual.spriteUvRectTrack.values[offset + 3],
+                        ]);
+                        visual.spriteUvRectFrame = frame;
+                    }
+                }
+                visual.textRasterizer?.setTime(time);
+                if (visual.pathMorph && visual.lastMorphTime !== time) {
+                    const next = tessellateAnimationPath(sampleVectorPathMorph(visual.pathMorph, time));
+                    visual.component.geometry.setData(next.positions, next.indices);
+                    visual.component.revision++;
+                    visual.lastMorphTime = time;
+                }
+                if (visual.vectorShape && visual.lastVectorTime !== undefined && visual.lastVectorTime !== time) {
+                    updateVectorVisual(visual, time);
+                    visual.lastVectorTime = time;
+                }
+                if (visual.sourceEffects && visual.lastEffectTime !== time) {
+                    updateVisualEffects(visual.component, visual.sourceEffects, time);
+                    visual.component.revision++;
+                    visual.lastEffectTime = time;
+                }
+                if (visual.compositeExpansionTracks && visual.lastCompositeTime !== time) {
+                    for (let index = 0; index < visual.compositeExpansionTracks.length; index++) {
+                        const track = visual.compositeExpansionTracks[index];
+                        if (track)
+                            visual.component.setCompositeExpansion(index, sampleVectorTrack(track, time)[0] ?? 0);
+                    }
+                    visual.lastCompositeTime = time;
+                }
+                const alpha = visual.styleAlpha * opacity;
+                if (Math.abs(alpha - visual.lastAlpha) < 1e-6)
+                    continue;
+                visual.color[3] = alpha;
+                visual.component.revision++;
+                visual.lastAlpha = alpha;
+            }
+            for (const extension of node.extensions) {
+                if (extension.apply)
+                    extension.apply(time, opacity);
+                else
+                    extension.setOpacity?.(opacity);
+            }
+        }
+        this._lastAppliedTime = time;
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this._abortController.abort();
+        for (const handle of this._assetHandles)
+            handle.release();
+        this._assetHandles.length = 0;
+        if (typeof document !== 'undefined' && document.fonts) {
+            for (const face of this._fontFaces)
+                document.fonts.delete(face);
+        }
+        this._fontFaces.length = 0;
+        this._fontLoads.clear();
+        for (const node of this._nodes) {
+            for (const visual of node.visuals)
+                visual.textRasterizer?.destroy();
+            for (const audio of node.audio)
+                audio.destroy();
+            node.audio.length = 0;
+            for (const extension of node.extensions)
+                extension.destroy?.();
+            node.extensions.length = 0;
+        }
+        this._root.destroy();
+        this._nodes.length = 0;
+        this._nodesById.clear();
+        this._tracksByNode.clear();
+        this._trackIndices.clear();
+    }
+    setPlaying(playing) {
+        this._playing = playing;
+        if (playing)
+            return;
+        for (const node of this._nodes) {
+            for (const particle of node.particles)
+                particle.playing = false;
+            for (const audio of node.audio)
+                audio.pause();
+        }
+    }
+    _loadTexture(resourceId, apply) {
+        const resource = this._animation.resources.find(candidate => candidate.id === resourceId);
+        if (!resource || resource.type !== 'image' || !this._assetManager) {
+            this._failedResourceCount++;
+            return;
+        }
+        this._pendingResourceCount++;
+        let request;
+        try {
+            request = this._assetManager.loadTexture(resource.uri, {
+                label: `Animation2D:${resource.id}`,
+                format: resource.colorSpace === 'linear' ? 'rgba8unorm' : 'rgba8unorm-srgb',
+                cacheKey: resource.integrity ?? resource.uri,
+                signal: this._abortController.signal,
+            });
+        }
+        catch {
+            this._pendingResourceCount--;
+            this._failedResourceCount++;
+            return;
+        }
+        void request.then(handle => {
+            if (this._destroyed) {
+                handle.release();
+                return;
+            }
+            this._assetHandles.push(handle);
+            apply(handle);
+        }).catch(() => {
+            if (!this._destroyed)
+                this._failedResourceCount++;
+        }).finally(() => {
+            this._pendingResourceCount = Math.max(0, this._pendingResourceCount - 1);
+        });
+    }
+    _materializeCoreVisual(node, deferred) {
+        let visual;
+        try {
+            visual = createCoreVisual(deferred.component, deferred.componentIndex, this._instanceId, node.source, deferred.order, deferred.sourceGroup, deferred.composite, deferred.effects);
+        }
+        catch {
+            this._unsupportedComponentCount++;
+            return;
+        }
+        node.content.addChild(new Entity(`${node.entity.name} visual`).addComponent(visual.component));
+        node.visuals.push(visual.runtime);
+        if (deferred.component.type === 'sprite2d') {
+            this._loadTexture(deferred.component.resource, handle => visual.component.setTextureHandle(handle));
+        }
+        else if (deferred.component.type === 'text2d' && visual.runtime.textRasterizer) {
+            this._loadTextFonts(deferred.component, visual.runtime.textRasterizer);
+        }
+    }
+    _loadTextFonts(component, rasterizer) {
+        const descriptors = [
+            component.fontResource ? {
+                resource: component.fontResource,
+                family: component.fontFamily ?? 'sans-serif',
+                style: component.fontStyle ?? 'normal',
+                weight: component.fontWeight ?? 400,
+            } : null,
+            ...(component.documents ?? []).map(document => document.fontResource ? {
+                resource: document.fontResource,
+                family: document.fontFamily ?? component.fontFamily ?? 'sans-serif',
+                style: document.fontStyle ?? component.fontStyle ?? 'normal',
+                weight: document.fontWeight ?? component.fontWeight ?? 400,
+            } : null),
+        ].filter((value) => value !== null);
+        for (const descriptor of descriptors)
+            this._loadFont(descriptor, rasterizer);
+    }
+    _loadFont(descriptor, rasterizer) {
+        const key = `${descriptor.resource}:${descriptor.family}:${descriptor.style}:${descriptor.weight}`;
+        const existing = this._fontLoads.get(key);
+        if (existing) {
+            if (existing.state === 'loaded')
+                rasterizer.invalidateFont();
+            else if (existing.state === 'loading')
+                existing.rasterizers.add(rasterizer);
+            return;
+        }
+        const load = { state: 'loading', rasterizers: new Set([rasterizer]) };
+        this._fontLoads.set(key, load);
+        const resource = this._animation.resources.find(candidate => candidate.id === descriptor.resource);
+        if (!resource || resource.type !== 'binary' || !this._assetManager || typeof FontFace === 'undefined'
+            || typeof document === 'undefined' || !document.fonts) {
+            this._fontLoads.set(key, { ...load, state: 'failed' });
+            this._failedResourceCount++;
+            return;
+        }
+        this._pendingResourceCount++;
+        let retainedHandle = null;
+        void this._assetManager.load(`Animation2D.font:${resource.integrity ?? resource.uri}`, async (signal) => {
+            const response = await fetch(resource.uri, signal ? { signal } : {});
+            if (!response.ok)
+                throw new Error(`Font request failed with HTTP ${response.status}.`);
+            return response.arrayBuffer();
+        }, () => { }, { signal: this._abortController.signal }).then(async (handle) => {
+            retainedHandle = handle;
+            if (this._destroyed) {
+                handle.release();
+                return;
+            }
+            const face = new FontFace(descriptor.family, handle.value, {
+                style: descriptor.style,
+                weight: String(descriptor.weight),
+            });
+            await face.load();
+            if (this._destroyed) {
+                handle.release();
+                return;
+            }
+            document.fonts.add(face);
+            this._fontFaces.push(face);
+            this._assetHandles.push(handle);
+            retainedHandle = null;
+            const current = this._fontLoads.get(key);
+            if (current) {
+                current.state = 'loaded';
+                for (const target of current.rasterizers)
+                    target.invalidateFont();
+                current.rasterizers.clear();
+            }
+        }).catch(() => {
+            retainedHandle?.release();
+            if (!this._destroyed) {
+                const current = this._fontLoads.get(key);
+                if (current) {
+                    current.state = 'failed';
+                    current.rasterizers.clear();
+                }
+                this._failedResourceCount++;
+            }
+        }).finally(() => {
+            this._pendingResourceCount = Math.max(0, this._pendingResourceCount - 1);
+        });
+    }
+    _applyTrack(node, track, time) {
+        const trackIndex = this._trackIndices.get(track);
+        const cursor = findFrame(track.times, time, this._trackCursors[trackIndex] ?? 0);
+        this._trackCursors[trackIndex] = cursor;
+        const progress = sampleProgress(track, cursor, time);
+        const offset = cursor * track.valueSize;
+        const nextOffset = Math.min(cursor + 1, track.times.length - 1) * track.valueSize;
+        let x = mix(track.values[offset], track.values[nextOffset], progress);
+        let y = track.valueSize === 2 ? mix(track.values[offset + 1], track.values[nextOffset + 1], progress) : 0;
+        if (track.property === 'position' && track.spatialTangents && cursor < track.times.length - 1) {
+            const tangentOffset = cursor * 4;
+            x = spatialBezier(track.values[offset], track.values[offset] + track.spatialTangents[tangentOffset], track.values[nextOffset] + track.spatialTangents[tangentOffset + 2], track.values[nextOffset], progress);
+            y = spatialBezier(track.values[offset + 1], track.values[offset + 1] + track.spatialTangents[tangentOffset + 1], track.values[nextOffset + 1] + track.spatialTangents[tangentOffset + 3], track.values[nextOffset + 1], progress);
+        }
+        switch (track.property) {
+            case 'position':
+                node.transform.setPosition(x, -y);
+                break;
+            case 'rotation':
+                node.transform.rotation = -x;
+                break;
+            case 'scale':
+                node.transform.setScale(x, y);
+                break;
+            case 'opacity':
+                node.opacity = clamp(x, 0, 1);
+                break;
+        }
+    }
+    _resolveOpacity(node) {
+        const cached = this._opacityMemo.get(node.source.id);
+        if (cached !== undefined)
+            return cached;
+        const parent = node.source.parent ? this._nodesById.get(node.source.parent) : undefined;
+        const result = clamp(node.opacity * (parent ? this._resolveOpacity(parent) : 1), 0, 1);
+        this._opacityMemo.set(node.source.id, result);
+        return result;
+    }
+    _isNodeActive(node) {
+        return isRuntimeNodeActive(node, this._nodesById);
+    }
+    /** @internal Applies state-machine-only component channels to the shared visual instance. */
+    _applyStateMachineVisualChannel(node, path, value) {
+        const match = /^components\.(\d+)\.(sprite\.uv-rect|vector\.morph|path\.morph)$/u.exec(path);
+        if (!match)
+            return false;
+        const componentIndex = Number(match[1]);
+        if (node.deferredVisuals.length > 0 && this._isNodeActive(node)) {
+            const deferred = node.deferredVisuals.filter(item => item.componentIndex === componentIndex);
+            node.deferredVisuals.splice(0, node.deferredVisuals.length, ...node.deferredVisuals.filter(item => item.componentIndex !== componentIndex));
+            for (const item of deferred)
+                this._materializeCoreVisual(node, item);
+        }
+        const visuals = node.visuals.filter(visual => visual.sourceComponentIndex === componentIndex);
+        if (match[2] === 'sprite.uv-rect') {
+            const uv = numericStateMachineValue(value, path, 4);
+            for (const visual of visuals)
+                visual.component.setUvRect([uv[0], uv[1], uv[2], uv[3]]);
+            return true;
+        }
+        const morph = numericStateMachineValue(value, path, 1);
+        for (const visual of visuals) {
+            if (match[2] === 'path.morph' && visual.pathMorph) {
+                const next = tessellateAnimationPath({
+                    type: 'path2d',
+                    commands: visual.pathMorph.commands,
+                    values: morph,
+                    fill: visual.pathMorph.fill,
+                    fillRule: visual.pathMorph.fillRule,
+                    ...(visual.pathMorph.tolerance === undefined ? {} : { tolerance: visual.pathMorph.tolerance }),
+                });
+                visual.component.geometry.setData(next.positions, next.indices);
+                visual.component.revision++;
+            }
+            else if (match[2] === 'vector.morph' && visual.vectorShape) {
+                const shape = visual.vectorShape;
+                let pathValues = morph;
+                if (shape.morphRelative) {
+                    pathValues = new Float32Array(morph.length);
+                    for (let index = 0; index < morph.length; index++) {
+                        pathValues[index] = morph[index] + (shape.values[index] ?? 0);
+                    }
+                }
+                updateVectorVisual(visual, 0, pathValues);
+            }
+        }
+        return true;
+    }
+}
+function numericStateMachineValue(value, bindingPath, minimumSize) {
+    if (!(value instanceof Float32Array) || value.length < minimumSize) {
+        throw new TypeError(`Animation2D state-machine binding "${bindingPath}" requires at least ${minimumSize} Float32 values.`);
+    }
+    return value;
+}
+function createEllipseGeometry(width, height, centerX, centerY) {
+    const segments = 48;
+    const positions = new Float32Array((segments + 1) * 2);
+    positions[0] = centerX;
+    positions[1] = centerY;
+    for (let index = 0; index < segments; index++) {
+        const angle = index / segments * Math.PI * 2;
+        positions[(index + 1) * 2] = centerX + Math.cos(angle) * width / 2;
+        positions[(index + 1) * 2 + 1] = centerY + Math.sin(angle) * height / 2;
+    }
+    const indices = new Uint16Array(segments * 3);
+    for (let index = 0; index < segments; index++) {
+        indices[index * 3] = 0;
+        indices[index * 3 + 1] = index + 1;
+        indices[index * 3 + 2] = index + 2 > segments ? 1 : index + 2;
+    }
+    return new Geometry2D(positions, indices);
+}
+function isShape2DComponent(component) {
+    return component.type === 'shape2d'
+        && component.size !== undefined
+        && component.fill !== undefined;
+}
+function isPath2DComponent(component) {
+    return component.type === 'path2d'
+        && typeof component.commands === 'string'
+        && component.values !== undefined;
+}
+function isSprite2DComponent(component) {
+    return component.type === 'sprite2d'
+        && typeof component.resource === 'string'
+        && component.size !== undefined;
+}
+function isText2DComponent(component) {
+    return component.type === 'text2d'
+        && typeof component.text === 'string'
+        && component.size !== undefined;
+}
+function isParticle2DComponent(component) {
+    return component.type === 'particle2d'
+        && typeof component.maxParticles === 'number';
+}
+function isAudioComponent(component) {
+    return component.type === 'audio' && typeof component.resource === 'string';
+}
+function isVectorStrokePathComponent(component) {
+    const candidate = component;
+    const inlinePath = typeof candidate.commands === 'string'
+        && /^[MLQCZ]+$/.test(candidate.commands)
+        && candidate.commands[0] === 'M'
+        && Array.isArray(candidate.values)
+        && candidate.values.length === strokePathValueCount(candidate.commands)
+        && candidate.values.every(value => typeof value === 'number' && Number.isFinite(value));
+    const sourcePath = typeof candidate.sourceComponent === 'number'
+        && Number.isSafeInteger(candidate.sourceComponent)
+        && candidate.sourceComponent >= 0;
+    return component.type === 'org.haiyue.vector-stroke@1'
+        && (inlinePath || sourcePath)
+        && Array.isArray(candidate.color)
+        && candidate.color.length === 4
+        && candidate.color.every(value => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1)
+        && typeof candidate.width === 'number' && Number.isFinite(candidate.width) && candidate.width > 0
+        && (candidate.lineCap === 'butt' || candidate.lineCap === 'round' || candidate.lineCap === 'square')
+        && (candidate.lineJoin === 'miter' || candidate.lineJoin === 'round' || candidate.lineJoin === 'bevel')
+        && typeof candidate.miterLimit === 'number' && Number.isFinite(candidate.miterLimit) && candidate.miterLimit >= 1
+        && (candidate.tolerance === undefined
+            || (typeof candidate.tolerance === 'number' && Number.isFinite(candidate.tolerance) && candidate.tolerance > 0));
+}
+function isVectorPathMorphComponent(component) {
+    const candidate = component;
+    return component.type === 'org.haiyue.vector-path-morph@1'
+        && typeof candidate.commands === 'string'
+        && /^[MLQCZ]+$/.test(candidate.commands)
+        && (Array.isArray(candidate.times) || candidate.times instanceof Float32Array) && candidate.times.length > 0
+        && Array.from(candidate.times).every(value => typeof value === 'number' && Number.isFinite(value))
+        && (Array.isArray(candidate.values) || candidate.values instanceof Float32Array)
+        && typeof candidate.valueSize === 'number' && Number.isSafeInteger(candidate.valueSize) && candidate.valueSize > 0
+        && candidate.values.length === candidate.times.length * candidate.valueSize
+        && Array.from(candidate.values).every(value => typeof value === 'number' && Number.isFinite(value))
+        && (candidate.interpolation === 'step' || candidate.interpolation === 'linear' || candidate.interpolation === 'cubic-bezier')
+        && Array.isArray(candidate.fill) && candidate.fill.length === 4;
+}
+function strokePathValueCount(commands) {
+    let count = 0;
+    for (const command of commands)
+        count += command === 'M' || command === 'L' ? 2 : command === 'Q' ? 4 : command === 'C' ? 6 : 0;
+    return count;
+}
+function isCoreVisualComponent(component) {
+    return isShape2DComponent(component) || isPath2DComponent(component) || isSprite2DComponent(component)
+        || isText2DComponent(component) || isVectorShapeComponent(component)
+        || isVectorStrokePathComponent(component) || isVectorPathMorphComponent(component);
+}
+function isVectorShapeComponent(component) {
+    return component.type === ANIMATION_VECTOR_SHAPE_EXTENSION_ID
+        && typeof component.commands === 'string';
+}
+function createCoreVisual(component, componentIndex, instanceId, node, order, sourceGroup, composite, effects) {
+    let geometry;
+    let color;
+    let textMaterial = null;
+    let gradient = null;
+    let vectorPaint;
+    if (component.type === 'path2d') {
+        geometry = tessellateAnimationPath(component);
+        color = [...component.fill];
+    }
+    else if (component.type === 'org.haiyue.vector-path-morph@1') {
+        geometry = tessellateAnimationPath(sampleVectorPathMorph(component, component.times[0] ?? 0));
+        color = [...component.fill];
+    }
+    else if (component.type === 'org.haiyue.vector-stroke@1') {
+        geometry = tessellateVectorStrokePath(resolveVectorStrokePath(component, node));
+        color = [...component.color];
+    }
+    else if (component.type === ANIMATION_VECTOR_SHAPE_EXTENSION_ID) {
+        const initialTime = component.morph?.times[0] ?? firstVectorModifierTime(component) ?? 0;
+        const pathValues = sampleVectorShapePath(component, initialTime);
+        const resolvedPath = resolveVectorPath(component, pathValues, initialTime, component.fill !== undefined);
+        if (component.fill) {
+            geometry = resolvedPath.commands.length === 0 ? emptyGeometry2D() : tessellateRuntimeFillPath({
+                type: 'path2d', commands: resolvedPath.commands, values: resolvedPath.values,
+                fill: [1, 1, 1, 1], fillRule: component.fillRule ?? 'nonzero',
+                ...(component.tolerance === undefined ? {} : { tolerance: component.tolerance }),
+            });
+            vectorPaint = 'fill';
+            if (component.fill.kind === 'solid')
+                color = [...component.fill.color];
+            else {
+                color = [1, 1, 1, 1];
+                gradient = createRuntimeGradient(component.fill);
+            }
+        }
+        else {
+            const stroke = component.stroke;
+            geometry = resolvedPath.commands.length === 0 ? emptyGeometry2D() : tessellateVectorStrokePath({
+                type: 'org.haiyue.vector-stroke@1', commands: resolvedPath.commands, values: resolvedPath.values,
+                color: stroke.color, width: stroke.width, lineCap: stroke.lineCap, lineJoin: stroke.lineJoin,
+                miterLimit: stroke.miterLimit,
+                ...(component.tolerance === undefined ? {} : { tolerance: component.tolerance }),
+                ...(stroke.dash ? { dash: stroke.dash } : {}),
+                ...(stroke.dashOffset === undefined ? {} : { dashOffset: stroke.dashOffset }),
+            }, true);
+            vectorPaint = 'stroke';
+            color = stroke.gradient ? [1, 1, 1, 1] : [...stroke.color];
+            if (stroke.gradient)
+                gradient = createRuntimeGradient(stroke.gradient);
+        }
+    }
+    else {
+        const position = component.position ?? [0, 0];
+        const centerX = position[0];
+        const centerY = -position[1];
+        geometry = component.type === 'shape2d' && component.shape === 'ellipse'
+            ? createEllipseGeometry(component.size[0], component.size[1], centerX, centerY)
+            : createRect2D({ width: component.size[0], height: component.size[1], x: centerX, y: centerY });
+        color = component.type === 'shape2d' ? [...component.fill]
+            : component.type === 'sprite2d' ? [...(component.tint ?? [1, 1, 1, 1])] : [1, 1, 1, 1];
+        if (component.type === 'text2d') {
+            textMaterial = new AnimationTextRasterizer(component);
+        }
+    }
+    const visual = new AnimationVisual2D({
+        geometry,
+        color,
+        instanceId,
+        nodeId: sourceGroup ?? node.id,
+        order,
+        sourceOnly: sourceGroup !== undefined,
+        ...(composite ? { composite } : {}),
+        ...(component.type === 'sprite2d' ? { requiresTexture: true, uvRect: component.uvRect ?? [0, 0, 1, 1] } : {}),
+        ...(component.type === 'text2d' ? { requiresTexture: true, textMaterial } : {}),
+        ...(gradient ? { gradient } : {}),
+        ...(effects?.length ? { effects: createVisualEffects(effects, 0) } : {}),
+    });
+    const initialStyleAlpha = component.type === ANIMATION_VECTOR_SHAPE_EXTENSION_ID
+        ? initialVectorStyleAlpha(component)
+        : visual.color[3];
+    const compositeExpansionTracks = composite
+        ? compositeLayers(composite).map(layer => layer.expansionTrack)
+        : [];
+    return {
+        component: visual,
+        runtime: {
+            component: visual,
+            sourceComponentIndex: componentIndex,
+            color: visual.color,
+            baseAlpha: visual.color[3],
+            styleAlpha: initialStyleAlpha,
+            lastAlpha: Number.NaN,
+            ...(component.type === 'org.haiyue.vector-path-morph@1' ? { pathMorph: component, lastMorphTime: component.times[0] ?? 0 } : {}),
+            ...(component.type === ANIMATION_VECTOR_SHAPE_EXTENSION_ID ? {
+                vectorShape: component,
+                vectorPaint: vectorPaint,
+                ...(isVectorShapeDynamic(component) ? { lastVectorTime: Number.NaN } : {}),
+            } : {}),
+            ...(textMaterial ? { textRasterizer: textMaterial } : {}),
+            ...(effects?.length ? { sourceEffects: effects, lastEffectTime: 0 } : {}),
+            ...(compositeExpansionTracks.some(track => track !== undefined) ? {
+                compositeExpansionTracks,
+                lastCompositeTime: Number.NaN,
+            } : {}),
+            ...(component.type === 'sprite2d' && component.uvRectTrack ? {
+                spriteUvRectTrack: component.uvRectTrack,
+                spriteUvRectFrame: -1,
+            } : {}),
+        },
+    };
+}
+function createVisualEffects(effects, time) {
+    return effects.map(effect => ({ kind: effect.kind, values: sampleEffectValues(effect, time) }));
+}
+function updateVisualEffects(visual, effects, time) {
+    const count = Math.min(visual.effects.length, effects.length);
+    for (let index = 0; index < count; index++) {
+        const sampled = sampleEffectValues(effects[index], time);
+        const target = visual.effects[index].values;
+        if (target.length === sampled.length)
+            target.set(sampled);
+    }
+}
+function sampleEffectValues(effect, time) {
+    switch (effect.kind) {
+        case 'tint': {
+            const black = effect.blackTrack ? sampleVectorTrack(effect.blackTrack, time) : effect.black;
+            const white = effect.whiteTrack ? sampleVectorTrack(effect.whiteTrack, time) : effect.white;
+            const amount = effect.amountTrack ? sampleVectorTrack(effect.amountTrack, time)[0] ?? effect.amount : effect.amount;
+            return new Float32Array([
+                black[0] ?? effect.black[0], black[1] ?? effect.black[1], black[2] ?? effect.black[2],
+                white[0] ?? effect.white[0], white[1] ?? effect.white[1], white[2] ?? effect.white[2],
+                clamp(amount, 0, 1),
+            ]);
+        }
+        case 'fill': {
+            const color = effect.colorTrack ? sampleVectorTrack(effect.colorTrack, time) : effect.color;
+            const opacity = effect.opacityTrack ? sampleVectorTrack(effect.opacityTrack, time)[0] ?? effect.opacity ?? 1 : effect.opacity ?? 1;
+            return new Float32Array([
+                color[0] ?? effect.color[0], color[1] ?? effect.color[1], color[2] ?? effect.color[2], color[3] ?? effect.color[3],
+                clamp(opacity, 0, 1),
+            ]);
+        }
+        case 'opacity': {
+            const opacity = effect.opacityTrack ? sampleVectorTrack(effect.opacityTrack, time)[0] ?? effect.opacity : effect.opacity;
+            return new Float32Array([clamp(opacity, 0, 1)]);
+        }
+        case 'color-matrix':
+            return new Float32Array(effect.matrixTrack ? sampleVectorTrack(effect.matrixTrack, time) : effect.matrix);
+        case 'blur': {
+            const radius = effect.radiusTrack ? sampleVectorTrack(effect.radiusTrack, time) : effect.radius;
+            return new Float32Array([Math.max(0, radius[0] ?? effect.radius[0]), Math.max(0, radius[1] ?? effect.radius[1])]);
+        }
+        case 'drop-shadow': {
+            const color = effect.colorTrack ? sampleVectorTrack(effect.colorTrack, time) : effect.color;
+            const opacity = effect.opacityTrack ? sampleVectorTrack(effect.opacityTrack, time)[0] ?? effect.opacity : effect.opacity;
+            const offset = effect.offsetTrack ? sampleVectorTrack(effect.offsetTrack, time) : effect.offset;
+            const blur = effect.blurTrack ? sampleVectorTrack(effect.blurTrack, time)[0] ?? effect.blur : effect.blur;
+            return new Float32Array([
+                color[0] ?? effect.color[0], color[1] ?? effect.color[1], color[2] ?? effect.color[2], color[3] ?? effect.color[3],
+                clamp(opacity, 0, 1), offset[0] ?? effect.offset[0], offset[1] ?? effect.offset[1], Math.max(0, blur),
+            ]);
+        }
+    }
+}
+function updateVectorVisual(visual, time, pathOverride) {
+    const shape = visual.vectorShape;
+    const paint = visual.vectorPaint;
+    const pathValues = pathOverride ?? sampleVectorShapePath(shape, time);
+    let geometryChanged = shape.morph !== undefined || hasAnimatedVectorModifier(shape);
+    if (paint === 'fill') {
+        const fill = shape.fill;
+        if (geometryChanged) {
+            const resolvedPath = resolveVectorPath(shape, pathValues, time, true);
+            const next = !resolvedPath.commands.length ? emptyGeometry2D() : tessellateRuntimeFillPath({
+                type: 'path2d', commands: resolvedPath.commands, values: resolvedPath.values,
+                fill: [1, 1, 1, 1], fillRule: shape.fillRule ?? 'nonzero',
+                ...(shape.tolerance === undefined ? {} : { tolerance: shape.tolerance }),
+            });
+            visual.component.geometry.setData(next.positions, next.indices);
+        }
+        if (fill.kind === 'solid') {
+            const sampledColor = fill.colorTrack ? sampleVectorTrack(fill.colorTrack, time) : fill.color;
+            visual.color[0] = sampledColor[0] ?? fill.color[0];
+            visual.color[1] = sampledColor[1] ?? fill.color[1];
+            visual.color[2] = sampledColor[2] ?? fill.color[2];
+            const sampledOpacity = fill.opacityTrack
+                ? sampleVectorTrack(fill.opacityTrack, time)[0] ?? fill.opacity ?? 1
+                : fill.opacity ?? 1;
+            visual.styleAlpha = clamp((sampledColor[3] ?? fill.color[3]) * sampledOpacity, 0, 1);
+        }
+        else {
+            updateRuntimeGradient(visual, fill, time);
+            visual.styleAlpha = 1;
+        }
+    }
+    else {
+        const stroke = shape.stroke;
+        const width = stroke.widthTrack ? sampleVectorTrack(stroke.widthTrack, time)[0] ?? stroke.width : stroke.width;
+        const dashOffset = stroke.dashOffsetTrack
+            ? sampleVectorTrack(stroke.dashOffsetTrack, time)[0] ?? stroke.dashOffset ?? 0
+            : stroke.dashOffset;
+        geometryChanged ||= stroke.widthTrack !== undefined || stroke.dashOffsetTrack !== undefined;
+        if (geometryChanged) {
+            const resolvedPath = resolveVectorPath(shape, pathValues, time, false);
+            const next = !resolvedPath.commands.length ? emptyGeometry2D() : tessellateVectorStrokePath({
+                type: 'org.haiyue.vector-stroke@1', commands: resolvedPath.commands, values: resolvedPath.values,
+                color: stroke.color, width, lineCap: stroke.lineCap, lineJoin: stroke.lineJoin,
+                miterLimit: stroke.miterLimit,
+                ...(shape.tolerance === undefined ? {} : { tolerance: shape.tolerance }),
+                ...(stroke.dash ? { dash: stroke.dash } : {}),
+                ...(dashOffset === undefined ? {} : { dashOffset }),
+            }, true);
+            visual.component.geometry.setData(next.positions, next.indices);
+        }
+        const sampledColor = stroke.colorTrack ? sampleVectorTrack(stroke.colorTrack, time) : stroke.color;
+        visual.color[0] = stroke.gradient ? 1 : sampledColor[0] ?? stroke.color[0];
+        visual.color[1] = stroke.gradient ? 1 : sampledColor[1] ?? stroke.color[1];
+        visual.color[2] = stroke.gradient ? 1 : sampledColor[2] ?? stroke.color[2];
+        const sampledOpacity = stroke.opacityTrack
+            ? sampleVectorTrack(stroke.opacityTrack, time)[0] ?? stroke.opacity ?? 1
+            : stroke.opacity ?? 1;
+        visual.styleAlpha = stroke.gradient ? 1 : clamp((sampledColor[3] ?? stroke.color[3]) * sampledOpacity, 0, 1);
+        if (stroke.gradient)
+            updateRuntimeGradient(visual, stroke.gradient, time);
+    }
+    visual.component.revision++;
+}
+function sampleVectorShapePath(shape, time) {
+    if (!shape.morph)
+        return shape.values instanceof Float32Array
+            ? shape.values
+            : new Float32Array(shape.values);
+    const sampled = sampleVectorTrack(shape.morph, time);
+    if (!shape.morphRelative)
+        return sampled;
+    for (let index = 0; index < sampled.length; index++) {
+        sampled[index] = (sampled[index] ?? 0) + (shape.values[index] ?? 0);
+    }
+    return sampled;
+}
+function createRuntimeGradient(paint) {
+    return {
+        kind: paint.kind === 'linear-gradient' ? 'linear' : 'radial',
+        start: [paint.start[0], -paint.start[1]],
+        end: [paint.end[0], -paint.end[1]],
+        stops: new Float32Array(paint.stops),
+        opacity: paint.opacity ?? 1,
+    };
+}
+function updateRuntimeGradient(visual, paint, time) {
+    const gradient = visual.component.gradient ??= createRuntimeGradient(paint);
+    const start = paint.startTrack ? sampleVectorTrack(paint.startTrack, time) : paint.start;
+    const end = paint.endTrack ? sampleVectorTrack(paint.endTrack, time) : paint.end;
+    const stops = paint.stopsTrack ? sampleVectorTrack(paint.stopsTrack, time) : paint.stops;
+    gradient.start[0] = start[0] ?? paint.start[0];
+    gradient.start[1] = -(start[1] ?? paint.start[1]);
+    gradient.end[0] = end[0] ?? paint.end[0];
+    gradient.end[1] = -(end[1] ?? paint.end[1]);
+    if (gradient.stops.length !== stops.length)
+        gradient.stops = new Float32Array(stops);
+    else
+        gradient.stops.set(stops);
+    gradient.opacity = paint.opacityTrack
+        ? sampleVectorTrack(paint.opacityTrack, time)[0] ?? paint.opacity ?? 1
+        : paint.opacity ?? 1;
+}
+function initialVectorStyleAlpha(component) {
+    if (component.fill)
+        return component.fill.kind === 'solid'
+            ? component.fill.color[3] * (component.fill.opacity ?? 1)
+            : 1;
+    const stroke = component.stroke;
+    return stroke.gradient ? 1 : stroke.color[3] * (stroke.opacity ?? 1);
+}
+function isVectorShapeDynamic(component) {
+    if (component.morph || hasAnimatedVectorModifier(component))
+        return true;
+    if (component.fill)
+        return component.fill.kind === 'solid'
+            ? component.fill.colorTrack !== undefined || component.fill.opacityTrack !== undefined
+            : component.fill.startTrack !== undefined || component.fill.endTrack !== undefined
+                || component.fill.stopsTrack !== undefined || component.fill.opacityTrack !== undefined;
+    const stroke = component.stroke;
+    return stroke.colorTrack !== undefined || stroke.opacityTrack !== undefined || stroke.widthTrack !== undefined
+        || stroke.dashOffsetTrack !== undefined || (stroke.gradient !== undefined && (stroke.gradient.startTrack !== undefined || stroke.gradient.endTrack !== undefined
+        || stroke.gradient.stopsTrack !== undefined || stroke.gradient.opacityTrack !== undefined));
+}
+function resolveVectorPath(component, values, time, closeOpen) {
+    if (!component.modifiers?.length)
+        return { commands: component.commands, values: new Float32Array(values) };
+    return applyVectorPathModifiers(component.commands, values, component.tolerance ?? 0.35, component.modifiers.map(modifier => modifier.kind === 'round-corners'
+        ? {
+            kind: modifier.kind,
+            radius: modifier.radiusTrack ? sampleVectorTrack(modifier.radiusTrack, time)[0] ?? modifier.radius : modifier.radius,
+        }
+        : {
+            kind: modifier.kind,
+            start: modifier.startTrack ? sampleVectorTrack(modifier.startTrack, time)[0] ?? modifier.start : modifier.start,
+            end: modifier.endTrack ? sampleVectorTrack(modifier.endTrack, time)[0] ?? modifier.end : modifier.end,
+            offset: modifier.offsetTrack ? sampleVectorTrack(modifier.offsetTrack, time)[0] ?? modifier.offset : modifier.offset,
+            mode: modifier.mode,
+        }), closeOpen);
+}
+function hasAnimatedVectorModifier(component) {
+    return component.modifiers?.some(modifier => modifier.kind === 'round-corners'
+        ? modifier.radiusTrack !== undefined
+        : modifier.startTrack !== undefined || modifier.endTrack !== undefined || modifier.offsetTrack !== undefined) ?? false;
+}
+function firstVectorModifierTime(component) {
+    for (const modifier of component.modifiers ?? []) {
+        const track = modifier.kind === 'round-corners'
+            ? modifier.radiusTrack
+            : modifier.startTrack ?? modifier.endTrack ?? modifier.offsetTrack;
+        if (track)
+            return track.times[0];
+    }
+    return undefined;
+}
+function emptyGeometry2D() {
+    // Geometry2D deliberately rejects empty buffers; a zero-area triangle keeps
+    // the renderer contract valid while producing no fragments for an empty trim.
+    return new Geometry2D(new Float32Array(6), new Uint16Array([0, 1, 2]));
+}
+function tessellateRuntimeFillPath(component) {
+    try {
+        return tessellateAnimationPath(component);
+    }
+    catch (error) {
+        if (error instanceof RangeError && (error.message === 'Animation path contains no drawable closed contour.'
+            || error.message === 'Animation path tessellation produced no triangles.'))
+            return emptyGeometry2D();
+        throw error;
+    }
+}
+function sampleVectorTrack(track, time) {
+    const frameCount = track.times.length;
+    if (frameCount === 0 || track.valueSize <= 0)
+        return new Float32Array();
+    const frame = findVectorTrackFrame(track, time);
+    const next = Math.min(frame + 1, frameCount - 1);
+    let progress = 0;
+    if (next !== frame && track.interpolation !== 'step') {
+        const start = track.times[frame];
+        const end = track.times[next];
+        progress = clamp((time - start) / Math.max(end - start, 1e-8), 0, 1);
+        if (track.interpolation === 'cubic-bezier' && track.easings) {
+            const offset = frame * 4;
+            progress = cubicBezierYForX(progress, track.easings[offset] ?? 0.333, track.easings[offset + 1] ?? 0.333, track.easings[offset + 2] ?? 0.667, track.easings[offset + 3] ?? 0.667);
+        }
+    }
+    const result = new Float32Array(track.valueSize);
+    const fromOffset = frame * track.valueSize;
+    const toOffset = next * track.valueSize;
+    for (let index = 0; index < track.valueSize; index++) {
+        const from = track.values[fromOffset + index] ?? 0;
+        result[index] = mix(from, track.values[toOffset + index] ?? from, progress);
+    }
+    return result;
+}
+function findVectorTrackFrame(track, time) {
+    let low = 0;
+    let high = track.times.length - 1;
+    while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        if (track.times[middle] <= time)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return low;
+}
+function isSourceNodeActiveAt(node, time, nodesById, animationDuration) {
+    let cursor = node;
+    while (cursor) {
+        const start = cursor.start ?? 0;
+        const end = start + (cursor.duration ?? animationDuration);
+        if (time < start || time > end)
+            return false;
+        cursor = cursor.parent ? nodesById.get(cursor.parent) : undefined;
+    }
+    return true;
+}
+function isRuntimeNodeActive(node, nodesById) {
+    let cursor = node;
+    while (cursor) {
+        if (cursor.entity.disabled)
+            return false;
+        cursor = cursor.source.parent ? nodesById.get(cursor.source.parent) : undefined;
+    }
+    return true;
+}
+function resolveVectorStrokePath(component, node) {
+    if (typeof component.commands === 'string' && component.values !== undefined)
+        return component;
+    const sourceIndex = component.sourceComponent;
+    const source = typeof sourceIndex === 'number' ? node.components?.[sourceIndex] : undefined;
+    if (!source || !isPath2DComponent(source))
+        throw new TypeError('Lottie stroke extension references a missing path2d source component.');
+    return { ...component, commands: source.commands, values: source.values };
+}
+function resolveSourceGroups(nodes, sources) {
+    const byId = new Map(nodes.map(node => [node.id, node]));
+    const result = new Map();
+    for (const node of nodes) {
+        let cursor = node;
+        while (cursor) {
+            if (sources.has(cursor.id)) {
+                result.set(node.id, cursor.id);
+                break;
+            }
+            cursor = cursor.parent ? byId.get(cursor.parent) : undefined;
+        }
+    }
+    return result;
+}
+function resolveInheritedEffects(nodes, sourceGroups) {
+    const byId = new Map(nodes.map(node => [node.id, node]));
+    const result = new Map();
+    for (const node of nodes) {
+        const sourceBoundary = sourceGroups.get(node.id);
+        let cursor = node;
+        while (cursor) {
+            if (cursor.effects?.length) {
+                result.set(node.id, cursor.effects);
+                break;
+            }
+            if (cursor.id === sourceBoundary)
+                break;
+            cursor = cursor.parent ? byId.get(cursor.parent) : undefined;
+        }
+    }
+    return result;
+}
+function resolveInheritedComposites(nodes, sourceGroups) {
+    const byId = new Map(nodes.map(node => [node.id, node]));
+    const result = new Map();
+    for (const node of nodes) {
+        const sourceBoundary = sourceGroups.get(node.id);
+        let cursor = node;
+        while (cursor) {
+            if (cursor.composite) {
+                result.set(node.id, cursor.composite);
+                break;
+            }
+            if (cursor.id === sourceBoundary)
+                break;
+            cursor = cursor.parent ? byId.get(cursor.parent) : undefined;
+        }
+    }
+    return result;
+}
+function compositeLayers(composite) {
+    if (!composite)
+        return [];
+    return 'layers' in composite ? composite.layers : [composite];
+}
+function findFrame(times, time, previous) {
+    if (times.length <= 1 || time <= times[0])
+        return 0;
+    if (time >= times[times.length - 1])
+        return times.length - 1;
+    let cursor = Math.min(previous, times.length - 2);
+    if (time >= times[cursor] && time < times[cursor + 1])
+        return cursor;
+    let low = 0;
+    let high = times.length - 1;
+    while (low + 1 < high) {
+        const middle = (low + high) >>> 1;
+        if (times[middle] <= time)
+            low = middle;
+        else
+            high = middle;
+    }
+    return low;
+}
+function sampleProgress(track, frame, time) {
+    if (frame >= track.times.length - 1 || track.interpolation === 'step')
+        return 0;
+    const start = track.times[frame];
+    const end = track.times[frame + 1];
+    const linear = clamp((time - start) / Math.max(end - start, 1e-8), 0, 1);
+    if (track.interpolation !== 'cubic-bezier' || !track.easings)
+        return linear;
+    const offset = frame * 4;
+    return cubicBezierYForX(linear, track.easings[offset], track.easings[offset + 1], track.easings[offset + 2], track.easings[offset + 3]);
+}
+function cubicBezierYForX(x, x1, y1, x2, y2) {
+    let t = x;
+    for (let iteration = 0; iteration < 5; iteration++) {
+        const estimate = bezier(t, x1, x2) - x;
+        const derivative = bezierDerivative(t, x1, x2);
+        if (Math.abs(derivative) < 1e-5)
+            break;
+        t = clamp(t - estimate / derivative, 0, 1);
+    }
+    return bezier(t, y1, y2);
+}
+function bezier(t, a, b) {
+    const inverse = 1 - t;
+    return 3 * inverse * inverse * t * a + 3 * inverse * t * t * b + t * t * t;
+}
+function bezierDerivative(t, a, b) {
+    const inverse = 1 - t;
+    return 3 * inverse * inverse * a + 6 * inverse * t * (b - a) + 3 * t * t * (1 - b);
+}
+function mix(a, b, t) {
+    return a + (b - a) * t;
+}
+function spatialBezier(start, control1, control2, end, t) {
+    const inverse = 1 - t;
+    return inverse * inverse * inverse * start
+        + 3 * inverse * inverse * t * control1
+        + 3 * inverse * t * t * control2
+        + t * t * t * end;
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+
+/**
+ * Creates a shared state-machine controller for a 2D mixer adapter.
+ *
+ * Animation2DComponent remains a single-composition player. A port must own
+ * the 2D pose sampling, blending, discrete-property policy, and side-effect
+ * lifecycle; this factory intentionally does not emulate those semantics by
+ * switching component timelines.
+ */
+function createAnimation2DStateMachineController(definition, port, options) {
+    return new Animation3DStateMachineController(compileAnimationStateMachineDefinition(definition), port, options);
+}
+
+export { Animation2DRuntime as A, AnimationVisual2D as a, createAnimation2DStateMachineController as c, tessellateAnimationPath as t };
+//# sourceMappingURL=Animation2DStateMachine-9IonguNa.js.map