@haiyue/extensions 0.1.0

package/dist/chunks/Spine2DRuntime-D9M9LAQR.js

@@ -0,0 +1,3056 @@
+import { Component, EngineError, EngineErrorCode } from '@haiyue/engine';
+import { UniqueCheckType } from '@haiyue/engine/ecs';
+import { ErrorRecovery, ErrorDomain } from '@haiyue/engine/core';
+import { parseAssetWorkerFirst, createAbortError } from '@haiyue/engine/experimental/async';
+import { S as SPINE_ASSET_PARSER } from './SpineAssetParser-BSDmPge1.js';
+
+class Spine2DComponent extends Component {
+    static UniqueCheckType = UniqueCheckType.SYMBOL | UniqueCheckType.REPLACE;
+    static UniqueSymbol = Symbol.for('Spine2DComponent');
+    static editor = {
+        fields: {
+            jsonUrl: { type: 'text', label: 'Skeleton JSON URL' },
+            atlasUrl: { type: 'text', label: 'Atlas URL' },
+            imageUrl: { type: 'text', label: 'Image URL Override' },
+            skin: { type: 'text', label: 'Skin' },
+            animation: { type: 'text', label: 'Animation' },
+            loop: { type: 'boolean', label: 'Loop' },
+            timeScale: { type: 'number', label: 'Time Scale', step: 0.1 },
+            scale: { type: 'number', label: 'Scale', min: 0.001, step: 0.1 },
+            premultipliedAlpha: { type: 'boolean', label: 'Premultiplied Alpha' },
+            debugMesh: { type: 'boolean', label: 'Debug Mesh' },
+            debugBones: { type: 'boolean', label: 'Debug Bones' },
+            mixDuration: { type: 'number', label: 'Mix Duration', min: 0, step: 0.05 },
+        },
+    };
+    _jsonUrl = '';
+    _atlasUrl = '';
+    _imageUrl = '';
+    _imageUrls = {};
+    _imageUrlsKey = '{}';
+    _skin = 'default';
+    _sourceKey = '';
+    _sourceKeyDirty = true;
+    animation;
+    loop;
+    timeScale;
+    scale;
+    premultipliedAlpha;
+    debugMesh;
+    debugBones;
+    mixDuration;
+    status = 'idle';
+    error = null;
+    elapsed = 0;
+    previousAnimation = '';
+    previousElapsed = 0;
+    mixElapsed = 0;
+    runtimeKey = '';
+    loadingKey = '';
+    constructor(options = {}) {
+        super('Spine2DComponent');
+        this.jsonUrl = options.jsonUrl ?? '';
+        this.atlasUrl = options.atlasUrl ?? '';
+        this.imageUrl = options.imageUrl ?? '';
+        this.imageUrls = options.imageUrls ?? {};
+        this.skin = options.skin ?? 'default';
+        this.animation = options.animation ?? '';
+        this.loop = options.loop ?? true;
+        this.timeScale = options.timeScale ?? 1;
+        this.scale = options.scale ?? 1;
+        this.premultipliedAlpha = options.premultipliedAlpha ?? false;
+        this.debugMesh = options.debugMesh ?? false;
+        this.debugBones = options.debugBones ?? false;
+        this.mixDuration = options.mixDuration ?? 0;
+    }
+    get jsonUrl() {
+        return this._jsonUrl;
+    }
+    set jsonUrl(value) {
+        if (this._jsonUrl === value)
+            return;
+        this._jsonUrl = value;
+        this.invalidateSourceKey(false);
+    }
+    get atlasUrl() {
+        return this._atlasUrl;
+    }
+    set atlasUrl(value) {
+        if (this._atlasUrl === value)
+            return;
+        this._atlasUrl = value;
+        this.invalidateSourceKey(false);
+    }
+    get imageUrl() {
+        return this._imageUrl;
+    }
+    set imageUrl(value) {
+        if (this._imageUrl === value)
+            return;
+        this._imageUrl = value;
+        this.invalidateSourceKey(false);
+    }
+    get imageUrls() {
+        return this._imageUrls;
+    }
+    set imageUrls(value) {
+        if (this._imageUrls === value)
+            return;
+        this._imageUrls = value;
+        this._imageUrlsKey = JSON.stringify(value);
+        this.invalidateSourceKey(false);
+    }
+    get skin() {
+        return this._skin;
+    }
+    set skin(value) {
+        if (this._skin === value)
+            return;
+        this._skin = value;
+        this.invalidateSourceKey(false);
+    }
+    get sourceKey() {
+        if (this._sourceKeyDirty) {
+            this._sourceKey = `${this._jsonUrl}|${this._atlasUrl}|${this._imageUrl}|${this._imageUrlsKey}|${this._skin}`;
+            this._sourceKeyDirty = false;
+        }
+        return this._sourceKey;
+    }
+    invalidateSourceKey(refreshImageUrlsKey = true) {
+        if (refreshImageUrlsKey)
+            this._imageUrlsKey = JSON.stringify(this._imageUrls);
+        this._sourceKeyDirty = true;
+        return this;
+    }
+    clone() {
+        return new Spine2DComponent({
+            jsonUrl: this.jsonUrl,
+            atlasUrl: this.atlasUrl,
+            imageUrl: this.imageUrl,
+            imageUrls: { ...this.imageUrls },
+            skin: this.skin,
+            animation: this.animation,
+            loop: this.loop,
+            timeScale: this.timeScale,
+            scale: this.scale,
+            premultipliedAlpha: this.premultipliedAlpha,
+            debugMesh: this.debugMesh,
+            debugBones: this.debugBones,
+            mixDuration: this.mixDuration,
+        });
+    }
+}
+
+const cache = new WeakMap();
+const EMPTY = [];
+function compileAnimationBoneTimelines(animations) {
+    for (const animation of Object.values(animations))
+        getAnimationBoneTimelines(animation);
+}
+function getAnimationBoneTimelines(animation) {
+    if (!animation || typeof animation !== 'object')
+        return EMPTY;
+    const cached = cache.get(animation);
+    if (cached)
+        return cached;
+    const entries = [];
+    for (const [boneName, timelines] of Object.entries(animation.bones ?? {})) {
+        entries.push({ boneName, timelines });
+    }
+    cache.set(animation, entries);
+    return entries;
+}
+
+class SpineFloatBuilder {
+    data;
+    length = 0;
+    constructor(initialCapacity = 1024) {
+        this.data = new Float32Array(initialCapacity);
+    }
+    clear() {
+        this.length = 0;
+    }
+    get byteLength() {
+        return this.length * 4;
+    }
+    get(index) {
+        return this.data[index] ?? 0;
+    }
+    push(...values) {
+        this.ensureCapacity(this.length + values.length);
+        this.data.set(values, this.length);
+        this.length += values.length;
+    }
+    push8(a, b, c, d, e, f, g, h) {
+        this.ensureCapacity(this.length + 8);
+        const offset = this.length;
+        this.data[offset] = a;
+        this.data[offset + 1] = b;
+        this.data[offset + 2] = c;
+        this.data[offset + 3] = d;
+        this.data[offset + 4] = e;
+        this.data[offset + 5] = f;
+        this.data[offset + 6] = g;
+        this.data[offset + 7] = h;
+        this.length += 8;
+    }
+    appendArray(values, length = values.length) {
+        this.ensureCapacity(this.length + length);
+        for (let i = 0; i < length; i++)
+            this.data[this.length + i] = values[i] ?? 0;
+        this.length += length;
+    }
+    truncate(length) {
+        this.length = Math.max(0, Math.min(this.length, length));
+    }
+    /** Grows storage if needed and exposes a reusable writable region without allocating a temporary array. */
+    reserveLength(length) {
+        const nextLength = Math.max(0, length);
+        this.ensureCapacity(nextLength);
+        this.length = nextLength;
+    }
+    ensureCapacity(required) {
+        if (this.data.length >= required)
+            return;
+        let nextCapacity = Math.max(1, this.data.length);
+        while (nextCapacity < required)
+            nextCapacity *= 2;
+        const next = new Float32Array(nextCapacity);
+        next.set(this.data.subarray(0, this.length));
+        this.data = next;
+    }
+}
+
+/** Reads an element whose presence is an internal runtime invariant. */
+function requiredItemAt(values, index, label) {
+    const value = values[index];
+    if (value === undefined) {
+        throw new RangeError(`${label} is missing element ${index} (length ${values.length}).`);
+    }
+    return value;
+}
+/** Reads a number whose presence is an internal runtime invariant. */
+function requiredNumberAt(values, index, label) {
+    const value = values[index];
+    if (value === undefined || !Number.isFinite(value)) {
+        throw new RangeError(`${label} requires a finite value at ${index} (length ${values.length}).`);
+    }
+    return value;
+}
+
+const CURVE_LINEAR = 0;
+const CURVE_STEPPED = 1;
+const CURVE_BEZIER = 2;
+const compiledFrames = new WeakMap();
+const animationDurations = new WeakMap();
+function createSpineTimelineSamplerState() {
+    return { cursors: new WeakMap(), cursorMisses: 0 };
+}
+/** Eagerly compiles every frame array reachable from the animation tree. */
+function compileSpineTimelines(animations, samplerState) {
+    let timelineCount = 0;
+    let frameCount = 0;
+    let numericChannelCount = 0;
+    for (const animation of Object.values(animations)) {
+        let duration = 0;
+        const visit = (value) => {
+            if (Array.isArray(value)) {
+                const compiled = compileFrameArray(value);
+                if (compiled) {
+                    getTimelineCursor(value, samplerState);
+                    timelineCount++;
+                    frameCount += compiled.times.length;
+                    numericChannelCount += compiled.numericChannels.size;
+                    const lastTime = compiled.times[compiled.times.length - 1];
+                    if (lastTime !== undefined && lastTime > duration)
+                        duration = lastTime;
+                }
+                else {
+                    for (const child of value)
+                        visit(child);
+                }
+                return;
+            }
+            if (!value || typeof value !== 'object')
+                return;
+            for (const child of Object.values(value))
+                visit(child);
+        };
+        visit(animation);
+        if (animation && typeof animation === 'object')
+            animationDurations.set(animation, duration);
+    }
+    return { timelineCount, frameCount, numericChannelCount };
+}
+function getCompiledAnimationDuration(animation) {
+    if (!animation || typeof animation !== 'object')
+        return 0;
+    const cached = animationDurations.get(animation);
+    if (cached !== undefined)
+        return cached;
+    let duration = 0;
+    const visit = (value) => {
+        if (Array.isArray(value)) {
+            const compiled = getOrCompileFrames(value);
+            if (compiled) {
+                const lastTime = compiled.times[compiled.times.length - 1];
+                if (lastTime !== undefined && lastTime > duration)
+                    duration = lastTime;
+            }
+            else {
+                for (const child of value)
+                    visit(child);
+            }
+            return;
+        }
+        if (!value || typeof value !== 'object')
+            return;
+        for (const child of Object.values(value))
+            visit(child);
+    };
+    visit(animation);
+    animationDurations.set(animation, duration);
+    return duration;
+}
+function sampleCompiledTimeline(frames, time, key, fallback, _duration = 0, _loop = false, samplerState) {
+    const timeline = getOrCompileFrames(frames);
+    if (!timeline || timeline.times.length === 0)
+        return fallback;
+    const channel = timeline.numericChannels.get(key) ?? timeline.numericChannels.get('value');
+    if (!channel)
+        return fallback;
+    const lastIndex = timeline.times.length - 1;
+    const firstTime = timeline.times[0] ?? 0;
+    if (time < firstTime)
+        return fallback;
+    const lastTime = timeline.times[lastIndex] ?? 0;
+    if (time >= lastTime)
+        return finiteOrFallback(channel.values[lastIndex], fallback);
+    const previousIndex = findIntervalIndex(timeline, time, getTimelineCursor(frames, samplerState));
+    const nextIndex = Math.min(lastIndex, previousIndex + 1);
+    const start = finiteOrFallback(channel.values[previousIndex], fallback);
+    const end = finiteOrFallback(channel.values[nextIndex], fallback);
+    const previousTime = timeline.times[previousIndex] ?? 0;
+    const nextTime = timeline.times[nextIndex] ?? previousTime;
+    if (nextIndex === previousIndex || nextTime === previousTime)
+        return start;
+    const curveKind = channel.curveKinds[previousIndex] ?? CURVE_LINEAR;
+    if (curveKind === CURVE_STEPPED)
+        return start;
+    if (curveKind === CURVE_BEZIER) {
+        return sampleBezierChannel(time, previousTime, start, channel.curves, previousIndex * 4, nextTime, end);
+    }
+    const alpha = clampUnit((time - previousTime) / (nextTime - previousTime));
+    return start + (end - start) * alpha;
+}
+/** Returns the last frame whose time is <= sample time, or -1 before the first frame. */
+function findCompiledFrameIndex(frames, time, samplerState) {
+    const timeline = getOrCompileFrames(frames);
+    if (!timeline || timeline.times.length === 0 || time < (timeline.times[0] ?? 0))
+        return -1;
+    const lastIndex = timeline.times.length - 1;
+    if (time >= (timeline.times[lastIndex] ?? 0)) {
+        const state = getTimelineCursor(frames, samplerState);
+        if (state) {
+            state.discreteCursor = lastIndex;
+            state.discreteTime = time;
+        }
+        return lastIndex;
+    }
+    const state = getTimelineCursor(frames, samplerState);
+    let cursor = state?.discreteCursor ?? 0;
+    if (state
+        && time >= state.discreteTime
+        && cursor >= 0
+        && cursor < lastIndex
+        && time >= (timeline.times[cursor] ?? 0)) {
+        while (cursor < lastIndex && (timeline.times[cursor + 1] ?? Infinity) <= time)
+            cursor++;
+    }
+    else {
+        cursor = upperBound(timeline.times, time) - 1;
+    }
+    if (state) {
+        state.discreteCursor = Math.max(0, cursor);
+        state.discreteTime = time;
+    }
+    return cursor;
+}
+function sampleCompiledColor(frames, time, fallback, out, samplerState) {
+    const timeline = getOrCompileFrames(frames);
+    if (!timeline?.color || timeline.times.length === 0)
+        return copyColor$1(fallback, out);
+    const channel = timeline.color;
+    const lastIndex = timeline.times.length - 1;
+    const firstTime = timeline.times[0] ?? 0;
+    if (time < firstTime)
+        return copyColor$1(fallback, out);
+    const lastTime = timeline.times[lastIndex] ?? 0;
+    if (time >= lastTime)
+        return copyCompiledColor(channel, lastIndex, fallback, out);
+    const previousIndex = findIntervalIndex(timeline, time, getTimelineCursor(frames, samplerState));
+    const nextIndex = Math.min(lastIndex, previousIndex + 1);
+    const previousTime = timeline.times[previousIndex] ?? 0;
+    const nextTime = timeline.times[nextIndex] ?? previousTime;
+    for (let colorChannel = 0; colorChannel < 4; colorChannel++) {
+        const start = finiteOrFallback(channel.values[previousIndex * 4 + colorChannel], fallback[colorChannel] ?? 1);
+        const end = finiteOrFallback(channel.values[nextIndex * 4 + colorChannel], fallback[colorChannel] ?? 1);
+        if (nextIndex === previousIndex || nextTime === previousTime) {
+            out[colorChannel] = start;
+            continue;
+        }
+        const curveIndex = previousIndex * 4 + colorChannel;
+        const curveKind = channel.curveKinds[curveIndex] ?? CURVE_LINEAR;
+        if (curveKind === CURVE_STEPPED)
+            out[colorChannel] = start;
+        else if (curveKind === CURVE_BEZIER) {
+            out[colorChannel] = sampleBezierChannel(time, previousTime, start, channel.curves, curveIndex * 4, nextTime, end);
+        }
+        else {
+            const alpha = clampUnit((time - previousTime) / (nextTime - previousTime));
+            out[colorChannel] = start + (end - start) * alpha;
+        }
+    }
+    return out;
+}
+function compileFrameArray(frames) {
+    if (frames.length === 0 || compiledFrames.has(frames))
+        return compiledFrames.get(frames) ?? null;
+    for (const frame of frames) {
+        if (!frame || typeof frame !== 'object' || Array.isArray(frame))
+            return null;
+    }
+    const records = frames;
+    const times = new Float64Array(records.length);
+    const numericKeys = new Set();
+    let hasColor = false;
+    for (let frameIndex = 0; frameIndex < records.length; frameIndex++) {
+        const frame = records[frameIndex];
+        if (!frame)
+            continue;
+        times[frameIndex] = finiteNumber(frame.time, 0);
+        for (const [key, value] of Object.entries(frame)) {
+            if (key === 'time' || key === 'curve')
+                continue;
+            if (key === 'color' && typeof value === 'string')
+                hasColor = true;
+            else if (typeof value === 'number')
+                numericKeys.add(key);
+        }
+    }
+    const numericChannels = new Map();
+    for (const key of numericKeys)
+        numericChannels.set(key, compileNumericChannel(records, key));
+    const timeline = {
+        times,
+        numericChannels,
+        color: hasColor ? compileColorChannel(records) : null,
+    };
+    compiledFrames.set(frames, timeline);
+    return timeline;
+}
+function compileNumericChannel(frames, key) {
+    const values = new Float32Array(frames.length);
+    const curveKinds = new Uint8Array(frames.length);
+    const curves = new Float32Array(frames.length * 4);
+    const curveOffset = getCurveOffset(key);
+    for (let frameIndex = 0; frameIndex < frames.length; frameIndex++) {
+        const frame = frames[frameIndex];
+        const value = frame?.[key] ?? frame?.value;
+        values[frameIndex] = typeof value === 'number' && Number.isFinite(value) ? value : Number.NaN;
+        compileCurve(frame?.curve, curveOffset, curveKinds, frameIndex, curves, frameIndex * 4);
+    }
+    return { values, curveKinds, curves };
+}
+function compileColorChannel(frames) {
+    const values = new Float32Array(frames.length * 4);
+    values.fill(Number.NaN);
+    const curveKinds = new Uint8Array(frames.length * 4);
+    const curves = new Float32Array(frames.length * 16);
+    for (let frameIndex = 0; frameIndex < frames.length; frameIndex++) {
+        const frame = frames[frameIndex];
+        writeHexColor(frame?.color, values, frameIndex * 4);
+        for (let channel = 0; channel < 4; channel++) {
+            const curveIndex = frameIndex * 4 + channel;
+            compileCurve(frame?.curve, channel * 4, curveKinds, curveIndex, curves, curveIndex * 4);
+        }
+    }
+    return { values, curveKinds, curves };
+}
+function compileCurve(curve, sourceOffset, kinds, kindIndex, curves, targetOffset) {
+    if (curve === 'stepped') {
+        kinds[kindIndex] = CURVE_STEPPED;
+        return;
+    }
+    if (!Array.isArray(curve) || curve.length < sourceOffset + 4)
+        return;
+    kinds[kindIndex] = CURVE_BEZIER;
+    curves[targetOffset] = finiteNumber(curve[sourceOffset], 0);
+    curves[targetOffset + 1] = finiteNumber(curve[sourceOffset + 1], 0);
+    curves[targetOffset + 2] = finiteNumber(curve[sourceOffset + 2], 0);
+    curves[targetOffset + 3] = finiteNumber(curve[sourceOffset + 3], 0);
+}
+function getOrCompileFrames(frames) {
+    if (!Array.isArray(frames) || frames.length === 0)
+        return null;
+    return compiledFrames.get(frames) ?? compileFrameArray(frames);
+}
+function findIntervalIndex(timeline, time, state) {
+    const times = timeline.times;
+    const lastInterval = Math.max(0, times.length - 2);
+    let cursor = Math.min(lastInterval, state?.intervalCursor ?? 0);
+    if (state
+        && time >= state.intervalTime
+        && time >= (times[cursor] ?? 0)
+        && time <= (times[cursor + 1] ?? Infinity)) {
+        state.intervalTime = time;
+        return cursor;
+    }
+    if (state && time >= state.intervalTime && time >= (times[cursor] ?? 0)) {
+        while (cursor < lastInterval && (times[cursor + 1] ?? Infinity) < time)
+            cursor++;
+    }
+    else {
+        cursor = Math.max(0, lowerBound(times, time) - 1);
+    }
+    if (state) {
+        state.intervalCursor = cursor;
+        state.intervalTime = time;
+    }
+    return cursor;
+}
+function getTimelineCursor(frames, samplerState) {
+    if (!frames || !samplerState)
+        return null;
+    let cursor = samplerState.cursors.get(frames);
+    if (!cursor) {
+        cursor = { intervalCursor: 0, intervalTime: -Infinity, discreteCursor: 0, discreteTime: -Infinity };
+        samplerState.cursors.set(frames, cursor);
+        samplerState.cursorMisses++;
+    }
+    return cursor;
+}
+function lowerBound(values, target) {
+    let low = 0;
+    let high = values.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if ((values[middle] ?? Infinity) < target)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}
+function upperBound(values, target) {
+    let low = 0;
+    let high = values.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if ((values[middle] ?? Infinity) <= target)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}
+function sampleBezierChannel(time, time1, value1, curves, curveOffset, time2, value2) {
+    const cx1 = curves[curveOffset] ?? time1;
+    const cy1 = curves[curveOffset + 1] ?? value1;
+    const cx2 = curves[curveOffset + 2] ?? time2;
+    const cy2 = curves[curveOffset + 3] ?? value2;
+    let low = 0;
+    let high = 1;
+    let parameter = 0;
+    for (let iteration = 0; iteration < 12; iteration++) {
+        parameter = (low + high) * 0.5;
+        if (cubicBezier(time1, cx1, cx2, time2, parameter) < time)
+            low = parameter;
+        else
+            high = parameter;
+    }
+    parameter = (low + high) * 0.5;
+    return cubicBezier(value1, cy1, cy2, value2, parameter);
+}
+function cubicBezier(p0, p1, p2, p3, time) {
+    const inverse = 1 - time;
+    return inverse * inverse * inverse * p0
+        + 3 * inverse * inverse * time * p1
+        + 3 * inverse * time * time * p2
+        + time * time * time * p3;
+}
+function copyCompiledColor(channel, frameIndex, fallback, out) {
+    for (let colorChannel = 0; colorChannel < 4; colorChannel++) {
+        out[colorChannel] = finiteOrFallback(channel.values[frameIndex * 4 + colorChannel], fallback[colorChannel] ?? 1);
+    }
+    return out;
+}
+function copyColor$1(source, out) {
+    out[0] = source[0] ?? 1;
+    out[1] = source[1] ?? 1;
+    out[2] = source[2] ?? 1;
+    out[3] = source[3] ?? 1;
+    return out;
+}
+function writeHexColor(value, out, offset) {
+    if (typeof value !== 'string' || value.length < 8)
+        return;
+    out[offset] = parseInt(value.slice(0, 2), 16) / 255;
+    out[offset + 1] = parseInt(value.slice(2, 4), 16) / 255;
+    out[offset + 2] = parseInt(value.slice(4, 6), 16) / 255;
+    out[offset + 3] = parseInt(value.slice(6, 8), 16) / 255;
+}
+function getCurveOffset(key) {
+    return key === 'y' || key === 'scaleY' || key === 'softness' ? 4 : 0;
+}
+function finiteNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function finiteOrFallback(value, fallback) {
+    return value !== undefined && Number.isFinite(value) ? value : fallback;
+}
+function clampUnit(value) {
+    return Math.max(0, Math.min(1, value));
+}
+
+function createSpinePathConstraintScratch() {
+    return {
+        pathBonesScratch: [],
+        pathConstrainedBonesScratch: new Set(),
+        pathSpacesScratch: [],
+        pathLengthsScratch: [],
+        pathWorldScratch: [],
+        pathOutScratch: [],
+        pathCurveWorldScratch: [],
+        pathCurvesScratch: [],
+        pathSegmentsScratch: [],
+        pathCurvePointScratch: [],
+        pathStateScratch: { position: 0, spacing: 0, mixRotate: 0, mixX: 0, mixY: 0 },
+    };
+}
+function applyPathConstraint(runtime, component, constraint, time, duration, loop, poses, children, deps) {
+    const data = runtime.data;
+    const slot = data.slots.find(item => item.name === constraint.slot);
+    if (!slot)
+        return;
+    const slotBone = poses.get(slot.bone);
+    if (!slotBone)
+        return;
+    const skin = data.skins[component.skin] ?? {};
+    const slotSkin = skin[slot.name] ?? data.skins.default?.[slot.name] ?? {};
+    const attachmentName = slot.attachment ?? Object.keys(slotSkin)[0];
+    const attachment = attachmentName ? slotSkin[attachmentName] : null;
+    if (!attachment || attachment.type !== 'path')
+        return;
+    const state = samplePathConstraint(runtime, constraint, data.animations[component.animation]?.path?.[constraint.name], time, duration, loop, runtime.pathStateScratch);
+    if (state.mixRotate === 0 && state.mixX === 0 && state.mixY === 0)
+        return;
+    const bones = runtime.pathBonesScratch;
+    const constrainedBones = runtime.pathConstrainedBonesScratch;
+    bones.length = 0;
+    constrainedBones.clear();
+    for (const name of constraint.bones) {
+        constrainedBones.add(name);
+        const bone = poses.get(name);
+        if (bone)
+            bones.push(bone);
+    }
+    const boneCount = bones.length;
+    if (boneCount === 0)
+        return;
+    const tangents = constraint.rotateMode === 'tangent';
+    const chainScale = constraint.rotateMode === 'chainScale';
+    const spacesCount = tangents ? boneCount : boneCount + 1;
+    const spaces = runtime.pathSpacesScratch;
+    const lengths = runtime.pathLengthsScratch;
+    spaces.length = spacesCount;
+    lengths.length = boneCount;
+    for (let i = 0; i < spacesCount; i++)
+        spaces[i] = 0;
+    for (let i = 0; i < boneCount; i++)
+        lengths[i] = 0;
+    switch (constraint.spacingMode) {
+        case 'percent':
+            if (chainScale) {
+                for (let i = 0; i < spacesCount - 1; i++) {
+                    lengths[i] = getBoneWorldLength(requiredItemAt(bones, i, 'path constrained bones'));
+                }
+            }
+            for (let i = 1; i < spacesCount; i++)
+                spaces[i] = state.spacing;
+            break;
+        case 'proportional': {
+            let sum = 0;
+            for (let i = 0; i < spacesCount - 1;) {
+                const length = getBoneWorldLength(requiredItemAt(bones, i, 'path constrained bones'));
+                if (chainScale)
+                    lengths[i] = length;
+                spaces[++i] = length < 0.000001 ? state.spacing : length;
+                sum += length < 0.000001 ? 0 : length;
+            }
+            if (sum > 0) {
+                const scale = spacesCount / sum * state.spacing;
+                for (let i = 1; i < spacesCount; i++)
+                    spaces[i] = requiredNumberAt(spaces, i, 'path spaces') * scale;
+            }
+            break;
+        }
+        default:
+            for (let i = 0; i < spacesCount - 1;) {
+                const bone = requiredItemAt(bones, i, 'path constrained bones');
+                const worldLength = getBoneWorldLength(bone);
+                if (chainScale)
+                    lengths[i] = worldLength;
+                spaces[++i] = constraint.spacingMode === 'length' && bone.data.length > 0
+                    ? Math.max(0, bone.data.length + state.spacing) * worldLength / bone.data.length
+                    : state.spacing;
+            }
+            break;
+    }
+    const positions = computePathWorldPositions(runtime, poses, slotBone, attachment, constraint, state.position, spaces, tangents);
+    let boneX = requiredNumberAt(positions, 0, 'path positions');
+    let boneY = requiredNumberAt(positions, 1, 'path positions');
+    let offsetRotation = constraint.offsetRotation * Math.PI / 180;
+    if (offsetRotation !== 0 && slotBone.a * slotBone.d - slotBone.b * slotBone.c < 0)
+        offsetRotation = -offsetRotation;
+    const tip = offsetRotation === 0 && constraint.rotateMode === 'chain';
+    for (let i = 0, positionIndex = 3; i < boneCount; i++, positionIndex += 3) {
+        const bone = requiredItemAt(bones, i, 'path constrained bones');
+        bone.worldX += (boneX - bone.worldX) * state.mixX;
+        bone.worldY += (boneY - bone.worldY) * state.mixY;
+        const x = requiredNumberAt(positions, positionIndex, 'path positions');
+        const y = requiredNumberAt(positions, positionIndex + 1, 'path positions');
+        const dx = x - boneX;
+        const dy = y - boneY;
+        if (chainScale) {
+            const length = requiredNumberAt(lengths, i, 'path lengths');
+            if (length !== 0) {
+                const scale = (Math.hypot(dx, dy) / length - 1) * state.mixRotate + 1;
+                bone.a *= scale;
+                bone.c *= scale;
+            }
+        }
+        boneX = x;
+        boneY = y;
+        if (state.mixRotate > 0) {
+            const a = bone.a;
+            const b = bone.b;
+            const c = bone.c;
+            const d = bone.d;
+            let rotation = tangents
+                ? requiredNumberAt(positions, positionIndex - 1, 'path positions')
+                : requiredNumberAt(spaces, i + 1, 'path spaces') === 0
+                    ? requiredNumberAt(positions, positionIndex + 2, 'path positions')
+                    : Math.atan2(dy, dx);
+            rotation -= Math.atan2(c, a);
+            if (tip) {
+                const cos = Math.cos(rotation);
+                const sin = Math.sin(rotation);
+                const length = bone.data.length;
+                boneX += (length * (cos * a - sin * c) - dx) * state.mixRotate;
+                boneY += (length * (sin * a + cos * c) - dy) * state.mixRotate;
+            }
+            else {
+                rotation += offsetRotation;
+            }
+            rotation = deps.normalizeRadians(rotation) * state.mixRotate;
+            const cos = Math.cos(rotation);
+            const sin = Math.sin(rotation);
+            bone.a = cos * a - sin * c;
+            bone.b = cos * b - sin * d;
+            bone.c = sin * a + cos * c;
+            bone.d = sin * b + cos * d;
+        }
+    }
+    for (const boneName of constraint.bones)
+        deps.updateDescendantBoneTrees(boneName, poses, children, constrainedBones);
+}
+function samplePathConstraint(runtime, constraint, frames, time, duration, loop, out) {
+    const sampler = runtime.timelineSamplerState;
+    out.position = sampleCompiledTimeline(frames ?? [], time, 'position', constraint.position, duration, loop, sampler);
+    out.spacing = sampleCompiledTimeline(frames ?? [], time, 'spacing', constraint.spacing, duration, loop, sampler);
+    out.mixRotate = sampleCompiledTimeline(frames ?? [], time, 'mixRotate', constraint.mixRotate, duration, loop, sampler);
+    out.mixX = sampleCompiledTimeline(frames ?? [], time, 'mixX', constraint.mixX, duration, loop, sampler);
+    out.mixY = sampleCompiledTimeline(frames ?? [], time, 'mixY', constraint.mixY, duration, loop, sampler);
+    return out;
+}
+function getBoneWorldLength(bone) {
+    return Math.hypot(bone.data.length * bone.a, bone.data.length * bone.c);
+}
+function computePathPoints(runtime, poses, slotBone, attachment, out) {
+    const data = runtime.data;
+    const vertices = attachment.vertices ?? [];
+    const vertexCount = attachment.vertices ? attachment.vertexCount ?? inferWeightedVertexCount(vertices) : 0;
+    out.length = 0;
+    if (vertexCount > 0 && vertices.length !== vertexCount * 2) {
+        let offset = 0;
+        for (let vertex = 0; vertex < vertexCount && offset < vertices.length; vertex++) {
+            const boneCount = vertices[offset++] ?? 0;
+            let x = 0;
+            let y = 0;
+            for (let influence = 0; influence < boneCount; influence++) {
+                const boneIndex = vertices[offset++] ?? -1;
+                const vx = vertices[offset++] ?? 0;
+                const vy = vertices[offset++] ?? 0;
+                const weight = vertices[offset++] ?? 0;
+                const boneName = data.bones[boneIndex]?.name;
+                const bone = boneName ? poses.get(boneName) : null;
+                if (!bone)
+                    continue;
+                x += (bone.a * vx + bone.b * vy + bone.worldX) * weight;
+                y += (bone.c * vx + bone.d * vy + bone.worldY) * weight;
+            }
+            out.push(x, y);
+        }
+        return out;
+    }
+    for (let i = 0; i < vertices.length - 1; i += 2) {
+        out.push(slotBone.a * requiredNumberAt(vertices, i, 'path vertices')
+            + slotBone.b * requiredNumberAt(vertices, i + 1, 'path vertices') + slotBone.worldX, slotBone.c * requiredNumberAt(vertices, i, 'path vertices')
+            + slotBone.d * requiredNumberAt(vertices, i + 1, 'path vertices') + slotBone.worldY);
+    }
+    return out;
+}
+function computePathWorldPositions(runtime, poses, slotBone, attachment, constraint, position, spaces, tangents) {
+    const vertexCount = attachment.vertexCount ?? inferWeightedVertexCount(attachment.vertices ?? []);
+    const world = computePathPoints(runtime, poses, slotBone, attachment, runtime.pathWorldScratch);
+    const spacesCount = spaces.length;
+    const out = runtime.pathOutScratch;
+    out.length = spacesCount * 3 + 2;
+    for (let i = 0; i < out.length; i++)
+        out[i] = 0;
+    if (world.length < 8)
+        return out;
+    const closed = attachment.closed ?? false;
+    let verticesLength = vertexCount * 2;
+    let curveCount = verticesLength / 6;
+    if (!attachment.constantSpeed) {
+        const lengths = attachment.lengths ?? [];
+        curveCount -= closed ? 1 : 2;
+        const pathLength = lengths[curveCount] ?? lengths[lengths.length - 1] ?? 0;
+        if (constraint.positionMode === 'percent')
+            position *= pathLength;
+        const multiplier = constraint.spacingMode === 'percent'
+            ? pathLength
+            : constraint.spacingMode === 'proportional'
+                ? pathLength / spacesCount
+                : 1;
+        let curve = 0;
+        let previousCurve = -4;
+        const curveWorld = runtime.pathCurveWorldScratch;
+        for (let i = 0, o = 0; i < spacesCount; i++, o += 3) {
+            position += requiredNumberAt(spaces, i, 'path spaces') * multiplier;
+            let p = position;
+            if (closed) {
+                p %= pathLength;
+                if (p < 0)
+                    p += pathLength;
+                curve = 0;
+            }
+            else if (p < 0) {
+                addBeforePathPosition(p, world, 2, out, o);
+                continue;
+            }
+            else if (p > pathLength) {
+                addAfterPathPosition(p - pathLength, world, verticesLength - 6, out, o);
+                continue;
+            }
+            for (;; curve++) {
+                const length = lengths[curve] ?? pathLength;
+                if (p > length)
+                    continue;
+                const previousLength = curve === 0 ? 0 : requiredNumberAt(lengths, curve - 1, 'path attachment lengths');
+                p = curve === 0 ? p / length : (p - previousLength) / (length - previousLength);
+                break;
+            }
+            if (curve !== previousCurve) {
+                previousCurve = curve;
+                curveWorld.length = 0;
+                if (closed && curve === curveCount) {
+                    appendArrayRange(curveWorld, world, verticesLength - 4, verticesLength);
+                    appendArrayRange(curveWorld, world, 0, 4);
+                }
+                else {
+                    appendArrayRange(curveWorld, world, curve * 6 + 2, curve * 6 + 10);
+                }
+            }
+            addCurvePathPosition(p, curveWorld, out, o, tangents || (i > 0 && requiredNumberAt(spaces, i, 'path spaces') === 0));
+        }
+        return out;
+    }
+    const pathWorld = runtime.pathCurveWorldScratch;
+    pathWorld.length = 0;
+    if (closed) {
+        verticesLength += 2;
+        appendArrayRange(pathWorld, world, 2, verticesLength - 2);
+        appendArrayRange(pathWorld, world, 0, 2);
+        pathWorld.push(requiredNumberAt(pathWorld, 0, 'closed path world points'), requiredNumberAt(pathWorld, 1, 'closed path world points'));
+    }
+    else {
+        curveCount--;
+        verticesLength -= 4;
+        appendArrayRange(pathWorld, world, 2, 2 + verticesLength);
+    }
+    const curves = runtime.pathCurvesScratch;
+    curves.length = curveCount;
+    let pathLength = 0;
+    let x1 = requiredNumberAt(pathWorld, 0, 'path world points');
+    let y1 = requiredNumberAt(pathWorld, 1, 'path world points');
+    let cx1 = 0;
+    let cy1 = 0;
+    let cx2 = 0;
+    let cy2 = 0;
+    let x2 = 0;
+    let y2 = 0;
+    let tmpx = 0;
+    let tmpy = 0;
+    let dddfx = 0;
+    let dddfy = 0;
+    let ddfx = 0;
+    let ddfy = 0;
+    let dfx = 0;
+    let dfy = 0;
+    for (let i = 0, w = 2; i < curveCount; i++, w += 6) {
+        cx1 = requiredNumberAt(pathWorld, w, 'path world points');
+        cy1 = requiredNumberAt(pathWorld, w + 1, 'path world points');
+        cx2 = requiredNumberAt(pathWorld, w + 2, 'path world points');
+        cy2 = requiredNumberAt(pathWorld, w + 3, 'path world points');
+        x2 = requiredNumberAt(pathWorld, w + 4, 'path world points');
+        y2 = requiredNumberAt(pathWorld, w + 5, 'path world points');
+        tmpx = (x1 - cx1 * 2 + cx2) * 0.1875;
+        tmpy = (y1 - cy1 * 2 + cy2) * 0.1875;
+        dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
+        dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
+        ddfx = tmpx * 2 + dddfx;
+        ddfy = tmpy * 2 + dddfy;
+        dfx = (cx1 - x1) * 0.75 + tmpx + dddfx * 0.16666667;
+        dfy = (cy1 - y1) * 0.75 + tmpy + dddfy * 0.16666667;
+        pathLength += Math.hypot(dfx, dfy);
+        dfx += ddfx;
+        dfy += ddfy;
+        ddfx += dddfx;
+        ddfy += dddfy;
+        pathLength += Math.hypot(dfx, dfy);
+        dfx += ddfx;
+        dfy += ddfy;
+        pathLength += Math.hypot(dfx, dfy);
+        dfx += ddfx + dddfx;
+        dfy += ddfy + dddfy;
+        pathLength += Math.hypot(dfx, dfy);
+        curves[i] = pathLength;
+        x1 = x2;
+        y1 = y2;
+    }
+    if (constraint.positionMode === 'percent')
+        position *= pathLength;
+    const multiplier = constraint.spacingMode === 'percent'
+        ? pathLength
+        : constraint.spacingMode === 'proportional'
+            ? pathLength / spacesCount
+            : 1;
+    const segments = runtime.pathSegmentsScratch;
+    segments.length = 10;
+    let curveLength = 0;
+    let previousCurve = -1;
+    let segment = 0;
+    for (let i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) {
+        const space = requiredNumberAt(spaces, i, 'path spaces') * multiplier;
+        position += space;
+        let p = position;
+        if (closed) {
+            p %= pathLength;
+            if (p < 0)
+                p += pathLength;
+            curve = 0;
+            segment = 0;
+        }
+        else if (p < 0) {
+            addBeforePathPosition(p, pathWorld, 0, out, o);
+            continue;
+        }
+        else if (p > pathLength) {
+            addAfterPathPosition(p - pathLength, pathWorld, pathWorld.length - 4, out, o);
+            continue;
+        }
+        for (;; curve++) {
+            const length = requiredNumberAt(curves, curve, 'path curve lengths');
+            if (p > length)
+                continue;
+            const previousLength = curve === 0 ? 0 : requiredNumberAt(curves, curve - 1, 'path curve lengths');
+            p = curve === 0 ? p / length : (p - previousLength) / (length - previousLength);
+            break;
+        }
+        if (curve !== previousCurve) {
+            previousCurve = curve;
+            const w = curve * 6;
+            x1 = requiredNumberAt(pathWorld, w, 'path world points');
+            y1 = requiredNumberAt(pathWorld, w + 1, 'path world points');
+            cx1 = requiredNumberAt(pathWorld, w + 2, 'path world points');
+            cy1 = requiredNumberAt(pathWorld, w + 3, 'path world points');
+            cx2 = requiredNumberAt(pathWorld, w + 4, 'path world points');
+            cy2 = requiredNumberAt(pathWorld, w + 5, 'path world points');
+            x2 = requiredNumberAt(pathWorld, w + 6, 'path world points');
+            y2 = requiredNumberAt(pathWorld, w + 7, 'path world points');
+            tmpx = (x1 - cx1 * 2 + cx2) * 0.03;
+            tmpy = (y1 - cy1 * 2 + cy2) * 0.03;
+            dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.006;
+            dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.006;
+            ddfx = tmpx * 2 + dddfx;
+            ddfy = tmpy * 2 + dddfy;
+            dfx = (cx1 - x1) * 0.3 + tmpx + dddfx * 0.16666667;
+            dfy = (cy1 - y1) * 0.3 + tmpy + dddfy * 0.16666667;
+            curveLength = Math.hypot(dfx, dfy);
+            segments[0] = curveLength;
+            for (let ii = 1; ii < 8; ii++) {
+                dfx += ddfx;
+                dfy += ddfy;
+                ddfx += dddfx;
+                ddfy += dddfy;
+                curveLength += Math.hypot(dfx, dfy);
+                segments[ii] = curveLength;
+            }
+            dfx += ddfx;
+            dfy += ddfy;
+            curveLength += Math.hypot(dfx, dfy);
+            segments[8] = curveLength;
+            dfx += ddfx + dddfx;
+            dfy += ddfy + dddfy;
+            curveLength += Math.hypot(dfx, dfy);
+            segments[9] = curveLength;
+            segment = 0;
+        }
+        p *= curveLength;
+        for (;; segment++) {
+            const length = requiredNumberAt(segments, segment, 'path segments');
+            if (p > length)
+                continue;
+            if (segment === 0)
+                p = length === 0 ? 0 : p / length;
+            else {
+                const previous = requiredNumberAt(segments, segment - 1, 'path segments');
+                p = length === previous ? segment : segment + (p - previous) / (length - previous);
+            }
+            break;
+        }
+        const curvePoint = runtime.pathCurvePointScratch;
+        curvePoint[0] = x1;
+        curvePoint[1] = y1;
+        curvePoint[2] = cx1;
+        curvePoint[3] = cy1;
+        curvePoint[4] = cx2;
+        curvePoint[5] = cy2;
+        curvePoint[6] = x2;
+        curvePoint[7] = y2;
+        addCurvePathPosition(p * 0.1, curvePoint, out, o, tangents || (i > 0 && space === 0));
+    }
+    return out;
+}
+function appendArrayRange(out, source, start, end) {
+    for (let i = start; i < end && i < source.length; i++) {
+        out.push(requiredNumberAt(source, i, 'path source range'));
+    }
+}
+function inferWeightedVertexCount(vertices) {
+    let count = 0;
+    let offset = 0;
+    while (offset < vertices.length) {
+        const boneCount = vertices[offset++] ?? 0;
+        offset += boneCount * 4;
+        count++;
+    }
+    return count;
+}
+function addBeforePathPosition(p, points, index, out, outIndex) {
+    const x1 = requiredNumberAt(points, index, 'path points');
+    const y1 = requiredNumberAt(points, index + 1, 'path points');
+    const dx = requiredNumberAt(points, index + 2, 'path points') - x1;
+    const dy = requiredNumberAt(points, index + 3, 'path points') - y1;
+    const r = Math.atan2(dy, dx);
+    out[outIndex] = x1 + p * Math.cos(r);
+    out[outIndex + 1] = y1 + p * Math.sin(r);
+    out[outIndex + 2] = r;
+}
+function addAfterPathPosition(p, points, index, out, outIndex) {
+    const x1 = requiredNumberAt(points, index + 2, 'path points');
+    const y1 = requiredNumberAt(points, index + 3, 'path points');
+    const dx = x1 - requiredNumberAt(points, index, 'path points');
+    const dy = y1 - requiredNumberAt(points, index + 1, 'path points');
+    const r = Math.atan2(dy, dx);
+    out[outIndex] = x1 + p * Math.cos(r);
+    out[outIndex + 1] = y1 + p * Math.sin(r);
+    out[outIndex + 2] = r;
+}
+function addCurvePathPosition(p, points, out, outIndex, tangents) {
+    const x1 = requiredNumberAt(points, 0, 'Bezier path points');
+    const y1 = requiredNumberAt(points, 1, 'Bezier path points');
+    const cx1 = requiredNumberAt(points, 2, 'Bezier path points');
+    const cy1 = requiredNumberAt(points, 3, 'Bezier path points');
+    const cx2 = requiredNumberAt(points, 4, 'Bezier path points');
+    const cy2 = requiredNumberAt(points, 5, 'Bezier path points');
+    const x2 = requiredNumberAt(points, 6, 'Bezier path points');
+    const y2 = requiredNumberAt(points, 7, 'Bezier path points');
+    if (p === 0 || Number.isNaN(p)) {
+        out[outIndex] = x1;
+        out[outIndex + 1] = y1;
+        out[outIndex + 2] = Math.atan2(cy1 - y1, cx1 - x1);
+        return;
+    }
+    const tt = p * p;
+    const ttt = tt * p;
+    const u = 1 - p;
+    const uu = u * u;
+    const uuu = uu * u;
+    const ut = u * p;
+    const ut3 = ut * 3;
+    const uut3 = u * ut3;
+    const utt3 = ut3 * p;
+    const x = x1 * uuu + cx1 * uut3 + cx2 * utt3 + x2 * ttt;
+    const y = y1 * uuu + cy1 * uut3 + cy2 * utt3 + y2 * ttt;
+    out[outIndex] = x;
+    out[outIndex + 1] = y;
+    if (tangents) {
+        if (p < 0.001)
+            out[outIndex + 2] = Math.atan2(cy1 - y1, cx1 - x1);
+        else
+            out[outIndex + 2] = Math.atan2(y - (y1 * uu + cy1 * ut * 2 + cy2 * tt), x - (x1 * uu + cx1 * ut * 2 + cx2 * tt));
+    }
+}
+
+const HASH_OFFSET = 2166136261;
+const HASH_PRIME = 16777619;
+function createEmptySlotCache(key) {
+    return {
+        key,
+        signature: 0,
+        debugSignature: 0,
+        vertices: new Float32Array(0),
+        vertexLength: 0,
+        vertexCapacity: 0,
+        debugVertices: new Float32Array(0),
+        debugVertexLength: 0,
+        debugVertexCapacity: 0,
+        batch: { blend: 'normal', page: '', vertexCount: 0 },
+        vertexOffset: -1,
+        debugVertexOffset: -1,
+    };
+}
+function copyBuilderData(builder, target) {
+    let output = target;
+    if (output.length < builder.length) {
+        output = new Float32Array(builder.length);
+    }
+    for (let index = 0; index < builder.length; index++)
+        output[index] = builder.data[index] ?? 0;
+    return output;
+}
+function hasInvalidOffsets(entries) {
+    let vertexOffset = 0;
+    let debugOffset = 0;
+    for (const entry of entries) {
+        if (entry.vertexOffset !== vertexOffset || entry.debugVertexOffset !== debugOffset)
+            return true;
+        vertexOffset += entry.vertexCapacity;
+        debugOffset += entry.debugVertexLength;
+    }
+    return false;
+}
+function rebuildCachedGeometryLayout(runtime, entries) {
+    const vertices = runtime.vertexBuilder;
+    const debugVertices = runtime.debugVertexBuilder;
+    vertices.clear();
+    debugVertices.clear();
+    for (const entry of entries) {
+        entry.vertexOffset = vertices.length;
+        entry.debugVertexOffset = debugVertices.length;
+        if (entry.vertexLength > 0) {
+            vertices.reserveLength(vertices.length + entry.vertexCapacity);
+            for (let index = 0; index < entry.vertexLength; index++) {
+                vertices.data[entry.vertexOffset + index] = entry.vertices[index] ?? 0;
+            }
+        }
+        else if (entry.vertexCapacity > 0) {
+            vertices.reserveLength(vertices.length + entry.vertexCapacity);
+        }
+        if (entry.debugVertexLength > 0) {
+            debugVertices.reserveLength(debugVertices.length + entry.debugVertexLength);
+            for (let index = 0; index < entry.debugVertexLength; index++) {
+                debugVertices.data[entry.debugVertexOffset + index] = entry.debugVertices[index] ?? 0;
+            }
+        }
+    }
+}
+function rebuildCachedDrawBatches(runtime, entries) {
+    const batches = runtime.batches;
+    batches.length = 0;
+    for (const entry of entries) {
+        if (entry.vertexLength <= 0 || entry.batch.vertexCount <= 0)
+            continue;
+        appendBatch(batches, runtime.batchPool, runtime.allocationStats, entry.batch.blend, entry.batch.page, entry.vertexOffset / 8, entry.batch.vertexCount);
+    }
+}
+function getSlotOrderHash(entries) {
+    let hash = HASH_OFFSET;
+    for (const entry of entries) {
+        hash = hashString(hash, entry.key);
+        hash = hashInt(hash, entry.vertexCapacity);
+        hash = hashInt(hash, entry.debugVertexLength);
+    }
+    return hash;
+}
+function getSlotBuildSignature(slot, attachmentName, attachment, regionName, region, bone, poses, slotColor, clip, component) {
+    let hash = HASH_OFFSET;
+    hash = hashString(hash, slot.name);
+    hash = hashString(hash, attachmentName);
+    hash = hashString(hash, attachment.type ?? '');
+    hash = hashString(hash, regionName);
+    hash = hashString(hash, region.page);
+    hash = hashString(hash, normalizeBlend(slot.blend));
+    hash = hashInt(hash, quantizeSignatureNumber(component.scale));
+    hash = hashColor(hash, slotColor);
+    hash = hashClip(hash, clip);
+    return attachment.type === 'mesh' ? hashAllPoses(hash, poses) : hashPose(hash, bone);
+}
+function getDebugBonesSignature(scale, poses) {
+    let hash = hashString(HASH_OFFSET, 'debugBones');
+    hash = hashInt(hash, quantizeSignatureNumber(scale));
+    return hashAllPoses(hash, poses);
+}
+function hashInt(hash, value) {
+    let input = value | 0;
+    for (let i = 0; i < 4; i++) {
+        hash ^= input & 0xff;
+        hash = Math.imul(hash, HASH_PRIME) >>> 0;
+        input >>= 8;
+    }
+    return hash;
+}
+function normalizeBlend(blend) {
+    return blend === 'additive' ? 'additive' : 'normal';
+}
+function computeClipPolygon(bone, attachment, scale) {
+    const vertices = attachment.vertices ?? [];
+    const polygon = [];
+    for (let i = 0; i < vertices.length - 1; i += 2) {
+        polygon.push(transformBonePoint(bone, requiredNumberAt(vertices, i, 'clip attachment vertices'), requiredNumberAt(vertices, i + 1, 'clip attachment vertices'), scale));
+    }
+    return signedPolygonArea(polygon) < 0 ? polygon.slice().reverse() : polygon;
+}
+function replaceClippedRange(floats, start, polygon, clipped) {
+    if (polygon.length < 3 || start >= floats.length)
+        return;
+    clipped.clear();
+    for (let i = start; i < floats.length; i += 24) {
+        const triangle = [
+            readVertex(floats, i),
+            readVertex(floats, i + 8),
+            readVertex(floats, i + 16),
+        ];
+        const clippedPolygon = clipVertexPolygon(triangle, polygon);
+        for (let vertex = 1; vertex < clippedPolygon.length - 1; vertex++) {
+            writeVertex(clipped, requiredItemAt(clippedPolygon, 0, 'clipped polygon'));
+            writeVertex(clipped, requiredItemAt(clippedPolygon, vertex, 'clipped polygon'));
+            writeVertex(clipped, requiredItemAt(clippedPolygon, vertex + 1, 'clipped polygon'));
+        }
+    }
+    floats.truncate(start);
+    floats.appendArray(clipped.data, clipped.length);
+}
+function appendRegionVertices(out, component, runtime, bone, slotColor, attachment, region) {
+    const w = attachment.width || region.originalWidth || region.width;
+    const h = attachment.height || region.originalHeight || region.height;
+    const sx = attachment.scaleX ?? 1;
+    const sy = attachment.scaleY ?? 1;
+    const rad = (attachment.rotation ?? 0) * Math.PI / 180;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    const halfW = w * 0.5;
+    const halfH = h * 0.5;
+    const tx = attachment.x ?? 0;
+    const ty = attachment.y ?? 0;
+    const scale = component.scale;
+    const x0 = -halfW * sx;
+    const y0 = -halfH * sy;
+    const x1 = halfW * sx;
+    const y1 = halfH * sy;
+    const rx0 = x0 * cos - y0 * sin + tx;
+    const ry0 = x0 * sin + y0 * cos + ty;
+    const rx1 = x1 * cos - y0 * sin + tx;
+    const ry1 = x1 * sin + y0 * cos + ty;
+    const rx2 = x1 * cos - y1 * sin + tx;
+    const ry2 = x1 * sin + y1 * cos + ty;
+    const rx3 = x0 * cos - y1 * sin + tx;
+    const ry3 = x0 * sin + y1 * cos + ty;
+    const px0 = (bone.a * rx0 + bone.b * ry0 + bone.worldX) * scale;
+    const py0 = (bone.c * rx0 + bone.d * ry0 + bone.worldY) * scale;
+    const px1 = (bone.a * rx1 + bone.b * ry1 + bone.worldX) * scale;
+    const py1 = (bone.c * rx1 + bone.d * ry1 + bone.worldY) * scale;
+    const px2 = (bone.a * rx2 + bone.b * ry2 + bone.worldX) * scale;
+    const py2 = (bone.c * rx2 + bone.d * ry2 + bone.worldY) * scale;
+    const px3 = (bone.a * rx3 + bone.b * ry3 + bone.worldX) * scale;
+    const py3 = (bone.c * rx3 + bone.d * ry3 + bone.worldY) * scale;
+    const page = runtime.pages.get(region.page);
+    const pageWidth = page?.width ?? 1;
+    const pageHeight = page?.height ?? 1;
+    const packedWidth = region.rotate === 90 ? region.height : region.width;
+    const packedHeight = region.rotate === 90 ? region.width : region.height;
+    const u0 = region.x / pageWidth;
+    const v0 = region.y / pageHeight;
+    const u1 = (region.x + packedWidth) / pageWidth;
+    const v1 = (region.y + packedHeight) / pageHeight;
+    const color = multiplyColor(slotColor, attachment.color, runtime.vertexColorScratch);
+    if (region.rotate === 90) {
+        pushVertex(out, px0, py0, u1, v1, color);
+        pushVertex(out, px1, py1, u1, v0, color);
+        pushVertex(out, px2, py2, u0, v0, color);
+        pushVertex(out, px0, py0, u1, v1, color);
+        pushVertex(out, px2, py2, u0, v0, color);
+        pushVertex(out, px3, py3, u0, v1, color);
+    }
+    else {
+        pushVertex(out, px0, py0, u0, v1, color);
+        pushVertex(out, px1, py1, u1, v1, color);
+        pushVertex(out, px2, py2, u1, v0, color);
+        pushVertex(out, px0, py0, u0, v1, color);
+        pushVertex(out, px2, py2, u1, v0, color);
+        pushVertex(out, px3, py3, u0, v0, color);
+    }
+}
+function appendMeshVertices(out, component, runtime, data, poses, bone, slotColor, attachment, region) {
+    const points = computeMeshPoints(data, poses, bone, attachment, component.scale, runtime.meshPointBuilder);
+    const triangles = attachment.triangles ?? [];
+    const color = multiplyColor(slotColor, attachment.color, runtime.vertexColorScratch);
+    for (let i = 0; i < triangles.length - 2; i += 3) {
+        const a = triangles[i] ?? -1;
+        const b = triangles[i + 1] ?? -1;
+        const c = triangles[i + 2] ?? -1;
+        if (!hasMeshPoint(points, a) || !hasMeshPoint(points, b) || !hasMeshPoint(points, c))
+            continue;
+        appendMeshVertex(out, points, region, runtime, attachment, a, color);
+        appendMeshVertex(out, points, region, runtime, attachment, b, color);
+        appendMeshVertex(out, points, region, runtime, attachment, c, color);
+    }
+}
+function appendMeshWireframe(out, component, runtime, data, poses, bone, attachment) {
+    const points = computeMeshPoints(data, poses, bone, attachment, component.scale, runtime.meshPointBuilder);
+    const triangles = attachment.triangles ?? [];
+    const seen = new Set();
+    for (let i = 0; i < triangles.length - 2; i += 3) {
+        appendMeshDebugEdge(out, points, triangles[i] ?? -1, triangles[i + 1] ?? -1, seen, [0.3, 0.85, 1, 0.8]);
+        appendMeshDebugEdge(out, points, triangles[i + 1] ?? -1, triangles[i + 2] ?? -1, seen, [0.3, 0.85, 1, 0.8]);
+        appendMeshDebugEdge(out, points, triangles[i + 2] ?? -1, triangles[i] ?? -1, seen, [0.3, 0.85, 1, 0.8]);
+    }
+}
+function appendRegionWireframe(out, component, bone, attachment, region) {
+    const w = attachment.width || region.originalWidth || region.width;
+    const h = attachment.height || region.originalHeight || region.height;
+    const sx = attachment.scaleX ?? 1;
+    const sy = attachment.scaleY ?? 1;
+    const rad = (attachment.rotation ?? 0) * Math.PI / 180;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    const localCorners = [
+        [-w / 2, -h / 2],
+        [w / 2, -h / 2],
+        [w / 2, h / 2],
+        [-w / 2, h / 2],
+    ];
+    const points = localCorners.map(([x, y]) => {
+        const lx = x * sx;
+        const ly = y * sy;
+        const rx = lx * cos - ly * sin + (attachment.x ?? 0);
+        const ry = lx * sin + ly * cos + (attachment.y ?? 0);
+        return transformBonePoint(bone, rx, ry, component.scale);
+    });
+    const seen = new Set();
+    appendDebugEdge(out, points, 0, 1, seen, [0.3, 0.85, 1, 0.8]);
+    appendDebugEdge(out, points, 1, 2, seen, [0.3, 0.85, 1, 0.8]);
+    appendDebugEdge(out, points, 2, 3, seen, [0.3, 0.85, 1, 0.8]);
+    appendDebugEdge(out, points, 3, 0, seen, [0.3, 0.85, 1, 0.8]);
+}
+function appendBoneDebug(out, data, poses, scale) {
+    for (const boneData of data.bones) {
+        const bone = poses.get(boneData.name);
+        if (!bone)
+            continue;
+        const start = [bone.worldX * scale, bone.worldY * scale];
+        const end = boneData.length > 0
+            ? [(bone.worldX + bone.a * boneData.length) * scale, (bone.worldY + bone.c * boneData.length) * scale]
+            : boneData.parent && poses.get(boneData.parent)
+                ? [poses.get(boneData.parent).worldX * scale, poses.get(boneData.parent).worldY * scale]
+                : start;
+        appendDebugLine(out, start, end, [1, 0.85, 0.25, 0.95]);
+        const joint = 3 / Math.max(0.001, scale);
+        appendDebugLine(out, transformBonePoint(bone, -joint, 0, scale), transformBonePoint(bone, joint, 0, scale), [1, 0.35, 0.3, 0.95]);
+        appendDebugLine(out, transformBonePoint(bone, 0, -joint, scale), transformBonePoint(bone, 0, joint, scale), [1, 0.35, 0.3, 0.95]);
+    }
+}
+function hashPose(hash, pose) {
+    hash = hashInt(hash, quantizeSignatureNumber(pose.a));
+    hash = hashInt(hash, quantizeSignatureNumber(pose.b));
+    hash = hashInt(hash, quantizeSignatureNumber(pose.c));
+    hash = hashInt(hash, quantizeSignatureNumber(pose.d));
+    hash = hashInt(hash, quantizeSignatureNumber(pose.worldX));
+    hash = hashInt(hash, quantizeSignatureNumber(pose.worldY));
+    return hash;
+}
+function hashAllPoses(hash, poses) {
+    for (const [name, pose] of poses) {
+        hash = hashString(hash, name);
+        hash = hashPose(hash, pose);
+    }
+    return hash;
+}
+function hashColor(hash, color) {
+    if (!color)
+        return hashInt(hash, 0);
+    hash = hashInt(hash, 1);
+    hash = hashInt(hash, quantizeSignatureNumber(color[0]));
+    hash = hashInt(hash, quantizeSignatureNumber(color[1]));
+    hash = hashInt(hash, quantizeSignatureNumber(color[2]));
+    return hashInt(hash, quantizeSignatureNumber(color[3]));
+}
+function hashClip(hash, clip) {
+    if (!clip)
+        return hashInt(hash, 0);
+    hash = hashInt(hash, 1);
+    hash = hashString(hash, clip.endSlot ?? '');
+    for (const point of clip.polygon) {
+        hash = hashInt(hash, quantizeSignatureNumber(point[0]));
+        hash = hashInt(hash, quantizeSignatureNumber(point[1]));
+    }
+    return hash;
+}
+function quantizeSignatureNumber(value) {
+    return Math.round(value * 10000);
+}
+function hashString(hash, value) {
+    for (let i = 0; i < value.length; i++)
+        hash = hashInt(hash, value.charCodeAt(i));
+    return hash;
+}
+function appendBatch(batches, pool, runtimeAllocationStats, blend, page, firstVertex, vertexCount) {
+    const last = batches[batches.length - 1];
+    if (last && last.blend === blend && last.page === page && last.firstVertex + last.vertexCount === firstVertex) {
+        last.vertexCount += vertexCount;
+        return;
+    }
+    const index = batches.length;
+    let batch = pool[index];
+    if (!batch) {
+        batch = { blend, page, firstVertex, vertexCount };
+        pool.push(batch);
+        if (runtimeAllocationStats)
+            runtimeAllocationStats.batchPoolMisses++;
+    }
+    else {
+        batch.blend = blend;
+        batch.page = page;
+        batch.firstVertex = firstVertex;
+        batch.vertexCount = vertexCount;
+    }
+    batches.push(batch);
+}
+function transformBonePoint(bone, x, y, scale) {
+    return [
+        (bone.a * x + bone.b * y + bone.worldX) * scale,
+        (bone.c * x + bone.d * y + bone.worldY) * scale,
+    ];
+}
+function computeMeshPoints(data, poses, slotBone, attachment, scale, out) {
+    const vertices = attachment.vertices ?? [];
+    const vertexCount = Math.floor((attachment.uvs?.length ?? 0) / 2);
+    out.clear();
+    if (vertices.length === vertexCount * 2) {
+        for (let i = 0; i < vertices.length; i += 2) {
+            const x = vertices[i] ?? 0;
+            const y = vertices[i + 1] ?? 0;
+            out.push((slotBone.a * x + slotBone.b * y + slotBone.worldX) * scale, (slotBone.c * x + slotBone.d * y + slotBone.worldY) * scale);
+        }
+        return out;
+    }
+    let offset = 0;
+    for (let vertex = 0; vertex < vertexCount && offset < vertices.length; vertex++) {
+        const boneCount = vertices[offset++] ?? 0;
+        let x = 0;
+        let y = 0;
+        for (let influence = 0; influence < boneCount; influence++) {
+            const boneIndex = vertices[offset++] ?? -1;
+            const vx = vertices[offset++] ?? 0;
+            const vy = vertices[offset++] ?? 0;
+            const weight = vertices[offset++] ?? 0;
+            const boneName = data.bones[boneIndex]?.name;
+            const bone = boneName ? poses.get(boneName) : null;
+            if (!bone)
+                continue;
+            x += (bone.a * vx + bone.b * vy + bone.worldX) * weight;
+            y += (bone.c * vx + bone.d * vy + bone.worldY) * weight;
+        }
+        out.push(x * scale, y * scale);
+    }
+    return out;
+}
+function hasMeshPoint(points, vertexIndex) {
+    return vertexIndex >= 0 && vertexIndex * 2 + 1 < points.length;
+}
+function appendMeshVertex(out, points, region, runtime, attachment, vertexIndex, color) {
+    const rawU = attachment.uvs?.[vertexIndex * 2] ?? 0;
+    const rawV = attachment.uvs?.[vertexIndex * 2 + 1] ?? 0;
+    const page = runtime.pages.get(region.page);
+    const textureWidth = page?.width ?? 1;
+    const textureHeight = page?.height ?? 1;
+    let u;
+    let v;
+    if (region.rotate === 90) {
+        const baseU = region.x / textureWidth - (region.originalHeight - region.offsetY - region.height) / textureWidth;
+        const baseV = region.y / textureHeight - (region.originalWidth - region.offsetX - region.width) / textureHeight;
+        u = baseU + rawV * region.originalHeight / textureWidth;
+        v = baseV + (1 - rawU) * region.originalWidth / textureHeight;
+    }
+    else if (region.rotate === 180) {
+        const baseU = region.x / textureWidth - (region.originalWidth - region.offsetX - region.width) / textureWidth;
+        const baseV = region.y / textureHeight - region.offsetY / textureHeight;
+        u = baseU + (1 - rawU) * region.originalWidth / textureWidth;
+        v = baseV + (1 - rawV) * region.originalHeight / textureHeight;
+    }
+    else if (region.rotate === 270) {
+        const baseU = region.x / textureWidth - region.offsetY / textureWidth;
+        const baseV = region.y / textureHeight - region.offsetX / textureHeight;
+        u = baseU + (1 - rawV) * region.originalHeight / textureWidth;
+        v = baseV + rawU * region.originalWidth / textureHeight;
+    }
+    else {
+        const baseU = region.x / textureWidth - region.offsetX / textureWidth;
+        const baseV = region.y / textureHeight - (region.originalHeight - region.offsetY - region.height) / textureHeight;
+        u = baseU + rawU * region.originalWidth / textureWidth;
+        v = baseV + rawV * region.originalHeight / textureHeight;
+    }
+    const pointOffset = vertexIndex * 2;
+    pushVertex(out, points.get(pointOffset), points.get(pointOffset + 1), u, v, color);
+}
+function appendDebugEdge(out, points, a, b, seen, color) {
+    if (!points[a] || !points[b])
+        return;
+    const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    appendDebugLine(out, points[a], points[b], color);
+}
+function appendMeshDebugEdge(out, points, a, b, seen, color) {
+    if (!hasMeshPoint(points, a) || !hasMeshPoint(points, b))
+        return;
+    const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    const aOffset = a * 2;
+    const bOffset = b * 2;
+    out.push(points.get(aOffset), points.get(aOffset + 1), 0, 0, ...color, points.get(bOffset), points.get(bOffset + 1), 0, 0, ...color);
+}
+function appendDebugLine(out, a, b, color) {
+    out.push(a[0], a[1], 0, 0, ...color, b[0], b[1], 0, 0, ...color);
+}
+function multiplyColor(a, b, out) {
+    out[0] = (a?.[0] ?? 1) * (b?.[0] ?? 1);
+    out[1] = (a?.[1] ?? 1) * (b?.[1] ?? 1);
+    out[2] = (a?.[2] ?? 1) * (b?.[2] ?? 1);
+    out[3] = (a?.[3] ?? 1) * (b?.[3] ?? 1);
+    return out;
+}
+function pushVertex(out, x, y, u, v, color) {
+    out.push8(x, y, u, v, color[0], color[1], color[2], color[3]);
+}
+function signedPolygonArea(polygon) {
+    let area = 0;
+    for (let i = 0; i < polygon.length; i++) {
+        const a = requiredItemAt(polygon, i, 'clip polygon');
+        const b = requiredItemAt(polygon, (i + 1) % polygon.length, 'clip polygon');
+        area += a[0] * b[1] - b[0] * a[1];
+    }
+    return area * 0.5;
+}
+function clipVertexPolygon(vertices, clipPolygon) {
+    let output = vertices;
+    for (let i = 0; i < clipPolygon.length; i++) {
+        const a = requiredItemAt(clipPolygon, i, 'clip polygon');
+        const b = requiredItemAt(clipPolygon, (i + 1) % clipPolygon.length, 'clip polygon');
+        const input = output;
+        output = [];
+        if (input.length === 0)
+            break;
+        let previous = requiredItemAt(input, input.length - 1, 'clip input polygon');
+        let previousInside = isInsideClipEdge(previous, a, b);
+        for (const current of input) {
+            const currentInside = isInsideClipEdge(current, a, b);
+            if (currentInside !== previousInside)
+                output.push(intersectClipEdge(previous, current, a, b));
+            if (currentInside)
+                output.push(current);
+            previous = current;
+            previousInside = currentInside;
+        }
+    }
+    return output;
+}
+function isInsideClipEdge(vertex, a, b) {
+    return (b[0] - a[0]) * (vertex.y - a[1]) - (b[1] - a[1]) * (vertex.x - a[0]) >= -1e-4;
+}
+function intersectClipEdge(start, end, a, b) {
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const edgeX = b[0] - a[0];
+    const edgeY = b[1] - a[1];
+    const denominator = edgeX * dy - edgeY * dx;
+    const t = Math.abs(denominator) < 0.000001
+        ? 0
+        : (edgeY * (start.x - a[0]) - edgeX * (start.y - a[1])) / denominator;
+    const clamped = Math.max(0, Math.min(1, t));
+    return lerpVertex(start, end, clamped);
+}
+function lerpVertex(start, end, t) {
+    return {
+        x: start.x + (end.x - start.x) * t,
+        y: start.y + (end.y - start.y) * t,
+        u: start.u + (end.u - start.u) * t,
+        v: start.v + (end.v - start.v) * t,
+        color: [
+            start.color[0] + (end.color[0] - start.color[0]) * t,
+            start.color[1] + (end.color[1] - start.color[1]) * t,
+            start.color[2] + (end.color[2] - start.color[2]) * t,
+            start.color[3] + (end.color[3] - start.color[3]) * t,
+        ],
+    };
+}
+function readVertex(floats, index) {
+    return {
+        x: floats.get(index),
+        y: floats.get(index + 1),
+        u: floats.get(index + 2),
+        v: floats.get(index + 3),
+        color: [floats.get(index + 4), floats.get(index + 5), floats.get(index + 6), floats.get(index + 7)],
+    };
+}
+function writeVertex(out, vertex) {
+    out.push(vertex.x, vertex.y, vertex.u, vertex.v, ...vertex.color);
+}
+
+const WHITE_COLOR = [1, 1, 1, 1];
+/** Resolves the active slot attachment timeline without owning pose evaluation. */
+function getSpineSlotAttachmentName(runtime, component, slot, time) {
+    let name = slot.attachment ?? null;
+    const frames = runtime.data.animations[component.animation]?.slots?.[slot.name]?.attachment;
+    if (!Array.isArray(frames) || frames.length === 0)
+        return name;
+    const frameIndex = findCompiledFrameIndex(frames, time, runtime.timelineSamplerState);
+    if (frameIndex >= 0)
+        name = frames[frameIndex]?.name ?? null;
+    return name;
+}
+/** Resolves sequence attachments across the base animation and slider overlays. */
+function getSpineAttachmentRegionName(runtime, component, slot, attachmentName, attachment, time, sliderStates) {
+    const basePath = attachment.path || attachment.name || attachmentName;
+    const sequence = attachment.sequence;
+    if (!sequence?.count)
+        return basePath;
+    let index = sampleSequenceIndex(getSequenceFrames(runtime.data, component.animation, component.skin, slot.name, attachmentName), time, sequence, runtime.timelineSamplerState);
+    for (const slider of sliderStates) {
+        const frames = getSequenceFrames(runtime.data, slider.animation, component.skin, slot.name, attachmentName);
+        if (Array.isArray(frames) && frames.length > 0) {
+            index = sampleSequenceIndex(frames, slider.time, sequence, runtime.timelineSamplerState);
+        }
+    }
+    const frame = String((sequence.start ?? 0) + index).padStart(sequence.digits ?? 0, '0');
+    return `${basePath}${frame}`;
+}
+/** Samples slot RGBA timelines and slider blends into runtime-owned scratch storage. */
+function getSpineSlotColor(runtime, component, slot, time, sliderStates) {
+    const frames = runtime.data.animations[component.animation]?.slots?.[slot.name]?.rgba;
+    const fallback = slot.color ?? WHITE_COLOR;
+    const color = runtime.slotColorScratch;
+    if (Array.isArray(frames) && frames.length > 0) {
+        sampleCompiledColor(frames, time, fallback, color, runtime.timelineSamplerState);
+    }
+    else {
+        copyColor(fallback, color);
+    }
+    for (const slider of sliderStates) {
+        const sliderFrames = runtime.data.animations[slider.animation]?.slots?.[slot.name]?.rgba;
+        if (!Array.isArray(sliderFrames) || sliderFrames.length === 0)
+            continue;
+        sampleCompiledColor(sliderFrames, slider.time, color, runtime.sliderColorScratch, runtime.timelineSamplerState);
+        mixColorInto(color, runtime.sliderColorScratch, slider.mix);
+    }
+    return color;
+}
+function getSequenceFrames(data, animationName, skinName, slotName, attachmentName) {
+    const frames = data.animations[animationName]?.attachments?.[skinName]?.[slotName]?.[attachmentName]?.sequence
+        ?? data.animations[animationName]?.attachments?.default?.[slotName]?.[attachmentName]?.sequence;
+    return Array.isArray(frames) ? frames : undefined;
+}
+function sampleSequenceIndex(frames, time, sequence, samplerState) {
+    const count = Math.max(1, sequence.count ?? 1);
+    if (!Array.isArray(frames) || frames.length === 0) {
+        return clampSequenceIndex(sequence.setup ?? 0, count);
+    }
+    const frameIndex = findCompiledFrameIndex(frames, time, samplerState);
+    if (frameIndex < 0)
+        return clampSequenceIndex(sequence.setup ?? 0, count);
+    const frame = frames[frameIndex];
+    if (!frame)
+        return clampSequenceIndex(sequence.setup ?? 0, count);
+    const before = frame.time ?? 0;
+    const delay = frame.delay ?? 0;
+    let index = frame.index ?? 0;
+    const mode = frame.mode ?? 'hold';
+    if (mode !== 'hold' && delay > 0) {
+        index += Math.floor((time - before) / delay + 0.00001);
+        switch (mode) {
+            case 'once':
+                index = Math.min(count - 1, index);
+                break;
+            case 'loop':
+                index %= count;
+                break;
+            case 'pingpong': {
+                const range = count * 2 - 2;
+                index = range === 0 ? 0 : index % range;
+                if (index >= count)
+                    index = range - index;
+                break;
+            }
+            case 'onceReverse':
+                index = Math.max(count - 1 - index, 0);
+                break;
+            case 'loopReverse':
+                index = count - 1 - (index % count);
+                break;
+            case 'pingpongReverse': {
+                const range = count * 2 - 2;
+                index = range === 0 ? 0 : (index + count - 1) % range;
+                if (index >= count)
+                    index = range - index;
+                break;
+            }
+        }
+    }
+    return clampSequenceIndex(index, count);
+}
+function clampSequenceIndex(index, count) {
+    return Math.max(0, Math.min(count - 1, Math.floor(index)));
+}
+function mixColorInto(out, to, mix) {
+    const alpha = Math.max(0, Math.min(1, mix));
+    out[0] += (to[0] - out[0]) * alpha;
+    out[1] += (to[1] - out[1]) * alpha;
+    out[2] += (to[2] - out[2]) * alpha;
+    out[3] += (to[3] - out[3]) * alpha;
+}
+function copyColor(source, out) {
+    out[0] = source[0];
+    out[1] = source[1];
+    out[2] = source[2];
+    out[3] = source[3];
+}
+
+class LocalPoseSnapshot {
+    data;
+    length = 0;
+    constructor(initialCapacity = 256) {
+        this.data = new Float32Array(initialCapacity);
+    }
+    capture(poses) {
+        const required = poses.size * 7;
+        if (this.data.length < required) {
+            let nextCapacity = Math.max(1, this.data.length);
+            while (nextCapacity < required)
+                nextCapacity *= 2;
+            this.data = new Float32Array(nextCapacity);
+        }
+        let offset = 0;
+        for (const pose of poses.values()) {
+            this.data[offset++] = pose.x;
+            this.data[offset++] = pose.y;
+            this.data[offset++] = pose.rotation;
+            this.data[offset++] = pose.shearX;
+            this.data[offset++] = pose.shearY;
+            this.data[offset++] = pose.scaleX;
+            this.data[offset++] = pose.scaleY;
+        }
+        this.length = offset;
+    }
+}
+const sliderPoseSnapshots = new WeakMap();
+const TWO_PI = Math.PI * 2;
+const PATH_CONSTRAINT_DEPS = { normalizeRadians, updateDescendantBoneTrees };
+function getSliderPoseSnapshot(component) {
+    let snapshot = sliderPoseSnapshots.get(component);
+    if (!snapshot) {
+        snapshot = new LocalPoseSnapshot();
+        sliderPoseSnapshots.set(component, snapshot);
+    }
+    return snapshot;
+}
+function advanceSpineRuntime(component, delta) {
+    component.elapsed += delta * component.timeScale;
+    if (component.previousAnimation)
+        component.mixElapsed += delta * component.timeScale;
+    if (component.previousAnimation && component.mixElapsed >= component.mixDuration * 1000)
+        component.previousAnimation = '';
+}
+function buildSpineVertices(component, runtime) {
+    const poses = computePoses(runtime, component);
+    const floats = runtime.vertexBuilder;
+    const debugFloats = runtime.debugVertexBuilder;
+    const skin = runtime.data.skins[component.skin] ?? runtime.data.skins.default ?? {};
+    const time = getCurrentAnimationTime(runtime.data, component);
+    const sliderStates = computeSliderAnimationStates(runtime, component, poses);
+    const entries = runtime.slotEntries;
+    const changedVertexEntries = runtime.changedVertexEntries;
+    const changedDebugEntries = runtime.changedDebugEntries;
+    const liveKeys = runtime.liveSlotKeys;
+    entries.length = 0;
+    changedVertexEntries.length = 0;
+    changedDebugEntries.length = 0;
+    liveKeys.clear();
+    let clip = null;
+    for (const slot of getDrawOrderedSlots(runtime, component, time)) {
+        const slotSkin = skin[slot.name] ?? {};
+        const attachmentName = getSpineSlotAttachmentName(runtime, component, slot, time);
+        if (!attachmentName) {
+            if (clip?.endSlot === slot.name)
+                clip = null;
+            continue;
+        }
+        const attachment = slotSkin[attachmentName];
+        if (!attachment || attachment.type === 'boundingbox') {
+            if (clip?.endSlot === slot.name)
+                clip = null;
+            continue;
+        }
+        const bone = poses.get(slot.bone);
+        if (attachment.type === 'clipping') {
+            if (bone)
+                clip = {
+                    ...(attachment.end === undefined ? {} : { endSlot: attachment.end }),
+                    polygon: computeClipPolygon(bone, attachment, component.scale),
+                };
+            continue;
+        }
+        const regionName = getSpineAttachmentRegionName(runtime, component, slot, attachmentName, attachment, time, sliderStates);
+        const region = runtime.atlas.get(regionName) ?? runtime.atlas.get(attachment.path || attachment.name || attachmentName) ?? runtime.atlas.get(attachmentName);
+        if (!bone || !region) {
+            if (clip?.endSlot === slot.name)
+                clip = null;
+            continue;
+        }
+        const slotColor = getSpineSlotColor(runtime, component, slot, time, sliderStates);
+        const cacheKey = runtime.slotCacheKeyByName.get(slot.name) ?? slot.name;
+        liveKeys.add(cacheKey);
+        const signature = getSlotBuildSignature(slot, attachmentName, attachment, regionName, region, bone, poses, slotColor, clip, component);
+        const debugSignature = component.debugMesh ? hashInt(signature, 1) : 0;
+        let cache = runtime.slotGeometryCache.get(cacheKey);
+        const verticesChanged = !cache || cache.signature !== signature;
+        const debugChanged = !cache || cache.debugSignature !== debugSignature;
+        if (!cache) {
+            cache = createEmptySlotCache(cacheKey);
+            runtime.slotGeometryCache.set(cacheKey, cache);
+        }
+        if (verticesChanged || debugChanged) {
+            runtime.slotVertexBuilder.clear();
+            runtime.slotDebugVertexBuilder.clear();
+            if (attachment.type === 'mesh') {
+                appendMeshVertices(runtime.slotVertexBuilder, component, runtime, runtime.data, poses, bone, slotColor, attachment, region);
+                if (component.debugMesh)
+                    appendMeshWireframe(runtime.slotDebugVertexBuilder, component, runtime, runtime.data, poses, bone, attachment);
+            }
+            else {
+                appendRegionVertices(runtime.slotVertexBuilder, component, runtime, bone, slotColor, attachment, region);
+                if (component.debugMesh)
+                    appendRegionWireframe(runtime.slotDebugVertexBuilder, component, bone, attachment, region);
+            }
+            if (clip)
+                replaceClippedRange(runtime.slotVertexBuilder, 0, clip.polygon, runtime.clipBuilder);
+            const previousVertexCapacity = cache.vertexCapacity;
+            const previousDebugCapacity = cache.debugVertexCapacity;
+            const previousDebugLength = cache.debugVertexLength;
+            cache.signature = signature;
+            cache.debugSignature = debugSignature;
+            const previousVertices = cache.vertices;
+            cache.vertices = copyBuilderData(runtime.slotVertexBuilder, cache.vertices);
+            if (cache.vertices !== previousVertices)
+                runtime.allocationStats.slotRegionGrowths++;
+            cache.vertexLength = runtime.slotVertexBuilder.length;
+            cache.vertexCapacity = cache.vertices.length;
+            const previousDebugVertices = cache.debugVertices;
+            cache.debugVertices = copyBuilderData(runtime.slotDebugVertexBuilder, cache.debugVertices);
+            if (cache.debugVertices !== previousDebugVertices)
+                runtime.allocationStats.slotRegionGrowths++;
+            cache.debugVertexLength = runtime.slotDebugVertexBuilder.length;
+            cache.debugVertexCapacity = cache.debugVertices.length;
+            cache.batch.blend = normalizeBlend(slot.blend);
+            cache.batch.page = region.page;
+            cache.batch.vertexCount = cache.vertexLength / 8;
+            if (cache.vertexCapacity !== previousVertexCapacity)
+                cache.vertexOffset = -1;
+            if (cache.debugVertexCapacity !== previousDebugCapacity || cache.debugVertexLength !== previousDebugLength) {
+                cache.debugVertexOffset = -1;
+            }
+        }
+        if (verticesChanged)
+            changedVertexEntries.push(cache);
+        if (debugChanged)
+            changedDebugEntries.push(cache);
+        entries.push(cache);
+        if (clip?.endSlot === slot.name)
+            clip = null;
+    }
+    if (component.debugBones) {
+        const cacheKey = '__debug_bones__';
+        liveKeys.add(cacheKey);
+        const signature = 0;
+        const debugSignature = getDebugBonesSignature(component.scale, poses);
+        let cache = runtime.slotGeometryCache.get(cacheKey);
+        const debugChanged = !cache || cache.debugSignature !== debugSignature;
+        if (!cache) {
+            cache = createEmptySlotCache(cacheKey);
+            runtime.slotGeometryCache.set(cacheKey, cache);
+        }
+        if (debugChanged) {
+            runtime.slotDebugVertexBuilder.clear();
+            appendBoneDebug(runtime.slotDebugVertexBuilder, runtime.data, poses, component.scale);
+            const previousDebugCapacity = cache.debugVertexCapacity;
+            const previousDebugLength = cache.debugVertexLength;
+            cache.signature = signature;
+            cache.debugSignature = debugSignature;
+            cache.vertexLength = 0;
+            const previousDebugVertices = cache.debugVertices;
+            cache.debugVertices = copyBuilderData(runtime.slotDebugVertexBuilder, cache.debugVertices);
+            if (cache.debugVertices !== previousDebugVertices)
+                runtime.allocationStats.slotRegionGrowths++;
+            cache.debugVertexLength = runtime.slotDebugVertexBuilder.length;
+            cache.debugVertexCapacity = cache.debugVertices.length;
+            cache.batch.vertexCount = 0;
+            if (cache.debugVertexCapacity !== previousDebugCapacity || cache.debugVertexLength !== previousDebugLength) {
+                cache.debugVertexOffset = -1;
+            }
+        }
+        if (debugChanged)
+            changedDebugEntries.push(cache);
+        entries.push(cache);
+    }
+    for (const key of runtime.slotGeometryCache.keys()) {
+        if (!liveKeys.has(key))
+            runtime.slotGeometryCache.delete(key);
+    }
+    const slotOrderHash = getSlotOrderHash(entries);
+    const layoutChanged = runtime.slotOrderHash !== slotOrderHash || hasInvalidOffsets(entries);
+    const vertexDirtyRanges = runtime.vertexDirtyRanges;
+    const debugDirtyRanges = runtime.debugDirtyRanges;
+    vertexDirtyRanges.length = 0;
+    debugDirtyRanges.length = 0;
+    if (layoutChanged) {
+        rebuildCachedGeometryLayout(runtime, entries);
+        runtime.slotOrderHash = slotOrderHash;
+        if (floats.byteLength > 0)
+            pushDirtyRange(runtime, vertexDirtyRanges, runtime.vertexDirtyRangePool, 0, floats.byteLength);
+        if (debugFloats.byteLength > 0)
+            pushDirtyRange(runtime, debugDirtyRanges, runtime.debugDirtyRangePool, 0, debugFloats.byteLength);
+    }
+    else {
+        for (const entry of changedVertexEntries) {
+            if (entry.vertexLength === 0)
+                continue;
+            for (let index = 0; index < entry.vertexLength; index++) {
+                floats.data[entry.vertexOffset + index] = entry.vertices[index] ?? 0;
+            }
+            pushDirtyRange(runtime, vertexDirtyRanges, runtime.vertexDirtyRangePool, entry.vertexOffset * 4, entry.vertexLength * 4);
+        }
+        for (const entry of changedDebugEntries) {
+            if (entry.debugVertexLength === 0)
+                continue;
+            for (let index = 0; index < entry.debugVertexLength; index++) {
+                debugFloats.data[entry.debugVertexOffset + index] = entry.debugVertices[index] ?? 0;
+            }
+            pushDirtyRange(runtime, debugDirtyRanges, runtime.debugDirtyRangePool, entry.debugVertexOffset * 4, entry.debugVertexLength * 4);
+        }
+    }
+    rebuildCachedDrawBatches(runtime, entries);
+    const result = runtime.vertexBuildResult;
+    result.verticesChanged = vertexDirtyRanges.length > 0;
+    result.debugVerticesChanged = debugDirtyRanges.length > 0;
+    return result;
+}
+function pushDirtyRange(runtime, ranges, pool, byteOffset, byteLength) {
+    const index = ranges.length;
+    let range = pool[index];
+    if (!range) {
+        range = { byteOffset, byteLength };
+        pool.push(range);
+        runtime.allocationStats.dirtyRangePoolMisses++;
+    }
+    else {
+        range.byteOffset = byteOffset;
+        range.byteLength = byteLength;
+    }
+    ranges.push(range);
+}
+async function loadSpineRuntime(gpuRenderer, component, options = {}) {
+    try {
+        return await loadSpineRuntimeUnchecked(gpuRenderer, component, options);
+    }
+    catch (error) {
+        if (error instanceof EngineError) {
+            throw new EngineError(error.code, error.message, {
+                domain: error.domain,
+                recoverable: error.recoverable,
+                recovery: error.recovery,
+                context: {
+                    resourceType: 'skeleton/spine',
+                    jsonUrl: component.jsonUrl,
+                    atlasUrl: component.atlasUrl,
+                    ...error.context,
+                },
+                ...(error.path === undefined ? {} : { path: error.path }),
+                cause: error,
+            });
+        }
+        throw new EngineError(EngineErrorCode.AssetInvalidData, 'Failed to create the Spine runtime.', {
+            domain: ErrorDomain.Component,
+            recovery: ErrorRecovery.ReleaseResource,
+            context: { resourceType: 'skeleton/spine', jsonUrl: component.jsonUrl, atlasUrl: component.atlasUrl },
+            path: 'spine',
+            cause: error,
+        });
+    }
+}
+async function loadSpineRuntimeUnchecked(gpuRenderer, component, options) {
+    const parsed = await parseAssetWorkerFirst({
+        parser: {
+            type: 'skeleton/spine',
+            parse: (_input, context) => loadAndParseSpineMain(component, context.signal),
+        },
+        input: Object.freeze({ jsonUrl: component.jsonUrl, atlasUrl: component.atlasUrl }),
+        context: { ...(options.signal ? { signal: options.signal } : {}), source: component.jsonUrl },
+        worker: options.assetWorker
+            ? async (_input, context) => requireSpineParsedAsset(await options.assetWorker.loadParsedAsset(component.jsonUrl, component.atlasUrl, context.signal ? { signal: context.signal } : {}), component.jsonUrl)
+            : null,
+    });
+    throwIfAborted(options.signal);
+    const data = parsed.data;
+    const atlas = new Map(parsed.regions);
+    const pages = await gpuRenderer.loadAtlasPages(component, atlas);
+    throwIfAborted(options.signal);
+    const runtimeBuffers = gpuRenderer.createRuntimeBuffers();
+    return createSpineRuntimeState(data, atlas, pages, runtimeBuffers);
+}
+function requireSpineParsedAsset(value, source) {
+    if (!value || typeof value !== 'object')
+        throw invalidSpineWorkerPayload(source, value);
+    const candidate = value;
+    const data = candidate.data;
+    if (!data || typeof data !== 'object' || !Array.isArray(data.bones) || !Array.isArray(candidate.regions)) {
+        throw invalidSpineWorkerPayload(source, value);
+    }
+    return candidate;
+}
+function invalidSpineWorkerPayload(source, cause) {
+    return new EngineError(EngineErrorCode.WorkerProtocolInvalid, 'Spine worker returned an invalid parsed asset.', {
+        domain: ErrorDomain.Worker,
+        recovery: ErrorRecovery.TerminateRuntime,
+        context: { url: source, resourceType: 'skeleton/spine' },
+        path: 'spine.worker.response',
+        cause,
+    });
+}
+function createSpineRuntimeState(data, atlas, pages, runtimeBuffers) {
+    const timelineSamplerState = createSpineTimelineSamplerState();
+    const timelineCompileStats = compileSpineTimelines(data.animations, timelineSamplerState);
+    compileAnimationBoneTimelines(data.animations);
+    const vertexBuilder = new SpineFloatBuilder(1024);
+    const debugVertexBuilder = new SpineFloatBuilder(256);
+    const batches = [];
+    const vertexDirtyRanges = [];
+    const debugDirtyRanges = [];
+    const rangePoolCapacity = Math.max(1, data.slots.length + 1);
+    const vertexBuildResult = {
+        vertices: vertexBuilder,
+        batches,
+        debugVertices: debugVertexBuilder,
+        vertexDirtyRanges,
+        debugDirtyRanges,
+        verticesChanged: false,
+        debugVerticesChanged: false,
+    };
+    return {
+        data,
+        atlas,
+        pages,
+        ...runtimeBuffers,
+        batches,
+        batchPool: createBatchPool(Math.max(1, data.slots.length)),
+        vertexBuilder,
+        debugVertexBuilder,
+        slotVertexBuilder: new SpineFloatBuilder(256),
+        slotDebugVertexBuilder: new SpineFloatBuilder(128),
+        clipBuilder: new SpineFloatBuilder(256),
+        meshPointBuilder: new SpineFloatBuilder(256),
+        slotGeometryCache: new Map(),
+        slotOrderHash: 0,
+        boneChildren: buildBoneChildren(data),
+        setupPoses: createSetupPoses(data),
+        previousSetupPoses: createSetupPoses(data),
+        slotIndexByName: buildSlotIndexByName(data),
+        slotCacheKeyByName: buildSlotCacheKeys(data),
+        sliderConstraintsByOrder: buildSliderConstraintsByOrder(data),
+        sortedConstraintsBySkin: new Map(),
+        transformConstraintBoneSets: new WeakMap(),
+        transformWorldSpaceBonesScratch: [],
+        drawOrderScratch: [],
+        unchangedSlotScratch: [],
+        orderedSlotScratch: [],
+        liveSlotKeys: new Set(),
+        slotEntries: [],
+        changedVertexEntries: [],
+        changedDebugEntries: [],
+        sliderStateScratch: [],
+        sliderStatePool: [],
+        vertexDirtyRanges,
+        debugDirtyRanges,
+        mergedDirtyRanges: [],
+        vertexDirtyRangePool: createDirtyRangePool(rangePoolCapacity),
+        debugDirtyRangePool: createDirtyRangePool(rangePoolCapacity),
+        mergedDirtyRangePool: createDirtyRangePool(rangePoolCapacity),
+        vertexBuildResult,
+        slotColorScratch: [1, 1, 1, 1],
+        sliderColorScratch: [1, 1, 1, 1],
+        vertexColorScratch: [1, 1, 1, 1],
+        timelineCompileStats,
+        timelineSamplerState,
+        allocationStats: { slotRegionGrowths: 0, batchPoolMisses: 0, dirtyRangePoolMisses: 0 },
+        ikStateScratch: { mix: 0, softness: 0, bendPositive: true },
+        transformStateScratch: { mixRotate: 0, mixX: 0, mixY: 0, mixScaleX: 0, mixScaleY: 0, mixShearY: 0 },
+        ...createSpinePathConstraintScratch(),
+    };
+}
+function createDirtyRangePool(capacity) {
+    return Array.from({ length: capacity }, () => ({ byteOffset: 0, byteLength: 0 }));
+}
+function createBatchPool(capacity) {
+    return Array.from({ length: capacity }, () => ({
+        blend: 'normal',
+        page: '',
+        firstVertex: 0,
+        vertexCount: 0,
+    }));
+}
+/** Monorepo benchmark adapter; not re-exported from the Spine package facade. */
+function createSpineRuntimeForBenchmark(data, atlas, pages) {
+    const placeholderBuffer = {};
+    return createSpineRuntimeState(data, atlas, pages, {
+        vertexBuffer: placeholderBuffer,
+        vertexBufferSize: 0,
+        debugVertexBuffer: placeholderBuffer,
+        debugVertexBufferSize: 0,
+    });
+}
+/** Monorepo benchmark adapter; samples the complete animation/constraint pose path. */
+function sampleSpinePosesForBenchmark(component, runtime) {
+    let checksum = 0;
+    for (const pose of computePoses(runtime, component).values()) {
+        checksum += pose.worldX + pose.worldY + pose.a + pose.d;
+    }
+    return checksum;
+}
+async function loadAndParseSpineMain(component, signal) {
+    const [json, atlasText] = await Promise.all([
+        fetchJson(component.jsonUrl, signal),
+        component.atlasUrl ? fetchText(component.atlasUrl, signal) : Promise.resolve(''),
+    ]);
+    return await SPINE_ASSET_PARSER.parse({ json, atlasText }, { source: component.jsonUrl, ...(signal === undefined ? {} : { signal }) });
+}
+async function fetchJson(url, signal) {
+    const response = await fetch(url, signal ? { signal } : undefined);
+    if (!response.ok) {
+        throw new EngineError(EngineErrorCode.AssetLoadFailed, `Failed to load Spine JSON: ${response.status} ${response.statusText}`, {
+            domain: ErrorDomain.Component,
+            recovery: ErrorRecovery.Retry,
+            context: { url, resourceType: 'skeleton/spine-json', status: response.status },
+            path: 'spine.json',
+        });
+    }
+    try {
+        return await response.json();
+    }
+    catch (error) {
+        throw new EngineError(EngineErrorCode.AssetInvalidData, 'Spine JSON is not valid JSON.', {
+            domain: ErrorDomain.Component,
+            recovery: ErrorRecovery.ReleaseResource,
+            context: { url, resourceType: 'skeleton/spine-json' },
+            path: 'spine.json',
+            cause: error,
+        });
+    }
+}
+async function fetchText(url, signal) {
+    const response = await fetch(url, signal ? { signal } : undefined);
+    if (!response.ok) {
+        throw new EngineError(EngineErrorCode.AssetLoadFailed, `Failed to load Spine atlas: ${response.status} ${response.statusText}`, {
+            domain: ErrorDomain.Component,
+            recovery: ErrorRecovery.Retry,
+            context: { url, resourceType: 'skeleton/spine-atlas', status: response.status },
+            path: 'spine.atlas',
+        });
+    }
+    return response.text();
+}
+function throwIfAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    throw createAbortError('Spine load aborted.', signal.reason);
+}
+function computePoses(runtime, component) {
+    const data = runtime.data;
+    const children = runtime.boneChildren;
+    const local = resetSetupPoses(runtime.setupPoses);
+    if (component.previousAnimation
+        && component.mixDuration > 0
+        && component.mixElapsed < component.mixDuration * 1000
+        && data.animations[component.previousAnimation]) {
+        const previous = resetSetupPoses(runtime.previousSetupPoses);
+        applyAnimationAt(runtime, data, component.previousAnimation, component.previousElapsed / 1000, component.loop, previous);
+        applyAnimationAt(runtime, data, component.animation, component.elapsed / 1000, component.loop, local);
+        const alpha = Math.max(0, Math.min(1, component.mixElapsed / (component.mixDuration * 1000)));
+        blendLocalPoses(local, previous, alpha);
+    }
+    else {
+        applyAnimation(runtime, data, component, local);
+    }
+    applySliderBoneAnimations(runtime, component, local, true);
+    updateWorldPoses(data, local);
+    applyConstraints(runtime, component, local, children);
+    if (applySliderBoneAnimations(runtime, component, local, false))
+        updateWorldPoses(data, local);
+    return local;
+}
+function buildBoneChildren(data) {
+    const children = new Map();
+    for (const bone of data.bones) {
+        if (!bone.parent)
+            continue;
+        const list = children.get(bone.parent) ?? [];
+        list.push(bone.name);
+        children.set(bone.parent, list);
+    }
+    return children;
+}
+function buildSlotIndexByName(data) {
+    const indices = new Map();
+    for (let i = 0; i < data.slots.length; i++) {
+        indices.set(requiredItemAt(data.slots, i, 'Spine slots').name, i);
+    }
+    return indices;
+}
+function buildSlotCacheKeys(data) {
+    const keys = new Map();
+    for (const slot of data.slots)
+        keys.set(slot.name, `slot:${slot.name}`);
+    return keys;
+}
+function buildSliderConstraintsByOrder(data) {
+    return data.sliders.slice().sort((a, b) => a.order - b.order);
+}
+function createSetupPoses(data) {
+    const local = new Map();
+    for (const bone of data.bones) {
+        local.set(bone.name, {
+            data: bone,
+            a: 1,
+            b: 0,
+            c: 0,
+            d: 1,
+            worldX: 0,
+            worldY: 0,
+            rotation: bone.rotation,
+            shearX: bone.shearX,
+            shearY: bone.shearY,
+            x: bone.x,
+            y: bone.y,
+            scaleX: bone.scaleX,
+            scaleY: bone.scaleY,
+        });
+    }
+    return local;
+}
+function resetSetupPoses(poses) {
+    for (const pose of poses.values()) {
+        const bone = pose.data;
+        pose.a = 1;
+        pose.b = 0;
+        pose.c = 0;
+        pose.d = 1;
+        pose.worldX = 0;
+        pose.worldY = 0;
+        pose.rotation = bone.rotation;
+        pose.shearX = bone.shearX;
+        pose.shearY = bone.shearY;
+        pose.x = bone.x;
+        pose.y = bone.y;
+        pose.scaleX = bone.scaleX;
+        pose.scaleY = bone.scaleY;
+    }
+    return poses;
+}
+function blendLocalPoses(current, previous, alpha) {
+    for (const [name, pose] of current) {
+        const from = previous.get(name);
+        if (!from)
+            continue;
+        pose.x = lerpNumber(from.x, pose.x, alpha);
+        pose.y = lerpNumber(from.y, pose.y, alpha);
+        pose.rotation = from.rotation + normalizeAngle(pose.rotation - from.rotation) * alpha;
+        pose.shearX = lerpNumber(from.shearX, pose.shearX, alpha);
+        pose.shearY = lerpNumber(from.shearY, pose.shearY, alpha);
+        pose.scaleX = lerpNumber(from.scaleX, pose.scaleX, alpha);
+        pose.scaleY = lerpNumber(from.scaleY, pose.scaleY, alpha);
+    }
+}
+function blendLocalPosesFromSnapshot(current, previous, alpha) {
+    let offset = 0;
+    for (const pose of current.values()) {
+        if (offset + 6 >= previous.length)
+            return;
+        const fromX = requiredNumberAt(previous.data, offset++, 'previous local pose');
+        const fromY = requiredNumberAt(previous.data, offset++, 'previous local pose');
+        const fromRotation = requiredNumberAt(previous.data, offset++, 'previous local pose');
+        const fromShearX = requiredNumberAt(previous.data, offset++, 'previous local pose');
+        const fromShearY = requiredNumberAt(previous.data, offset++, 'previous local pose');
+        const fromScaleX = requiredNumberAt(previous.data, offset++, 'previous local pose');
+        const fromScaleY = requiredNumberAt(previous.data, offset++, 'previous local pose');
+        pose.x = lerpNumber(fromX, pose.x, alpha);
+        pose.y = lerpNumber(fromY, pose.y, alpha);
+        pose.rotation = fromRotation + normalizeAngle(pose.rotation - fromRotation) * alpha;
+        pose.shearX = lerpNumber(fromShearX, pose.shearX, alpha);
+        pose.shearY = lerpNumber(fromShearY, pose.shearY, alpha);
+        pose.scaleX = lerpNumber(fromScaleX, pose.scaleX, alpha);
+        pose.scaleY = lerpNumber(fromScaleY, pose.scaleY, alpha);
+    }
+}
+function lerpNumber(a, b, t) {
+    return a + (b - a) * t;
+}
+function getDrawOrderedSlots(runtime, component, time) {
+    const data = runtime.data;
+    const frames = data.animations[component.animation]?.drawOrder;
+    if (!Array.isArray(frames) || frames.length === 0)
+        return data.slots;
+    const frameIndex = findCompiledFrameIndex(frames, time, runtime.timelineSamplerState);
+    const frame = frameIndex >= 0 ? frames[frameIndex] : null;
+    if (!frame?.offsets?.length)
+        return data.slots;
+    const drawOrder = runtime.drawOrderScratch;
+    const unchanged = runtime.unchangedSlotScratch;
+    const ordered = runtime.orderedSlotScratch;
+    drawOrder.length = data.slots.length;
+    unchanged.length = 0;
+    ordered.length = 0;
+    for (let i = 0; i < drawOrder.length; i++)
+        drawOrder[i] = -1;
+    let originalIndex = 0;
+    for (const offset of frame.offsets) {
+        const slotIndex = runtime.slotIndexByName.get(offset.slot) ?? -1;
+        if (slotIndex < 0)
+            continue;
+        while (originalIndex < slotIndex)
+            unchanged.push(originalIndex++);
+        const drawIndex = originalIndex + (offset.offset ?? 0);
+        if (drawIndex >= 0 && drawIndex < drawOrder.length)
+            drawOrder[drawIndex] = originalIndex;
+        originalIndex++;
+    }
+    while (originalIndex < data.slots.length)
+        unchanged.push(originalIndex++);
+    let unchangedIndex = unchanged.length - 1;
+    for (let i = drawOrder.length - 1; i >= 0; i--) {
+        if (drawOrder[i] === -1)
+            drawOrder[i] = unchanged[unchangedIndex--] ?? i;
+    }
+    for (let i = 0; i < drawOrder.length; i++) {
+        const drawIndex = drawOrder[i];
+        const slot = drawIndex === undefined ? undefined : data.slots[drawIndex];
+        if (slot)
+            ordered.push(slot);
+    }
+    return ordered;
+}
+function updateWorldPoses(data, poses) {
+    for (const bone of data.bones) {
+        const pose = poses.get(bone.name);
+        const parent = bone.parent ? poses.get(bone.parent) ?? null : null;
+        updateWorldPose(pose, parent);
+    }
+}
+function updateWorldPose(pose, parent) {
+    const rx = (pose.rotation + pose.shearX) * Math.PI / 180;
+    const ry = (pose.rotation + 90 + pose.shearY) * Math.PI / 180;
+    const la = Math.cos(rx) * pose.scaleX;
+    const lb = Math.cos(ry) * pose.scaleY;
+    const lc = Math.sin(rx) * pose.scaleX;
+    const ld = Math.sin(ry) * pose.scaleY;
+    if (!parent) {
+        pose.worldX = pose.x;
+        pose.worldY = pose.y;
+        pose.a = la;
+        pose.b = lb;
+        pose.c = lc;
+        pose.d = ld;
+        return;
+    }
+    pose.worldX = parent.a * pose.x + parent.b * pose.y + parent.worldX;
+    pose.worldY = parent.c * pose.x + parent.d * pose.y + parent.worldY;
+    switch (pose.data.inherit) {
+        case 'onlyTranslation':
+            pose.a = la;
+            pose.b = lb;
+            pose.c = lc;
+            pose.d = ld;
+            return;
+        case 'noRotationOrReflection':
+            updateNoRotationOrReflectionWorldPose(pose, parent);
+            return;
+        case 'noScale':
+        case 'noScaleOrReflection':
+            updateNoScaleWorldPose(pose, parent);
+            return;
+        default:
+            pose.a = parent.a * la + parent.b * lc;
+            pose.b = parent.a * lb + parent.b * ld;
+            pose.c = parent.c * la + parent.d * lc;
+            pose.d = parent.c * lb + parent.d * ld;
+    }
+}
+function updateNoRotationOrReflectionWorldPose(pose, parent) {
+    let pa = parent.a;
+    let pb = parent.b;
+    let pc = parent.c;
+    let pd = parent.d;
+    let s = pa * pa + pc * pc;
+    let rotation = 0;
+    if (s > 0.000001) {
+        s = Math.abs(pa * pd - pb * pc) / s;
+        pb = pc * s;
+        pd = pa * s;
+        rotation = pose.rotation - Math.atan2(pc, pa) * 180 / Math.PI;
+    }
+    else {
+        pa = 0;
+        pc = 0;
+        rotation = pose.rotation - 90 + Math.atan2(pd, pb) * 180 / Math.PI;
+    }
+    const rx = (rotation + pose.shearX) * Math.PI / 180;
+    const ry = (rotation + 90 + pose.shearY) * Math.PI / 180;
+    const la = Math.cos(rx) * pose.scaleX;
+    const lb = Math.cos(ry) * pose.scaleY;
+    const lc = Math.sin(rx) * pose.scaleX;
+    const ld = Math.sin(ry) * pose.scaleY;
+    pose.a = pa * la - pb * lc;
+    pose.b = pa * lb - pb * ld;
+    pose.c = pc * la + pd * lc;
+    pose.d = pc * lb + pd * ld;
+}
+function updateNoScaleWorldPose(pose, parent) {
+    const rotation = pose.rotation * Math.PI / 180;
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    let za = parent.a * cos + parent.b * sin;
+    let zc = parent.c * cos + parent.d * sin;
+    const length = Math.sqrt(za * za + zc * zc);
+    if (length > 0.000001) {
+        za /= length;
+        zc /= length;
+    }
+    let zb = -zc;
+    let zd = za;
+    const determinant = parent.a * parent.d - parent.b * parent.c;
+    if (pose.data.inherit === 'noScale' && determinant < 0) {
+        zb = -zb;
+        zd = -zd;
+    }
+    const rx = pose.shearX * Math.PI / 180;
+    const ry = (90 + pose.shearY) * Math.PI / 180;
+    const la = Math.cos(rx) * pose.scaleX;
+    const lb = Math.cos(ry) * pose.scaleY;
+    const lc = Math.sin(rx) * pose.scaleX;
+    const ld = Math.sin(ry) * pose.scaleY;
+    pose.a = za * la + zb * lc;
+    pose.b = za * lb + zb * ld;
+    pose.c = zc * la + zd * lc;
+    pose.d = zc * lb + zd * ld;
+}
+function applyAnimation(runtime, data, component, poses) {
+    applyAnimationAt(runtime, data, component.animation, getCurrentAnimationTime(data, component), component.loop, poses);
+}
+function applyAnimationAt(runtime, data, animationName, rawTime, loop, poses) {
+    const animation = data.animations[animationName];
+    if (!animation?.bones)
+        return;
+    const duration = getCompiledAnimationDuration(animation);
+    const time = loop && duration > 0 ? rawTime % duration : Math.min(rawTime, duration);
+    for (const entry of getAnimationBoneTimelines(animation)) {
+        const pose = poses.get(entry.boneName);
+        if (!pose)
+            continue;
+        const timelines = entry.timelines;
+        if (timelines.rotate)
+            pose.rotation = pose.data.rotation + sampleCompiledTimeline(timelines.rotate, time, 'angle', 0, duration, loop, runtime.timelineSamplerState);
+        if (timelines.translate) {
+            pose.x = pose.data.x + sampleCompiledTimeline(timelines.translate, time, 'x', 0, duration, loop, runtime.timelineSamplerState);
+            pose.y = pose.data.y + sampleCompiledTimeline(timelines.translate, time, 'y', 0, duration, loop, runtime.timelineSamplerState);
+        }
+        if (timelines.scale) {
+            pose.scaleX = pose.data.scaleX * sampleCompiledTimeline(timelines.scale, time, 'x', 1, duration, loop, runtime.timelineSamplerState);
+            pose.scaleY = pose.data.scaleY * sampleCompiledTimeline(timelines.scale, time, 'y', 1, duration, loop, runtime.timelineSamplerState);
+        }
+        if (timelines.shear) {
+            pose.shearX = pose.data.shearX + sampleCompiledTimeline(timelines.shear, time, 'x', 0, duration, loop, runtime.timelineSamplerState);
+            pose.shearY = pose.data.shearY + sampleCompiledTimeline(timelines.shear, time, 'y', 0, duration, loop, runtime.timelineSamplerState);
+        }
+    }
+}
+function computeSliderAnimationStates(runtime, component, poses, localOnly) {
+    const data = runtime.data;
+    const states = runtime.sliderStateScratch;
+    states.length = 0;
+    if (!runtime.sliderConstraintsByOrder.length)
+        return states;
+    const currentAnimation = data.animations[component.animation];
+    const currentDuration = getCompiledAnimationDuration(currentAnimation);
+    const currentTime = getCurrentAnimationTime(data, component);
+    for (const slider of runtime.sliderConstraintsByOrder) {
+        if (localOnly !== undefined && slider.local !== localOnly)
+            continue;
+        if (slider.animation === component.animation)
+            continue;
+        if (!slider.animation || slider.mix <= 0 || !data.animations[slider.animation])
+            continue;
+        if (!isConstraintActiveForSkin(data, component.skin, 'slider', slider.name, slider.skin))
+            continue;
+        const mix = sampleCompiledTimeline(currentAnimation?.slider?.[slider.name]?.mix ?? [], currentTime, 'mix', slider.mix, currentDuration, component.loop, runtime.timelineSamplerState);
+        if (mix <= 0)
+            continue;
+        const duration = getCompiledAnimationDuration(data.animations[slider.animation]);
+        let time = slider.offset;
+        if (slider.bone) {
+            const bone = poses.get(slider.bone);
+            if (!bone)
+                continue;
+            time += getSliderBoneProperty(bone, slider.property, slider.local) * slider.scale;
+        }
+        if (slider.loop && duration > 0) {
+            time %= duration;
+            if (time < 0)
+                time += duration;
+        }
+        else {
+            time = Math.max(0, Math.min(time, duration));
+        }
+        const stateIndex = states.length;
+        let state = runtime.sliderStatePool[stateIndex];
+        if (!state) {
+            state = { animation: slider.animation, time, loop: slider.loop, mix };
+            runtime.sliderStatePool.push(state);
+        }
+        else {
+            state.animation = slider.animation;
+            state.time = time;
+            state.loop = slider.loop;
+            state.mix = mix;
+        }
+        states.push(state);
+    }
+    return states;
+}
+function applySliderBoneAnimations(runtime, component, poses, localOnly) {
+    const data = runtime.data;
+    let applied = false;
+    let before = null;
+    for (const slider of computeSliderAnimationStates(runtime, component, poses, localOnly)) {
+        if (!data.animations[slider.animation]?.bones)
+            continue;
+        if (slider.mix < 1) {
+            before ??= getSliderPoseSnapshot(component);
+            before.capture(poses);
+        }
+        applyAnimationAt(runtime, data, slider.animation, slider.time, slider.loop, poses);
+        if (slider.mix < 1 && before)
+            blendLocalPosesFromSnapshot(poses, before, slider.mix);
+        applied = true;
+    }
+    return applied;
+}
+function getSliderBoneProperty(bone, property, local) {
+    if (local) {
+        if (property === 'x')
+            return bone.x;
+        if (property === 'y')
+            return bone.y;
+        if (property === 'scaleX')
+            return bone.scaleX;
+        if (property === 'scaleY')
+            return bone.scaleY;
+        if (property === 'shearX')
+            return bone.shearX;
+        if (property === 'shearY')
+            return bone.shearY;
+        return bone.rotation;
+    }
+    if (property === 'x')
+        return bone.worldX;
+    if (property === 'y')
+        return bone.worldY;
+    if (property === 'scaleX')
+        return Math.hypot(bone.a, bone.c);
+    if (property === 'scaleY')
+        return Math.hypot(bone.b, bone.d);
+    if (property === 'shearY')
+        return Math.atan2(bone.d, bone.b) * 180 / Math.PI - Math.atan2(bone.c, bone.a) * 180 / Math.PI - 90;
+    return Math.atan2(bone.c, bone.a) * 180 / Math.PI;
+}
+function applyConstraints(runtime, component, poses, children) {
+    const data = runtime.data;
+    const animation = data.animations[component.animation];
+    const duration = getCompiledAnimationDuration(animation);
+    const time = getCurrentAnimationTime(data, component);
+    const constraints = getSortedConstraintEntries(runtime, component.skin);
+    for (const constraint of constraints) {
+        if (constraint.type === 'ik') {
+            applyIkConstraint(runtime, animation, constraint.constraint, time, duration, component.loop, poses, children);
+        }
+        else if (constraint.type === 'path') {
+            applyPathConstraint(runtime, component, constraint.constraint, time, duration, component.loop, poses, children, PATH_CONSTRAINT_DEPS);
+        }
+        else {
+            applyTransformConstraint(runtime, animation, constraint.constraint, time, duration, component.loop, poses, children);
+        }
+    }
+}
+function getSortedConstraintEntries(runtime, skinName) {
+    const cached = runtime.sortedConstraintsBySkin.get(skinName);
+    if (cached)
+        return cached;
+    const data = runtime.data;
+    const constraints = [];
+    for (const constraint of data.ik) {
+        if (isConstraintActiveForSkin(data, skinName, 'ik', constraint.name, constraint.skin)) {
+            constraints.push({ type: 'ik', order: constraint.order, constraint });
+        }
+    }
+    for (const constraint of data.path) {
+        if (isConstraintActiveForSkin(data, skinName, 'path', constraint.name, constraint.skin)) {
+            constraints.push({ type: 'path', order: constraint.order, constraint });
+        }
+    }
+    for (const constraint of data.transform) {
+        if (isConstraintActiveForSkin(data, skinName, 'transform', constraint.name, constraint.skin)) {
+            constraints.push({ type: 'transform', order: constraint.order, constraint });
+        }
+    }
+    constraints.sort((a, b) => a.order - b.order);
+    runtime.sortedConstraintsBySkin.set(skinName, constraints);
+    return constraints;
+}
+function isConstraintActiveForSkin(data, skinName, type, constraintName, skinRequired) {
+    if (!skinRequired)
+        return true;
+    return data.skinConstraints[skinName]?.[type]?.includes(constraintName) ?? false;
+}
+function applyIkConstraint(runtime, animation, constraint, time, duration, loop, poses, children) {
+    const timeline = animation?.ik?.[constraint.name];
+    const state = sampleIkConstraint(constraint, timeline, time, duration, loop, runtime.ikStateScratch, runtime.timelineSamplerState);
+    if (state.mix <= 0)
+        return;
+    if (constraint.bones.length === 1) {
+        const rootBone = constraint.bones[0];
+        if (rootBone === undefined)
+            return;
+        applyOneBoneIk(constraint, state, poses);
+        updateBoneTree(rootBone, poses, children);
+    }
+    else if (constraint.bones.length === 2) {
+        const rootBone = constraint.bones[0];
+        if (rootBone === undefined)
+            return;
+        applyTwoBoneIk(constraint, state, poses);
+        updateBoneTree(rootBone, poses, children);
+    }
+}
+function sampleIkConstraint(constraint, frames, time, duration, loop, out, samplerState) {
+    out.mix = sampleCompiledTimeline(frames ?? [], time, 'mix', constraint.mix, duration, loop, samplerState);
+    out.softness = sampleCompiledTimeline(frames ?? [], time, 'softness', constraint.softness, duration, loop, samplerState);
+    let bendPositive = constraint.bendPositive;
+    if (!Array.isArray(frames) || frames.length === 0) {
+        out.bendPositive = bendPositive;
+        return out;
+    }
+    const frameIndex = findCompiledFrameIndex(frames, time, samplerState);
+    const frame = frameIndex >= 0 ? frames[frameIndex] : null;
+    if (frame && typeof frame === 'object') {
+        const value = frame.bendPositive;
+        if (typeof value === 'boolean')
+            bendPositive = value;
+    }
+    out.bendPositive = bendPositive;
+    return out;
+}
+function applyTransformConstraint(runtime, animation, constraint, time, duration, loop, poses, children) {
+    const state = sampleTransformConstraint(constraint, animation?.transform?.[constraint.name], time, duration, loop, runtime.transformStateScratch, runtime.timelineSamplerState);
+    if (state.mixRotate === 0
+        && state.mixX === 0
+        && state.mixY === 0
+        && state.mixScaleX === 0
+        && state.mixScaleY === 0
+        && state.mixShearY === 0)
+        return;
+    const source = poses.get(constraint.target);
+    if (!source)
+        return;
+    let constrainedBones = runtime.transformConstraintBoneSets.get(constraint);
+    if (!constrainedBones) {
+        constrainedBones = new Set(constraint.bones);
+        runtime.transformConstraintBoneSets.set(constraint, constrainedBones);
+    }
+    const worldSpaceBones = runtime.transformWorldSpaceBonesScratch;
+    worldSpaceBones.length = 0;
+    for (const boneName of constraint.bones) {
+        const bone = poses.get(boneName);
+        if (!bone)
+            continue;
+        if (constraint.localTarget || constraint.localSource) {
+            applyLocalTransformConstraint(constraint, state, source, bone);
+            updateBoneTree(boneName, poses, children);
+        }
+        else {
+            applyWorldTransformConstraint(constraint, state, source, bone);
+            worldSpaceBones.push(boneName);
+        }
+    }
+    for (const boneName of worldSpaceBones)
+        updateDescendantBoneTrees(boneName, poses, children, constrainedBones);
+}
+function sampleTransformConstraint(constraint, frames, time, duration, loop, out, samplerState) {
+    out.mixRotate = sampleCompiledTimeline(frames ?? [], time, 'mixRotate', constraint.mixRotate, duration, loop, samplerState);
+    out.mixX = sampleCompiledTimeline(frames ?? [], time, 'mixX', constraint.mixX, duration, loop, samplerState);
+    out.mixY = sampleCompiledTimeline(frames ?? [], time, 'mixY', constraint.mixY, duration, loop, samplerState);
+    out.mixScaleX = sampleCompiledTimeline(frames ?? [], time, 'mixScaleX', constraint.mixScaleX, duration, loop, samplerState);
+    out.mixScaleY = sampleCompiledTimeline(frames ?? [], time, 'mixScaleY', constraint.mixScaleY, duration, loop, samplerState);
+    out.mixShearY = sampleCompiledTimeline(frames ?? [], time, 'mixShearY', constraint.mixShearY, duration, loop, samplerState);
+    return out;
+}
+function applyWorldTransformConstraint(constraint, state, source, bone) {
+    if (state.mixRotate !== 0) {
+        let value = Math.atan2(source.c, source.a) * 180 / Math.PI
+            + ((source.a * source.d - source.b * source.c) > 0 ? constraint.rotation : -constraint.rotation);
+        if (value < 0)
+            value += 360;
+        if (!constraint.additive)
+            value -= Math.atan2(bone.c, bone.a) * 180 / Math.PI;
+        value = normalizeAngle(value) * Math.PI / 180 * state.mixRotate;
+        const cos = Math.cos(value);
+        const sin = Math.sin(value);
+        const a = bone.a;
+        const b = bone.b;
+        const c = bone.c;
+        const d = bone.d;
+        bone.a = cos * a - sin * c;
+        bone.b = cos * b - sin * d;
+        bone.c = sin * a + cos * c;
+        bone.d = sin * b + cos * d;
+    }
+    if (state.mixX !== 0) {
+        let value = constraint.x * source.a + constraint.y * source.b + source.worldX;
+        if (!constraint.additive)
+            value -= bone.worldX;
+        bone.worldX += value * state.mixX;
+    }
+    if (state.mixY !== 0) {
+        let value = constraint.x * source.c + constraint.y * source.d + source.worldY;
+        if (!constraint.additive)
+            value -= bone.worldY;
+        bone.worldY += value * state.mixY;
+    }
+    if (state.mixScaleX !== 0) {
+        const sourceScale = Math.hypot(source.a, source.c) + constraint.scaleX;
+        const boneScale = Math.hypot(bone.a, bone.c);
+        if (constraint.additive) {
+            const scale = 1 + (sourceScale - 1) * state.mixScaleX;
+            bone.a *= scale;
+            bone.c *= scale;
+        }
+        else if (boneScale !== 0) {
+            const scale = 1 + (sourceScale - boneScale) * state.mixScaleX / boneScale;
+            bone.a *= scale;
+            bone.c *= scale;
+        }
+    }
+    if (state.mixScaleY !== 0) {
+        const sourceScale = Math.hypot(source.b, source.d) + constraint.scaleY;
+        const boneScale = Math.hypot(bone.b, bone.d);
+        if (constraint.additive) {
+            const scale = 1 + (sourceScale - 1) * state.mixScaleY;
+            bone.b *= scale;
+            bone.d *= scale;
+        }
+        else if (boneScale !== 0) {
+            const scale = 1 + (sourceScale - boneScale) * state.mixScaleY / boneScale;
+            bone.b *= scale;
+            bone.d *= scale;
+        }
+    }
+    if (state.mixShearY !== 0) {
+        const by = Math.atan2(bone.d, bone.b);
+        let value = (Math.atan2(source.d, source.b) - Math.atan2(source.c, source.a)) * 180 / Math.PI - 90 + constraint.shearY;
+        value = (value + 90) * Math.PI / 180;
+        if (constraint.additive)
+            value -= Math.PI / 2;
+        else
+            value = by + normalizeRadians(value - by + Math.atan2(bone.c, bone.a)) * state.mixShearY;
+        const scale = Math.hypot(bone.b, bone.d);
+        bone.b = Math.cos(value) * scale;
+        bone.d = Math.sin(value) * scale;
+    }
+}
+function applyLocalTransformConstraint(constraint, state, source, bone) {
+    if (state.mixRotate !== 0) {
+        const value = source.rotation + constraint.rotation;
+        bone.rotation += (constraint.additive ? value : value - bone.rotation) * state.mixRotate;
+    }
+    if (state.mixX !== 0) {
+        const value = source.x + constraint.x;
+        bone.x += (constraint.additive ? value : value - bone.x) * state.mixX;
+    }
+    if (state.mixY !== 0) {
+        const value = source.y + constraint.y;
+        bone.y += (constraint.additive ? value : value - bone.y) * state.mixY;
+    }
+    if (state.mixScaleX !== 0) {
+        const value = source.scaleX + constraint.scaleX;
+        if (constraint.additive)
+            bone.scaleX *= 1 + (value - 1) * state.mixScaleX;
+        else
+            bone.scaleX += (value - bone.scaleX) * state.mixScaleX;
+    }
+    if (state.mixScaleY !== 0) {
+        const value = source.scaleY + constraint.scaleY;
+        if (constraint.additive)
+            bone.scaleY *= 1 + (value - 1) * state.mixScaleY;
+        else
+            bone.scaleY += (value - bone.scaleY) * state.mixScaleY;
+    }
+}
+function applyOneBoneIk(constraint, state, poses) {
+    const boneName = constraint.bones[0];
+    if (boneName === undefined)
+        return;
+    const bone = poses.get(boneName);
+    const target = poses.get(constraint.target);
+    if (!bone || !target)
+        return;
+    const parent = bone.data.parent ? poses.get(bone.data.parent) : null;
+    const [targetX, targetY] = parent
+        ? worldToLocal(parent, target.worldX, target.worldY)
+        : [target.worldX, target.worldY];
+    const rotation = Math.atan2(targetY - bone.y, targetX - bone.x) * 180 / Math.PI;
+    bone.rotation += normalizeAngle(rotation - bone.rotation) * state.mix;
+}
+function applyTwoBoneIk(constraint, state, poses) {
+    const parentName = constraint.bones[0];
+    const childName = constraint.bones[1];
+    if (parentName === undefined || childName === undefined)
+        return;
+    const parent = poses.get(parentName);
+    const child = poses.get(childName);
+    const target = poses.get(constraint.target);
+    if (!parent || !child || !target)
+        return;
+    if (parent.data.inherit && parent.data.inherit !== 'normal')
+        return;
+    if (child.data.inherit && child.data.inherit !== 'normal')
+        return;
+    const grandParent = parent.data.parent ? poses.get(parent.data.parent) : null;
+    if (!grandParent)
+        return;
+    let parentScaleX = parent.scaleX;
+    let parentScaleY = parent.scaleY;
+    let childScaleX = child.scaleX;
+    let parentOffset = 0;
+    let childOffset = 0;
+    let sign = 1;
+    if (parentScaleX < 0) {
+        parentScaleX = -parentScaleX;
+        parentOffset = 180;
+        sign = -1;
+    }
+    if (parentScaleY < 0) {
+        parentScaleY = -parentScaleY;
+        sign = -sign;
+    }
+    if (childScaleX < 0) {
+        childScaleX = -childScaleX;
+        childOffset = 180;
+    }
+    let childWorldX = 0;
+    let childWorldY = 0;
+    const uniformScale = Math.abs(parentScaleX - parentScaleY) <= 0.000001;
+    if (!uniformScale) {
+        child.y = 0;
+        childWorldX = parent.a * child.x + parent.worldX;
+        childWorldY = parent.c * child.x + parent.worldY;
+    }
+    else {
+        childWorldX = parent.a * child.x + parent.b * child.y + parent.worldX;
+        childWorldY = parent.c * child.x + parent.d * child.y + parent.worldY;
+    }
+    let a = grandParent.a;
+    let b = grandParent.b;
+    let c = grandParent.c;
+    let d = grandParent.d;
+    let det = a * d - b * c;
+    det = Math.abs(det) <= 0.000001 ? 0 : 1 / det;
+    let x = childWorldX - grandParent.worldX;
+    let y = childWorldY - grandParent.worldY;
+    const dx = (x * d - y * b) * det - parent.x;
+    const dy = (y * a - x * c) * det - parent.y;
+    let length1 = Math.hypot(dx, dy);
+    let length2 = child.data.length * childScaleX;
+    if (length1 < 0.000001) {
+        applyOneBoneIk({ ...constraint, bones: [parentName] }, state, poses);
+        child.rotation = 0;
+        return;
+    }
+    x = target.worldX - grandParent.worldX;
+    y = target.worldY - grandParent.worldY;
+    let targetX = (x * d - y * b) * det - parent.x;
+    let targetY = (y * a - x * c) * det - parent.y;
+    let distanceSq = targetX * targetX + targetY * targetY;
+    if (state.softness !== 0) {
+        const softness = state.softness * parentScaleX * (childScaleX + 1) * 0.5;
+        const targetDistance = Math.sqrt(distanceSq);
+        const softDistance = targetDistance - length1 - length2 * parentScaleX + softness;
+        if (softDistance > 0 && targetDistance > 0.000001) {
+            let percent = Math.min(1, softDistance / (softness * 2)) - 1;
+            percent = (softDistance - softness * (1 - percent * percent)) / targetDistance;
+            targetX -= percent * targetX;
+            targetY -= percent * targetY;
+            distanceSq = targetX * targetX + targetY * targetY;
+        }
+    }
+    const bend = state.bendPositive ? 1 : -1;
+    let angle1 = 0;
+    let angle2 = 0;
+    if (uniformScale) {
+        length2 *= parentScaleX;
+        let cos = (distanceSq - length1 * length1 - length2 * length2) / (2 * length1 * length2);
+        if (cos < -1) {
+            cos = -1;
+            angle2 = Math.PI * bend;
+        }
+        else if (cos > 1) {
+            cos = 1;
+            angle2 = 0;
+        }
+        else {
+            angle2 = Math.acos(cos) * bend;
+        }
+        a = length1 + length2 * cos;
+        b = length2 * Math.sin(angle2);
+        angle1 = Math.atan2(targetY * a - targetX * b, targetX * a + targetY * b);
+    }
+    else {
+        a = parentScaleX * length2;
+        b = parentScaleY * length2;
+        const aa = a * a;
+        const bb = b * b;
+        const targetAngle = Math.atan2(targetY, targetX);
+        c = bb * length1 * length1 + aa * distanceSq - aa * bb;
+        const c1 = -2 * bb * length1;
+        const c2 = bb - aa;
+        d = c1 * c1 - 4 * c2 * c;
+        if (d >= 0) {
+            let q = Math.sqrt(d);
+            if (c1 < 0)
+                q = -q;
+            q = -(c1 + q) * 0.5;
+            let r0 = q / c2;
+            const r1 = c / q;
+            const r = Math.abs(r0) < Math.abs(r1) ? r0 : r1;
+            r0 = distanceSq - r * r;
+            if (r0 >= 0) {
+                y = Math.sqrt(r0) * bend;
+                angle1 = targetAngle - Math.atan2(y, r);
+                angle2 = Math.atan2(y / parentScaleY, (r - length1) / parentScaleX);
+            }
+        }
+        if (!Number.isFinite(angle1) || !Number.isFinite(angle2)) {
+            const minX = length1 - a;
+            const maxX = length1 + a;
+            if (distanceSq <= (minX * minX + maxX * maxX) * 0.5) {
+                angle1 = targetAngle;
+                angle2 = Math.PI * bend;
+            }
+            else {
+                angle1 = targetAngle;
+                angle2 = 0;
+            }
+        }
+    }
+    const childOffsetAngle = Math.atan2(child.y, child.x) * sign;
+    let parentDelta = (angle1 - childOffsetAngle) * 180 / Math.PI + parentOffset - parent.rotation;
+    parent.rotation += normalizeAngle(parentDelta) * state.mix;
+    let childDelta = ((angle2 + childOffsetAngle) * 180 / Math.PI) * sign + childOffset - child.rotation;
+    child.rotation += normalizeAngle(childDelta) * state.mix;
+}
+function updateBoneTree(name, poses, children) {
+    const pose = poses.get(name);
+    if (!pose)
+        return;
+    const parent = pose.data.parent ? poses.get(pose.data.parent) ?? null : null;
+    updateWorldPose(pose, parent);
+    for (const childName of children.get(name) ?? [])
+        updateBoneTree(childName, poses, children);
+}
+function updateDescendantBoneTrees(name, poses, children, blockedRoots = new Set()) {
+    for (const childName of children.get(name) ?? []) {
+        if (blockedRoots.has(childName))
+            continue;
+        updateBoneTree(childName, poses, children);
+    }
+}
+function worldToLocal(bone, worldX, worldY) {
+    const dx = worldX - bone.worldX;
+    const dy = worldY - bone.worldY;
+    const det = bone.a * bone.d - bone.b * bone.c;
+    if (Math.abs(det) < 0.000001)
+        return [dx, dy];
+    return [
+        (dx * bone.d - dy * bone.b) / det,
+        (dy * bone.a - dx * bone.c) / det,
+    ];
+}
+function normalizeAngle(value) {
+    return ((value % 360) + 540) % 360 - 180;
+}
+function normalizeRadians(value) {
+    let angle = value % TWO_PI;
+    if (angle > Math.PI)
+        angle -= TWO_PI;
+    else if (angle < -Math.PI)
+        angle += TWO_PI;
+    return angle;
+}
+function getCurrentAnimationTime(data, component) {
+    const animation = data.animations[component.animation];
+    const duration = getCompiledAnimationDuration(animation);
+    return component.loop && duration > 0 ? (component.elapsed / 1000) % duration : Math.min(component.elapsed / 1000, duration);
+}
+
+export { Spine2DComponent as S, createSpineTimelineSamplerState as a, sampleCompiledTimeline as b, compileSpineTimelines as c, advanceSpineRuntime as d, sampleSpinePosesForBenchmark as e, findCompiledFrameIndex as f, buildSpineVertices as g, createSpineRuntimeForBenchmark as h, loadSpineRuntime as l, sampleCompiledColor as s };
+//# sourceMappingURL=Spine2DRuntime-D9M9LAQR.js.map