Initial

resources/app/node_modules/@pixi/ticker/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2013-2023 Mathew Groves, Chad Engler
+
+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.

resources/app/node_modules/@pixi/ticker/lib/Ticker.js

@@ -0,0 +1,276 @@
+"use strict";
+var _const = require("./const.js"), TickerListener = require("./TickerListener.js");
+const _Ticker = class _Ticker2 {
+  constructor() {
+    this.autoStart = !1, this.deltaTime = 1, this.lastTime = -1, this.speed = 1, this.started = !1, this._requestId = null, this._maxElapsedMS = 100, this._minElapsedMS = 0, this._protected = !1, this._lastFrame = -1, this._head = new TickerListener.TickerListener(null, null, 1 / 0), this.deltaMS = 1 / _Ticker2.targetFPMS, this.elapsedMS = 1 / _Ticker2.targetFPMS, this._tick = (time) => {
+      this._requestId = null, this.started && (this.update(time), this.started && this._requestId === null && this._head.next && (this._requestId = requestAnimationFrame(this._tick)));
+    };
+  }
+  /**
+   * Conditionally requests a new animation frame.
+   * If a frame has not already been requested, and if the internal
+   * emitter has listeners, a new frame is requested.
+   * @private
+   */
+  _requestIfNeeded() {
+    this._requestId === null && this._head.next && (this.lastTime = performance.now(), this._lastFrame = this.lastTime, this._requestId = requestAnimationFrame(this._tick));
+  }
+  /**
+   * Conditionally cancels a pending animation frame.
+   * @private
+   */
+  _cancelIfNeeded() {
+    this._requestId !== null && (cancelAnimationFrame(this._requestId), this._requestId = null);
+  }
+  /**
+   * Conditionally requests a new animation frame.
+   * If the ticker has been started it checks if a frame has not already
+   * been requested, and if the internal emitter has listeners. If these
+   * conditions are met, a new frame is requested. If the ticker has not
+   * been started, but autoStart is `true`, then the ticker starts now,
+   * and continues with the previous conditions to request a new frame.
+   * @private
+   */
+  _startIfPossible() {
+    this.started ? this._requestIfNeeded() : this.autoStart && this.start();
+  }
+  /**
+   * Register a handler for tick events. Calls continuously unless
+   * it is removed or the ticker is stopped.
+   * @param fn - The listener function to be added for updates
+   * @param context - The listener context
+   * @param {number} [priority=PIXI.UPDATE_PRIORITY.NORMAL] - The priority for emitting
+   * @returns This instance of a ticker
+   */
+  add(fn, context, priority = _const.UPDATE_PRIORITY.NORMAL) {
+    return this._addListener(new TickerListener.TickerListener(fn, context, priority));
+  }
+  /**
+   * Add a handler for the tick event which is only execute once.
+   * @param fn - The listener function to be added for one update
+   * @param context - The listener context
+   * @param {number} [priority=PIXI.UPDATE_PRIORITY.NORMAL] - The priority for emitting
+   * @returns This instance of a ticker
+   */
+  addOnce(fn, context, priority = _const.UPDATE_PRIORITY.NORMAL) {
+    return this._addListener(new TickerListener.TickerListener(fn, context, priority, !0));
+  }
+  /**
+   * Internally adds the event handler so that it can be sorted by priority.
+   * Priority allows certain handler (user, AnimatedSprite, Interaction) to be run
+   * before the rendering.
+   * @private
+   * @param listener - Current listener being added.
+   * @returns This instance of a ticker
+   */
+  _addListener(listener) {
+    let current = this._head.next, previous = this._head;
+    if (!current)
+      listener.connect(previous);
+    else {
+      for (; current; ) {
+        if (listener.priority > current.priority) {
+          listener.connect(previous);
+          break;
+        }
+        previous = current, current = current.next;
+      }
+      listener.previous || listener.connect(previous);
+    }
+    return this._startIfPossible(), this;
+  }
+  /**
+   * Removes any handlers matching the function and context parameters.
+   * If no handlers are left after removing, then it cancels the animation frame.
+   * @param fn - The listener function to be removed
+   * @param context - The listener context to be removed
+   * @returns This instance of a ticker
+   */
+  remove(fn, context) {
+    let listener = this._head.next;
+    for (; listener; )
+      listener.match(fn, context) ? listener = listener.destroy() : listener = listener.next;
+    return this._head.next || this._cancelIfNeeded(), this;
+  }
+  /**
+   * The number of listeners on this ticker, calculated by walking through linked list
+   * @readonly
+   * @member {number}
+   */
+  get count() {
+    if (!this._head)
+      return 0;
+    let count = 0, current = this._head;
+    for (; current = current.next; )
+      count++;
+    return count;
+  }
+  /** Starts the ticker. If the ticker has listeners a new animation frame is requested at this point. */
+  start() {
+    this.started || (this.started = !0, this._requestIfNeeded());
+  }
+  /** Stops the ticker. If the ticker has requested an animation frame it is canceled at this point. */
+  stop() {
+    this.started && (this.started = !1, this._cancelIfNeeded());
+  }
+  /** Destroy the ticker and don't use after this. Calling this method removes all references to internal events. */
+  destroy() {
+    if (!this._protected) {
+      this.stop();
+      let listener = this._head.next;
+      for (; listener; )
+        listener = listener.destroy(!0);
+      this._head.destroy(), this._head = null;
+    }
+  }
+  /**
+   * Triggers an update. An update entails setting the
+   * current {@link PIXI.Ticker#elapsedMS},
+   * the current {@link PIXI.Ticker#deltaTime},
+   * invoking all listeners with current deltaTime,
+   * and then finally setting {@link PIXI.Ticker#lastTime}
+   * with the value of currentTime that was provided.
+   * This method will be called automatically by animation
+   * frame callbacks if the ticker instance has been started
+   * and listeners are added.
+   * @param {number} [currentTime=performance.now()] - the current time of execution
+   */
+  update(currentTime = performance.now()) {
+    let elapsedMS;
+    if (currentTime > this.lastTime) {
+      if (elapsedMS = this.elapsedMS = currentTime - this.lastTime, elapsedMS > this._maxElapsedMS && (elapsedMS = this._maxElapsedMS), elapsedMS *= this.speed, this._minElapsedMS) {
+        const delta = currentTime - this._lastFrame | 0;
+        if (delta < this._minElapsedMS)
+          return;
+        this._lastFrame = currentTime - delta % this._minElapsedMS;
+      }
+      this.deltaMS = elapsedMS, this.deltaTime = this.deltaMS * _Ticker2.targetFPMS;
+      const head = this._head;
+      let listener = head.next;
+      for (; listener; )
+        listener = listener.emit(this.deltaTime);
+      head.next || this._cancelIfNeeded();
+    } else
+      this.deltaTime = this.deltaMS = this.elapsedMS = 0;
+    this.lastTime = currentTime;
+  }
+  /**
+   * The frames per second at which this ticker is running.
+   * The default is approximately 60 in most modern browsers.
+   * **Note:** This does not factor in the value of
+   * {@link PIXI.Ticker#speed}, which is specific
+   * to scaling {@link PIXI.Ticker#deltaTime}.
+   * @member {number}
+   * @readonly
+   */
+  get FPS() {
+    return 1e3 / this.elapsedMS;
+  }
+  /**
+   * Manages the maximum amount of milliseconds allowed to
+   * elapse between invoking {@link PIXI.Ticker#update}.
+   * This value is used to cap {@link PIXI.Ticker#deltaTime},
+   * but does not effect the measured value of {@link PIXI.Ticker#FPS}.
+   * When setting this property it is clamped to a value between
+   * `0` and `Ticker.targetFPMS * 1000`.
+   * @member {number}
+   * @default 10
+   */
+  get minFPS() {
+    return 1e3 / this._maxElapsedMS;
+  }
+  set minFPS(fps) {
+    const minFPS = Math.min(this.maxFPS, fps), minFPMS = Math.min(Math.max(0, minFPS) / 1e3, _Ticker2.targetFPMS);
+    this._maxElapsedMS = 1 / minFPMS;
+  }
+  /**
+   * Manages the minimum amount of milliseconds required to
+   * elapse between invoking {@link PIXI.Ticker#update}.
+   * This will effect the measured value of {@link PIXI.Ticker#FPS}.
+   * If it is set to `0`, then there is no limit; PixiJS will render as many frames as it can.
+   * Otherwise it will be at least `minFPS`
+   * @member {number}
+   * @default 0
+   */
+  get maxFPS() {
+    return this._minElapsedMS ? Math.round(1e3 / this._minElapsedMS) : 0;
+  }
+  set maxFPS(fps) {
+    if (fps === 0)
+      this._minElapsedMS = 0;
+    else {
+      const maxFPS = Math.max(this.minFPS, fps);
+      this._minElapsedMS = 1 / (maxFPS / 1e3);
+    }
+  }
+  /**
+   * The shared ticker instance used by {@link PIXI.AnimatedSprite} and by
+   * {@link PIXI.VideoResource} to update animation frames / video textures.
+   *
+   * It may also be used by {@link PIXI.Application} if created with the `sharedTicker` option property set to true.
+   *
+   * The property {@link PIXI.Ticker#autoStart} is set to `true` for this instance.
+   * Please follow the examples for usage, including how to opt-out of auto-starting the shared ticker.
+   * @example
+   * import { Ticker } from 'pixi.js';
+   *
+   * const ticker = Ticker.shared;
+   * // Set this to prevent starting this ticker when listeners are added.
+   * // By default this is true only for the PIXI.Ticker.shared instance.
+   * ticker.autoStart = false;
+   *
+   * // FYI, call this to ensure the ticker is stopped. It should be stopped
+   * // if you have not attempted to render anything yet.
+   * ticker.stop();
+   *
+   * // Call this when you are ready for a running shared ticker.
+   * ticker.start();
+   * @example
+   * import { autoDetectRenderer, Container } from 'pixi.js';
+   *
+   * // You may use the shared ticker to render...
+   * const renderer = autoDetectRenderer();
+   * const stage = new Container();
+   * document.body.appendChild(renderer.view);
+   * ticker.add((time) => renderer.render(stage));
+   *
+   * // Or you can just update it manually.
+   * ticker.autoStart = false;
+   * ticker.stop();
+   * const animate = (time) => {
+   *     ticker.update(time);
+   *     renderer.render(stage);
+   *     requestAnimationFrame(animate);
+   * };
+   * animate(performance.now());
+   * @member {PIXI.Ticker}
+   * @static
+   */
+  static get shared() {
+    if (!_Ticker2._shared) {
+      const shared = _Ticker2._shared = new _Ticker2();
+      shared.autoStart = !0, shared._protected = !0;
+    }
+    return _Ticker2._shared;
+  }
+  /**
+   * The system ticker instance used by {@link PIXI.BasePrepare} for core timing
+   * functionality that shouldn't usually need to be paused, unlike the `shared`
+   * ticker which drives visual animations and rendering which may want to be paused.
+   *
+   * The property {@link PIXI.Ticker#autoStart} is set to `true` for this instance.
+   * @member {PIXI.Ticker}
+   * @static
+   */
+  static get system() {
+    if (!_Ticker2._system) {
+      const system = _Ticker2._system = new _Ticker2();
+      system.autoStart = !0, system._protected = !0;
+    }
+    return _Ticker2._system;
+  }
+};
+_Ticker.targetFPMS = 0.06;
+let Ticker = _Ticker;
+exports.Ticker = Ticker;
+//# sourceMappingURL=Ticker.js.map

