@vpmedia/phaser 1.120.0 → 1.121.0

package/src/phaser/core/sound_sprite.ts

@@ -1,11 +1,26 @@
 import type { Game } from './game.js';
+import type { Sound } from './sound.js';
+
+/** One region of a sound sprite, as the audio atlas describes it. */
+export type SoundSpriteMarker = {
+  start: number;
+  end: number;
+  loop?: boolean;
+};
+
+/** An audio atlas: the markers it carries and the one to start on. */
+export type SoundSpriteConfig = {
+  spritemap: Record<string, SoundSpriteMarker>;
+  autoplay?: string;
+};
+
 export class SoundSprite {
   public game!: Game;
-  public key!: any;
-  public config!: any;
-  public autoplayKey!: any;
-  public autoplay!: any;
-  public sounds!: any;
+  public key!: string;
+  public config!: SoundSpriteConfig;
+  public autoplayKey!: string | null;
+  public autoplay!: Sound | boolean;
+  public sounds!: Record<string, Sound>;
   /**
    * TBD.
    * @param {Game} game - TBD.
@@ -14,21 +29,19 @@ export class SoundSprite {
   public constructor(game: Game, key: string) {
     this.game = game;
     this.key = key;
-    this.config = this.game.cache.getJSON(`${key}-audioatlas`);
+    this.config = this.game.cache.getJSON<SoundSpriteConfig>(`${key}-audioatlas`);
     this.autoplayKey = null;
     this.autoplay = false;
-    /** @type {{[key: string]: Sound}} */
     this.sounds = {};
-    for (const k in this.config.spritemap) {
-      const marker = this.config.spritemap[k];
+    for (const [markerKey, marker] of Object.entries(this.config.spritemap)) {
       const sound = this.game.sound.add(this.key);
-      sound.addMarker(k, marker.start, marker.end - marker.start, undefined, marker.loop);
-      this.sounds[k] = sound;
+      sound.addMarker(markerKey, marker.start, marker.end - marker.start, undefined, marker.loop);
+      this.sounds[markerKey] = sound;
     }
     if (this.config.autoplay) {
       this.autoplayKey = this.config.autoplay;
       this.play(this.autoplayKey);
-      this.autoplay = this.sounds[this.autoplayKey];
+      this.autoplay = this.sounds[this.autoplayKey]!;
     }
   }
 
@@ -38,8 +51,8 @@ export class SoundSprite {
    * @param {number} volume - TBD.
    * @returns {Sound} TBD.
    */
-  public play(marker: string, volume = 1) {
-    return this.sounds[marker].play(marker, null, volume);
+  public play(marker: string, volume = 1): Sound | undefined {
+    return this.sounds[marker]?.play(marker, undefined, volume);
   }
 
   /**
@@ -47,12 +60,12 @@ export class SoundSprite {
    * @param {string} marker - TBD.
    */
   public stop(marker: string): void {
-    if (!marker) {
-      for (const key in this.sounds) {
-        this.sounds[key].stop();
-      }
-    } else {
-      this.sounds[marker].stop();
+    if (marker) {
+      this.sounds[marker]?.stop();
+      return;
+    }
+    for (const sound of Object.values(this.sounds)) {
+      sound.stop();
     }
   }
 
@@ -61,7 +74,7 @@ export class SoundSprite {
    * @param {string} marker - TBD.
    * @returns {Sound} TBD.
    */
-  public get(marker: string) {
+  public get(marker: string): Sound | undefined {
     return this.sounds[marker];
   }
 }

package/src/phaser/core/stage.ts

@@ -66,8 +66,8 @@ export class Stage extends DisplayObject {
   public override preUpdate(): void {
     this.currentRenderOrderID = 0;
     //  This can't loop in reverse, we need the renderOrderID to be in sequence
-    for (let i = 0; i < this.children.length; i += 1) {
-      this.children[i]!.preUpdate();
+    for (const child of this.children) {
+      child.preUpdate();
     }
   }
 
@@ -86,8 +86,8 @@ export class Stage extends DisplayObject {
    * Post-updates the stage and its children.
    */
   public override postUpdate(): void {
-    for (let i = 0; i < this.children.length; i += 1) {
-      this.children[i]!.postUpdate();
+    for (const child of this.children) {
+      child.postUpdate();
     }
     this.updateTransform();
   }

package/src/phaser/core/timer.ts

@@ -1,6 +1,7 @@
 import type { Game } from './game.js';
 import { Signal } from './signal.js';
 import { TimerEvent } from './timer_event.js';
+import type { AppliedCallback, Callback } from './callback.js';
 
 export class Timer {
   public game!: Game;
@@ -65,17 +66,13 @@ export class Timer {
     delay: number,
     loop: boolean,
     repeatCount: number,
-    callback: Function,
-    callbackContext: unknown | null = null,
+    callback: Callback,
+    callbackContext: unknown = null,
     args: any = []
   ): TimerEvent {
     const roundedDelay = Math.round(delay);
     let tick = roundedDelay;
-    if (this._now === 0) {
-      tick += this.game.time.time;
-    } else {
-      tick += this._now;
-    }
+    tick += this._now === 0 ? this.game.time.time : this._now;
     const event = new TimerEvent(this, roundedDelay, tick, repeatCount, loop, callback, callbackContext, args);
     this.events.push(event);
     this.order();
@@ -91,12 +88,7 @@ export class Timer {
    * @param {...any} args - Arguments to pass to the callback function.
    * @returns {TimerEvent} The created TimerEvent.
    */
-  public add(
-    delay: number,
-    callback: Function,
-    callbackContext: unknown | null = null,
-    ...args: unknown[]
-  ): TimerEvent {
+  public add(delay: number, callback: Callback, callbackContext: unknown = null, ...args: unknown[]): TimerEvent {
     return this.create(delay, false, 0, callback, callbackContext, args);
   }
 
@@ -127,8 +119,8 @@ export class Timer {
   public repeat(
     delay: number,
     repeatCount: number,
-    callback: Function,
-    callbackContext: unknown | null = null,
+    callback: Callback,
+    callbackContext: unknown = null,
     ...args: unknown[]
   ): TimerEvent {
     return this.create(delay, false, repeatCount, callback, callbackContext, args);
@@ -142,12 +134,7 @@ export class Timer {
    * @param {...any} args - Arguments to pass to the callback function.
    * @returns {TimerEvent} The created TimerEvent.
    */
-  public loop(
-    delay: number,
-    callback: Function,
-    callbackContext: unknown | null = null,
-    ...args: unknown[]
-  ): TimerEvent {
+  public loop(delay: number, callback: Callback, callbackContext: unknown = null, ...args: unknown[]): TimerEvent {
     return this.create(delay, true, 0, callback, callbackContext, args);
   }
 
@@ -199,7 +186,7 @@ export class Timer {
     if (this.events.length > 0) {
       //  Sort the events so the one with the lowest tick is first
       this.events.sort(this.sortHandler);
-      const first = this.events[0];
+      const [first] = this.events;
       if (first) {
         this.nextTick = first.tick;
       }
@@ -271,15 +258,15 @@ export class Timer {
           }
           if (event.loop) {
             event.tick = this._newTick;
-            event.callback.apply(event.callbackContext, event.args);
+            (event.callback as AppliedCallback).apply(event.callbackContext, event.args);
           } else if (event.repeatCount > 0) {
             event.repeatCount -= 1;
             event.tick = this._newTick;
-            event.callback.apply(event.callbackContext, event.args);
+            (event.callback as AppliedCallback).apply(event.callbackContext, event.args);
           } else {
             this._marked += 1;
             event.pendingDelete = true;
-            event.callback.apply(event.callbackContext, event.args);
+            (event.callback as AppliedCallback).apply(event.callbackContext, event.args);
           }
           this._i += 1;
         } else {
@@ -343,11 +330,7 @@ export class Timer {
       }
     }
     const d = this.nextTick - baseTime;
-    if (d < 0) {
-      this.nextTick = this._now;
-    } else {
-      this.nextTick = this._now + d;
-    }
+    this.nextTick = d < 0 ? this._now : this._now + d;
   }
 
   /**

package/src/phaser/core/timer_event.ts

@@ -1,4 +1,5 @@
 import type { Timer } from './timer.js';
+import type { Callback } from './callback.js';
 
 export class TimerEvent {
   public timer: Timer;
@@ -6,7 +7,7 @@ export class TimerEvent {
   public tick: number;
   public repeatCount: number;
   public loop: boolean;
-  public callback: Function;
+  public callback: Callback;
   public callbackContext: unknown;
   public args: unknown[];
   public pendingDelete: boolean;
@@ -17,7 +18,7 @@ export class TimerEvent {
     tick: number,
     repeatCount: number,
     loop: boolean,
-    callback: Function,
+    callback: Callback,
     callbackContext: unknown,
     args: unknown[]
   ) {

package/src/phaser/core/tween.ts

@@ -5,6 +5,7 @@ import { Signal } from './signal.js';
 import { TweenData } from './tween_data.js';
 import type { Game } from './game.js';
 import type { TweenManager } from './tween_manager.js';
+import type { AppliedCallback, Callback, EasingFunction, InterpolationFunction } from './callback.js';
 
 export class Tween {
   public game!: Game;
@@ -25,7 +26,7 @@ export class Tween {
   public properties!: any;
   public chainedTween!: Tween | null;
   public isPaused!: boolean;
-  public _onUpdateCallback!: Function | null;
+  public _onUpdateCallback!: Callback | null;
   public _onUpdateCallbackContext!: unknown;
   public _pausedTime!: number;
   public _codePaused!: boolean;
@@ -93,7 +94,7 @@ export class Tween {
   public to(
     properties: any,
     duration = 1000,
-    ease: string | Function = 'Linear',
+    ease: string | EasingFunction = 'Linear',
     autoStart = false,
     delay = 0,
     repeat = 0,
@@ -126,7 +127,7 @@ export class Tween {
   public from(
     properties: any,
     duration = 1000,
-    ease: string | Function = 'Linear',
+    ease: string | EasingFunction = 'Linear',
     autoStart = false,
     delay = 0,
     repeat = 0,
@@ -282,7 +283,7 @@ export class Tween {
    * @param {number} index - The index in the timeline to apply easing to.
    * @returns {Tween} This Tween object for chaining.
    */
-  public easing(ease: string | Function, index: number): this {
+  public easing(ease: string | EasingFunction, index: number): this {
     if (typeof ease === 'string' && this.manager.easeMap[ease]) {
       ease = this.manager.easeMap[ease]!;
     }
@@ -296,7 +297,7 @@ export class Tween {
    * @param {number} index - The index in the timeline to apply interpolation to.
    * @returns {Tween} This Tween object for chaining.
    */
-  public interpolation(interpolation: Function, context: unknown = MathUtils, index = 0): this {
+  public interpolation(interpolation: InterpolationFunction, context: unknown = MathUtils, index = 0): this {
     this.updateTweenData('interpolationFunction', interpolation, index);
     return this.updateTweenData('interpolationContext', context, index);
   }
@@ -345,7 +346,7 @@ export class Tween {
    * @param {object} callbackContext - The context in which to call the callback.
    * @returns {Tween} This Tween object for chaining.
    */
-  public onUpdateCallback(callback: Function, callbackContext: unknown): this {
+  public onUpdateCallback(callback: Callback, callbackContext: unknown): this {
     this._onUpdateCallback = callback;
     this._onUpdateCallbackContext = callbackContext;
     return this;
@@ -415,7 +416,7 @@ export class Tween {
         this._hasStarted = true;
       }
       if (this._onUpdateCallback !== null) {
-        this._onUpdateCallback.call(
+        (this._onUpdateCallback as AppliedCallback).call(
           this._onUpdateCallbackContext,
           this,
           this.timeline[this.current]!.value,
@@ -504,7 +505,7 @@ export class Tween {
       tweenData.loadValues();
     }
     for (const tweenData of this.timeline) {
-      data = data.concat(tweenData.generateData(frameRate));
+      data = [...data, ...tweenData.generateData(frameRate)];
     }
     return data;
   }

package/src/phaser/core/tween_data.ts

@@ -2,6 +2,7 @@ import type { Game } from './game.js';
 import * as MathUtils from '../util/math.js';
 import { TWEEN_COMPLETE, TWEEN_LOOPED, TWEEN_PENDING, TWEEN_RUNNING } from './const.js';
 import type { Tween } from './tween.js';
+import type { InterpolationFunction } from './callback.js';
 
 export class TweenData {
   public parent!: Tween;
@@ -24,7 +25,7 @@ export class TweenData {
   public dt!: number;
   public startTime!: number | null;
   public easingFunction!: (k: number) => number;
-  public interpolationFunction!: Function;
+  public interpolationFunction!: InterpolationFunction;
   public interpolationContext!: unknown;
   public isRunning!: boolean;
   public isFrom!: boolean;
@@ -108,16 +109,8 @@ export class TweenData {
    */
   public start(): this {
     this.startTime = this.game.time.time + this.delay;
-    if (this.parent.reverse) {
-      this.dt = this.duration;
-    } else {
-      this.dt = 0;
-    }
-    if (this.delay > 0) {
-      this.isRunning = false;
-    } else {
-      this.isRunning = true;
-    }
+    this.dt = this.parent.reverse ? this.duration : 0;
+    this.isRunning = this.delay <= 0;
     if (this.isFrom) {
       //  Reverse them all and instant set them
       const keys = Object.keys(this.vStartCache);
@@ -145,12 +138,11 @@ export class TweenData {
       //  Check if an Array was provided as property value
       if (Array.isArray(this.vEnd[property])) {
         if (this.vEnd[property].length === 0) {
-          // pass
-          // TODO: this was continue;
+          // an empty end array leaves the property untouched for this step
         } else if (this.percent === 0) {
           //  Put the start value at the beginning of the array
           //  but we only want to do this once, if the Tween hasn't run before
-          this.vEnd[property] = [this.vStart[property]].concat(this.vEnd[property]);
+          this.vEnd[property] = [this.vStart[property], ...this.vEnd[property]];
         }
       }
       if (this.vEnd[property] !== undefined) {
@@ -199,15 +191,9 @@ export class TweenData {
     for (const property of keys) {
       const start = this.vStart[property];
       const end = this.vEnd[property];
-      if (Array.isArray(end)) {
-        (this.parent.target as unknown as Record<string, any>)[property] = this.interpolationFunction.call(
-          this.interpolationContext,
-          end,
-          this.value
-        );
-      } else {
-        (this.parent.target as unknown as Record<string, any>)[property] = start + (end - start) * this.value;
-      }
+      (this.parent.target as unknown as Record<string, any>)[property] = Array.isArray(end)
+        ? this.interpolationFunction.call(this.interpolationContext, end, this.value)
+        : start + (end - start) * this.value;
     }
     if ((!this.parent.reverse && this.percent === 1) || (this.parent.reverse && this.percent === 0)) {
       return this.repeat();
@@ -221,11 +207,7 @@ export class TweenData {
    * @returns {object[]} An array of tween data points.
    */
   public generateData(frameRate: number): Record<string, number>[] {
-    if (this.parent.reverse) {
-      this.dt = this.duration;
-    } else {
-      this.dt = 0;
-    }
+    this.dt = this.parent.reverse ? this.duration : 0;
     let data = [];
     let complete = false;
     const fps = (1 / frameRate) * 1000;
@@ -244,11 +226,9 @@ export class TweenData {
       for (const property of keys) {
         const start = this.vStart[property];
         const end = this.vEnd[property];
-        if (Array.isArray(end)) {
-          blob[property] = this.interpolationFunction(end, this.value);
-        } else {
-          blob[property] = start + (end - start) * this.value;
-        }
+        blob[property] = Array.isArray(end)
+          ? this.interpolationFunction(end, this.value)
+          : start + (end - start) * this.value;
       }
       data.push(blob);
       if ((!this.parent.reverse && this.percent === 1) || (this.parent.reverse && this.percent === 0)) {
@@ -256,9 +236,7 @@ export class TweenData {
       }
     } while (!complete);
     if (this.yoyo) {
-      const reversed = [...data];
-      reversed.reverse();
-      data = data.concat(reversed);
+      data = [...data, ...data.toReversed()];
     }
     return data;
   }
@@ -311,11 +289,7 @@ export class TweenData {
     } else if (!this.inReverse) {
       this.startTime += this.repeatDelay;
     }
-    if (this.parent.reverse) {
-      this.dt = this.duration;
-    } else {
-      this.dt = 0;
-    }
+    this.dt = this.parent.reverse ? this.duration : 0;
     return TWEEN_LOOPED;
   }
 }

package/src/phaser/core/tween_easing.test.ts

@@ -4,79 +4,79 @@ import * as Easing from './tween_easing.js';
 const SAMPLE_POINTS = [0, 0.1, 0.25, 0.4, 0.5, 0.6, 0.75, 0.9, 1];
 
 const EXPECTED: Record<string, number[]> = {
-  BackIn: [
+  backIn: [
     -0, -0.014314220000000002, -0.06413656250000001, -0.09935168000000003, -0.08769750000000004, -0.02902752000000009,
     0.1825903124999999, 0.5911720199999999, 0.9999999999999998,
   ],
-  BackInOut: [
+  backInOut: [
     -0, -0.037518552000000004, -0.09968184375, 0.0899257920000001, 0.5, 0.9100742079999999, 1.09968184375,
     1.0375185519999999, 1,
   ],
-  BackOut: [
+  backOut: [
     2.220446049250313e-16, 0.4088279800000001, 0.8174096875000001, 1.02902752, 1.0876975, 1.09935168, 1.0641365625,
     1.01431422, 1,
   ],
-  BounceIn: [
+  bounceIn: [
     0, 0.01187500000000008, 0.02734375, 0.22750000000000004, 0.234375, 0.09000000000000019, 0.52734375,
     0.9243750000000001, 1,
   ],
-  BounceInOut: [0, 0.030000000000000027, 0.1171875, 0.34875000000000006, 0.5, 0.6512499999999999, 0.8828125, 0.97, 1],
-  BounceOut: [
+  bounceInOut: [0, 0.030000000000000027, 0.1171875, 0.34875000000000006, 0.5, 0.6512499999999999, 0.8828125, 0.97, 1],
+  bounceOut: [
     0, 0.07562500000000001, 0.47265625, 0.9099999999999998, 0.765625, 0.7725, 0.97265625, 0.9881249999999999, 1,
   ],
-  CircularIn: [
+  circularIn: [
     0, 0.005012562893380035, 0.031754163448145745, 0.08348486100883201, 0.1339745962155614, 0.19999999999999996,
     0.3385621722338523, 0.5641101056459328, 1,
   ],
-  CircularInOut: [
+  circularInOut: [
     -0, 0.010102051443364402, 0.0669872981077807, 0.20000000000000007, 0.5, 0.7999999999999999, 0.9330127018922193,
     0.9898979485566356, 1,
   ],
-  CircularOut: [
+  circularOut: [
     0, 0.4358898943540673, 0.6614378277661477, 0.8, 0.8660254037844386, 0.916515138991168, 0.9682458365518543,
     0.99498743710662, 1,
   ],
-  CubicIn: [0, 0.0010000000000000002, 0.015625, 0.06400000000000002, 0.125, 0.216, 0.421875, 0.7290000000000001, 1],
-  CubicInOut: [0, 0.004000000000000001, 0.0625, 0.25600000000000006, 0.5, 0.744, 0.9375, 0.996, 1],
-  CubicOut: [0, 0.2709999999999999, 0.578125, 0.784, 0.875, 0.9359999999999999, 0.984375, 0.999, 1],
-  ElasticIn: [
+  cubicIn: [0, 0.0010000000000000002, 0.015625, 0.06400000000000002, 0.125, 0.216, 0.421875, 0.7290000000000001, 1],
+  cubicInOut: [0, 0.004000000000000001, 0.0625, 0.25600000000000006, 0.5, 0.744, 0.9375, 0.996, 1],
+  cubicOut: [0, 0.2709999999999999, 0.578125, 0.784, 0.875, 0.9359999999999999, 0.984375, 0.999, 1],
+  elasticIn: [
     0, 1.1959441397923372e-18, 0.0039062499999999952, -0.015625, 1.1481063742006436e-17, 0.0625, -0.12500000000000003,
     6.123233995736767e-17, 1,
   ],
-  ElasticInOut: [0, 0.001953125, 5.740531871003218e-18, -0.12500000000000003, 0.5, 1.125, 1, 0.998046875, 1],
-  ElasticOut: [0, 1, 1.125, 0.9375, 1, 1.015625, 0.99609375, 1, 1],
-  ExponentialIn: [
+  elasticInOut: [0, 0.001953125, 5.740531871003218e-18, -0.12500000000000003, 0.5, 1.125, 1, 0.998046875, 1],
+  elasticOut: [0, 1, 1.125, 0.9375, 1, 1.015625, 0.99609375, 1, 1],
+  exponentialIn: [
     0, 0.0019531249999999998, 0.005524271728019903, 0.015625000000000003, 0.03125, 0.06249999999999999,
     0.1767766952966369, 0.5000000000000001, 1,
   ],
-  ExponentialInOut: [0, 0.0019531249999999993, 0.015625, 0.12500000000000003, 0.5, 0.875, 0.984375, 0.998046875, 1],
-  ExponentialOut: [0, 0.5, 0.8232233047033631, 0.9375, 0.96875, 0.984375, 0.99447572827198, 0.998046875, 1],
-  LinearNone: [0, 0.1, 0.25, 0.4, 0.5, 0.6, 0.75, 0.9, 1],
-  QuadraticIn: [0, 0.010000000000000002, 0.0625, 0.16000000000000003, 0.25, 0.36, 0.5625, 0.81, 1],
-  QuadraticInOut: [0, 0.020000000000000004, 0.125, 0.32000000000000006, 0.5, 0.6799999999999999, 0.875, 0.98, 1],
-  QuadraticOut: [0, 0.19, 0.4375, 0.6400000000000001, 0.75, 0.84, 0.9375, 0.9900000000000001, 1],
-  QuarticIn: [
+  exponentialInOut: [0, 0.0019531249999999993, 0.015625, 0.12500000000000003, 0.5, 0.875, 0.984375, 0.998046875, 1],
+  exponentialOut: [0, 0.5, 0.8232233047033631, 0.9375, 0.96875, 0.984375, 0.99447572827198, 0.998046875, 1],
+  linearNone: [0, 0.1, 0.25, 0.4, 0.5, 0.6, 0.75, 0.9, 1],
+  quadraticIn: [0, 0.010000000000000002, 0.0625, 0.16000000000000003, 0.25, 0.36, 0.5625, 0.81, 1],
+  quadraticInOut: [0, 0.020000000000000004, 0.125, 0.32000000000000006, 0.5, 0.6799999999999999, 0.875, 0.98, 1],
+  quadraticOut: [0, 0.19, 0.4375, 0.6400000000000001, 0.75, 0.84, 0.9375, 0.9900000000000001, 1],
+  quarticIn: [
     0, 0.00010000000000000003, 0.00390625, 0.025600000000000008, 0.0625, 0.1296, 0.31640625, 0.6561000000000001, 1,
   ],
-  QuarticInOut: [0, 0.0008000000000000003, 0.03125, 0.20480000000000007, 0.5, 0.7951999999999999, 0.96875, 0.9992, 1],
-  QuarticOut: [0, 0.3438999999999999, 0.68359375, 0.8704000000000001, 0.9375, 0.9744, 0.99609375, 0.9999, 1],
-  QuinticIn: [
+  quarticInOut: [0, 0.0008000000000000003, 0.03125, 0.20480000000000007, 0.5, 0.7951999999999999, 0.96875, 0.9992, 1],
+  quarticOut: [0, 0.3438999999999999, 0.68359375, 0.8704000000000001, 0.9375, 0.9744, 0.99609375, 0.9999, 1],
+  quinticIn: [
     0, 0.000010000000000000004, 0.0009765625, 0.010240000000000004, 0.03125, 0.07776, 0.2373046875, 0.5904900000000002,
     1,
   ],
-  QuinticInOut: [
+  quinticInOut: [
     0, 0.00016000000000000007, 0.015625, 0.16384000000000007, 0.5, 0.8361599999999999, 0.984375, 0.99984, 1,
   ],
-  QuinticOut: [0, 0.4095099999999998, 0.7626953125, 0.92224, 0.96875, 0.98976, 0.9990234375, 0.99999, 1],
-  SinusoidalIn: [
+  quinticOut: [0, 0.4095099999999998, 0.7626953125, 0.92224, 0.96875, 0.98976, 0.9990234375, 0.99999, 1],
+  sinusoidalIn: [
     0, 0.01231165940486223, 0.07612046748871326, 0.19098300562505255, 0.2928932188134524, 0.41221474770752686,
     0.6173165676349102, 0.843565534959769, 1,
   ],
-  SinusoidalInOut: [
+  sinusoidalInOut: [
     0, 0.024471741852423234, 0.1464466094067262, 0.3454915028125263, 0.49999999999999994, 0.6545084971874737,
     0.8535533905932737, 0.9755282581475768, 1,
   ],
-  SinusoidalOut: [
+  sinusoidalOut: [
     0, 0.15643446504023087, 0.3826834323650898, 0.5877852522924731, 0.7071067811865475, 0.8090169943749475,
     0.9238795325112867, 0.9876883405951378, 1,
   ],
@@ -86,9 +86,9 @@ describe('tween_easing', () => {
   it.each(Object.keys(EXPECTED))('%s matches its reference curve', (name) => {
     const fn = (Easing as unknown as Record<string, (k: number) => number>)[name]!;
     const actual = SAMPLE_POINTS.map((k) => fn(k));
-    actual.forEach((value, index) => {
+    for (const [index, value] of actual.entries()) {
       expect(value).toBeCloseTo(EXPECTED[name]![index]!, 12);
-    });
+    }
   });
 
   it.each(Object.keys(EXPECTED))('%s is anchored at both ends', (name) => {
@@ -99,8 +99,8 @@ describe('tween_easing', () => {
 
   it.each(Object.keys(EXPECTED))('%s does not mutate beyond its return value', (name) => {
     const fn = (Easing as unknown as Record<string, (k: number) => number>)[name]!;
-    SAMPLE_POINTS.forEach((k) => {
+    for (const k of SAMPLE_POINTS) {
       expect(fn(k)).toBe(fn(k));
-    });
+    }
   });
 });