Initial

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