@vunk/plus 1.12.2 → 1.13.1

package/components/pixi-frame/index.mjs

@@ -1,1003 +1,465 @@
-import { provide, inject, watchEffect, onBeforeUnmount, defineComponent, useId, ref, onMounted, renderSlot, watch, computed, openBlock, createElementBlock, resolveComponent, createBlock, withCtx, createVNode } from 'vue';
-import { TickerStatus } from '@vunk/shared/enum';
-export { TickerStatus } from '@vunk/shared/enum';
-import { Deferred, sleep } from '@vunk/shared/promise';
-import { c as commonjsGlobal, g as getDefaultExportFromCjs } from '../_commonjsHelpers.mjs';
-import { Application, Sprite, Assets, Texture, ImageSource, BufferImageSource } from 'pixi.js';
-import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
-import { pickObject } from '@vunk/shared/object';
-import { useModelComputed, useDeferred } from '@vunk/core/composables';
-
-var lib = {exports: {}};
-
-(function (module, exports) {
-	(function webpackUniversalModuleDefinition(root, factory) {
-		module.exports = factory();
-	})(commonjsGlobal, function() {
-	return /******/ (function(modules) { // webpackBootstrap
-	/******/ 	// The module cache
-	/******/ 	var installedModules = {};
-
-	/******/ 	// The require function
-	/******/ 	function __webpack_require__(moduleId) {
-
-	/******/ 		// Check if module is in cache
-	/******/ 		if(installedModules[moduleId])
-	/******/ 			return installedModules[moduleId].exports;
-
-	/******/ 		// Create a new module (and put it into the cache)
-	/******/ 		var module = installedModules[moduleId] = {
-	/******/ 			exports: {},
-	/******/ 			id: moduleId,
-	/******/ 			loaded: false
-	/******/ 		};
-
-	/******/ 		// Execute the module function
-	/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-
-	/******/ 		// Flag the module as loaded
-	/******/ 		module.loaded = true;
-
-	/******/ 		// Return the exports of the module
-	/******/ 		return module.exports;
-	/******/ 	}
-
-
-	/******/ 	// expose the modules object (__webpack_modules__)
-	/******/ 	__webpack_require__.m = modules;
-
-	/******/ 	// expose the module cache
-	/******/ 	__webpack_require__.c = installedModules;
-
-	/******/ 	// __webpack_public_path__
-	/******/ 	__webpack_require__.p = "";
-
-	/******/ 	// Load entry module and return exports
-	/******/ 	return __webpack_require__(0);
-	/******/ })
-	/************************************************************************/
-	/******/ ([
-	/* 0 */
-	/***/ (function(module, exports, __webpack_require__) {
-
-		Object.defineProperty(exports, "__esModule", {
-		    value: true
-		});
-		exports.isNotPNG = isNotPNG;
-		exports.isNotAPNG = isNotAPNG;
-		exports.default = parseAPNG;
-
-		var _crc = __webpack_require__(1);
-
-		var _crc2 = _interopRequireDefault(_crc);
-
-		var _structs = __webpack_require__(2);
-
-		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-		var errNotPNG = new Error('Not a PNG');
-		var errNotAPNG = new Error('Not an animated PNG');
-
-		function isNotPNG(err) {
-		    return err === errNotPNG;
-		}
-		function isNotAPNG(err) {
-		    return err === errNotAPNG;
-		}
-
-		// '\x89PNG\x0d\x0a\x1a\x0a'
-		var PNGSignature = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-
-		/**
-		 * Parse APNG data
-		 * @param {ArrayBuffer} buffer
-		 * @return {APNG|Error}
-		 */
-		function parseAPNG(buffer) {
-		    var bytes = new Uint8Array(buffer);
-
-		    if (Array.prototype.some.call(PNGSignature, function (b, i) {
-		        return b !== bytes[i];
-		    })) {
-		        return errNotPNG;
-		    }
-
-		    // fast animation test
-		    var isAnimated = false;
-		    eachChunk(bytes, function (type) {
-		        return !(isAnimated = type === 'acTL');
-		    });
-		    if (!isAnimated) {
-		        return errNotAPNG;
-		    }
-
-		    var preDataParts = [],
-		        postDataParts = [];
-		    var headerDataBytes = null,
-		        frame = null,
-		        frameNumber = 0,
-		        apng = new _structs.APNG();
-
-		    eachChunk(bytes, function (type, bytes, off, length) {
-		        var dv = new DataView(bytes.buffer);
-		        switch (type) {
-		            case 'IHDR':
-		                headerDataBytes = bytes.subarray(off + 8, off + 8 + length);
-		                apng.width = dv.getUint32(off + 8);
-		                apng.height = dv.getUint32(off + 12);
-		                break;
-		            case 'acTL':
-		                apng.numPlays = dv.getUint32(off + 8 + 4);
-		                break;
-		            case 'fcTL':
-		                if (frame) {
-		                    apng.frames.push(frame);
-		                    frameNumber++;
-		                }
-		                frame = new _structs.Frame();
-		                frame.width = dv.getUint32(off + 8 + 4);
-		                frame.height = dv.getUint32(off + 8 + 8);
-		                frame.left = dv.getUint32(off + 8 + 12);
-		                frame.top = dv.getUint32(off + 8 + 16);
-		                var delayN = dv.getUint16(off + 8 + 20);
-		                var delayD = dv.getUint16(off + 8 + 22);
-		                if (delayD === 0) {
-		                    delayD = 100;
-		                }
-		                frame.delay = 1000 * delayN / delayD;
-		                // https://bugzilla.mozilla.org/show_bug.cgi?id=125137
-		                // https://bugzilla.mozilla.org/show_bug.cgi?id=139677
-		                // https://bugzilla.mozilla.org/show_bug.cgi?id=207059
-		                if (frame.delay <= 10) {
-		                    frame.delay = 100;
-		                }
-		                apng.playTime += frame.delay;
-		                frame.disposeOp = dv.getUint8(off + 8 + 24);
-		                frame.blendOp = dv.getUint8(off + 8 + 25);
-		                frame.dataParts = [];
-		                if (frameNumber === 0 && frame.disposeOp === 2) {
-		                    frame.disposeOp = 1;
-		                }
-		                break;
-		            case 'fdAT':
-		                if (frame) {
-		                    frame.dataParts.push(bytes.subarray(off + 8 + 4, off + 8 + length));
-		                }
-		                break;
-		            case 'IDAT':
-		                if (frame) {
-		                    frame.dataParts.push(bytes.subarray(off + 8, off + 8 + length));
-		                }
-		                break;
-		            case 'IEND':
-		                postDataParts.push(subBuffer(bytes, off, 12 + length));
-		                break;
-		            default:
-		                preDataParts.push(subBuffer(bytes, off, 12 + length));
-		        }
-		    });
-
-		    if (frame) {
-		        apng.frames.push(frame);
-		    }
-
-		    if (apng.frames.length == 0) {
-		        return errNotAPNG;
-		    }
-
-		    var preBlob = new Blob(preDataParts),
-		        postBlob = new Blob(postDataParts);
-
-		    apng.frames.forEach(function (frame) {
-		        var bb = [];
-		        bb.push(PNGSignature);
-		        headerDataBytes.set(makeDWordArray(frame.width), 0);
-		        headerDataBytes.set(makeDWordArray(frame.height), 4);
-		        bb.push(makeChunkBytes('IHDR', headerDataBytes));
-		        bb.push(preBlob);
-		        frame.dataParts.forEach(function (p) {
-		            return bb.push(makeChunkBytes('IDAT', p));
-		        });
-		        bb.push(postBlob);
-		        frame.imageData = new Blob(bb, { 'type': 'image/png' });
-		        delete frame.dataParts;
-		        bb = null;
-		    });
-
-		    return apng;
-		}
-
-		/**
-		 * @param {Uint8Array} bytes
-		 * @param {function(string, Uint8Array, int, int): boolean} callback
-		 */
-		function eachChunk(bytes, callback) {
-		    var dv = new DataView(bytes.buffer);
-		    var off = 8,
-		        type = void 0,
-		        length = void 0,
-		        res = void 0;
-		    do {
-		        length = dv.getUint32(off);
-		        type = readString(bytes, off + 4, 4);
-		        res = callback(type, bytes, off, length);
-		        off += 12 + length;
-		    } while (res !== false && type != 'IEND' && off < bytes.length);
-		}
-
-		/**
-		 *
-		 * @param {Uint8Array} bytes
-		 * @param {number} off
-		 * @param {number} length
-		 * @return {string}
-		 */
-		function readString(bytes, off, length) {
-		    var chars = Array.prototype.slice.call(bytes.subarray(off, off + length));
-		    return String.fromCharCode.apply(String, chars);
-		}
-
-		/**
-		 *
-		 * @param {string} x
-		 * @return {Uint8Array}
-		 */
-		function makeStringArray(x) {
-		    var res = new Uint8Array(x.length);
-		    for (var i = 0; i < x.length; i++) {
-		        res[i] = x.charCodeAt(i);
-		    }
-		    return res;
-		}
-
-		/**
-		 * @param {Uint8Array} bytes
-		 * @param {int} start
-		 * @param {int} length
-		 * @return {Uint8Array}
-		 */
-		function subBuffer(bytes, start, length) {
-		    var a = new Uint8Array(length);
-		    a.set(bytes.subarray(start, start + length));
-		    return a;
-		}
-
-		/**
-		 * @param {string} type
-		 * @param {Uint8Array} dataBytes
-		 * @return {Uint8Array}
-		 */
-		var makeChunkBytes = function makeChunkBytes(type, dataBytes) {
-		    var crcLen = type.length + dataBytes.length;
-		    var bytes = new Uint8Array(crcLen + 8);
-		    var dv = new DataView(bytes.buffer);
-
-		    dv.setUint32(0, dataBytes.length);
-		    bytes.set(makeStringArray(type), 4);
-		    bytes.set(dataBytes, 8);
-		    var crc = (0, _crc2.default)(bytes, 4, crcLen);
-		    dv.setUint32(crcLen + 4, crc);
-		    return bytes;
-		};
-
-		var makeDWordArray = function makeDWordArray(x) {
-		    return new Uint8Array([x >>> 24 & 0xff, x >>> 16 & 0xff, x >>> 8 & 0xff, x & 0xff]);
-		};
-
-	/***/ }),
-	/* 1 */
-	/***/ (function(module, exports) {
-
-		Object.defineProperty(exports, "__esModule", {
-		  value: true
-		});
-
-		exports.default = function (bytes) {
-		  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-		  var length = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : bytes.length - start;
-
-		  var crc = -1;
-		  for (var _i = start, l = start + length; _i < l; _i++) {
-		    crc = crc >>> 8 ^ table[(crc ^ bytes[_i]) & 0xFF];
-		  }
-		  return crc ^ -1;
-		};
-
-		var table = new Uint32Array(256);
-
-		for (var i = 0; i < 256; i++) {
-		  var c = i;
-		  for (var k = 0; k < 8; k++) {
-		    c = (c & 1) !== 0 ? 0xEDB88320 ^ c >>> 1 : c >>> 1;
-		  }
-		  table[i] = c;
-		}
-
-		/**
-		 *
-		 * @param {Uint8Array} bytes
-		 * @param {number} start
-		 * @param {number} length
-		 * @return {number}
-		 */
-
-	/***/ }),
-	/* 2 */
-	/***/ (function(module, exports, __webpack_require__) {
-
-		Object.defineProperty(exports, "__esModule", {
-		    value: true
-		});
-		exports.Frame = exports.APNG = undefined;
-
-		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-		var _player = __webpack_require__(3);
-
-		var _player2 = _interopRequireDefault(_player);
-
-		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-		/**
-		 * @property {number} currFrameNumber
-		 * @property {Frame} currFrame
-		 * @property {boolean} paused
-		 * @property {boolean} ended
-		 */
-		exports.APNG = function () {
-		    function APNG() {
-		        _classCallCheck(this, APNG);
-
-		        this.width = 0;
-		        this.height = 0;
-		        this.numPlays = 0;
-		        this.playTime = 0;
-		        this.frames = [];
-		    }
-		    /** @type {number} */
-
-		    /** @type {number} */
-
-		    /** @type {number} */
-
-		    /** @type {number} */
-
-		    /** @type {Frame[]} */
-
-
-		    _createClass(APNG, [{
-		        key: 'createImages',
-
-
-		        /**
-		         *
-		         * @return {Promise.<*>}
-		         */
-		        value: function createImages() {
-		            return Promise.all(this.frames.map(function (f) {
-		                return f.createImage();
-		            }));
-		        }
-
-		        /**
-		         *
-		         * @param {CanvasRenderingContext2D} context
-		         * @param {boolean} autoPlay
-		         * @return {Promise.<Player>}
-		         */
-
-		    }, {
-		        key: 'getPlayer',
-		        value: function getPlayer(context) {
-		            var _this = this;
-
-		            var autoPlay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-
-		            return this.createImages().then(function () {
-		                return new _player2.default(_this, context, autoPlay);
-		            });
-		        }
-		    }]);
-
-		    return APNG;
-		}();
-
-		exports.Frame = function () {
-		    function Frame() {
-		        _classCallCheck(this, Frame);
-
-		        this.left = 0;
-		        this.top = 0;
-		        this.width = 0;
-		        this.height = 0;
-		        this.delay = 0;
-		        this.disposeOp = 0;
-		        this.blendOp = 0;
-		        this.imageData = null;
-		        this.imageElement = null;
-		    }
-		    /** @type {number} */
-
-		    /** @type {number} */
-
-		    /** @type {number} */
-
-		    /** @type {number} */
-
-		    /** @type {number} */
-
-		    /** @type {number} */
-
-		    /** @type {number} */
-
-		    /** @type {Blob} */
-
-		    /** @type {HTMLImageElement} */
-
-
-		    _createClass(Frame, [{
-		        key: 'createImage',
-		        value: function createImage() {
-		            var _this2 = this;
-
-		            if (this.imageElement) {
-		                return Promise.resolve();
-		            }
-		            return new Promise(function (resolve, reject) {
-		                var url = URL.createObjectURL(_this2.imageData);
-		                _this2.imageElement = document.createElement('img');
-		                _this2.imageElement.onload = function () {
-		                    URL.revokeObjectURL(url);
-		                    resolve();
-		                };
-		                _this2.imageElement.onerror = function () {
-		                    URL.revokeObjectURL(url);
-		                    _this2.imageElement = null;
-		                    reject(new Error("Image creation error"));
-		                };
-		                _this2.imageElement.src = url;
-		            });
-		        }
-		    }]);
-
-		    return Frame;
-		}();
-
-	/***/ }),
-	/* 3 */
-	/***/ (function(module, exports, __webpack_require__) {
-
-		Object.defineProperty(exports, "__esModule", {
-		    value: true
-		});
-
-		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-		var _events = __webpack_require__(4);
-
-		var _events2 = _interopRequireDefault(_events);
-
-		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-		var _class = function (_EventEmitter) {
-		    _inherits(_class, _EventEmitter);
-
-		    /**
-		     * @param {APNG} apng
-		     * @param {CanvasRenderingContext2D} context
-		     * @param {boolean} autoPlay
-		     */
-
-		    /** @type {number} */
-
-
-		    /** @type {boolean} */
-
-		    /** @type {ImageData} */
-
-
-		    /** @type {APNG} */
-
-		    /** @type {CanvasRenderingContext2D} */
-		    function _class(apng, context, autoPlay) {
-		        _classCallCheck(this, _class);
-
-		        var _this = _possibleConstructorReturn(this, (_class.__proto__ || Object.getPrototypeOf(_class)).call(this));
-
-		        _this.playbackRate = 1.0;
-		        _this._currentFrameNumber = 0;
-		        _this._ended = false;
-		        _this._paused = true;
-		        _this._numPlays = 0;
-		        _this._rafId = null;
-
-		        _this._apng = apng;
-		        _this.context = context;
-		        _this.stop();
-		        if (autoPlay) {
-		            _this.play();
-		        }
-		        return _this;
-		    }
-
-		    /**
-		     *
-		     * @return {number}
-		     */
-
-		    /** @type {number|null} */
-
-		    /** @type {boolean} */
-
-		    /** @type {number} */
-
-		    /** @type {Frame} */
-
-		    /** @type {number} */
-
-
-		    _createClass(_class, [{
-		        key: 'renderNextFrame',
-		        value: function renderNextFrame() {
-		            this._currentFrameNumber = (this._currentFrameNumber + 1) % this._apng.frames.length;
-		            if (this._currentFrameNumber === this._apng.frames.length - 1) {
-		                this._numPlays++;
-		                if (this._apng.numPlays !== 0 && this._numPlays >= this._apng.numPlays) {
-		                    this._ended = true;
-		                    this._paused = true;
-		                }
-		            }
-
-		            if (this._prevFrame && this._prevFrame.disposeOp == 1) {
-		                this.context.clearRect(this._prevFrame.left, this._prevFrame.top, this._prevFrame.width, this._prevFrame.height);
-		            } else if (this._prevFrame && this._prevFrame.disposeOp == 2) {
-		                this.context.putImageData(this._prevFrameData, this._prevFrame.left, this._prevFrame.top);
-		            }
-
-		            var frame = this.currentFrame;
-		            this._prevFrame = frame;
-		            this._prevFrameData = null;
-		            if (frame.disposeOp == 2) {
-		                this._prevFrameData = this.context.getImageData(frame.left, frame.top, frame.width, frame.height);
-		            }
-		            if (frame.blendOp == 0) {
-		                this.context.clearRect(frame.left, frame.top, frame.width, frame.height);
-		            }
-
-		            this.context.drawImage(frame.imageElement, frame.left, frame.top);
-
-		            this.emit('frame', this._currentFrameNumber);
-		            if (this._ended) {
-		                this.emit('end');
-		            }
-		        }
-
-		        // playback
-
-		    }, {
-		        key: 'play',
-		        value: function play() {
-		            var _this2 = this;
-
-		            if (this._rafId) {
-		                cancelAnimationFrame(this._rafId);
-		            }
-
-		            this.emit('play');
-
-		            if (this._ended) {
-		                this.stop();
-		            }
-		            this._paused = false;
-
-		            var nextRenderTime = performance.now() + this.currentFrame.delay / this.playbackRate;
-		            var tick = function tick(now) {
-		                if (_this2._ended || _this2._paused) {
-		                    return;
-		                }
-		                if (now >= nextRenderTime) {
-		                    while (now - nextRenderTime >= _this2._apng.playTime / _this2.playbackRate) {
-		                        nextRenderTime += _this2._apng.playTime / _this2.playbackRate;
-		                        _this2._numPlays++;
-		                    }
-		                    do {
-		                        _this2.renderNextFrame();
-		                        nextRenderTime += _this2.currentFrame.delay / _this2.playbackRate;
-		                    } while (!_this2._ended && !_this2._paused && now > nextRenderTime);
-		                }
-		                _this2._rafId = requestAnimationFrame(tick);
-		            };
-		            this._rafId = requestAnimationFrame(tick);
-		        }
-		    }, {
-		        key: 'pause',
-		        value: function pause() {
-		            if (!this._paused) {
-		                if (this._rafId) {
-		                    cancelAnimationFrame(this._rafId);
-		                    this._rafId = null;
-		                }
-		                this.emit('pause');
-		                this._paused = true;
-		            }
-		        }
-		    }, {
-		        key: 'stop',
-		        value: function stop() {
-		            if (this._rafId) {
-		                cancelAnimationFrame(this._rafId);
-		                this._rafId = null;
-		            }
-		            this.emit('stop');
-		            this._numPlays = 0;
-		            this._ended = false;
-		            this._paused = true;
-		            // render first frame
-		            this._currentFrameNumber = -1;
-		            this.context.clearRect(0, 0, this._apng.width, this._apng.height);
-		            this.renderNextFrame();
-		        }
-		    }, {
-		        key: 'currentFrameNumber',
-		        get: function get() {
-		            return this._currentFrameNumber;
-		        }
-
-		        /**
-		         *
-		         * @return {Frame}
-		         */
-
-		    }, {
-		        key: 'currentFrame',
-		        get: function get() {
-		            return this._apng.frames[this._currentFrameNumber];
-		        }
-		    }, {
-		        key: 'paused',
-		        get: function get() {
-		            return this._paused;
-		        }
-		    }, {
-		        key: 'ended',
-		        get: function get() {
-		            return this._ended;
-		        }
-		    }]);
-
-		    return _class;
-		}(_events2.default);
-
-		exports.default = _class;
-
-	/***/ }),
-	/* 4 */
-	/***/ (function(module, exports) {
-
-		// Copyright Joyent, Inc. and other Node contributors.
-		//
-		// Permission is hereby granted, free of charge, to any person obtaining a
-		// copy of this software and associated documentation files (the
-		// "Software"), to deal in the Software without restriction, including
-		// without limitation the rights to use, copy, modify, merge, publish,
-		// distribute, sublicense, and/or sell copies of the Software, and to permit
-		// persons to whom the Software is furnished to do so, subject to the
-		// following conditions:
-		//
-		// The above copyright notice and this permission notice shall be included
-		// in all copies or substantial portions of the Software.
-		//
-		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-		// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-		// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-		// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-		// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-		// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-		// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-		function EventEmitter() {
-		  this._events = this._events || {};
-		  this._maxListeners = this._maxListeners || undefined;
-		}
-		module.exports = EventEmitter;
-
-		// Backwards-compat with node 0.10.x
-		EventEmitter.EventEmitter = EventEmitter;
-
-		EventEmitter.prototype._events = undefined;
-		EventEmitter.prototype._maxListeners = undefined;
-
-		// By default EventEmitters will print a warning if more than 10 listeners are
-		// added to it. This is a useful default which helps finding memory leaks.
-		EventEmitter.defaultMaxListeners = 10;
-
-		// Obviously not all Emitters should be limited to 10. This function allows
-		// that to be increased. Set to zero for unlimited.
-		EventEmitter.prototype.setMaxListeners = function(n) {
-		  if (!isNumber(n) || n < 0 || isNaN(n))
-		    throw TypeError('n must be a positive number');
-		  this._maxListeners = n;
-		  return this;
-		};
-
-		EventEmitter.prototype.emit = function(type) {
-		  var er, handler, len, args, i, listeners;
-
-		  if (!this._events)
-		    this._events = {};
-
-		  // If there is no 'error' event listener then throw.
-		  if (type === 'error') {
-		    if (!this._events.error ||
-		        (isObject(this._events.error) && !this._events.error.length)) {
-		      er = arguments[1];
-		      if (er instanceof Error) {
-		        throw er; // Unhandled 'error' event
-		      } else {
-		        // At least give some kind of context to the user
-		        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
-		        err.context = er;
-		        throw err;
-		      }
-		    }
-		  }
-
-		  handler = this._events[type];
-
-		  if (isUndefined(handler))
-		    return false;
-
-		  if (isFunction(handler)) {
-		    switch (arguments.length) {
-		      // fast cases
-		      case 1:
-		        handler.call(this);
-		        break;
-		      case 2:
-		        handler.call(this, arguments[1]);
-		        break;
-		      case 3:
-		        handler.call(this, arguments[1], arguments[2]);
-		        break;
-		      // slower
-		      default:
-		        args = Array.prototype.slice.call(arguments, 1);
-		        handler.apply(this, args);
-		    }
-		  } else if (isObject(handler)) {
-		    args = Array.prototype.slice.call(arguments, 1);
-		    listeners = handler.slice();
-		    len = listeners.length;
-		    for (i = 0; i < len; i++)
-		      listeners[i].apply(this, args);
-		  }
-
-		  return true;
-		};
-
-		EventEmitter.prototype.addListener = function(type, listener) {
-		  var m;
-
-		  if (!isFunction(listener))
-		    throw TypeError('listener must be a function');
-
-		  if (!this._events)
-		    this._events = {};
-
-		  // To avoid recursion in the case that type === "newListener"! Before
-		  // adding it to the listeners, first emit "newListener".
-		  if (this._events.newListener)
-		    this.emit('newListener', type,
-		              isFunction(listener.listener) ?
-		              listener.listener : listener);
-
-		  if (!this._events[type])
-		    // Optimize the case of one listener. Don't need the extra array object.
-		    this._events[type] = listener;
-		  else if (isObject(this._events[type]))
-		    // If we've already got an array, just append.
-		    this._events[type].push(listener);
-		  else
-		    // Adding the second element, need to change to array.
-		    this._events[type] = [this._events[type], listener];
-
-		  // Check for listener leak
-		  if (isObject(this._events[type]) && !this._events[type].warned) {
-		    if (!isUndefined(this._maxListeners)) {
-		      m = this._maxListeners;
-		    } else {
-		      m = EventEmitter.defaultMaxListeners;
-		    }
-
-		    if (m && m > 0 && this._events[type].length > m) {
-		      this._events[type].warned = true;
-		      console.error('(node) warning: possible EventEmitter memory ' +
-		                    'leak detected. %d listeners added. ' +
-		                    'Use emitter.setMaxListeners() to increase limit.',
-		                    this._events[type].length);
-		      if (typeof console.trace === 'function') {
-		        // not supported in IE 10
-		        console.trace();
-		      }
-		    }
-		  }
-
-		  return this;
-		};
-
-		EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-
-		EventEmitter.prototype.once = function(type, listener) {
-		  if (!isFunction(listener))
-		    throw TypeError('listener must be a function');
-
-		  var fired = false;
-
-		  function g() {
-		    this.removeListener(type, g);
-
-		    if (!fired) {
-		      fired = true;
-		      listener.apply(this, arguments);
-		    }
-		  }
-
-		  g.listener = listener;
-		  this.on(type, g);
-
-		  return this;
-		};
-
-		// emits a 'removeListener' event iff the listener was removed
-		EventEmitter.prototype.removeListener = function(type, listener) {
-		  var list, position, length, i;
-
-		  if (!isFunction(listener))
-		    throw TypeError('listener must be a function');
-
-		  if (!this._events || !this._events[type])
-		    return this;
-
-		  list = this._events[type];
-		  length = list.length;
-		  position = -1;
-
-		  if (list === listener ||
-		      (isFunction(list.listener) && list.listener === listener)) {
-		    delete this._events[type];
-		    if (this._events.removeListener)
-		      this.emit('removeListener', type, listener);
-
-		  } else if (isObject(list)) {
-		    for (i = length; i-- > 0;) {
-		      if (list[i] === listener ||
-		          (list[i].listener && list[i].listener === listener)) {
-		        position = i;
-		        break;
-		      }
-		    }
-
-		    if (position < 0)
-		      return this;
-
-		    if (list.length === 1) {
-		      list.length = 0;
-		      delete this._events[type];
-		    } else {
-		      list.splice(position, 1);
-		    }
-
-		    if (this._events.removeListener)
-		      this.emit('removeListener', type, listener);
-		  }
-
-		  return this;
-		};
-
-		EventEmitter.prototype.removeAllListeners = function(type) {
-		  var key, listeners;
-
-		  if (!this._events)
-		    return this;
-
-		  // not listening for removeListener, no need to emit
-		  if (!this._events.removeListener) {
-		    if (arguments.length === 0)
-		      this._events = {};
-		    else if (this._events[type])
-		      delete this._events[type];
-		    return this;
-		  }
-
-		  // emit removeListener for all listeners on all events
-		  if (arguments.length === 0) {
-		    for (key in this._events) {
-		      if (key === 'removeListener') continue;
-		      this.removeAllListeners(key);
-		    }
-		    this.removeAllListeners('removeListener');
-		    this._events = {};
-		    return this;
-		  }
-
-		  listeners = this._events[type];
-
-		  if (isFunction(listeners)) {
-		    this.removeListener(type, listeners);
-		  } else if (listeners) {
-		    // LIFO order
-		    while (listeners.length)
-		      this.removeListener(type, listeners[listeners.length - 1]);
-		  }
-		  delete this._events[type];
-
-		  return this;
-		};
-
-		EventEmitter.prototype.listeners = function(type) {
-		  var ret;
-		  if (!this._events || !this._events[type])
-		    ret = [];
-		  else if (isFunction(this._events[type]))
-		    ret = [this._events[type]];
-		  else
-		    ret = this._events[type].slice();
-		  return ret;
-		};
-
-		EventEmitter.prototype.listenerCount = function(type) {
-		  if (this._events) {
-		    var evlistener = this._events[type];
-
-		    if (isFunction(evlistener))
-		      return 1;
-		    else if (evlistener)
-		      return evlistener.length;
-		  }
-		  return 0;
-		};
-
-		EventEmitter.listenerCount = function(emitter, type) {
-		  return emitter.listenerCount(type);
-		};
-
-		function isFunction(arg) {
-		  return typeof arg === 'function';
-		}
-
-		function isNumber(arg) {
-		  return typeof arg === 'number';
-		}
-
-		function isObject(arg) {
-		  return typeof arg === 'object' && arg !== null;
-		}
-
-		function isUndefined(arg) {
-		  return arg === void 0;
-		}
-
-
-	/***/ })
-	/******/ ])
-	});
-} (lib));
-
-var libExports = lib.exports;
-var parseAPNG = /*@__PURE__*/getDefaultExportFromCjs(libExports);
-
-const props = {
+import { inject as fe, provide as de, watchEffect as B, onBeforeUnmount as S, defineComponent as C, useId as ne, ref as U, onMounted as ae, renderSlot as V, watch as Q, computed as J, createElementBlock as me, openBlock as H, resolveComponent as K, createBlock as Y, withCtx as he, createVNode as ve } from "vue";
+import { TickerStatus as m } from "@vunk/shared/enum";
+import { TickerStatus as Ye } from "@vunk/shared/enum";
+import { Deferred as ge, sleep as Z } from "@vunk/shared/promise";
+import { Application as _e, Sprite as ye, Assets as R, Texture as ee, ImageSource as oe, BufferImageSource as we } from "pixi.js";
+import { pickObject as se } from "@vunk/shared/object";
+import { useModelComputed as ie, useDeferred as be } from "@vunk/core/composables";
+import { _ as xe } from "../_plugin-vue_export-helper-CHgC5LLL.mjs";
+function Fe(o) {
+  return o && o.__esModule && Object.prototype.hasOwnProperty.call(o, "default") ? o.default : o;
+}
+var X = { exports: {} }, ke = X.exports, ue;
+function Pe() {
+  return ue || (ue = 1, (function(o, P) {
+    (function(r, p) {
+      o.exports = p();
+    })(ke, function() {
+      return (
+        /******/
+        (function(t) {
+          var r = {};
+          function p(l) {
+            if (r[l])
+              return r[l].exports;
+            var v = r[l] = {
+              /******/
+              exports: {},
+              /******/
+              id: l,
+              /******/
+              loaded: !1
+              /******/
+            };
+            return t[l].call(v.exports, v, v.exports, p), v.loaded = !0, v.exports;
+          }
+          return p.m = t, p.c = r, p.p = "", p(0);
+        })([
+          /* 0 */
+          /***/
+          (function(t, r, p) {
+            Object.defineProperty(r, "__esModule", {
+              value: !0
+            }), r.isNotPNG = a, r.isNotAPNG = u, r.default = s;
+            var l = p(1), v = w(l), _ = p(2);
+            function w(f) {
+              return f && f.__esModule ? f : { default: f };
+            }
+            var e = new Error("Not a PNG"), n = new Error("Not an animated PNG");
+            function a(f) {
+              return f === e;
+            }
+            function u(f) {
+              return f === n;
+            }
+            var i = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+            function s(f) {
+              var g = new Uint8Array(f);
+              if (Array.prototype.some.call(i, function(T, D) {
+                return T !== g[D];
+              }))
+                return e;
+              var c = !1;
+              if (b(g, function(T) {
+                return !(c = T === "acTL");
+              }), !c)
+                return n;
+              var x = [], I = [], N = null, k = null, M = 0, O = new _.APNG();
+              if (b(g, function(T, D, E, $) {
+                var L = new DataView(D.buffer);
+                switch (T) {
+                  case "IHDR":
+                    N = D.subarray(E + 8, E + 8 + $), O.width = L.getUint32(E + 8), O.height = L.getUint32(E + 12);
+                    break;
+                  case "acTL":
+                    O.numPlays = L.getUint32(E + 8 + 4);
+                    break;
+                  case "fcTL":
+                    k && (O.frames.push(k), M++), k = new _.Frame(), k.width = L.getUint32(E + 8 + 4), k.height = L.getUint32(E + 8 + 8), k.left = L.getUint32(E + 8 + 12), k.top = L.getUint32(E + 8 + 16);
+                    var pe = L.getUint16(E + 8 + 20), te = L.getUint16(E + 8 + 22);
+                    te === 0 && (te = 100), k.delay = 1e3 * pe / te, k.delay <= 10 && (k.delay = 100), O.playTime += k.delay, k.disposeOp = L.getUint8(E + 8 + 24), k.blendOp = L.getUint8(E + 8 + 25), k.dataParts = [], M === 0 && k.disposeOp === 2 && (k.disposeOp = 1);
+                    break;
+                  case "fdAT":
+                    k && k.dataParts.push(D.subarray(E + 8 + 4, E + 8 + $));
+                    break;
+                  case "IDAT":
+                    k && k.dataParts.push(D.subarray(E + 8, E + 8 + $));
+                    break;
+                  case "IEND":
+                    I.push(y(D, E, 12 + $));
+                    break;
+                  default:
+                    x.push(y(D, E, 12 + $));
+                }
+              }), k && O.frames.push(k), O.frames.length == 0)
+                return n;
+              var G = new Blob(x), W = new Blob(I);
+              return O.frames.forEach(function(T) {
+                var D = [];
+                D.push(i), N.set(d(T.width), 0), N.set(d(T.height), 4), D.push(F("IHDR", N)), D.push(G), T.dataParts.forEach(function(E) {
+                  return D.push(F("IDAT", E));
+                }), D.push(W), T.imageData = new Blob(D, { type: "image/png" }), delete T.dataParts, D = null;
+              }), O;
+            }
+            function b(f, g) {
+              var c = new DataView(f.buffer), x = 8, I = void 0, N = void 0, k = void 0;
+              do
+                N = c.getUint32(x), I = h(f, x + 4, 4), k = g(I, f, x, N), x += 12 + N;
+              while (k !== !1 && I != "IEND" && x < f.length);
+            }
+            function h(f, g, c) {
+              var x = Array.prototype.slice.call(f.subarray(g, g + c));
+              return String.fromCharCode.apply(String, x);
+            }
+            function A(f) {
+              for (var g = new Uint8Array(f.length), c = 0; c < f.length; c++)
+                g[c] = f.charCodeAt(c);
+              return g;
+            }
+            function y(f, g, c) {
+              var x = new Uint8Array(c);
+              return x.set(f.subarray(g, g + c)), x;
+            }
+            var F = function(g, c) {
+              var x = g.length + c.length, I = new Uint8Array(x + 8), N = new DataView(I.buffer);
+              N.setUint32(0, c.length), I.set(A(g), 4), I.set(c, 8);
+              var k = (0, v.default)(I, 4, x);
+              return N.setUint32(x + 4, k), I;
+            }, d = function(g) {
+              return new Uint8Array([g >>> 24 & 255, g >>> 16 & 255, g >>> 8 & 255, g & 255]);
+            };
+          }),
+          /* 1 */
+          /***/
+          (function(t, r) {
+            Object.defineProperty(r, "__esModule", {
+              value: !0
+            }), r.default = function(w) {
+              for (var e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0, n = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : w.length - e, a = -1, u = e, i = e + n; u < i; u++)
+                a = a >>> 8 ^ p[(a ^ w[u]) & 255];
+              return a ^ -1;
+            };
+            for (var p = new Uint32Array(256), l = 0; l < 256; l++) {
+              for (var v = l, _ = 0; _ < 8; _++)
+                v = (v & 1) !== 0 ? 3988292384 ^ v >>> 1 : v >>> 1;
+              p[l] = v;
+            }
+          }),
+          /* 2 */
+          /***/
+          (function(t, r, p) {
+            Object.defineProperty(r, "__esModule", {
+              value: !0
+            }), r.Frame = r.APNG = void 0;
+            var l = /* @__PURE__ */ (function() {
+              function n(a, u) {
+                for (var i = 0; i < u.length; i++) {
+                  var s = u[i];
+                  s.enumerable = s.enumerable || !1, s.configurable = !0, "value" in s && (s.writable = !0), Object.defineProperty(a, s.key, s);
+                }
+              }
+              return function(a, u, i) {
+                return u && n(a.prototype, u), i && n(a, i), a;
+              };
+            })(), v = p(3), _ = w(v);
+            function w(n) {
+              return n && n.__esModule ? n : { default: n };
+            }
+            function e(n, a) {
+              if (!(n instanceof a))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            r.APNG = (function() {
+              function n() {
+                e(this, n), this.width = 0, this.height = 0, this.numPlays = 0, this.playTime = 0, this.frames = [];
+              }
+              return l(n, [{
+                key: "createImages",
+                /**
+                 *
+                 * @return {Promise.<*>}
+                 */
+                value: function() {
+                  return Promise.all(this.frames.map(function(u) {
+                    return u.createImage();
+                  }));
+                }
+                /**
+                 *
+                 * @param {CanvasRenderingContext2D} context
+                 * @param {boolean} autoPlay
+                 * @return {Promise.<Player>}
+                 */
+              }, {
+                key: "getPlayer",
+                value: function(u) {
+                  var i = this, s = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+                  return this.createImages().then(function() {
+                    return new _.default(i, u, s);
+                  });
+                }
+              }]), n;
+            })(), r.Frame = (function() {
+              function n() {
+                e(this, n), this.left = 0, this.top = 0, this.width = 0, this.height = 0, this.delay = 0, this.disposeOp = 0, this.blendOp = 0, this.imageData = null, this.imageElement = null;
+              }
+              return l(n, [{
+                key: "createImage",
+                value: function() {
+                  var u = this;
+                  return this.imageElement ? Promise.resolve() : new Promise(function(i, s) {
+                    var b = URL.createObjectURL(u.imageData);
+                    u.imageElement = document.createElement("img"), u.imageElement.onload = function() {
+                      URL.revokeObjectURL(b), i();
+                    }, u.imageElement.onerror = function() {
+                      URL.revokeObjectURL(b), u.imageElement = null, s(new Error("Image creation error"));
+                    }, u.imageElement.src = b;
+                  });
+                }
+              }]), n;
+            })();
+          }),
+          /* 3 */
+          /***/
+          (function(t, r, p) {
+            Object.defineProperty(r, "__esModule", {
+              value: !0
+            });
+            var l = /* @__PURE__ */ (function() {
+              function i(s, b) {
+                for (var h = 0; h < b.length; h++) {
+                  var A = b[h];
+                  A.enumerable = A.enumerable || !1, A.configurable = !0, "value" in A && (A.writable = !0), Object.defineProperty(s, A.key, A);
+                }
+              }
+              return function(s, b, h) {
+                return b && i(s.prototype, b), h && i(s, h), s;
+              };
+            })(), v = p(4), _ = w(v);
+            function w(i) {
+              return i && i.__esModule ? i : { default: i };
+            }
+            function e(i, s) {
+              if (!(i instanceof s))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            function n(i, s) {
+              if (!i)
+                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+              return s && (typeof s == "object" || typeof s == "function") ? s : i;
+            }
+            function a(i, s) {
+              if (typeof s != "function" && s !== null)
+                throw new TypeError("Super expression must either be null or a function, not " + typeof s);
+              i.prototype = Object.create(s && s.prototype, { constructor: { value: i, enumerable: !1, writable: !0, configurable: !0 } }), s && (Object.setPrototypeOf ? Object.setPrototypeOf(i, s) : i.__proto__ = s);
+            }
+            var u = (function(i) {
+              a(s, i);
+              function s(b, h, A) {
+                e(this, s);
+                var y = n(this, (s.__proto__ || Object.getPrototypeOf(s)).call(this));
+                return y.playbackRate = 1, y._currentFrameNumber = 0, y._ended = !1, y._paused = !0, y._numPlays = 0, y._rafId = null, y._apng = b, y.context = h, y.stop(), A && y.play(), y;
+              }
+              return l(s, [{
+                key: "renderNextFrame",
+                value: function() {
+                  this._currentFrameNumber = (this._currentFrameNumber + 1) % this._apng.frames.length, this._currentFrameNumber === this._apng.frames.length - 1 && (this._numPlays++, this._apng.numPlays !== 0 && this._numPlays >= this._apng.numPlays && (this._ended = !0, this._paused = !0)), this._prevFrame && this._prevFrame.disposeOp == 1 ? this.context.clearRect(this._prevFrame.left, this._prevFrame.top, this._prevFrame.width, this._prevFrame.height) : this._prevFrame && this._prevFrame.disposeOp == 2 && this.context.putImageData(this._prevFrameData, this._prevFrame.left, this._prevFrame.top);
+                  var h = this.currentFrame;
+                  this._prevFrame = h, this._prevFrameData = null, h.disposeOp == 2 && (this._prevFrameData = this.context.getImageData(h.left, h.top, h.width, h.height)), h.blendOp == 0 && this.context.clearRect(h.left, h.top, h.width, h.height), this.context.drawImage(h.imageElement, h.left, h.top), this.emit("frame", this._currentFrameNumber), this._ended && this.emit("end");
+                }
+                // playback
+              }, {
+                key: "play",
+                value: function() {
+                  var h = this;
+                  this._rafId && cancelAnimationFrame(this._rafId), this.emit("play"), this._ended && this.stop(), this._paused = !1;
+                  var A = performance.now() + this.currentFrame.delay / this.playbackRate, y = function F(d) {
+                    if (!(h._ended || h._paused)) {
+                      if (d >= A) {
+                        for (; d - A >= h._apng.playTime / h.playbackRate; )
+                          A += h._apng.playTime / h.playbackRate, h._numPlays++;
+                        do
+                          h.renderNextFrame(), A += h.currentFrame.delay / h.playbackRate;
+                        while (!h._ended && !h._paused && d > A);
+                      }
+                      h._rafId = requestAnimationFrame(F);
+                    }
+                  };
+                  this._rafId = requestAnimationFrame(y);
+                }
+              }, {
+                key: "pause",
+                value: function() {
+                  this._paused || (this._rafId && (cancelAnimationFrame(this._rafId), this._rafId = null), this.emit("pause"), this._paused = !0);
+                }
+              }, {
+                key: "stop",
+                value: function() {
+                  this._rafId && (cancelAnimationFrame(this._rafId), this._rafId = null), this.emit("stop"), this._numPlays = 0, this._ended = !1, this._paused = !0, this._currentFrameNumber = -1, this.context.clearRect(0, 0, this._apng.width, this._apng.height), this.renderNextFrame();
+                }
+              }, {
+                key: "currentFrameNumber",
+                get: function() {
+                  return this._currentFrameNumber;
+                }
+                /**
+                 *
+                 * @return {Frame}
+                 */
+              }, {
+                key: "currentFrame",
+                get: function() {
+                  return this._apng.frames[this._currentFrameNumber];
+                }
+              }, {
+                key: "paused",
+                get: function() {
+                  return this._paused;
+                }
+              }, {
+                key: "ended",
+                get: function() {
+                  return this._ended;
+                }
+              }]), s;
+            })(_.default);
+            r.default = u;
+          }),
+          /* 4 */
+          /***/
+          (function(t, r) {
+            function p() {
+              this._events = this._events || {}, this._maxListeners = this._maxListeners || void 0;
+            }
+            t.exports = p, p.EventEmitter = p, p.prototype._events = void 0, p.prototype._maxListeners = void 0, p.defaultMaxListeners = 10, p.prototype.setMaxListeners = function(e) {
+              if (!v(e) || e < 0 || isNaN(e))
+                throw TypeError("n must be a positive number");
+              return this._maxListeners = e, this;
+            }, p.prototype.emit = function(e) {
+              var n, a, u, i, s, b;
+              if (this._events || (this._events = {}), e === "error" && (!this._events.error || _(this._events.error) && !this._events.error.length)) {
+                if (n = arguments[1], n instanceof Error)
+                  throw n;
+                var h = new Error('Uncaught, unspecified "error" event. (' + n + ")");
+                throw h.context = n, h;
+              }
+              if (a = this._events[e], w(a))
+                return !1;
+              if (l(a))
+                switch (arguments.length) {
+                  // fast cases
+                  case 1:
+                    a.call(this);
+                    break;
+                  case 2:
+                    a.call(this, arguments[1]);
+                    break;
+                  case 3:
+                    a.call(this, arguments[1], arguments[2]);
+                    break;
+                  // slower
+                  default:
+                    i = Array.prototype.slice.call(arguments, 1), a.apply(this, i);
+                }
+              else if (_(a))
+                for (i = Array.prototype.slice.call(arguments, 1), b = a.slice(), u = b.length, s = 0; s < u; s++)
+                  b[s].apply(this, i);
+              return !0;
+            }, p.prototype.addListener = function(e, n) {
+              var a;
+              if (!l(n))
+                throw TypeError("listener must be a function");
+              return this._events || (this._events = {}), this._events.newListener && this.emit(
+                "newListener",
+                e,
+                l(n.listener) ? n.listener : n
+              ), this._events[e] ? _(this._events[e]) ? this._events[e].push(n) : this._events[e] = [this._events[e], n] : this._events[e] = n, _(this._events[e]) && !this._events[e].warned && (w(this._maxListeners) ? a = p.defaultMaxListeners : a = this._maxListeners, a && a > 0 && this._events[e].length > a && (this._events[e].warned = !0, console.error(
+                "(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",
+                this._events[e].length
+              ), typeof console.trace == "function" && console.trace())), this;
+            }, p.prototype.on = p.prototype.addListener, p.prototype.once = function(e, n) {
+              if (!l(n))
+                throw TypeError("listener must be a function");
+              var a = !1;
+              function u() {
+                this.removeListener(e, u), a || (a = !0, n.apply(this, arguments));
+              }
+              return u.listener = n, this.on(e, u), this;
+            }, p.prototype.removeListener = function(e, n) {
+              var a, u, i, s;
+              if (!l(n))
+                throw TypeError("listener must be a function");
+              if (!this._events || !this._events[e])
+                return this;
+              if (a = this._events[e], i = a.length, u = -1, a === n || l(a.listener) && a.listener === n)
+                delete this._events[e], this._events.removeListener && this.emit("removeListener", e, n);
+              else if (_(a)) {
+                for (s = i; s-- > 0; )
+                  if (a[s] === n || a[s].listener && a[s].listener === n) {
+                    u = s;
+                    break;
+                  }
+                if (u < 0)
+                  return this;
+                a.length === 1 ? (a.length = 0, delete this._events[e]) : a.splice(u, 1), this._events.removeListener && this.emit("removeListener", e, n);
+              }
+              return this;
+            }, p.prototype.removeAllListeners = function(e) {
+              var n, a;
+              if (!this._events)
+                return this;
+              if (!this._events.removeListener)
+                return arguments.length === 0 ? this._events = {} : this._events[e] && delete this._events[e], this;
+              if (arguments.length === 0) {
+                for (n in this._events)
+                  n !== "removeListener" && this.removeAllListeners(n);
+                return this.removeAllListeners("removeListener"), this._events = {}, this;
+              }
+              if (a = this._events[e], l(a))
+                this.removeListener(e, a);
+              else if (a)
+                for (; a.length; )
+                  this.removeListener(e, a[a.length - 1]);
+              return delete this._events[e], this;
+            }, p.prototype.listeners = function(e) {
+              var n;
+              return !this._events || !this._events[e] ? n = [] : l(this._events[e]) ? n = [this._events[e]] : n = this._events[e].slice(), n;
+            }, p.prototype.listenerCount = function(e) {
+              if (this._events) {
+                var n = this._events[e];
+                if (l(n))
+                  return 1;
+                if (n)
+                  return n.length;
+              }
+              return 0;
+            }, p.listenerCount = function(e, n) {
+              return e.listenerCount(n);
+            };
+            function l(e) {
+              return typeof e == "function";
+            }
+            function v(e) {
+              return typeof e == "number";
+            }
+            function _(e) {
+              return typeof e == "object" && e !== null;
+            }
+            function w(e) {
+              return e === void 0;
+            }
+          })
+          /******/
+        ])
+      );
+    });
+  })(X)), X.exports;
+}
+var Ae = Pe();
+const Ee = /* @__PURE__ */ Fe(Ae), q = {
   url: {
     type: String,
-    requierd: false
+    requierd: !1
   },
   data: {
     type: Array,
@@ -1008,14 +470,14 @@ const props = {
    */
   loop: {
     type: Boolean,
-    default: false
+    default: !1
   },
   /**
    * @description v-model:status 控制动画状态
    */
   status: {
     type: String,
-    default: TickerStatus.pending
+    default: m.pending
   },
   frameRate: {
     type: Number,
@@ -1034,551 +496,318 @@ const props = {
    */
   prerender: {
     type: Boolean,
-    default: false
+    default: !1
   },
   visible: {
     type: Boolean,
-    default: true
+    default: !0
   }
-};
-const emits = {
+}, j = {
   "update:status": null,
   "update:data": null,
-  "setData": null
-};
-
-const appInjectKey = /* @__PURE__ */ Symbol("appInjectKey");
-function initPixiApp() {
-  const application = new Application();
-  const whenDef = new Deferred();
-  const context = {
-    whenDef,
-    when: () => whenDef.promise
+  setData: null
+}, le = /* @__PURE__ */ Symbol("appInjectKey");
+function Ie() {
+  const o = new _e(), P = new ge(), t = {
+    whenDef: P,
+    when: () => P.promise
   };
-  provide(appInjectKey, {
-    application,
-    context
-  });
-  return { application, context };
+  return de(le, {
+    application: o,
+    context: t
+  }), { application: o, context: t };
 }
-function usePixiApp() {
-  const core = inject(appInjectKey);
-  if (!core) {
+function ce() {
+  const o = fe(le);
+  if (!o)
     throw new Error("Pixi app not provided");
-  }
-  return core;
+  return o;
 }
-
-function useSprite(props) {
-  const autoResize = props.autoResize ?? true;
-  const resize = props.resize ?? defaultResize;
-  const { application: app, context } = usePixiApp();
-  const sprite = new Sprite();
-  app.stage.addChild(sprite);
-  watchEffect(() => {
-    sprite.visible = props.visible ?? true;
-  });
-  watchEffect(() => {
-    props.label && (sprite.label = props.label);
-  });
-  autoResize && context.when().then((app2) => {
-    if (sprite.texture) {
-      resizeSprite();
-      app2.renderer.on("resize", resizeSprite);
-    }
+function z(o) {
+  const P = o.autoResize ?? !0, t = o.resize ?? _, { application: r, context: p } = ce(), l = new ye();
+  r.stage.addChild(l), B(() => {
+    l.visible = o.visible ?? !0;
+  }), B(() => {
+    o.label && (l.label = o.label);
+  }), P && p.when().then((w) => {
+    l.texture && (v(), w.renderer.on("resize", v));
   });
-  function resizeSprite() {
-    if (!app.renderer?.screen)
+  function v() {
+    if (!r.renderer?.screen)
       return;
-    const meta = sprite.texture._meta;
-    resize({
-      application: app,
-      sprite,
-      meta
+    const w = l.texture._meta;
+    t({
+      application: r,
+      sprite: l,
+      meta: w
     });
   }
-  onBeforeUnmount(() => {
-    app.renderer.off("resize", resizeSprite);
-    app.stage.removeChild(sprite);
+  S(() => {
+    r.renderer.off("resize", v), r.stage.removeChild(l);
   });
-  function defaultResize() {
-    const scaleX = app.screen.width / sprite.texture.width;
-    const scaleY = app.screen.height / sprite.texture.height;
-    const scale = Math.min(scaleX, scaleY);
-    sprite.scale.set(scale);
-    sprite.x = (app.screen.width - sprite.width) / 2;
-    sprite.y = (app.screen.height - sprite.height) / 2;
+  function _() {
+    const w = r.screen.width / l.texture.width, e = r.screen.height / l.texture.height, n = Math.min(w, e);
+    l.scale.set(n), l.x = (r.screen.width - l.width) / 2, l.y = (r.screen.height - l.height) / 2;
   }
   return {
-    sprite,
-    resizeSprite,
-    application: app
+    sprite: l,
+    resizeSprite: v,
+    application: r
   };
 }
-
-var _sfc_main$8 = /* @__PURE__ */ defineComponent({
+const Ne = /* @__PURE__ */ C({
   __name: "apng",
   props: {
-    ...props,
+    ...q,
     url: {
       type: String,
-      required: true
+      required: !0
     }
   },
-  emits,
-  setup(__props, { expose: __expose, emit: __emit }) {
-    __expose();
-    const props = __props;
-    const emit = __emit;
-    const compId = useId();
-    const getAlias = (frameIndex) => `${compId}-apng-frame-${frameIndex}`;
-    const { sprite, resizeSprite } = useSprite(props);
-    const frames = ref([]);
-    const index = ref(0);
-    const isLoaded = ref(false);
-    const error = ref("");
-    const textureMap = /* @__PURE__ */ new Map();
-    let timer = null;
-    let reusableCanvas = null;
-    let reusableCtx = null;
-    onMounted(() => loadAPNG(props.url));
-    function getReusableCanvas(width, height) {
-      if (!reusableCanvas) {
-        reusableCanvas = document.createElement("canvas");
-        reusableCtx = reusableCanvas.getContext("2d", {
-          willReadFrequently: true
-        });
-      }
-      if (reusableCanvas.width !== width || reusableCanvas.height !== height) {
-        reusableCanvas.width = width;
-        reusableCanvas.height = height;
-      }
-      return { canvas: reusableCanvas, ctx: reusableCtx };
+  emits: j,
+  setup(o, { emit: P }) {
+    const t = o, r = P, p = ne(), l = (c) => `${p}-apng-frame-${c}`, { sprite: v, resizeSprite: _ } = z(t), w = U([]), e = U(0), n = U(!1), a = U(""), u = /* @__PURE__ */ new Map();
+    let i = null, s = null, b = null;
+    ae(() => A(t.url));
+    function h(c, x) {
+      return s || (s = document.createElement("canvas"), b = s.getContext("2d", {
+        willReadFrequently: !0
+      })), (s.width !== c || s.height !== x) && (s.width = c, s.height = x), { canvas: s, ctx: b };
     }
-    async function loadAPNG(url) {
+    async function A(c) {
       try {
-        error.value = "";
-        isLoaded.value = false;
-        await cleanup();
-        const response = await fetch(url);
-        if (!response.ok) {
-          throw new Error(`\u52A0\u8F7DAPNG\u5931\u8D25: ${response.status}`);
-        }
-        const arrayBuffer = await response.arrayBuffer();
-        const apng = parseAPNG(arrayBuffer);
-        if (apng instanceof Error) {
-          throw new TypeError(`APNG\u89E3\u6790\u5931\u8D25: ${apng.message}`);
-        }
-        const { canvas, ctx } = getReusableCanvas(apng.width, apng.height);
-        const framePromises = apng.frames.map(async (frame, frameIndex) => {
-          ctx.clearRect(0, 0, canvas.width, canvas.height);
-          await frame.createImage();
-          const img = frame.imageElement;
-          ctx.drawImage(img, frame.left, frame.top);
-          const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
-          const alias = getAlias(frameIndex);
-          textureMap.set(alias, void 0);
-          ctx.putImageData(imageData, 0, 0);
-          const dataUrl = canvas.toDataURL();
-          Assets.add({ alias, src: dataUrl });
-          const texture = await Assets.load(alias);
-          textureMap.set(alias, texture);
-          if (frameIndex === 0) {
-            sprite.texture = texture;
-            resizeSprite();
-          }
-          return alias;
+        a.value = "", n.value = !1, await g();
+        const x = await fetch(c);
+        if (!x.ok)
+          throw new Error(`加载APNG失败: ${x.status}`);
+        const I = await x.arrayBuffer(), N = Ee(I);
+        if (N instanceof Error)
+          throw new TypeError(`APNG解析失败: ${N.message}`);
+        const { canvas: k, ctx: M } = h(N.width, N.height), O = N.frames.map(async (G, W) => {
+          M.clearRect(0, 0, k.width, k.height), await G.createImage();
+          const T = G.imageElement;
+          M.drawImage(T, G.left, G.top);
+          const D = M.getImageData(0, 0, k.width, k.height), E = l(W);
+          u.set(E, void 0), M.putImageData(D, 0, 0);
+          const $ = k.toDataURL();
+          R.add({ alias: E, src: $ });
+          const L = await R.load(E);
+          return u.set(E, L), W === 0 && (v.texture = L, _()), E;
         });
-        frames.value = await Promise.all(framePromises);
-        isLoaded.value = true;
-      } catch (err) {
-        console.error("\u52A0\u8F7DAPNG\u5931\u8D25:", err);
-        error.value = err instanceof Error ? err.message : "\u52A0\u8F7DAPNG\u5931\u8D25";
-        emit("update:status", TickerStatus.stopped);
+        w.value = await Promise.all(O), n.value = !0;
+      } catch (x) {
+        console.error("加载APNG失败:", x), a.value = x instanceof Error ? x.message : "加载APNG失败", r("update:status", m.stopped);
       }
     }
-    function startFrameLoop() {
-      if (timer !== null)
-        return;
-      timer = window.setInterval(() => {
-        if (frames.value.length === 0 || props.status !== TickerStatus.playing) {
+    function y() {
+      i === null && (i = window.setInterval(() => {
+        if (w.value.length === 0 || t.status !== m.playing)
           return;
-        }
-        const currentTexture = textureMap.get(
-          getAlias(index.value)
+        const c = u.get(
+          l(e.value)
         );
-        if (currentTexture) {
-          const originIndex = index.value - 1;
-          if (originIndex >= 0 && !props.loop) {
-            Promise.resolve().then(() => sleep(500)).then(() => {
-              Assets.unload(getAlias(originIndex));
-              textureMap.delete(getAlias(originIndex));
-            });
-          }
-          sprite.texture = currentTexture;
-          resizeSprite();
-          index.value = props.loop ? (index.value + 1) % frames.value.length : index.value + 1;
-        } else {
-          if (!props.loop)
-            emit("update:status", TickerStatus.paused);
-        }
-      }, 1e3 / props.frameRate);
+        if (c) {
+          const x = e.value - 1;
+          x >= 0 && !t.loop && Promise.resolve().then(() => Z(500)).then(() => {
+            R.unload(l(x)), u.delete(l(x));
+          }), v.texture = c, _(), e.value = t.loop ? (e.value + 1) % w.value.length : e.value + 1;
+        } else
+          t.loop || r("update:status", m.paused);
+      }, 1e3 / t.frameRate));
     }
-    function play() {
-      if (!isLoaded.value || frames.value.length <= 1) {
-        return;
-      }
-      emit("update:status", TickerStatus.playing);
-      startFrameLoop();
+    function F() {
+      !n.value || w.value.length <= 1 || (r("update:status", m.playing), y());
     }
-    function pause() {
-      if (timer !== null) {
-        clearInterval(timer);
-        timer = null;
-      }
-      emit("update:status", TickerStatus.paused);
+    function d() {
+      i !== null && (clearInterval(i), i = null), r("update:status", m.paused);
     }
-    function stop() {
-      if (timer !== null) {
-        clearInterval(timer);
-        timer = null;
-      }
-      index.value = 0;
-      const firstTexture = textureMap.get(getAlias(0));
-      if (firstTexture) {
-        sprite.texture = firstTexture;
-        resizeSprite();
-      }
-      emit("update:status", TickerStatus.stopped);
+    function f() {
+      i !== null && (clearInterval(i), i = null), e.value = 0;
+      const c = u.get(l(0));
+      c && (v.texture = c, _()), r("update:status", m.stopped);
     }
-    async function cleanup() {
-      if (timer !== null) {
-        clearInterval(timer);
-        timer = null;
-      }
-      const unloadPromises = [];
-      for (const [alias, texture] of textureMap) {
-        if (texture && texture !== Texture.EMPTY) {
-          unloadPromises.push(Assets.unload(alias));
-        }
-      }
-      await Promise.all(unloadPromises);
-      textureMap.clear();
-      frames.value = [];
-      index.value = 0;
-      isLoaded.value = false;
-      error.value = "";
-      if (reusableCanvas) {
-        reusableCanvas.width = 0;
-        reusableCanvas.height = 0;
-      }
+    async function g() {
+      i !== null && (clearInterval(i), i = null);
+      const c = [];
+      for (const [x, I] of u)
+        I && I !== ee.EMPTY && c.push(R.unload(x));
+      await Promise.all(c), u.clear(), w.value = [], e.value = 0, n.value = !1, a.value = "", s && (s.width = 0, s.height = 0);
     }
-    watchEffect(() => {
-      switch (props.status) {
-        case TickerStatus.play:
-          play();
+    return B(() => {
+      switch (t.status) {
+        case m.play:
+          F();
           break;
-        case TickerStatus.pause:
-          pause();
+        case m.pause:
+          d();
           break;
-        case TickerStatus.stop:
-          stop();
+        case m.stop:
+          f();
           break;
       }
-    });
-    onBeforeUnmount(async () => {
-      await cleanup();
-      reusableCanvas = null;
-      reusableCtx = null;
-    });
-    const __returned__ = { props, emit, compId, getAlias, sprite, resizeSprite, frames, index, isLoaded, error, textureMap, get timer() {
-      return timer;
-    }, set timer(v) {
-      timer = v;
-    }, get reusableCanvas() {
-      return reusableCanvas;
-    }, set reusableCanvas(v) {
-      reusableCanvas = v;
-    }, get reusableCtx() {
-      return reusableCtx;
-    }, set reusableCtx(v) {
-      reusableCtx = v;
-    }, getReusableCanvas, loadAPNG, startFrameLoop, play, pause, stop, cleanup };
-    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
-    return __returned__;
+    }), S(async () => {
+      await g(), s = null, b = null;
+    }), (c, x) => V(c.$slots, "default");
   }
-});
-
-function _sfc_render$8(_ctx, _cache, $props, $setup, $data, $options) {
-  return renderSlot(_ctx.$slots, "default");
-}
-var ApngComp = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["render", _sfc_render$8], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/pixi-frame/src/apng.vue"]]);
-
-var _sfc_main$7 = /* @__PURE__ */ defineComponent({
+}), Ge = /* @__PURE__ */ C({
   __name: "bitmap-generator",
   props: {
-    ...pickObject(props, {
+    ...se(q, {
       excludes: ["loop"]
     }),
     generator: {
       type: Object,
-      required: true
+      required: !0
     }
   },
   emits: {
     "update:status": null,
-    "load": (e) => e
+    load: (o) => o
   },
-  setup(__props, { expose: __expose, emit: __emit }) {
-    __expose();
-    const props = __props;
-    const emit = __emit;
-    const { sprite, resizeSprite, application } = useSprite(props);
-    const texture = new Texture({
-      dynamic: true
+  setup(o, { emit: P }) {
+    const t = o, r = P, { sprite: p, resizeSprite: l, application: v } = z(t), _ = new ee({
+      dynamic: !0
     });
-    sprite.texture = texture;
-    function updateTextureFromBitmap(bitmap) {
-      texture.source.destroy();
-      const source = new ImageSource({
-        resource: bitmap
+    p.texture = _;
+    function w(i) {
+      _.source.destroy();
+      const s = new oe({
+        resource: i
       });
-      texture.source = source;
-      texture.update();
-      resizeSprite();
+      _.source = s, _.update(), l();
     }
-    emit("load", {
-      application,
-      sprite
-    });
-    watch(() => props.status, (newStatus) => {
-      newStatus === TickerStatus.play && play();
-      newStatus === TickerStatus.pause && pause();
-      newStatus === TickerStatus.stop && stop();
-    }, { immediate: true });
-    function drawFrame() {
-      if (props.status !== TickerStatus.playing) {
-        return;
-      }
-      props.generator.next().then(({ value, done }) => {
-        if (done) {
-          return emit("update:status", TickerStatus.stopped);
-        }
-        updateTextureFromBitmap(value);
+    r("load", {
+      application: v,
+      sprite: p
+    }), Q(() => t.status, (i) => {
+      i === m.play && n(), i === m.pause && a(), i === m.stop && u();
+    }, { immediate: !0 });
+    function e() {
+      t.status === m.playing && t.generator.next().then(({ value: i, done: s }) => {
+        if (s)
+          return r("update:status", m.stopped);
+        w(i);
       });
     }
-    function play() {
-      application.ticker.minFPS = props.frameRate;
-      application.ticker.maxFPS = props.frameRate;
-      emit("update:status", TickerStatus.playing);
-      application.ticker.add(drawFrame);
+    function n() {
+      v.ticker.minFPS = t.frameRate, v.ticker.maxFPS = t.frameRate, r("update:status", m.playing), v.ticker.add(e);
     }
-    function pause() {
-      application.ticker.remove(drawFrame);
-      emit("update:status", TickerStatus.paused);
+    function a() {
+      v.ticker.remove(e), r("update:status", m.paused);
     }
-    function stop() {
-      application.ticker.remove(drawFrame);
-      emit("update:status", TickerStatus.stopped);
+    function u() {
+      v.ticker.remove(e), r("update:status", m.stopped);
     }
-    onBeforeUnmount(() => {
-      stop();
-      texture.destroy();
-    });
-    const __returned__ = { props, emit, sprite, resizeSprite, application, texture, updateTextureFromBitmap, drawFrame, play, pause, stop };
-    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
-    return __returned__;
+    return S(() => {
+      u(), _.destroy();
+    }), (i, s) => V(i.$slots, "default");
   }
-});
-
-function _sfc_render$7(_ctx, _cache, $props, $setup, $data, $options) {
-  return renderSlot(_ctx.$slots, "default");
-}
-var bitmapGenerator = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["render", _sfc_render$7], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/pixi-frame/src/bitmap-generator.vue"]]);
-
-var _sfc_main$6 = /* @__PURE__ */ defineComponent({
+}), De = /* @__PURE__ */ C({
   __name: "bitmap",
   props: {
-    ...pickObject(props, {
+    ...se(q, {
       excludes: ["loop"]
     }),
     data: {
       type: void 0,
-      required: true
+      required: !0
     },
     frameIndex: {
       type: Number
     }
   },
   emits: {
-    ...emits,
-    "load": (e) => e,
+    ...j,
+    load: (o) => o,
     "update:frameIndex": null,
-    "notFound": (_index) => true
+    notFound: (o) => !0
   },
-  setup(__props, { expose: __expose, emit: __emit }) {
-    __expose();
-    const props = __props;
-    const emit = __emit;
-    const { sprite, resizeSprite, application } = useSprite(props);
-    const texture = new Texture({
-      dynamic: true
+  setup(o, { emit: P }) {
+    const t = o, r = P, { sprite: p, resizeSprite: l, application: v } = z(t), _ = new ee({
+      dynamic: !0
     });
-    sprite.texture = texture;
-    function updateTextureFromBitmap(bitmap) {
-      texture.source?.resource?.close();
-      texture.source?.destroy();
-      const source = new ImageSource({
-        resource: bitmap
+    p.texture = _;
+    function w(d) {
+      _.source?.resource?.close(), _.source?.destroy();
+      const f = new oe({
+        resource: d
       });
-      texture.source = source;
-      texture.update();
-      resizeSprite();
+      _.source = f, _.update(), l();
     }
-    emit("load", {
-      application,
-      sprite
+    r("load", {
+      application: v,
+      sprite: p
     });
-    const index = useModelComputed({
+    const e = ie({
       default: 0,
       key: "frameIndex"
-    }, props, emit);
-    const lastScheduledClearIndex = ref(-1);
-    function scheduleClearFrame(frameIndex) {
-      if (frameIndex <= lastScheduledClearIndex.value)
-        return;
-      lastScheduledClearIndex.value = frameIndex;
-      sleep(0).then(() => {
-        emit("setData", {
-          k: frameIndex,
+    }, t, r), n = U(-1);
+    function a(d) {
+      d <= n.value || (n.value = d, Z(0).then(() => {
+        r("setData", {
+          k: d,
           v: null
         });
-      });
+      }));
     }
-    let animationId = null;
-    let lastFrameTime = 0;
-    let frameCount = 0;
-    let lastFpsUpdateTime = 0;
-    function startFrameLoop() {
-      if (animationId !== null)
+    let u = null, i = 0, s = 0, b = 0;
+    function h() {
+      if (u !== null)
         return;
-      lastFrameTime = performance.now();
-      lastFpsUpdateTime = lastFrameTime;
-      frameCount = 0;
-      function renderFrame() {
-        const now = performance.now();
-        const frameDuration = 1e3 / props.frameRate;
-        const delta = now - lastFrameTime;
-        if (delta >= frameDuration) {
-          lastFrameTime = now - delta % frameDuration;
-          drawFrame();
-          frameCount++;
-          const elapsed = now - lastFpsUpdateTime;
-          if (elapsed >= 1e3) {
-            const currentFps = Math.round(frameCount * 1e3 / elapsed);
-            console.log(`[Bitmap] FPS: ${currentFps}`);
-            frameCount = 0;
-            lastFpsUpdateTime = now;
+      i = performance.now(), b = i, s = 0;
+      function d() {
+        const g = performance.now(), c = 1e3 / t.frameRate, x = g - i;
+        if (x >= c) {
+          i = g - x % c, f(), s++;
+          const I = g - b;
+          if (I >= 1e3) {
+            const N = Math.round(s * 1e3 / I);
+            console.log(`[Bitmap] FPS: ${N}`), s = 0, b = g;
           }
         }
-        if (props.status === TickerStatus.playing) {
-          animationId = requestAnimationFrame(renderFrame);
-        } else {
-          animationId = null;
-        }
+        t.status === m.playing ? u = requestAnimationFrame(d) : u = null;
       }
-      function drawFrame() {
-        if (props.data.length === 0 || props.status !== TickerStatus.playing) {
+      function f() {
+        if (t.data.length === 0 || t.status !== m.playing)
           return;
-        }
-        const bitmap = props.data[index.value];
-        if (bitmap) {
-          const originIndex = index.value - 1;
-          if (originIndex >= 0) {
-            scheduleClearFrame(originIndex);
-          }
-          updateTextureFromBitmap(bitmap);
-          index.value = index.value + 1;
-        } else {
+        const g = t.data[e.value];
+        if (g) {
+          const c = e.value - 1;
+          c >= 0 && a(c), w(g), e.value = e.value + 1;
+        } else
           console.warn(
-            `Bitmap for index ${index.value} not found. Ensure the data is loaded.`
-          );
-          emit("notFound", index.value);
-        }
+            `Bitmap for index ${e.value} not found. Ensure the data is loaded.`
+          ), r("notFound", e.value);
       }
-      animationId = requestAnimationFrame(renderFrame);
+      u = requestAnimationFrame(d);
     }
-    watchEffect(() => {
-      if (props.prerender && index.value === 0 && props.data.length > 0 && props.data[0]) {
-        updateTextureFromBitmap(props.data[0]);
-      }
-    });
-    watch(() => props.status, (newStatus) => {
-      newStatus === TickerStatus.play && play();
-      newStatus === TickerStatus.pause && pause();
-      newStatus === TickerStatus.stop && stop();
-    }, { immediate: true });
-    function play() {
-      if (props.data.length > 0) {
-        emit("update:status", TickerStatus.playing);
-        startFrameLoop();
-      } else {
-        emit("update:status", TickerStatus.stopped);
-      }
+    B(() => {
+      t.prerender && e.value === 0 && t.data.length > 0 && t.data[0] && w(t.data[0]);
+    }), Q(() => t.status, (d) => {
+      d === m.play && A(), d === m.pause && y(), d === m.stop && F();
+    }, { immediate: !0 });
+    function A() {
+      t.data.length > 0 ? (r("update:status", m.playing), h()) : r("update:status", m.stopped);
     }
-    function pause() {
-      emit("update:status", TickerStatus.paused);
+    function y() {
+      r("update:status", m.paused);
     }
-    function stop() {
-      emit("update:status", TickerStatus.stopped);
-      if (animationId !== null) {
-        cancelAnimationFrame(animationId);
-        animationId = null;
-      }
-      emit("update:data", []);
-      index.value = 0;
-      lastScheduledClearIndex.value = -1;
+    function F() {
+      r("update:status", m.stopped), u !== null && (cancelAnimationFrame(u), u = null), r("update:data", []), e.value = 0, n.value = -1;
     }
-    onBeforeUnmount(() => {
-      stop();
-      texture.destroy();
-    });
-    const __returned__ = { props, emit, sprite, resizeSprite, application, texture, updateTextureFromBitmap, index, lastScheduledClearIndex, scheduleClearFrame, get animationId() {
-      return animationId;
-    }, set animationId(v) {
-      animationId = v;
-    }, get lastFrameTime() {
-      return lastFrameTime;
-    }, set lastFrameTime(v) {
-      lastFrameTime = v;
-    }, get frameCount() {
-      return frameCount;
-    }, set frameCount(v) {
-      frameCount = v;
-    }, get lastFpsUpdateTime() {
-      return lastFpsUpdateTime;
-    }, set lastFpsUpdateTime(v) {
-      lastFpsUpdateTime = v;
-    }, startFrameLoop, play, pause, stop };
-    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
-    return __returned__;
+    return S(() => {
+      F(), _.destroy();
+    }), (d, f) => V(d.$slots, "default");
   }
-});
-
-function _sfc_render$6(_ctx, _cache, $props, $setup, $data, $options) {
-  return renderSlot(_ctx.$slots, "default");
-}
-var Bitmap = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["render", _sfc_render$6], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/pixi-frame/src/bitmap.vue"]]);
-
-var _sfc_main$5 = /* @__PURE__ */ defineComponent({
+}), je = /* @__PURE__ */ C({
   __name: "buffer-image",
   props: {
-    ...pickObject(props, {
+    ...se(q, {
       excludes: ["loop"]
     }),
     data: {
       type: Array,
-      required: true
+      required: !0
     },
     /**
      * Pixel format for BufferImageSource.
@@ -1593,525 +822,285 @@ var _sfc_main$5 = /* @__PURE__ */ defineComponent({
     },
     height: {
       type: Number,
-      required: true
+      required: !0
     },
     width: {
       type: Number,
-      required: true
+      required: !0
     }
   },
   emits: {
-    ...emits,
-    "load": (e) => e,
+    ...j,
+    load: (o) => o,
     "update:frameIndex": null,
-    "notFound": (_index) => true
+    notFound: (o) => !0
   },
-  setup(__props, { expose: __expose, emit: __emit }) {
-    __expose();
-    const props = __props;
-    const emit = __emit;
-    const { sprite, resizeSprite, application } = useSprite(props);
-    const texture = new Texture({
-      dynamic: true
+  setup(o, { emit: P }) {
+    const t = o, r = P, { sprite: p, resizeSprite: l, application: v } = z(t), _ = new ee({
+      dynamic: !0
     });
-    sprite.texture = texture;
-    function updateTexture(resource) {
-      texture.source?.destroy();
-      const source = new BufferImageSource({
-        resource,
-        height: props.height,
-        width: props.width,
-        format: props.format
+    p.texture = _;
+    function w(d) {
+      _.source?.destroy();
+      const f = new we({
+        resource: d,
+        height: t.height,
+        width: t.width,
+        format: t.format
       });
-      texture.source = source;
-      texture.update();
-      resizeSprite();
+      _.source = f, _.update(), l();
     }
-    emit("load", {
-      application,
-      sprite
+    r("load", {
+      application: v,
+      sprite: p
     });
-    const index = useModelComputed({
+    const e = ie({
       default: 0,
       key: "frameIndex"
-    }, props, emit);
-    const lastScheduledClearIndex = ref(-1);
-    function scheduleClearFrame(frameIndex) {
-      if (frameIndex <= lastScheduledClearIndex.value)
-        return;
-      lastScheduledClearIndex.value = frameIndex;
-      sleep(0).then(() => {
-        emit("setData", {
-          k: frameIndex,
+    }, t, r), n = U(-1);
+    function a(d) {
+      d <= n.value || (n.value = d, Z(0).then(() => {
+        r("setData", {
+          k: d,
           v: null
         });
-      });
+      }));
     }
-    let animationId = null;
-    let lastFrameTime = 0;
-    let frameCount = 0;
-    let lastFpsUpdateTime = 0;
-    function startFrameLoop() {
-      if (animationId !== null)
+    let u = null, i = 0, s = 0, b = 0;
+    function h() {
+      if (u !== null)
         return;
-      lastFrameTime = performance.now();
-      lastFpsUpdateTime = lastFrameTime;
-      frameCount = 0;
-      function renderFrame() {
-        const now = performance.now();
-        const frameDuration = 1e3 / props.frameRate;
-        const delta = now - lastFrameTime;
-        if (delta >= frameDuration) {
-          lastFrameTime = now - delta % frameDuration;
-          drawFrame();
-          frameCount++;
-          const elapsed = now - lastFpsUpdateTime;
-          if (elapsed >= 1e3) {
-            const currentFps = Math.round(frameCount * 1e3 / elapsed);
-            console.log(`[Bitmap] FPS: ${currentFps}`);
-            frameCount = 0;
-            lastFpsUpdateTime = now;
+      i = performance.now(), b = i, s = 0;
+      function d() {
+        const g = performance.now(), c = 1e3 / t.frameRate, x = g - i;
+        if (x >= c) {
+          i = g - x % c, f(), s++;
+          const I = g - b;
+          if (I >= 1e3) {
+            const N = Math.round(s * 1e3 / I);
+            console.log(`[Bitmap] FPS: ${N}`), s = 0, b = g;
           }
         }
-        if (props.status === TickerStatus.playing) {
-          animationId = requestAnimationFrame(renderFrame);
-        } else {
-          animationId = null;
-        }
+        t.status === m.playing ? u = requestAnimationFrame(d) : u = null;
       }
-      function drawFrame() {
-        if (props.data.length === 0 || props.status !== TickerStatus.playing) {
+      function f() {
+        if (t.data.length === 0 || t.status !== m.playing)
           return;
-        }
-        const bitmap = props.data[index.value];
-        if (bitmap) {
-          const originIndex = index.value - 1;
-          if (originIndex >= 0) {
-            scheduleClearFrame(originIndex);
-          }
-          updateTexture(bitmap);
-          index.value = index.value + 1;
-        } else {
+        const g = t.data[e.value];
+        if (g) {
+          const c = e.value - 1;
+          c >= 0 && a(c), w(g), e.value = e.value + 1;
+        } else
           console.warn(
-            `Bitmap for index ${index.value} not found. Ensure the data is loaded.`
-          );
-          emit("notFound", index.value);
-        }
+            `Bitmap for index ${e.value} not found. Ensure the data is loaded.`
+          ), r("notFound", e.value);
       }
-      animationId = requestAnimationFrame(renderFrame);
+      u = requestAnimationFrame(d);
     }
-    watchEffect(() => {
-      if (props.prerender && index.value === 0 && props.data.length > 0 && props.data[0]) {
-        updateTexture(props.data[0]);
-      }
-    });
-    watch(() => props.status, (newStatus) => {
-      newStatus === TickerStatus.play && play();
-      newStatus === TickerStatus.pause && pause();
-      newStatus === TickerStatus.stop && stop();
-    }, { immediate: true });
-    function play() {
-      if (props.data.length > 0) {
-        emit("update:status", TickerStatus.playing);
-        startFrameLoop();
-      } else {
-        emit("update:status", TickerStatus.stopped);
-      }
+    B(() => {
+      t.prerender && e.value === 0 && t.data.length > 0 && t.data[0] && w(t.data[0]);
+    }), Q(() => t.status, (d) => {
+      d === m.play && A(), d === m.pause && y(), d === m.stop && F();
+    }, { immediate: !0 });
+    function A() {
+      t.data.length > 0 ? (r("update:status", m.playing), h()) : r("update:status", m.stopped);
     }
-    function pause() {
-      emit("update:status", TickerStatus.paused);
+    function y() {
+      r("update:status", m.paused);
     }
-    function stop() {
-      emit("update:status", TickerStatus.stopped);
-      if (animationId !== null) {
-        cancelAnimationFrame(animationId);
-        animationId = null;
-      }
-      emit("update:data", []);
-      index.value = 0;
-      lastScheduledClearIndex.value = -1;
+    function F() {
+      r("update:status", m.stopped), u !== null && (cancelAnimationFrame(u), u = null), r("update:data", []), e.value = 0, n.value = -1;
     }
-    onBeforeUnmount(() => {
-      stop();
-      texture.destroy();
-    });
-    const __returned__ = { props, emit, sprite, resizeSprite, application, texture, updateTexture, index, lastScheduledClearIndex, scheduleClearFrame, get animationId() {
-      return animationId;
-    }, set animationId(v) {
-      animationId = v;
-    }, get lastFrameTime() {
-      return lastFrameTime;
-    }, set lastFrameTime(v) {
-      lastFrameTime = v;
-    }, get frameCount() {
-      return frameCount;
-    }, set frameCount(v) {
-      frameCount = v;
-    }, get lastFpsUpdateTime() {
-      return lastFpsUpdateTime;
-    }, set lastFpsUpdateTime(v) {
-      lastFpsUpdateTime = v;
-    }, startFrameLoop, play, pause, stop };
-    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
-    return __returned__;
+    return S(() => {
+      F(), _.destroy();
+    }), (d, f) => V(d.$slots, "default");
   }
-});
-
-function _sfc_render$5(_ctx, _cache, $props, $setup, $data, $options) {
-  return renderSlot(_ctx.$slots, "default");
-}
-var bufferImage = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["render", _sfc_render$5], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/pixi-frame/src/buffer-image.vue"]]);
-
-var _sfc_main$4 = /* @__PURE__ */ defineComponent({
+}), ze = /* @__PURE__ */ C({
   __name: "core",
   props: {
-    ...props,
+    ...q,
     data: {
       type: void 0,
-      required: true
+      required: !0
     },
     frameIndex: {
       type: Number
     }
   },
   emits: {
-    ...emits,
-    "load": (e) => e,
+    ...j,
+    load: (o) => o,
     "update:frameIndex": null,
-    "notFound": (_index) => true
+    notFound: (o) => !0
   },
-  setup(__props, { expose: __expose, emit: __emit }) {
-    __expose();
-    const props = __props;
-    const emit = __emit;
-    const compId = useId();
-    const getAlias = (key) => `${compId}-${key}`;
-    const { sprite, resizeSprite, application } = useSprite(props);
-    const textureMap = /* @__PURE__ */ new Map();
-    const completedIndex = ref(0);
-    const enabledData = computed(() => {
-      return props.data.slice(completedIndex.value);
-    });
-    watchEffect(() => {
-      for (const key in enabledData.value) {
-        const theKey = +key + completedIndex.value;
-        const alias = `${compId}-${theKey}`;
-        const src = typeof enabledData.value[key] === "string" ? enabledData.value[key] : enabledData.value[key]?.src;
-        if (!src) {
-          continue;
-        }
-        if (textureMap.has(alias)) {
-          continue;
-        }
-        Assets.add({
-          alias,
-          src,
+  setup(o, { emit: P }) {
+    const t = o, r = P, p = ne(), l = (F) => `${p}-${F}`, { sprite: v, resizeSprite: _, application: w } = z(t), e = /* @__PURE__ */ new Map(), n = U(0), a = J(() => t.data.slice(n.value));
+    B(() => {
+      for (const F in a.value) {
+        const d = +F + n.value, f = `${p}-${d}`, g = typeof a.value[F] == "string" ? a.value[F] : a.value[F]?.src;
+        g && (e.has(f) || (R.add({
+          alias: f,
+          src: g,
           loadParser: "loadTextures"
-        });
-        textureMap.set(alias, void 0);
-        Assets.load(alias).then((res) => {
-          res._meta = enabledData.value[key];
-          textureMap.set(alias, res);
-          if (props.prerender && theKey === 0) {
-            sprite.texture = res;
-            resizeSprite();
-          }
-        });
+        }), e.set(f, void 0), R.load(f).then((c) => {
+          c._meta = a.value[F], e.set(f, c), t.prerender && d === 0 && (v.texture = c, _());
+        })));
       }
+    }), r("load", {
+      application: w,
+      sprite: v
     });
-    emit("load", {
-      application,
-      sprite
-    });
-    const index = useModelComputed({
+    const u = ie({
       default: 0,
       key: "frameIndex"
-    }, props, emit);
-    let animationId = null;
-    let lastFrameTime = 0;
-    function startFrameLoop() {
-      if (animationId !== null)
+    }, t, r);
+    let i = null, s = 0;
+    function b() {
+      if (i !== null)
         return;
-      lastFrameTime = performance.now();
-      function renderFrame() {
-        const now = performance.now();
-        const frameDuration = 1e3 / props.frameRate;
-        const delta = now - lastFrameTime;
-        if (delta >= frameDuration) {
-          lastFrameTime = now - delta % frameDuration;
-          drawFrame();
-        }
-        if (props.status === TickerStatus.playing) {
-          animationId = requestAnimationFrame(renderFrame);
-        } else {
-          animationId = null;
-        }
+      s = performance.now();
+      function F() {
+        const f = performance.now(), g = 1e3 / t.frameRate, c = f - s;
+        c >= g && (s = f - c % g, d()), t.status === m.playing ? i = requestAnimationFrame(F) : i = null;
       }
-      function drawFrame() {
-        if (props.data.length === 0 || props.status !== TickerStatus.playing) {
+      function d() {
+        if (t.data.length === 0 || t.status !== m.playing)
           return;
-        }
-        const currentTexture = textureMap.get(
-          getAlias(index.value)
+        const f = e.get(
+          l(u.value)
         );
-        if (currentTexture) {
-          const originTexture = sprite.texture;
-          const originIndex = index.value - 1;
-          if (originTexture && originIndex >= 0 && !props.loop) {
-            Promise.resolve(sleep(500)).then(() => Assets.unload(
-              getAlias(originIndex)
-            )).then(() => {
-              textureMap.set(
-                getAlias(originIndex),
-                void 0
-              );
-              emit("setData", {
-                k: originIndex,
-                v: ""
-              });
-              completedIndex.value = originIndex;
-            });
-          }
-          sprite.texture = currentTexture;
-          resizeSprite();
-          index.value = props.loop ? (index.value + 1) % props.data.length : index.value + 1;
-        } else {
+        if (f) {
+          const g = v.texture, c = u.value - 1;
+          g && c >= 0 && !t.loop && Promise.resolve(Z(500)).then(() => R.unload(
+            l(c)
+          )).then(() => {
+            e.set(
+              l(c),
+              void 0
+            ), r("setData", {
+              k: c,
+              v: ""
+            }), n.value = c;
+          }), v.texture = f, _(), u.value = t.loop ? (u.value + 1) % t.data.length : u.value + 1;
+        } else
           console.warn(
-            `Texture for index ${index.value} not found. Ensure the texture is loaded.`
-          );
-          emit("notFound", index.value);
-          if (!props.loop)
-            emit("update:status", TickerStatus.paused);
-        }
+            `Texture for index ${u.value} not found. Ensure the texture is loaded.`
+          ), r("notFound", u.value), t.loop || r("update:status", m.paused);
       }
-      animationId = requestAnimationFrame(renderFrame);
+      i = requestAnimationFrame(F);
     }
-    watch(() => props.status, (newStatus) => {
-      newStatus === TickerStatus.play && play();
-      newStatus === TickerStatus.pause && pause();
-      newStatus === TickerStatus.stop && stop();
-    }, { immediate: true });
-    function play() {
-      if (props.data.length > 0) {
-        emit("update:status", TickerStatus.playing);
-        startFrameLoop();
-      } else {
-        emit("update:status", TickerStatus.stopped);
-      }
+    Q(() => t.status, (F) => {
+      F === m.play && h(), F === m.pause && A(), F === m.stop && y();
+    }, { immediate: !0 });
+    function h() {
+      t.data.length > 0 ? (r("update:status", m.playing), b()) : r("update:status", m.stopped);
     }
-    function pause() {
-      emit("update:status", TickerStatus.paused);
+    function A() {
+      r("update:status", m.paused);
     }
-    function stop() {
-      emit("update:status", TickerStatus.stopped);
-      if (animationId !== null) {
-        cancelAnimationFrame(animationId);
-        animationId = null;
-      }
-      emit("update:data", []);
-      textureMap.clear();
-      index.value = 0;
+    function y() {
+      r("update:status", m.stopped), i !== null && (cancelAnimationFrame(i), i = null), r("update:data", []), e.clear(), u.value = 0;
     }
-    onBeforeUnmount(() => {
-      const entries = Array.from(textureMap.entries());
-      entries.forEach(([alias, texture]) => {
-        if (texture) {
-          Assets.unload(alias);
-        }
-      });
-      stop();
-    });
-    const __returned__ = { props, emit, compId, getAlias, sprite, resizeSprite, application, textureMap, completedIndex, enabledData, index, get animationId() {
-      return animationId;
-    }, set animationId(v) {
-      animationId = v;
-    }, get lastFrameTime() {
-      return lastFrameTime;
-    }, set lastFrameTime(v) {
-      lastFrameTime = v;
-    }, startFrameLoop, play, pause, stop };
-    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
-    return __returned__;
+    return S(() => {
+      Array.from(e.entries()).forEach(([d, f]) => {
+        f && R.unload(d);
+      }), y();
+    }), (F, d) => V(F.$slots, "default");
   }
-});
-
-function _sfc_render$4(_ctx, _cache, $props, $setup, $data, $options) {
-  return renderSlot(_ctx.$slots, "default");
-}
-var core = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["render", _sfc_render$4], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/pixi-frame/src/core.vue"]]);
-
-var _sfc_main$3 = /* @__PURE__ */ defineComponent({
+}), Le = /* @__PURE__ */ C({
   __name: "provider",
-  setup(__props, { expose: __expose }) {
-    __expose();
-    initPixiApp();
-    const __returned__ = {};
-    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
-    return __returned__;
+  setup(o) {
+    return Ie(), (P, t) => V(P.$slots, "default");
   }
-});
-
-function _sfc_render$3(_ctx, _cache, $props, $setup, $data, $options) {
-  return renderSlot(_ctx.$slots, "default");
-}
-var ProviderComp = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["render", _sfc_render$3], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/pixi-frame/src/provider.vue"]]);
-
-var _sfc_main$2 = /* @__PURE__ */ defineComponent({
+}), Re = /* @__PURE__ */ C({
   __name: "video",
   props: {
-    ...props,
+    ...q,
     url: {
       type: String,
-      required: true
+      required: !0
     }
   },
-  emits,
-  setup(__props, { expose: __expose, emit: __emit }) {
-    __expose();
-    const props = __props;
-    const emit = __emit;
-    const compId = useId();
-    const getAlias = () => `${compId}-video`;
-    const { sprite, resizeSprite } = useSprite(props);
-    const texture = ref();
-    const video = computed(() => {
-      if (texture.value?.source && texture.value.source.resource) {
-        const resource = texture.value.source.resource;
-        if (resource instanceof HTMLVideoElement) {
-          return resource;
-        }
+  emits: j,
+  setup(o, { emit: P }) {
+    const t = o, r = P, p = ne(), l = () => `${p}-video`, { sprite: v, resizeSprite: _ } = z(t), w = U(), e = J(() => {
+      if (w.value?.source && w.value.source.resource) {
+        const y = w.value.source.resource;
+        if (y instanceof HTMLVideoElement)
+          return y;
       }
       return null;
-    });
-    const readyDef = useDeferred();
-    const videoError = ref("");
-    readyDef.promise.then(() => {
-      if (props.status === TickerStatus.play) {
-        play();
-      }
-    });
-    watchEffect(() => {
-      video.value && (video.value.loop = props.loop);
-    });
-    onMounted(() => loadVideoTexture(props.url));
-    async function loadVideoTexture(url) {
+    }), n = be(), a = U("");
+    n.promise.then(() => {
+      t.status === m.play && b();
+    }), B(() => {
+      e.value && (e.value.loop = t.loop);
+    }), ae(() => u(t.url));
+    async function u(y) {
       try {
-        videoError.value = "";
-        const alias = getAlias();
-        if (Assets.cache.has(alias)) {
-          await Assets.unload(alias);
-        }
-        Assets.add({ alias, src: url });
-        const videoTexture = await Assets.load(alias);
-        texture.value = videoTexture;
-        sprite.texture = videoTexture;
-        if (video.value) {
-          video.value.loop = props.loop;
-          video.value.muted = true;
-          video.value.crossOrigin = "anonymous";
-          setupVideoEvents(video.value);
-          readyDef.resolve();
-        }
-        resizeSprite();
-        return videoTexture;
-      } catch (error) {
-        console.error("\u52A0\u8F7D\u89C6\u9891\u7EB9\u7406\u5931\u8D25:", error);
-        videoError.value = "\u89C6\u9891\u52A0\u8F7D\u5931\u8D25";
-        return null;
+        a.value = "";
+        const F = l();
+        R.cache.has(F) && await R.unload(F), R.add({ alias: F, src: y });
+        const d = await R.load(F);
+        return w.value = d, v.texture = d, e.value && (e.value.loop = t.loop, e.value.muted = !0, e.value.crossOrigin = "anonymous", i(e.value), n.resolve()), _(), d;
+      } catch (F) {
+        return console.error("加载视频纹理失败:", F), a.value = "视频加载失败", null;
       }
     }
-    function setupVideoEvents(video2) {
-      video2.addEventListener("play", () => {
-        if (props.status !== TickerStatus.playing) {
-          emit("update:status", TickerStatus.playing);
-        }
-      });
-      video2.addEventListener("pause", () => {
-        if (props.status !== TickerStatus.paused) {
-          emit("update:status", TickerStatus.paused);
-        }
-      });
-      video2.addEventListener("ended", () => {
-        if (props.loop) {
-          video2.currentTime = 0;
-          video2.play();
-        } else {
-          emit("update:status", TickerStatus.stopped);
-        }
-      });
-      video2.addEventListener("error", (e) => {
-        const error = video2.error;
-        let errorMessage = "\u89C6\u9891\u64AD\u653E\u5931\u8D25";
-        if (error) {
-          switch (error.code) {
-            case error.MEDIA_ERR_ABORTED:
-              errorMessage = "\u89C6\u9891\u64AD\u653E\u88AB\u4E2D\u6B62";
+    function i(y) {
+      y.addEventListener("play", () => {
+        t.status !== m.playing && r("update:status", m.playing);
+      }), y.addEventListener("pause", () => {
+        t.status !== m.paused && r("update:status", m.paused);
+      }), y.addEventListener("ended", () => {
+        t.loop ? (y.currentTime = 0, y.play()) : r("update:status", m.stopped);
+      }), y.addEventListener("error", (F) => {
+        const d = y.error;
+        let f = "视频播放失败";
+        if (d)
+          switch (d.code) {
+            case d.MEDIA_ERR_ABORTED:
+              f = "视频播放被中止";
               break;
-            case error.MEDIA_ERR_NETWORK:
-              errorMessage = "\u7F51\u7EDC\u9519\u8BEF\u5BFC\u81F4\u89C6\u9891\u64AD\u653E\u5931\u8D25";
+            case d.MEDIA_ERR_NETWORK:
+              f = "网络错误导致视频播放失败";
               break;
-            case error.MEDIA_ERR_DECODE:
-              errorMessage = "\u89C6\u9891\u89E3\u7801\u5931\u8D25";
+            case d.MEDIA_ERR_DECODE:
+              f = "视频解码失败";
               break;
-            case error.MEDIA_ERR_SRC_NOT_SUPPORTED:
-              errorMessage = "\u4E0D\u652F\u6301\u7684\u89C6\u9891\u683C\u5F0F";
+            case d.MEDIA_ERR_SRC_NOT_SUPPORTED:
+              f = "不支持的视频格式";
               break;
           }
-        }
-        console.error("\u89C6\u9891\u64AD\u653E\u9519\u8BEF:", errorMessage, e);
-        videoError.value = errorMessage;
-        emit("update:status", TickerStatus.stopped);
+        console.error("视频播放错误:", f, F), a.value = f, r("update:status", m.stopped);
       });
     }
-    async function cleanupVideo() {
-      if (texture.value) {
-        const alias = getAlias();
-        texture.value.destroy(true);
-        texture.value = void 0;
-        if (Assets.cache.has(alias)) {
-          await Assets.unload(alias);
-        }
+    async function s() {
+      if (w.value) {
+        const y = l();
+        w.value.destroy(!0), w.value = void 0, R.cache.has(y) && await R.unload(y);
       }
-      videoError.value = "";
+      a.value = "";
     }
-    watchEffect(() => {
-      props.status === TickerStatus.play && play();
-      props.status === TickerStatus.pause && pause();
-      props.status === TickerStatus.stop && stop();
+    B(() => {
+      t.status === m.play && b(), t.status === m.pause && h(), t.status === m.stop && A();
+    }), S(() => {
+      s();
     });
-    onBeforeUnmount(() => {
-      cleanupVideo();
-    });
-    function play() {
-      if (video.value) {
-        video.value.play().catch((error) => {
-          console.error("\u89C6\u9891\u64AD\u653E\u5931\u8D25:", error);
-          videoError.value = "\u89C6\u9891\u64AD\u653E\u5931\u8D25";
-        });
-      }
+    function b() {
+      e.value && e.value.play().catch((y) => {
+        console.error("视频播放失败:", y), a.value = "视频播放失败";
+      });
     }
-    function pause() {
-      video.value?.pause();
+    function h() {
+      e.value?.pause();
     }
-    function stop() {
-      if (video.value) {
-        video.value.pause();
-        video.value.currentTime = 0;
-      }
-      emit("update:status", TickerStatus.stopped);
+    function A() {
+      e.value && (e.value.pause(), e.value.currentTime = 0), r("update:status", m.stopped);
     }
-    const __returned__ = { props, emit, compId, getAlias, sprite, resizeSprite, texture, video, readyDef, videoError, loadVideoTexture, setupVideoEvents, cleanupVideo, play, pause, stop };
-    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
-    return __returned__;
+    return (y, F) => V(y.$slots, "default");
   }
-});
-
-function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
-  return renderSlot(_ctx.$slots, "default");
-}
-var VideoComp = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render$2], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/pixi-frame/src/video.vue"]]);
-
-var _sfc_main$1 = /* @__PURE__ */ defineComponent({
+}), Te = /* @__PURE__ */ C({
   __name: "view",
   props: {
     defaultOptions: {
@@ -2119,114 +1108,97 @@ var _sfc_main$1 = /* @__PURE__ */ defineComponent({
       default: () => ({})
     }
   },
-  setup(__props, { expose: __expose }) {
-    __expose();
-    const props = __props;
-    const { application: app, context } = usePixiApp();
-    const appRef = ref();
-    onMounted(async () => {
-      await app.init({
-        resizeTo: appRef.value,
-        ...props.defaultOptions
-      });
-      context.whenDef.resolve(app);
-      appRef.value.appendChild(app.canvas);
-    });
-    const __returned__ = { props, app, context, appRef };
-    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
-    return __returned__;
+  setup(o) {
+    const P = o, { application: t, context: r } = ce(), p = U();
+    return ae(async () => {
+      await t.init({
+        resizeTo: p.value,
+        ...P.defaultOptions
+      }), r.whenDef.resolve(t), p.value.appendChild(t.canvas);
+    }), (l, v) => (H(), me("div", {
+      ref_key: "appRef",
+      ref: p,
+      class: "vk-pixi-frame"
+    }, null, 512));
   }
-});
-
-const _hoisted_1 = {
-  ref: "appRef",
-  class: "vk-pixi-frame"
-};
-function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
-  return openBlock(), createElementBlock(
-    "div",
-    _hoisted_1,
-    null,
-    512
-    /* NEED_PATCH */
-  );
-}
-var ViewComp = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render$1], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/pixi-frame/src/view.vue"]]);
-
-var _sfc_main = defineComponent({
+}), Oe = C({
   name: "VkPixiFrame",
   components: {
-    ApngComp,
+    ApngComp: Ne,
     // CoreComp,
-    ProviderComp,
-    ViewComp,
-    VideoComp,
-    Bitmap
+    ProviderComp: Le,
+    ViewComp: Te,
+    VideoComp: Re,
+    Bitmap: De
   },
-  props,
-  emits,
-  setup(props2) {
-    const isApng = computed(() => {
-      if (!props2.url)
-        return false;
-      const url = props2.url.toLowerCase();
-      return url.includes(".png") && !url.includes(".mp4") && !url.includes(".webm");
-    });
-    const isVideo = computed(() => {
-      if (!props2.url)
-        return false;
-      const url = props2.url.toLowerCase();
-      return url.includes(".mp4") || url.includes(".webm") || url.includes(".mov");
+  props: q,
+  emits: j,
+  setup(o) {
+    const P = J(() => {
+      if (!o.url)
+        return !1;
+      const r = o.url.toLowerCase();
+      return r.includes(".png") && !r.includes(".mp4") && !r.includes(".webm");
+    }), t = J(() => {
+      if (!o.url)
+        return !1;
+      const r = o.url.toLowerCase();
+      return r.includes(".mp4") || r.includes(".webm") || r.includes(".mov");
     });
     return {
-      isApng,
-      isVideo
+      isApng: P,
+      isVideo: t
     };
   }
 });
-
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_ViewComp = resolveComponent("ViewComp");
-  const _component_ApngComp = resolveComponent("ApngComp");
-  const _component_VideoComp = resolveComponent("VideoComp");
-  const _component_Bitmap = resolveComponent("Bitmap");
-  const _component_ProviderComp = resolveComponent("ProviderComp");
-  return openBlock(), createBlock(_component_ProviderComp, null, {
-    default: withCtx(() => [
-      createVNode(_component_ViewComp),
-      _ctx.isApng && _ctx.url ? (openBlock(), createBlock(_component_ApngComp, {
+function Ue(o, P, t, r, p, l) {
+  const v = K("ViewComp"), _ = K("ApngComp"), w = K("VideoComp"), e = K("Bitmap"), n = K("ProviderComp");
+  return H(), Y(n, null, {
+    default: he(() => [
+      ve(v),
+      o.isApng && o.url ? (H(), Y(_, {
         key: 0,
-        url: _ctx.url,
-        loop: _ctx.loop,
-        status: _ctx.status,
-        "onUpdate:status": _cache[0] || (_cache[0] = ($event) => _ctx.$emit("update:status", $event))
-      }, null, 8, ["url", "loop", "status"])) : _ctx.isVideo && _ctx.url ? (openBlock(), createBlock(_component_VideoComp, {
+        url: o.url,
+        loop: o.loop,
+        status: o.status,
+        "onUpdate:status": P[0] || (P[0] = (a) => o.$emit("update:status", a))
+      }, null, 8, ["url", "loop", "status"])) : o.isVideo && o.url ? (H(), Y(w, {
         key: 1,
-        url: _ctx.url,
-        loop: _ctx.loop,
-        status: _ctx.status,
-        "onUpdate:status": _cache[1] || (_cache[1] = ($event) => _ctx.$emit("update:status", $event))
-      }, null, 8, ["url", "loop", "status"])) : (openBlock(), createBlock(_component_Bitmap, {
+        url: o.url,
+        loop: o.loop,
+        status: o.status,
+        "onUpdate:status": P[1] || (P[1] = (a) => o.$emit("update:status", a))
+      }, null, 8, ["url", "loop", "status"])) : (H(), Y(e, {
         key: 2,
-        data: _ctx.data,
-        loop: _ctx.loop,
-        status: _ctx.status,
-        onSetData: _cache[2] || (_cache[2] = ($event) => _ctx.$emit("setData", $event)),
-        "onUpdate:status": _cache[3] || (_cache[3] = ($event) => _ctx.$emit("update:status", $event))
+        data: o.data,
+        loop: o.loop,
+        status: o.status,
+        onSetData: P[2] || (P[2] = (a) => o.$emit("setData", a)),
+        "onUpdate:status": P[3] || (P[3] = (a) => o.$emit("update:status", a))
       }, null, 8, ["data", "loop", "status"]))
     ]),
     _: 1
-    /* STABLE */
   });
 }
-var VkPixiFrame = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/pixi-frame/src/index.vue"]]);
-
-var types = /*#__PURE__*/Object.freeze({
-	__proto__: null
-});
-
-VkPixiFrame.install = (app) => {
-  app.component(VkPixiFrame.name || "VkPixiFrame", VkPixiFrame);
+const re = /* @__PURE__ */ xe(Oe, [["render", Ue]]), Ke = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null
+}, Symbol.toStringTag, { value: "Module" }));
+re.install = (o) => {
+  o.component(re.name || "VkPixiFrame", re);
+};
+export {
+  Ye as TickerStatus,
+  re as VkPixiFrame,
+  Ne as VkPixiFrameApng,
+  De as VkPixiFrameBitmap,
+  Ge as VkPixiFrameBitmapGenerator,
+  je as VkPixiFrameBufferImage,
+  ze as VkPixiFrameCore,
+  Le as VkPixiFrameProvider,
+  Re as VkPixiFrameVideo,
+  Te as VkPixiFrameView,
+  Ke as __VkPixiFrame,
+  re as default,
+  ce as usePixiApp,
+  z as useSprite
 };
-
-export { VkPixiFrame, ApngComp as VkPixiFrameApng, Bitmap as VkPixiFrameBitmap, bitmapGenerator as VkPixiFrameBitmapGenerator, bufferImage as VkPixiFrameBufferImage, core as VkPixiFrameCore, ProviderComp as VkPixiFrameProvider, VideoComp as VkPixiFrameVideo, ViewComp as VkPixiFrameView, types as __VkPixiFrame, VkPixiFrame as default, usePixiApp, useSprite };