resources/app/node_modules/@pixi/ticker/lib/Ticker.mjs

@@ -0,0 +1,278 @@
+import { UPDATE_PRIORITY } from "./const.mjs";
+import { TickerListener } from "./TickerListener.mjs";
+const _Ticker = class _Ticker2 {
+  constructor() {
+    this.autoStart = !1, this.deltaTime = 1, this.lastTime = -1, this.speed = 1, this.started = !1, this._requestId = null, this._maxElapsedMS = 100, this._minElapsedMS = 0, this._protected = !1, this._lastFrame = -1, this._head = new TickerListener(null, null, 1 / 0), this.deltaMS = 1 / _Ticker2.targetFPMS, this.elapsedMS = 1 / _Ticker2.targetFPMS, this._tick = (time) => {
+      this._requestId = null, this.started && (this.update(time), this.started && this._requestId === null && this._head.next && (this._requestId = requestAnimationFrame(this._tick)));
+    };
+  }
+  /**
+   * Conditionally requests a new animation frame.
+   * If a frame has not already been requested, and if the internal
+   * emitter has listeners, a new frame is requested.
+   * @private
+   */
+  _requestIfNeeded() {
+    this._requestId === null && this._head.next && (this.lastTime = performance.now(), this._lastFrame = this.lastTime, this._requestId = requestAnimationFrame(this._tick));
+  }
+  /**
+   * Conditionally cancels a pending animation frame.
+   * @private
+   */
+  _cancelIfNeeded() {
+    this._requestId !== null && (cancelAnimationFrame(this._requestId), this._requestId = null);
+  }
+  /**
+   * Conditionally requests a new animation frame.
+   * If the ticker has been started it checks if a frame has not already
+   * been requested, and if the internal emitter has listeners. If these
+   * conditions are met, a new frame is requested. If the ticker has not
+   * been started, but autoStart is `true`, then the ticker starts now,
+   * and continues with the previous conditions to request a new frame.
+   * @private
+   */
+  _startIfPossible() {
+    this.started ? this._requestIfNeeded() : this.autoStart && this.start();
+  }
+  /**
+   * Register a handler for tick events. Calls continuously unless
+   * it is removed or the ticker is stopped.
+   * @param fn - The listener function to be added for updates
+   * @param context - The listener context
+   * @param {number} [priority=PIXI.UPDATE_PRIORITY.NORMAL] - The priority for emitting
+   * @returns This instance of a ticker
+   */
+  add(fn, context, priority = UPDATE_PRIORITY.NORMAL) {
+    return this._addListener(new TickerListener(fn, context, priority));
+  }
+  /**
+   * Add a handler for the tick event which is only execute once.
+   * @param fn - The listener function to be added for one update
+   * @param context - The listener context
+   * @param {number} [priority=PIXI.UPDATE_PRIORITY.NORMAL] - The priority for emitting
+   * @returns This instance of a ticker
+   */
+  addOnce(fn, context, priority = UPDATE_PRIORITY.NORMAL) {
+    return this._addListener(new TickerListener(fn, context, priority, !0));
+  }
+  /**
+   * Internally adds the event handler so that it can be sorted by priority.
+   * Priority allows certain handler (user, AnimatedSprite, Interaction) to be run
+   * before the rendering.
+   * @private
+   * @param listener - Current listener being added.
+   * @returns This instance of a ticker
+   */
+  _addListener(listener) {
+    let current = this._head.next, previous = this._head;
+    if (!current)
+      listener.connect(previous);
+    else {
+      for (; current; ) {
+        if (listener.priority > current.priority) {
+          listener.connect(previous);
+          break;
+        }
+        previous = current, current = current.next;
+      }
+      listener.previous || listener.connect(previous);
+    }
+    return this._startIfPossible(), this;
+  }
+  /**
+   * Removes any handlers matching the function and context parameters.
+   * If no handlers are left after removing, then it cancels the animation frame.
+   * @param fn - The listener function to be removed
+   * @param context - The listener context to be removed
+   * @returns This instance of a ticker
+   */
+  remove(fn, context) {
+    let listener = this._head.next;
+    for (; listener; )
+      listener.match(fn, context) ? listener = listener.destroy() : listener = listener.next;
+    return this._head.next || this._cancelIfNeeded(), this;
+  }
+  /**
+   * The number of listeners on this ticker, calculated by walking through linked list
+   * @readonly
+   * @member {number}
+   */
+  get count() {
+    if (!this._head)
+      return 0;
+    let count = 0, current = this._head;
+    for (; current = current.next; )
+      count++;
+    return count;
+  }
+  /** Starts the ticker. If the ticker has listeners a new animation frame is requested at this point. */
+  start() {
+    this.started || (this.started = !0, this._requestIfNeeded());
+  }
+  /** Stops the ticker. If the ticker has requested an animation frame it is canceled at this point. */
+  stop() {
+    this.started && (this.started = !1, this._cancelIfNeeded());
+  }
+  /** Destroy the ticker and don't use after this. Calling this method removes all references to internal events. */
+  destroy() {
+    if (!this._protected) {
+      this.stop();
+      let listener = this._head.next;
+      for (; listener; )
+        listener = listener.destroy(!0);
+      this._head.destroy(), this._head = null;
+    }
+  }
+  /**
+   * Triggers an update. An update entails setting the
+   * current {@link PIXI.Ticker#elapsedMS},
+   * the current {@link PIXI.Ticker#deltaTime},
+   * invoking all listeners with current deltaTime,
+   * and then finally setting {@link PIXI.Ticker#lastTime}
+   * with the value of currentTime that was provided.
+   * This method will be called automatically by animation
+   * frame callbacks if the ticker instance has been started
+   * and listeners are added.
+   * @param {number} [currentTime=performance.now()] - the current time of execution
+   */
+  update(currentTime = performance.now()) {
+    let elapsedMS;
+    if (currentTime > this.lastTime) {
+      if (elapsedMS = this.elapsedMS = currentTime - this.lastTime, elapsedMS > this._maxElapsedMS && (elapsedMS = this._maxElapsedMS), elapsedMS *= this.speed, this._minElapsedMS) {
+        const delta = currentTime - this._lastFrame | 0;
+        if (delta < this._minElapsedMS)
+          return;
+        this._lastFrame = currentTime - delta % this._minElapsedMS;
+      }
+      this.deltaMS = elapsedMS, this.deltaTime = this.deltaMS * _Ticker2.targetFPMS;
+      const head = this._head;
+      let listener = head.next;
+      for (; listener; )
+        listener = listener.emit(this.deltaTime);
+      head.next || this._cancelIfNeeded();
+    } else
+      this.deltaTime = this.deltaMS = this.elapsedMS = 0;
+    this.lastTime = currentTime;
+  }
+  /**
+   * The frames per second at which this ticker is running.
+   * The default is approximately 60 in most modern browsers.
+   * **Note:** This does not factor in the value of
+   * {@link PIXI.Ticker#speed}, which is specific
+   * to scaling {@link PIXI.Ticker#deltaTime}.
+   * @member {number}
+   * @readonly
+   */
+  get FPS() {
+    return 1e3 / this.elapsedMS;
+  }
+  /**
+   * Manages the maximum amount of milliseconds allowed to
+   * elapse between invoking {@link PIXI.Ticker#update}.
+   * This value is used to cap {@link PIXI.Ticker#deltaTime},
+   * but does not effect the measured value of {@link PIXI.Ticker#FPS}.
+   * When setting this property it is clamped to a value between
+   * `0` and `Ticker.targetFPMS * 1000`.
+   * @member {number}
+   * @default 10
+   */
+  get minFPS() {
+    return 1e3 / this._maxElapsedMS;
+  }
+  set minFPS(fps) {
+    const minFPS = Math.min(this.maxFPS, fps), minFPMS = Math.min(Math.max(0, minFPS) / 1e3, _Ticker2.targetFPMS);
+    this._maxElapsedMS = 1 / minFPMS;
+  }
+  /**
+   * Manages the minimum amount of milliseconds required to
+   * elapse between invoking {@link PIXI.Ticker#update}.
+   * This will effect the measured value of {@link PIXI.Ticker#FPS}.
+   * If it is set to `0`, then there is no limit; PixiJS will render as many frames as it can.
+   * Otherwise it will be at least `minFPS`
+   * @member {number}
+   * @default 0
+   */
+  get maxFPS() {
+    return this._minElapsedMS ? Math.round(1e3 / this._minElapsedMS) : 0;
+  }
+  set maxFPS(fps) {
+    if (fps === 0)
+      this._minElapsedMS = 0;
+    else {
+      const maxFPS = Math.max(this.minFPS, fps);
+      this._minElapsedMS = 1 / (maxFPS / 1e3);
+    }
+  }
+  /**
+   * The shared ticker instance used by {@link PIXI.AnimatedSprite} and by
+   * {@link PIXI.VideoResource} to update animation frames / video textures.
+   *
+   * It may also be used by {@link PIXI.Application} if created with the `sharedTicker` option property set to true.
+   *
+   * The property {@link PIXI.Ticker#autoStart} is set to `true` for this instance.
+   * Please follow the examples for usage, including how to opt-out of auto-starting the shared ticker.
+   * @example
+   * import { Ticker } from 'pixi.js';
+   *
+   * const ticker = Ticker.shared;
+   * // Set this to prevent starting this ticker when listeners are added.
+   * // By default this is true only for the PIXI.Ticker.shared instance.
+   * ticker.autoStart = false;
+   *
+   * // FYI, call this to ensure the ticker is stopped. It should be stopped
+   * // if you have not attempted to render anything yet.
+   * ticker.stop();
+   *
+   * // Call this when you are ready for a running shared ticker.
+   * ticker.start();
+   * @example
+   * import { autoDetectRenderer, Container } from 'pixi.js';
+   *
+   * // You may use the shared ticker to render...
+   * const renderer = autoDetectRenderer();
+   * const stage = new Container();
+   * document.body.appendChild(renderer.view);
+   * ticker.add((time) => renderer.render(stage));
+   *
+   * // Or you can just update it manually.
+   * ticker.autoStart = false;
+   * ticker.stop();
+   * const animate = (time) => {
+   *     ticker.update(time);
+   *     renderer.render(stage);
+   *     requestAnimationFrame(animate);
+   * };
+   * animate(performance.now());
+   * @member {PIXI.Ticker}
+   * @static
+   */
+  static get shared() {
+    if (!_Ticker2._shared) {
+      const shared = _Ticker2._shared = new _Ticker2();
+      shared.autoStart = !0, shared._protected = !0;
+    }
+    return _Ticker2._shared;
+  }
+  /**
+   * The system ticker instance used by {@link PIXI.BasePrepare} for core timing
+   * functionality that shouldn't usually need to be paused, unlike the `shared`
+   * ticker which drives visual animations and rendering which may want to be paused.
+   *
+   * The property {@link PIXI.Ticker#autoStart} is set to `true` for this instance.
+   * @member {PIXI.Ticker}
+   * @static
+   */
+  static get system() {
+    if (!_Ticker2._system) {
+      const system = _Ticker2._system = new _Ticker2();
+      system.autoStart = !0, system._protected = !0;
+    }
+    return _Ticker2._system;
+  }
+};
+_Ticker.targetFPMS = 0.06;
+let Ticker = _Ticker;
+export {
+  Ticker
+};
+//# sourceMappingURL=Ticker.mjs.map

