@haiyue/extensions 0.1.0 → 0.2.0

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

@@ -1,3245 +0,0 @@
-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