@chao-component/bag-animation-ui 1.0.0

package/dist/index.mjs

@@ -0,0 +1,772 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/apng-js/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/apng-js/lib/index.js"(exports, module) {
+    "use strict";
+    (function webpackUniversalModuleDefinition(root, factory) {
+      if (typeof exports === "object" && typeof module === "object")
+        module.exports = factory();
+      else if (typeof define === "function" && define.amd)
+        define([], factory);
+      else if (typeof exports === "object")
+        exports["apng-js"] = factory();
+      else
+        root["apng-js"] = factory();
+    })(exports, function() {
+      return (
+        /******/
+        (function(modules) {
+          var installedModules = {};
+          function __webpack_require__(moduleId) {
+            if (installedModules[moduleId])
+              return installedModules[moduleId].exports;
+            var module2 = installedModules[moduleId] = {
+              /******/
+              exports: {},
+              /******/
+              id: moduleId,
+              /******/
+              loaded: false
+              /******/
+            };
+            modules[moduleId].call(module2.exports, module2, module2.exports, __webpack_require__);
+            module2.loaded = true;
+            return module2.exports;
+          }
+          __webpack_require__.m = modules;
+          __webpack_require__.c = installedModules;
+          __webpack_require__.p = "";
+          return __webpack_require__(0);
+        })([
+          /* 0 */
+          /***/
+          (function(module2, exports2, __webpack_require__) {
+            "use strict";
+            Object.defineProperty(exports2, "__esModule", {
+              value: true
+            });
+            exports2.isNotPNG = isNotPNG;
+            exports2.isNotAPNG = isNotAPNG;
+            exports2.default = parseAPNG2;
+            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;
+            }
+            var PNGSignature = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+            function parseAPNG2(buffer) {
+              var bytes = new Uint8Array(buffer);
+              if (Array.prototype.some.call(PNGSignature, function(b, i) {
+                return b !== bytes[i];
+              })) {
+                return errNotPNG;
+              }
+              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, bytes2, off, length) {
+                var dv = new DataView(bytes2.buffer);
+                switch (type) {
+                  case "IHDR":
+                    headerDataBytes = bytes2.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 = 1e3 * delayN / delayD;
+                    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(bytes2.subarray(off + 8 + 4, off + 8 + length));
+                    }
+                    break;
+                  case "IDAT":
+                    if (frame) {
+                      frame.dataParts.push(bytes2.subarray(off + 8, off + 8 + length));
+                    }
+                    break;
+                  case "IEND":
+                    postDataParts.push(subBuffer(bytes2, off, 12 + length));
+                    break;
+                  default:
+                    preDataParts.push(subBuffer(bytes2, 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(frame2) {
+                var bb = [];
+                bb.push(PNGSignature);
+                headerDataBytes.set(makeDWordArray(frame2.width), 0);
+                headerDataBytes.set(makeDWordArray(frame2.height), 4);
+                bb.push(makeChunkBytes("IHDR", headerDataBytes));
+                bb.push(preBlob);
+                frame2.dataParts.forEach(function(p) {
+                  return bb.push(makeChunkBytes("IDAT", p));
+                });
+                bb.push(postBlob);
+                frame2.imageData = new Blob(bb, { "type": "image/png" });
+                delete frame2.dataParts;
+                bb = null;
+              });
+              return apng;
+            }
+            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);
+            }
+            function readString(bytes, off, length) {
+              var chars = Array.prototype.slice.call(bytes.subarray(off, off + length));
+              return String.fromCharCode.apply(String, chars);
+            }
+            function makeStringArray(x) {
+              var res = new Uint8Array(x.length);
+              for (var i = 0; i < x.length; i++) {
+                res[i] = x.charCodeAt(i);
+              }
+              return res;
+            }
+            function subBuffer(bytes, start, length) {
+              var a = new Uint8Array(length);
+              a.set(bytes.subarray(start, start + length));
+              return a;
+            }
+            var makeChunkBytes = function makeChunkBytes2(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 makeDWordArray2(x) {
+              return new Uint8Array([x >>> 24 & 255, x >>> 16 & 255, x >>> 8 & 255, x & 255]);
+            };
+          }),
+          /* 1 */
+          /***/
+          (function(module2, exports2) {
+            "use strict";
+            Object.defineProperty(exports2, "__esModule", {
+              value: true
+            });
+            exports2.default = function(bytes) {
+              var start = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+              var length = arguments.length > 2 && arguments[2] !== void 0 ? 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]) & 255];
+              }
+              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 ? 3988292384 ^ c >>> 1 : c >>> 1;
+              }
+              table[i] = c;
+            }
+          }),
+          /* 2 */
+          /***/
+          (function(module2, exports2, __webpack_require__) {
+            "use strict";
+            Object.defineProperty(exports2, "__esModule", {
+              value: true
+            });
+            exports2.Frame = exports2.APNG = void 0;
+            var _createClass = /* @__PURE__ */ (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");
+              }
+            }
+            var APNG = exports2.APNG = (function() {
+              function APNG2() {
+                _classCallCheck(this, APNG2);
+                this.width = 0;
+                this.height = 0;
+                this.numPlays = 0;
+                this.playTime = 0;
+                this.frames = [];
+              }
+              _createClass(APNG2, [{
+                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] !== void 0 ? arguments[1] : false;
+                  return this.createImages().then(function() {
+                    return new _player2.default(_this, context, autoPlay);
+                  });
+                }
+              }]);
+              return APNG2;
+            })();
+            var Frame = exports2.Frame = (function() {
+              function Frame2() {
+                _classCallCheck(this, Frame2);
+                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;
+              }
+              _createClass(Frame2, [{
+                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 Frame2;
+            })();
+          }),
+          /* 3 */
+          /***/
+          (function(module2, exports2, __webpack_require__) {
+            "use strict";
+            Object.defineProperty(exports2, "__esModule", {
+              value: true
+            });
+            var _createClass = /* @__PURE__ */ (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(_class2, _EventEmitter);
+              function _class2(apng, context, autoPlay) {
+                _classCallCheck(this, _class2);
+                var _this = _possibleConstructorReturn(this, (_class2.__proto__ || Object.getPrototypeOf(_class2)).call(this));
+                _this.playbackRate = 1;
+                _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;
+              }
+              _createClass(_class2, [{
+                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 tick2(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(tick2);
+                  };
+                  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;
+                  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 _class2;
+            })(_events2.default);
+            exports2.default = _class;
+          }),
+          /* 4 */
+          /***/
+          (function(module2, exports2) {
+            function EventEmitter() {
+              this._events = this._events || {};
+              this._maxListeners = this._maxListeners || void 0;
+            }
+            module2.exports = EventEmitter;
+            EventEmitter.EventEmitter = EventEmitter;
+            EventEmitter.prototype._events = void 0;
+            EventEmitter.prototype._maxListeners = void 0;
+            EventEmitter.defaultMaxListeners = 10;
+            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 (type === "error") {
+                if (!this._events.error || isObject(this._events.error) && !this._events.error.length) {
+                  er = arguments[1];
+                  if (er instanceof Error) {
+                    throw er;
+                  } else {
+                    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 = {};
+              if (this._events.newListener)
+                this.emit(
+                  "newListener",
+                  type,
+                  isFunction(listener.listener) ? listener.listener : listener
+                );
+              if (!this._events[type])
+                this._events[type] = listener;
+              else if (isObject(this._events[type]))
+                this._events[type].push(listener);
+              else
+                this._events[type] = [this._events[type], listener];
+              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") {
+                    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;
+            };
+            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;
+              if (!this._events.removeListener) {
+                if (arguments.length === 0)
+                  this._events = {};
+                else if (this._events[type])
+                  delete this._events[type];
+                return this;
+              }
+              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) {
+                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;
+            }
+          })
+          /******/
+        ])
+      );
+    });
+  }
+});
+
+// src/BagAnimation.tsx
+var import_apng_js = __toESM(require_lib());
+import { useEffect, useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";