resources/app/node_modules/@pixi/ticker/lib/TickerListener.js

@@ -0,0 +1,57 @@
+"use strict";
+class TickerListener {
+  /**
+   * Constructor
+   * @private
+   * @param fn - The listener function to be added for one update
+   * @param context - The listener context
+   * @param priority - The priority for emitting
+   * @param once - If the handler should fire once
+   */
+  constructor(fn, context = null, priority = 0, once = !1) {
+    this.next = null, this.previous = null, this._destroyed = !1, this.fn = fn, this.context = context, this.priority = priority, this.once = once;
+  }
+  /**
+   * Simple compare function to figure out if a function and context match.
+   * @private
+   * @param fn - The listener function to be added for one update
+   * @param context - The listener context
+   * @returns `true` if the listener match the arguments
+   */
+  match(fn, context = null) {
+    return this.fn === fn && this.context === context;
+  }
+  /**
+   * Emit by calling the current function.
+   * @private
+   * @param deltaTime - time since the last emit.
+   * @returns Next ticker
+   */
+  emit(deltaTime) {
+    this.fn && (this.context ? this.fn.call(this.context, deltaTime) : this.fn(deltaTime));
+    const redirect = this.next;
+    return this.once && this.destroy(!0), this._destroyed && (this.next = null), redirect;
+  }
+  /**
+   * Connect to the list.
+   * @private
+   * @param previous - Input node, previous listener
+   */
+  connect(previous) {
+    this.previous = previous, previous.next && (previous.next.previous = this), this.next = previous.next, previous.next = this;
+  }
+  /**
+   * Destroy and don't use after this.
+   * @private
+   * @param hard - `true` to remove the `next` reference, this
+   *        is considered a hard destroy. Soft destroy maintains the next reference.
+   * @returns The listener to redirect while emitting or removing.
+   */
+  destroy(hard = !1) {
+    this._destroyed = !0, this.fn = null, this.context = null, this.previous && (this.previous.next = this.next), this.next && (this.next.previous = this.previous);
+    const redirect = this.next;
+    return this.next = hard ? null : redirect, this.previous = null, redirect;
+  }
+}
+exports.TickerListener = TickerListener;
+//# sourceMappingURL=TickerListener.js.map

resources/app/node_modules/@pixi/ticker/lib/TickerListener.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TickerListener.js","sources":["../src/TickerListener.ts"],"sourcesContent":["import type { TickerCallback } from './Ticker';\n\n/**\n * Internal class for handling the priority sorting of ticker handlers.\n * @private\n * @class\n * @memberof PIXI\n */\nexport class TickerListener<T = any>\n{\n    /** The current priority. */\n    public priority: number;\n    /** The next item in chain. */\n    public next: TickerListener = null;\n    /** The previous item in chain. */\n    public previous: TickerListener = null;\n\n    /** The handler function to execute. */\n    private fn: TickerCallback<T>;\n    /** The calling to execute. */\n    private context: T;\n    /** If this should only execute once. */\n    private once: boolean;\n    /** `true` if this listener has been destroyed already. */\n    private _destroyed = false;\n\n    /**\n     * Constructor\n     * @private\n     * @param fn - The listener function to be added for one update\n     * @param context - The listener context\n     * @param priority - The priority for emitting\n     * @param once - If the handler should fire once\n     */\n    constructor(fn: TickerCallback<T>, context: T = null, priority = 0, once = false)\n    {\n        this.fn = fn;\n        this.context = context;\n        this.priority = priority;\n        this.once = once;\n    }\n\n    /**\n     * Simple compare function to figure out if a function and context match.\n     * @private\n     * @param fn - The listener function to be added for one update\n     * @param context - The listener context\n     * @returns `true` if the listener match the arguments\n     */\n    match(fn: TickerCallback<T>, context: any = null): boolean\n    {\n        return this.fn === fn && this.context === context;\n    }\n\n    /**\n     * Emit by calling the current function.\n     * @private\n     * @param deltaTime - time since the last emit.\n     * @returns Next ticker\n     */\n    emit(deltaTime: number): TickerListener\n    {\n        if (this.fn)\n        {\n            if (this.context)\n            {\n                this.fn.call(this.context, deltaTime);\n            }\n            else\n            {\n                (this as TickerListener<any>).fn(deltaTime);\n            }\n        }\n\n        const redirect = this.next;\n\n        if (this.once)\n        {\n            this.destroy(true);\n        }\n\n        // Soft-destroying should remove\n        // the next reference\n        if (this._destroyed)\n        {\n            this.next = null;\n        }\n\n        return redirect;\n    }\n\n    /**\n     * Connect to the list.\n     * @private\n     * @param previous - Input node, previous listener\n     */\n    connect(previous: TickerListener): void\n    {\n        this.previous = previous;\n        if (previous.next)\n        {\n            previous.next.previous = this;\n        }\n        this.next = previous.next;\n        previous.next = this;\n    }\n\n    /**\n     * Destroy and don't use after this.\n     * @private\n     * @param hard - `true` to remove the `next` reference, this\n     *        is considered a hard destroy. Soft destroy maintains the next reference.\n     * @returns The listener to redirect while emitting or removing.\n     */\n    destroy(hard = false): TickerListener\n    {\n        this._destroyed = true;\n        this.fn = null;\n        this.context = null;\n\n        // Disconnect, hook up next and previous\n        if (this.previous)\n        {\n            this.previous.next = this.next;\n        }\n\n        if (this.next)\n        {\n            this.next.previous = this.previous;\n        }\n\n        // Redirect to the next item\n        const redirect = this.next;\n\n        // Remove references\n        this.next = hard ? null : redirect;\n        this.previous = null;\n\n        return redirect;\n    }\n}\n"],"names":[],"mappings":";AAQO,MAAM,eACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAyBI,YAAY,IAAuB,UAAa,MAAM,WAAW,GAAG,OAAO,IAC3E;AAtBA,SAAO,OAAuB,MAE9B,KAAO,WAA2B,MASlC,KAAQ,aAAa,IAYZ,KAAA,KAAK,IACV,KAAK,UAAU,SACf,KAAK,WAAW,UAChB,KAAK,OAAO;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,IAAuB,UAAe,MAC5C;AACI,WAAO,KAAK,OAAO,MAAM,KAAK,YAAY;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,KAAK,WACL;AACQ,SAAK,OAED,KAAK,UAEL,KAAK,GAAG,KAAK,KAAK,SAAS,SAAS,IAInC,KAA6B,GAAG,SAAS;AAIlD,UAAM,WAAW,KAAK;AAElB,WAAA,KAAK,QAEL,KAAK,QAAQ,EAAI,GAKjB,KAAK,eAEL,KAAK,OAAO,OAGT;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,QAAQ,UACR;AACI,SAAK,WAAW,UACZ,SAAS,SAET,SAAS,KAAK,WAAW,OAE7B,KAAK,OAAO,SAAS,MACrB,SAAS,OAAO;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,QAAQ,OAAO,IACf;AACS,SAAA,aAAa,IAClB,KAAK,KAAK,MACV,KAAK,UAAU,MAGX,KAAK,aAEL,KAAK,SAAS,OAAO,KAAK,OAG1B,KAAK,SAEL,KAAK,KAAK,WAAW,KAAK;AAI9B,UAAM,WAAW,KAAK;AAGtB,WAAA,KAAK,OAAO,OAAO,OAAO,UAC1B,KAAK,WAAW,MAET;AAAA,EACX;AACJ;;"}

resources/app/node_modules/@pixi/ticker/lib/TickerListener.mjs

@@ -0,0 +1,58 @@
+class TickerListener {
+  /**
+   * Constructor
+   * @private
+   * @param fn - The listener function to be added for one update
+   * @param context - The listener context
+   * @param priority - The priority for emitting
+   * @param once - If the handler should fire once
+   */
+  constructor(fn, context = null, priority = 0, once = !1) {
+    this.next = null, this.previous = null, this._destroyed = !1, this.fn = fn, this.context = context, this.priority = priority, this.once = once;
+  }
+  /**
+   * Simple compare function to figure out if a function and context match.
+   * @private
+   * @param fn - The listener function to be added for one update
+   * @param context - The listener context
+   * @returns `true` if the listener match the arguments
+   */
+  match(fn, context = null) {
+    return this.fn === fn && this.context === context;
+  }
+  /**
+   * Emit by calling the current function.
+   * @private
+   * @param deltaTime - time since the last emit.
+   * @returns Next ticker
+   */
+  emit(deltaTime) {
+    this.fn && (this.context ? this.fn.call(this.context, deltaTime) : this.fn(deltaTime));
+    const redirect = this.next;
+    return this.once && this.destroy(!0), this._destroyed && (this.next = null), redirect;
+  }
+  /**
+   * Connect to the list.
+   * @private
+   * @param previous - Input node, previous listener
+   */
+  connect(previous) {
+    this.previous = previous, previous.next && (previous.next.previous = this), this.next = previous.next, previous.next = this;
+  }
+  /**
+   * Destroy and don't use after this.
+   * @private
+   * @param hard - `true` to remove the `next` reference, this
+   *        is considered a hard destroy. Soft destroy maintains the next reference.
+   * @returns The listener to redirect while emitting or removing.
+   */
+  destroy(hard = !1) {
+    this._destroyed = !0, this.fn = null, this.context = null, this.previous && (this.previous.next = this.next), this.next && (this.next.previous = this.previous);
+    const redirect = this.next;
+    return this.next = hard ? null : redirect, this.previous = null, redirect;
+  }
+}
+export {
+  TickerListener
+};
+//# sourceMappingURL=TickerListener.mjs.map

resources/app/node_modules/@pixi/ticker/lib/TickerListener.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TickerListener.mjs","sources":["../src/TickerListener.ts"],"sourcesContent":["import type { TickerCallback } from './Ticker';\n\n/**\n * Internal class for handling the priority sorting of ticker handlers.\n * @private\n * @class\n * @memberof PIXI\n */\nexport class TickerListener<T = any>\n{\n    /** The current priority. */\n    public priority: number;\n    /** The next item in chain. */\n    public next: TickerListener = null;\n    /** The previous item in chain. */\n    public previous: TickerListener = null;\n\n    /** The handler function to execute. */\n    private fn: TickerCallback<T>;\n    /** The calling to execute. */\n    private context: T;\n    /** If this should only execute once. */\n    private once: boolean;\n    /** `true` if this listener has been destroyed already. */\n    private _destroyed = false;\n\n    /**\n     * Constructor\n     * @private\n     * @param fn - The listener function to be added for one update\n     * @param context - The listener context\n     * @param priority - The priority for emitting\n     * @param once - If the handler should fire once\n     */\n    constructor(fn: TickerCallback<T>, context: T = null, priority = 0, once = false)\n    {\n        this.fn = fn;\n        this.context = context;\n        this.priority = priority;\n        this.once = once;\n    }\n\n    /**\n     * Simple compare function to figure out if a function and context match.\n     * @private\n     * @param fn - The listener function to be added for one update\n     * @param context - The listener context\n     * @returns `true` if the listener match the arguments\n     */\n    match(fn: TickerCallback<T>, context: any = null): boolean\n    {\n        return this.fn === fn && this.context === context;\n    }\n\n    /**\n     * Emit by calling the current function.\n     * @private\n     * @param deltaTime - time since the last emit.\n     * @returns Next ticker\n     */\n    emit(deltaTime: number): TickerListener\n    {\n        if (this.fn)\n        {\n            if (this.context)\n            {\n                this.fn.call(this.context, deltaTime);\n            }\n            else\n            {\n                (this as TickerListener<any>).fn(deltaTime);\n            }\n        }\n\n        const redirect = this.next;\n\n        if (this.once)\n        {\n            this.destroy(true);\n        }\n\n        // Soft-destroying should remove\n        // the next reference\n        if (this._destroyed)\n        {\n            this.next = null;\n        }\n\n        return redirect;\n    }\n\n    /**\n     * Connect to the list.\n     * @private\n     * @param previous - Input node, previous listener\n     */\n    connect(previous: TickerListener): void\n    {\n        this.previous = previous;\n        if (previous.next)\n        {\n            previous.next.previous = this;\n        }\n        this.next = previous.next;\n        previous.next = this;\n    }\n\n    /**\n     * Destroy and don't use after this.\n     * @private\n     * @param hard - `true` to remove the `next` reference, this\n     *        is considered a hard destroy. Soft destroy maintains the next reference.\n     * @returns The listener to redirect while emitting or removing.\n     */\n    destroy(hard = false): TickerListener\n    {\n        this._destroyed = true;\n        this.fn = null;\n        this.context = null;\n\n        // Disconnect, hook up next and previous\n        if (this.previous)\n        {\n            this.previous.next = this.next;\n        }\n\n        if (this.next)\n        {\n            this.next.previous = this.previous;\n        }\n\n        // Redirect to the next item\n        const redirect = this.next;\n\n        // Remove references\n        this.next = hard ? null : redirect;\n        this.previous = null;\n\n        return redirect;\n    }\n}\n"],"names":[],"mappings":"AAQO,MAAM,eACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAyBI,YAAY,IAAuB,UAAa,MAAM,WAAW,GAAG,OAAO,IAC3E;AAtBA,SAAO,OAAuB,MAE9B,KAAO,WAA2B,MASlC,KAAQ,aAAa,IAYZ,KAAA,KAAK,IACV,KAAK,UAAU,SACf,KAAK,WAAW,UAChB,KAAK,OAAO;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,IAAuB,UAAe,MAC5C;AACI,WAAO,KAAK,OAAO,MAAM,KAAK,YAAY;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,KAAK,WACL;AACQ,SAAK,OAED,KAAK,UAEL,KAAK,GAAG,KAAK,KAAK,SAAS,SAAS,IAInC,KAA6B,GAAG,SAAS;AAIlD,UAAM,WAAW,KAAK;AAElB,WAAA,KAAK,QAEL,KAAK,QAAQ,EAAI,GAKjB,KAAK,eAEL,KAAK,OAAO,OAGT;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,QAAQ,UACR;AACI,SAAK,WAAW,UACZ,SAAS,SAET,SAAS,KAAK,WAAW,OAE7B,KAAK,OAAO,SAAS,MACrB,SAAS,OAAO;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,QAAQ,OAAO,IACf;AACS,SAAA,aAAa,IAClB,KAAK,KAAK,MACV,KAAK,UAAU,MAGX,KAAK,aAEL,KAAK,SAAS,OAAO,KAAK,OAG1B,KAAK,SAEL,KAAK,KAAK,WAAW,KAAK;AAI9B,UAAM,WAAW,KAAK;AAGtB,WAAA,KAAK,OAAO,OAAO,OAAO,UAC1B,KAAK,WAAW,MAET;AAAA,EACX;AACJ;"}

resources/app/node_modules/@pixi/ticker/lib/TickerPlugin.js

@@ -0,0 +1,46 @@
+"use strict";
+var extensions = require("@pixi/extensions"), _const = require("./const.js"), Ticker = require("./Ticker.js");
+class TickerPlugin {
+  /**
+   * Initialize the plugin with scope of application instance
+   * @static
+   * @private
+   * @param {object} [options] - See application options
+   */
+  static init(options) {
+    options = Object.assign({
+      autoStart: !0,
+      sharedTicker: !1
+    }, options), Object.defineProperty(
+      this,
+      "ticker",
+      {
+        set(ticker) {
+          this._ticker && this._ticker.remove(this.render, this), this._ticker = ticker, ticker && ticker.add(this.render, this, _const.UPDATE_PRIORITY.LOW);
+        },
+        get() {
+          return this._ticker;
+        }
+      }
+    ), this.stop = () => {
+      this._ticker.stop();
+    }, this.start = () => {
+      this._ticker.start();
+    }, this._ticker = null, this.ticker = options.sharedTicker ? Ticker.Ticker.shared : new Ticker.Ticker(), options.autoStart && this.start();
+  }
+  /**
+   * Clean up the ticker, scoped to application.
+   * @static
+   * @private
+   */
+  static destroy() {
+    if (this._ticker) {
+      const oldTicker = this._ticker;
+      this.ticker = null, oldTicker.destroy();
+    }
+  }
+}
+TickerPlugin.extension = extensions.ExtensionType.Application;
+extensions.extensions.add(TickerPlugin);
+exports.TickerPlugin = TickerPlugin;
+//# sourceMappingURL=TickerPlugin.js.map

resources/app/node_modules/@pixi/ticker/lib/TickerPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TickerPlugin.js","sources":["../src/TickerPlugin.ts"],"sourcesContent":["import { extensions, ExtensionType } from '@pixi/extensions';\nimport { UPDATE_PRIORITY } from './const';\nimport { Ticker } from './Ticker';\n\nimport type { ExtensionMetadata } from '@pixi/extensions';\n\nexport interface TickerPluginOptions\n{\n    /**\n     * Automatically starts the rendering after the construction.\n     *  **Note**: Setting this parameter to `false` does NOT stop the shared ticker even if you set\n     *  `options.sharedTicker` to `true` in case that it is already started. Stop it by your own.\n     * @memberof PIXI.IApplicationOptions\n     * @default true\n     */\n    autoStart?: boolean;\n    /**\n     * Set`true` to use `Ticker.shared`, `false` to create new ticker.\n     *  If set to `false`, you cannot register a handler to occur before anything that runs on the shared ticker.\n     *  The system ticker will always run before both the shared ticker and the app ticker.\n     * @memberof PIXI.IApplicationOptions\n     * @default false\n     */\n    sharedTicker?: boolean;\n}\n\n/**\n * Middleware for for Application Ticker.\n * @class\n * @memberof PIXI\n */\nexport class TickerPlugin\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = ExtensionType.Application;\n\n    static start: () => void;\n    static stop: () => void;\n    static _ticker: Ticker;\n    static ticker: Ticker;\n\n    /**\n     * Initialize the plugin with scope of application instance\n     * @static\n     * @private\n     * @param {object} [options] - See application options\n     */\n    static init(options?: GlobalMixins.IApplicationOptions): void\n    {\n        // Set default\n        options = Object.assign({\n            autoStart: true,\n            sharedTicker: false,\n        }, options);\n\n        // Create ticker setter\n        Object.defineProperty(this, 'ticker',\n            {\n                set(ticker)\n                {\n                    if (this._ticker)\n                    {\n                        this._ticker.remove(this.render, this);\n                    }\n                    this._ticker = ticker;\n                    if (ticker)\n                    {\n                        ticker.add(this.render, this, UPDATE_PRIORITY.LOW);\n                    }\n                },\n                get()\n                {\n                    return this._ticker;\n                },\n            });\n\n        /**\n         * Convenience method for stopping the render.\n         * @method\n         * @memberof PIXI.Application\n         * @instance\n         */\n        this.stop = (): void =>\n        {\n            this._ticker.stop();\n        };\n\n        /**\n         * Convenience method for starting the render.\n         * @method\n         * @memberof PIXI.Application\n         * @instance\n         */\n        this.start = (): void =>\n        {\n            this._ticker.start();\n        };\n\n        /**\n         * Internal reference to the ticker.\n         * @type {PIXI.Ticker}\n         * @name _ticker\n         * @memberof PIXI.Application#\n         * @private\n         */\n        this._ticker = null;\n\n        /**\n         * Ticker for doing render updates.\n         * @type {PIXI.Ticker}\n         * @name ticker\n         * @memberof PIXI.Application#\n         * @default PIXI.Ticker.shared\n         */\n        this.ticker = options.sharedTicker ? Ticker.shared : new Ticker();\n\n        // Start the rendering\n        if (options.autoStart)\n        {\n            this.start();\n        }\n    }\n\n    /**\n     * Clean up the ticker, scoped to application.\n     * @static\n     * @private\n     */\n    static destroy(): void\n    {\n        if (this._ticker)\n        {\n            const oldTicker = this._ticker;\n\n            this.ticker = null;\n            oldTicker.destroy();\n        }\n    }\n}\n\nextensions.add(TickerPlugin);\n"],"names":["UPDATE_PRIORITY","Ticker","ExtensionType","extensions"],"mappings":";;AA+BO,MAAM,aACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeI,OAAO,KAAK,SACZ;AAEI,cAAU,OAAO,OAAO;AAAA,MACpB,WAAW;AAAA,MACX,cAAc;AAAA,IAAA,GACf,OAAO,GAGV,OAAO;AAAA,MAAe;AAAA,MAAM;AAAA,MACxB;AAAA,QACI,IAAI,QACJ;AACQ,eAAK,WAEL,KAAK,QAAQ,OAAO,KAAK,QAAQ,IAAI,GAEzC,KAAK,UAAU,QACX,UAEA,OAAO,IAAI,KAAK,QAAQ,MAAMA,uBAAgB,GAAG;AAAA,QAEzD;AAAA,QACA,MACA;AACI,iBAAO,KAAK;AAAA,QAChB;AAAA,MACJ;AAAA,IAAA,GAQJ,KAAK,OAAO,MACZ;AACI,WAAK,QAAQ;IAAK,GAStB,KAAK,QAAQ,MACb;AACI,WAAK,QAAQ;IAAM,GAUvB,KAAK,UAAU,MASf,KAAK,SAAS,QAAQ,eAAeC,OAAO,OAAA,SAAS,IAAIA,OAAAA,UAGrD,QAAQ,aAER,KAAK;EAEb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAO,UACP;AACI,QAAI,KAAK,SACT;AACI,YAAM,YAAY,KAAK;AAElB,WAAA,SAAS,MACd,UAAU,QAAQ;AAAA,IACtB;AAAA,EACJ;AACJ;AA3Ga,aAGF,YAA+BC,WAAc,cAAA;AA0GxDC,WAAAA,WAAW,IAAI,YAAY;;"}

resources/app/node_modules/@pixi/ticker/lib/TickerPlugin.mjs

@@ -0,0 +1,49 @@
+import { ExtensionType, extensions } from "@pixi/extensions";
+import { UPDATE_PRIORITY } from "./const.mjs";
+import { Ticker } from "./Ticker.mjs";
+class TickerPlugin {
+  /**
+   * Initialize the plugin with scope of application instance
+   * @static
+   * @private
+   * @param {object} [options] - See application options
+   */
+  static init(options) {
+    options = Object.assign({
+      autoStart: !0,
+      sharedTicker: !1
+    }, options), Object.defineProperty(
+      this,
+      "ticker",
+      {
+        set(ticker) {
+          this._ticker && this._ticker.remove(this.render, this), this._ticker = ticker, ticker && ticker.add(this.render, this, UPDATE_PRIORITY.LOW);
+        },
+        get() {
+          return this._ticker;
+        }
+      }
+    ), this.stop = () => {
+      this._ticker.stop();
+    }, this.start = () => {
+      this._ticker.start();
+    }, this._ticker = null, this.ticker = options.sharedTicker ? Ticker.shared : new Ticker(), options.autoStart && this.start();
+  }
+  /**
+   * Clean up the ticker, scoped to application.
+   * @static
+   * @private
+   */
+  static destroy() {
+    if (this._ticker) {
+      const oldTicker = this._ticker;
+      this.ticker = null, oldTicker.destroy();
+    }
+  }
+}
+TickerPlugin.extension = ExtensionType.Application;
+extensions.add(TickerPlugin);
+export {
+  TickerPlugin
+};
+//# sourceMappingURL=TickerPlugin.mjs.map

resources/app/node_modules/@pixi/ticker/lib/TickerPlugin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TickerPlugin.mjs","sources":["../src/TickerPlugin.ts"],"sourcesContent":["import { extensions, ExtensionType } from '@pixi/extensions';\nimport { UPDATE_PRIORITY } from './const';\nimport { Ticker } from './Ticker';\n\nimport type { ExtensionMetadata } from '@pixi/extensions';\n\nexport interface TickerPluginOptions\n{\n    /**\n     * Automatically starts the rendering after the construction.\n     *  **Note**: Setting this parameter to `false` does NOT stop the shared ticker even if you set\n     *  `options.sharedTicker` to `true` in case that it is already started. Stop it by your own.\n     * @memberof PIXI.IApplicationOptions\n     * @default true\n     */\n    autoStart?: boolean;\n    /**\n     * Set`true` to use `Ticker.shared`, `false` to create new ticker.\n     *  If set to `false`, you cannot register a handler to occur before anything that runs on the shared ticker.\n     *  The system ticker will always run before both the shared ticker and the app ticker.\n     * @memberof PIXI.IApplicationOptions\n     * @default false\n     */\n    sharedTicker?: boolean;\n}\n\n/**\n * Middleware for for Application Ticker.\n * @class\n * @memberof PIXI\n */\nexport class TickerPlugin\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = ExtensionType.Application;\n\n    static start: () => void;\n    static stop: () => void;\n    static _ticker: Ticker;\n    static ticker: Ticker;\n\n    /**\n     * Initialize the plugin with scope of application instance\n     * @static\n     * @private\n     * @param {object} [options] - See application options\n     */\n    static init(options?: GlobalMixins.IApplicationOptions): void\n    {\n        // Set default\n        options = Object.assign({\n            autoStart: true,\n            sharedTicker: false,\n        }, options);\n\n        // Create ticker setter\n        Object.defineProperty(this, 'ticker',\n            {\n                set(ticker)\n                {\n                    if (this._ticker)\n                    {\n                        this._ticker.remove(this.render, this);\n                    }\n                    this._ticker = ticker;\n                    if (ticker)\n                    {\n                        ticker.add(this.render, this, UPDATE_PRIORITY.LOW);\n                    }\n                },\n                get()\n                {\n                    return this._ticker;\n                },\n            });\n\n        /**\n         * Convenience method for stopping the render.\n         * @method\n         * @memberof PIXI.Application\n         * @instance\n         */\n        this.stop = (): void =>\n        {\n            this._ticker.stop();\n        };\n\n        /**\n         * Convenience method for starting the render.\n         * @method\n         * @memberof PIXI.Application\n         * @instance\n         */\n        this.start = (): void =>\n        {\n            this._ticker.start();\n        };\n\n        /**\n         * Internal reference to the ticker.\n         * @type {PIXI.Ticker}\n         * @name _ticker\n         * @memberof PIXI.Application#\n         * @private\n         */\n        this._ticker = null;\n\n        /**\n         * Ticker for doing render updates.\n         * @type {PIXI.Ticker}\n         * @name ticker\n         * @memberof PIXI.Application#\n         * @default PIXI.Ticker.shared\n         */\n        this.ticker = options.sharedTicker ? Ticker.shared : new Ticker();\n\n        // Start the rendering\n        if (options.autoStart)\n        {\n            this.start();\n        }\n    }\n\n    /**\n     * Clean up the ticker, scoped to application.\n     * @static\n     * @private\n     */\n    static destroy(): void\n    {\n        if (this._ticker)\n        {\n            const oldTicker = this._ticker;\n\n            this.ticker = null;\n            oldTicker.destroy();\n        }\n    }\n}\n\nextensions.add(TickerPlugin);\n"],"names":[],"mappings":";;;AA+BO,MAAM,aACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeI,OAAO,KAAK,SACZ;AAEI,cAAU,OAAO,OAAO;AAAA,MACpB,WAAW;AAAA,MACX,cAAc;AAAA,IAAA,GACf,OAAO,GAGV,OAAO;AAAA,MAAe;AAAA,MAAM;AAAA,MACxB;AAAA,QACI,IAAI,QACJ;AACQ,eAAK,WAEL,KAAK,QAAQ,OAAO,KAAK,QAAQ,IAAI,GAEzC,KAAK,UAAU,QACX,UAEA,OAAO,IAAI,KAAK,QAAQ,MAAM,gBAAgB,GAAG;AAAA,QAEzD;AAAA,QACA,MACA;AACI,iBAAO,KAAK;AAAA,QAChB;AAAA,MACJ;AAAA,IAAA,GAQJ,KAAK,OAAO,MACZ;AACI,WAAK,QAAQ;IAAK,GAStB,KAAK,QAAQ,MACb;AACI,WAAK,QAAQ;IAAM,GAUvB,KAAK,UAAU,MASf,KAAK,SAAS,QAAQ,eAAe,OAAO,SAAS,IAAI,UAGrD,QAAQ,aAER,KAAK;EAEb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAO,UACP;AACI,QAAI,KAAK,SACT;AACI,YAAM,YAAY,KAAK;AAElB,WAAA,SAAS,MACd,UAAU,QAAQ;AAAA,IACtB;AAAA,EACJ;AACJ;AA3Ga,aAGF,YAA+B,cAAc;AA0GxD,WAAW,IAAI,YAAY;"}

resources/app/node_modules/@pixi/ticker/lib/const.js

@@ -0,0 +1,4 @@
+"use strict";
+var UPDATE_PRIORITY = /* @__PURE__ */ ((UPDATE_PRIORITY2) => (UPDATE_PRIORITY2[UPDATE_PRIORITY2.INTERACTION = 50] = "INTERACTION", UPDATE_PRIORITY2[UPDATE_PRIORITY2.HIGH = 25] = "HIGH", UPDATE_PRIORITY2[UPDATE_PRIORITY2.NORMAL = 0] = "NORMAL", UPDATE_PRIORITY2[UPDATE_PRIORITY2.LOW = -25] = "LOW", UPDATE_PRIORITY2[UPDATE_PRIORITY2.UTILITY = -50] = "UTILITY", UPDATE_PRIORITY2))(UPDATE_PRIORITY || {});
+exports.UPDATE_PRIORITY = UPDATE_PRIORITY;
+//# sourceMappingURL=const.js.map

resources/app/node_modules/@pixi/ticker/lib/const.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.js","sources":["../src/const.ts"],"sourcesContent":["/**\n * Represents the update priorities used by internal PIXI classes when registered with\n * the {@link PIXI.Ticker} object. Higher priority items are updated first and lower\n * priority items, such as render, should go later.\n * @static\n * @memberof PIXI\n * @enum {number}\n */\nexport enum UPDATE_PRIORITY\n// eslint-disable-next-line @typescript-eslint/indent\n{\n    /**\n     * Highest priority used for interaction events in {@link PIXI.EventSystem}\n     * @default 50\n     */\n    INTERACTION = 50,\n    /**\n     * High priority updating, used by {@link PIXI.AnimatedSprite}\n     * @default 25\n     */\n    HIGH = 25,\n    /**\n     * Default priority for ticker events, see {@link PIXI.Ticker#add}.\n     * @default 0\n     */\n    NORMAL = 0,\n    /**\n     * Low priority used for {@link PIXI.Application} rendering.\n     * @default -25\n     */\n    LOW = -25,\n    /**\n     * Lowest priority used for {@link PIXI.BasePrepare} utility.\n     * @default -50\n     */\n    UTILITY = -50,\n}\n"],"names":["UPDATE_PRIORITY"],"mappings":";AAQY,IAAA,oCAAAA,sBAORA,iBAAAA,iBAAA,cAAc,EAAd,IAAA,eAKAA,iBAAA,iBAAA,OAAO,EAAP,IAAA,QAKAA,kCAAA,SAAS,CAAA,IAAT,UAKAA,iBAAAA,iBAAA,MAAM,GAAA,IAAN,OAKAA,iBAAA,iBAAA,UAAU,GAAV,IAAA,WA3BQA,mBAAA,mBAAA,CAAA,CAAA;;"}

resources/app/node_modules/@pixi/ticker/lib/const.mjs

@@ -0,0 +1,5 @@
+var UPDATE_PRIORITY = /* @__PURE__ */ ((UPDATE_PRIORITY2) => (UPDATE_PRIORITY2[UPDATE_PRIORITY2.INTERACTION = 50] = "INTERACTION", UPDATE_PRIORITY2[UPDATE_PRIORITY2.HIGH = 25] = "HIGH", UPDATE_PRIORITY2[UPDATE_PRIORITY2.NORMAL = 0] = "NORMAL", UPDATE_PRIORITY2[UPDATE_PRIORITY2.LOW = -25] = "LOW", UPDATE_PRIORITY2[UPDATE_PRIORITY2.UTILITY = -50] = "UTILITY", UPDATE_PRIORITY2))(UPDATE_PRIORITY || {});
+export {
+  UPDATE_PRIORITY
+};
+//# sourceMappingURL=const.mjs.map

resources/app/node_modules/@pixi/ticker/lib/const.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.mjs","sources":["../src/const.ts"],"sourcesContent":["/**\n * Represents the update priorities used by internal PIXI classes when registered with\n * the {@link PIXI.Ticker} object. Higher priority items are updated first and lower\n * priority items, such as render, should go later.\n * @static\n * @memberof PIXI\n * @enum {number}\n */\nexport enum UPDATE_PRIORITY\n// eslint-disable-next-line @typescript-eslint/indent\n{\n    /**\n     * Highest priority used for interaction events in {@link PIXI.EventSystem}\n     * @default 50\n     */\n    INTERACTION = 50,\n    /**\n     * High priority updating, used by {@link PIXI.AnimatedSprite}\n     * @default 25\n     */\n    HIGH = 25,\n    /**\n     * Default priority for ticker events, see {@link PIXI.Ticker#add}.\n     * @default 0\n     */\n    NORMAL = 0,\n    /**\n     * Low priority used for {@link PIXI.Application} rendering.\n     * @default -25\n     */\n    LOW = -25,\n    /**\n     * Lowest priority used for {@link PIXI.BasePrepare} utility.\n     * @default -50\n     */\n    UTILITY = -50,\n}\n"],"names":["UPDATE_PRIORITY"],"mappings":"AAQY,IAAA,oCAAAA,sBAORA,iBAAAA,iBAAA,cAAc,EAAd,IAAA,eAKAA,iBAAA,iBAAA,OAAO,EAAP,IAAA,QAKAA,kCAAA,SAAS,CAAA,IAAT,UAKAA,iBAAAA,iBAAA,MAAM,GAAA,IAAN,OAKAA,iBAAA,iBAAA,UAAU,GAAV,IAAA,WA3BQA,mBAAA,mBAAA,CAAA,CAAA;"}

resources/app/node_modules/@pixi/ticker/lib/index.js

@@ -0,0 +1,7 @@
+"use strict";
+require("./settings.js");
+var _const = require("./const.js"), Ticker = require("./Ticker.js"), TickerPlugin = require("./TickerPlugin.js");
+exports.UPDATE_PRIORITY = _const.UPDATE_PRIORITY;
+exports.Ticker = Ticker.Ticker;
+exports.TickerPlugin = TickerPlugin.TickerPlugin;
+//# sourceMappingURL=index.js.map

resources/app/node_modules/@pixi/ticker/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

resources/app/node_modules/@pixi/ticker/lib/index.mjs

@@ -0,0 +1,10 @@
+import "./settings.mjs";
+import { UPDATE_PRIORITY } from "./const.mjs";
+import { Ticker } from "./Ticker.mjs";
+import { TickerPlugin } from "./TickerPlugin.mjs";
+export {
+  Ticker,
+  TickerPlugin,
+  UPDATE_PRIORITY
+};
+//# sourceMappingURL=index.mjs.map

resources/app/node_modules/@pixi/ticker/lib/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

resources/app/node_modules/@pixi/ticker/lib/settings.js

@@ -0,0 +1,28 @@
+"use strict";
+var settings = require("@pixi/settings"), utils = require("@pixi/utils"), Ticker = require("./Ticker.js");
+Object.defineProperties(settings.settings, {
+  /**
+   * Target frames per millisecond.
+   * @static
+   * @name TARGET_FPMS
+   * @memberof PIXI.settings
+   * @type {number}
+   * @deprecated since 7.1.0
+   * @see PIXI.Ticker.targetFPMS
+   */
+  TARGET_FPMS: {
+    get() {
+      return Ticker.Ticker.targetFPMS;
+    },
+    set(value) {
+      utils.deprecation("7.1.0", "settings.TARGET_FPMS is deprecated, use Ticker.targetFPMS"), Ticker.Ticker.targetFPMS = value;
+    }
+  }
+});
+Object.defineProperty(exports, "settings", {
+  enumerable: !0,
+  get: function() {
+    return settings.settings;
+  }
+});
+//# sourceMappingURL=settings.js.map

resources/app/node_modules/@pixi/ticker/lib/settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.js","sources":["../src/settings.ts"],"sourcesContent":["import { settings } from '@pixi/settings';\nimport { deprecation } from '@pixi/utils';\nimport { Ticker } from './Ticker';\n\nObject.defineProperties(settings, {\n    /**\n     * Target frames per millisecond.\n     * @static\n     * @name TARGET_FPMS\n     * @memberof PIXI.settings\n     * @type {number}\n     * @deprecated since 7.1.0\n     * @see PIXI.Ticker.targetFPMS\n     */\n    TARGET_FPMS: {\n        get()\n        {\n            return Ticker.targetFPMS;\n        },\n        set(value: number)\n        {\n            if (process.env.DEBUG)\n            {\n                deprecation('7.1.0', 'settings.TARGET_FPMS is deprecated, use Ticker.targetFPMS');\n            }\n\n            Ticker.targetFPMS = value;\n        },\n    },\n});\n\nexport { settings };\n"],"names":["settings","Ticker","deprecation"],"mappings":";;AAIA,OAAO,iBAAiBA,SAAAA,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAU9B,aAAa;AAAA,IACT,MACA;AACI,aAAOC,OAAAA,OAAO;AAAA,IAClB;AAAA,IACA,IAAI,OACJ;AAGQC,YAAA,YAAY,SAAS,2DAA2D,GAGpFD,OAAAA,OAAO,aAAa;AAAA,IACxB;AAAA,EACJ;AACJ,CAAC;;;;;;;"}

resources/app/node_modules/@pixi/ticker/lib/settings.mjs

@@ -0,0 +1,27 @@
+import { settings } from "@pixi/settings";
+import { settings as settings2 } from "@pixi/settings";
+import { deprecation } from "@pixi/utils";
+import { Ticker } from "./Ticker.mjs";
+Object.defineProperties(settings, {
+  /**
+   * Target frames per millisecond.
+   * @static
+   * @name TARGET_FPMS
+   * @memberof PIXI.settings
+   * @type {number}
+   * @deprecated since 7.1.0
+   * @see PIXI.Ticker.targetFPMS
+   */
+  TARGET_FPMS: {
+    get() {
+      return Ticker.targetFPMS;
+    },
+    set(value) {
+      deprecation("7.1.0", "settings.TARGET_FPMS is deprecated, use Ticker.targetFPMS"), Ticker.targetFPMS = value;
+    }
+  }
+});
+export {
+  settings2 as settings
+};
+//# sourceMappingURL=settings.mjs.map

resources/app/node_modules/@pixi/ticker/lib/settings.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.mjs","sources":["../src/settings.ts"],"sourcesContent":["import { settings } from '@pixi/settings';\nimport { deprecation } from '@pixi/utils';\nimport { Ticker } from './Ticker';\n\nObject.defineProperties(settings, {\n    /**\n     * Target frames per millisecond.\n     * @static\n     * @name TARGET_FPMS\n     * @memberof PIXI.settings\n     * @type {number}\n     * @deprecated since 7.1.0\n     * @see PIXI.Ticker.targetFPMS\n     */\n    TARGET_FPMS: {\n        get()\n        {\n            return Ticker.targetFPMS;\n        },\n        set(value: number)\n        {\n            if (process.env.DEBUG)\n            {\n                deprecation('7.1.0', 'settings.TARGET_FPMS is deprecated, use Ticker.targetFPMS');\n            }\n\n            Ticker.targetFPMS = value;\n        },\n    },\n});\n\nexport { settings };\n"],"names":[],"mappings":";;;;AAIA,OAAO,iBAAiB,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAU9B,aAAa;AAAA,IACT,MACA;AACI,aAAO,OAAO;AAAA,IAClB;AAAA,IACA,IAAI,OACJ;AAGQ,kBAAY,SAAS,2DAA2D,GAGpF,OAAO,aAAa;AAAA,IACxB;AAAA,EACJ;AACJ,CAAC;"}

resources/app/node_modules/@pixi/ticker/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@pixi/ticker",
+  "version": "7.4.2",
+  "main": "lib/index.js",
+  "module": "lib/index.mjs",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.mjs"
+      },
+      "require": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      }
+    }
+  },
+  "description": "Tickers are control the timings within PixiJS",
+  "author": "Mat Groves",
+  "homepage": "http://pixijs.com/",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pixijs/pixijs.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "lib",
+    "*.d.ts"
+  ],
+  "dependencies": {
+    "@pixi/extensions": "7.4.2",
+    "@pixi/settings": "7.4.2",
+    "@pixi/utils": "7.4.2"
+  }
+}