@vpmedia/phaser 1.123.0 → 1.125.0

package/src/phaser/display/canvas/util.test.ts

@@ -3,36 +3,36 @@ import { addToDOM, create, removeFromDOM, setBackgroundColor, setTouchAction, se
 
 const createCanvas = (): HTMLCanvasElement => create(null, 32, 16, '', true);
 
-describe('canvas util', () => {
-  afterEach(() => {
+describe('canvas util', (): void => {
+  afterEach((): void => {
     document.body.innerHTML = '';
   });
 
-  describe('create', () => {
-    it('sizes the canvas as asked', () => {
+  describe('create', (): void => {
+    it('sizes the canvas as asked', (): void => {
       const canvas = createCanvas();
       expect(canvas.width).toBe(32);
       expect(canvas.height).toBe(16);
     });
 
-    it('falls back to 256 square for a zero size', () => {
+    it('falls back to 256 square for a zero size', (): void => {
       const canvas = create(null, 0, 0, '', true);
       expect(canvas.width).toBe(256);
       expect(canvas.height).toBe(256);
     });
 
-    it('assigns the id it is given and leaves an empty one off', () => {
+    it('assigns the id it is given and leaves an empty one off', (): void => {
       expect(create(null, 32, 16, 'stage', true).id).toBe('stage');
       expect(createCanvas().id).toBe('');
     });
 
-    it('takes the canvas out of the flow', () => {
+    it('takes the canvas out of the flow', (): void => {
       expect(createCanvas().style.display).toBe('block');
     });
   });
 
-  describe('addToDOM', () => {
-    it('appends to the element with the given id', () => {
+  describe('addToDOM', (): void => {
+    it('appends to the element with the given id', (): void => {
       const host = document.createElement('div');
       host.id = 'host';
       document.body.append(host);
@@ -41,7 +41,7 @@ describe('canvas util', () => {
       expect(canvas.parentElement).toBe(host);
     });
 
-    it('appends to an element passed directly', () => {
+    it('appends to an element passed directly', (): void => {
       const host = document.createElement('div');
       document.body.append(host);
       const canvas = createCanvas();
@@ -49,26 +49,26 @@ describe('canvas util', () => {
       expect(canvas.parentElement).toBe(host);
     });
 
-    it('falls back to the body for an id nothing matches', () => {
+    it('falls back to the body for an id nothing matches', (): void => {
       const canvas = createCanvas();
       addToDOM(canvas, 'nothing-here');
       expect(canvas.parentElement).toBe(document.body);
     });
 
-    it('falls back to the body when given no parent', () => {
+    it('falls back to the body when given no parent', (): void => {
       const canvas = createCanvas();
       addToDOM(canvas, null);
       expect(canvas.parentElement).toBe(document.body);
     });
 
     // An empty id used to build the selector `#`, which throws before the body fallback is reached.
-    it('falls back to the body for an empty id', () => {
+    it('falls back to the body for an empty id', (): void => {
       const canvas = createCanvas();
       addToDOM(canvas, '');
       expect(canvas.parentElement).toBe(document.body);
     });
 
-    it('hides the parent overflow unless told not to', () => {
+    it('hides the parent overflow unless told not to', (): void => {
       const host = document.createElement('div');
       document.body.append(host);
       addToDOM(createCanvas(), host);
@@ -79,7 +79,7 @@ describe('canvas util', () => {
       expect(other.style.overflow).toBe('');
     });
 
-    it('survives an id that is not a valid bare selector', () => {
+    it('survives an id that is not a valid bare selector', (): void => {
       const host = document.createElement('div');
       host.id = 'game.container';
       document.body.append(host);
@@ -89,40 +89,40 @@ describe('canvas util', () => {
     });
   });
 
-  describe('removeFromDOM', () => {
-    it('detaches an attached canvas', () => {
+  describe('removeFromDOM', (): void => {
+    it('detaches an attached canvas', (): void => {
       const canvas = createCanvas();
       document.body.append(canvas);
       removeFromDOM(canvas);
       expect(canvas.parentElement).toBeNull();
     });
 
-    it('leaves a detached canvas alone', () => {
+    it('leaves a detached canvas alone', (): void => {
       const canvas = createCanvas();
-      expect(() => {
+      expect((): void => {
         removeFromDOM(canvas);
       }).not.toThrow();
     });
   });
 
-  describe('style helpers', () => {
-    it('sets the background colour', () => {
+  describe('style helpers', (): void => {
+    it('sets the background colour', (): void => {
       expect(setBackgroundColor(createCanvas(), 'rgb(255, 0, 0)').style.backgroundColor).toBe('rgb(255, 0, 0)');
     });
 
-    it('disables touch actions', () => {
+    it('disables touch actions', (): void => {
       expect(setTouchAction(createCanvas()).style.getPropertyValue('touch-action')).toBe('none');
     });
 
-    it('falls back to none for an empty touch action', () => {
+    it('falls back to none for an empty touch action', (): void => {
       expect(setTouchAction(createCanvas(), '').style.getPropertyValue('touch-action')).toBe('none');
     });
 
-    it('disables user selection', () => {
+    it('disables user selection', (): void => {
       expect(setUserSelect(createCanvas()).style.getPropertyValue('user-select')).toBe('none');
     });
 
-    it('falls back to none for an empty user selection', () => {
+    it('falls back to none for an empty user selection', (): void => {
       expect(setUserSelect(createCanvas(), '').style.getPropertyValue('user-select')).toBe('none');
     });
   });

package/src/phaser/display/canvas/util.ts

@@ -141,7 +141,7 @@ export const getSmoothingPrefix = (context: CanvasRenderingContext2D): string |
   const smoothingFlags = context as unknown as Record<string, boolean | undefined>;
   for (const vendor of VENDORS) {
     const flag = `${vendor}mageSmoothingEnabled`;
-    if (smoothingFlags[flag]) {
+    if (smoothingFlags[flag] !== undefined) {
       return flag;
     }
   }
@@ -166,7 +166,7 @@ export const setSmoothing = (context: CanvasRenderingContext2D, property: string
  */
 export const setSmoothingEnabled = (context: CanvasRenderingContext2D, value: boolean): CanvasRenderingContext2D => {
   const s = getSmoothingPrefix(context);
-  if (s) {
+  if (s !== null) {
     setSmoothing(context, s, value);
   }
   return context;

package/src/phaser/display/display_object.ts

@@ -10,6 +10,7 @@ import type { UserData } from '../core/callback.js';
 import type { EventManager } from '../core/event_manager.js';
 import type { Image } from './image.js';
 import type { RenderSession } from './render_session.js';
+import type { IdentifiedWebGLRenderingContext } from './webgl/util.js';
 
 export class DisplayObject {
   /** @type {boolean} */
@@ -123,9 +124,11 @@ export class DisplayObject {
 
   /**
    * Destroys this display object and cleans up resources.
+   * @param {boolean} _destroyChildren - Whether the subclass should destroy its children too.
+   * @param {boolean} _destroyTexture - Whether the subclass should destroy its texture too.
    */
-  public destroy(): void {
-    if (this.children) {
+  public destroy(_destroyChildren = true, _destroyTexture = false): void {
+    if (this.children as DisplayObject[] | undefined) {
       let i = this.children.length;
       while (i) {
         i -= 1;
@@ -282,12 +285,12 @@ export class DisplayObject {
    * @returns {DisplayObject[]} The array of removed child display objects.
    * @throws {Error} If the range is invalid.
    */
-  public removeChildren(beginIndex: number, endIndex: number): DisplayObject[] {
-    beginIndex ??= 0;
-    endIndex ??= this.children.length;
-    const range = endIndex - beginIndex;
-    if (range > 0 && range <= endIndex) {
-      const removed = this.children.splice(beginIndex, range);
+  public removeChildren(beginIndex?: number, endIndex?: number): DisplayObject[] {
+    const begin = beginIndex ?? 0;
+    const end = endIndex ?? this.children.length;
+    const range = end - begin;
+    if (range > 0 && range <= end) {
+      const removed = this.children.splice(begin, range);
       for (const child of removed) {
         child.parent = null;
       }
@@ -308,7 +311,7 @@ export class DisplayObject {
     if (!parent && !this.parent) {
       return this;
     }
-    if (!this.game || !this.visible) {
+    if (!(this.game as Game | undefined) || !this.visible) {
       return this;
     }
     const p = parent ?? this.parent ?? this.game.world;
@@ -605,12 +608,10 @@ export class DisplayObject {
    * @param {DisplayObject} from - The display object to convert from (defaults to this).
    * @returns {Point} The converted local position.
    */
-  public toLocal(position: Point, from: DisplayObject): Point {
-    if (from) {
-      position = from.toGlobal(position);
-    }
+  public toLocal(position: Point, from: DisplayObject | null): Point {
+    const global = from ? from.toGlobal(position) : position;
     this.updateTransform();
-    return this.worldTransform.applyInverse(position);
+    return this.worldTransform.applyInverse(global);
   }
 
   /**
@@ -622,7 +623,7 @@ export class DisplayObject {
       return;
     }
     this._cachedSprite.worldAlpha = this.worldAlpha;
-    if (renderSession.gl) {
+    if (renderSession.gl as IdentifiedWebGLRenderingContext | undefined) {
       renderWebGL(this._cachedSprite, renderSession);
     } else {
       renderCanvas(this._cachedSprite, renderSession);

package/src/phaser/display/graphics.test.ts

@@ -9,11 +9,11 @@ const createGame = (): Game => ({ renderer: { resolution: 1 } }) as unknown as G
 
 const createGraphics = (): Graphics => new Graphics(createGame());
 
-describe('Graphics', () => {
-  describe('containsPoint', () => {
+describe('Graphics', (): void => {
+  describe('containsPoint', (): void => {
     // The index never advanced here, so any filled shape that did not contain the point spun
     // forever. A vitest timeout is the only way a hang shows up as a failure.
-    it('returns false for a point outside a filled shape instead of hanging', { timeout: 2000 }, () => {
+    it('returns false for a point outside a filled shape instead of hanging', { timeout: 2000 }, (): void => {
       const graphics = createGraphics();
       graphics.beginFill(0xff0000);
       graphics.drawRect(0, 0, 10, 10);
@@ -21,7 +21,7 @@ describe('Graphics', () => {
       expect(graphics.containsPoint(new Point(100, 100), new Point())).toBe(false);
     });
 
-    it('returns true for a point inside a filled shape', { timeout: 2000 }, () => {
+    it('returns true for a point inside a filled shape', { timeout: 2000 }, (): void => {
       const graphics = createGraphics();
       graphics.beginFill(0xff0000);
       graphics.drawRect(0, 0, 10, 10);
@@ -29,7 +29,7 @@ describe('Graphics', () => {
       expect(graphics.containsPoint(new Point(5, 5), new Point())).toBe(true);
     });
 
-    it('walks past a non-matching shape to a later matching one', { timeout: 2000 }, () => {
+    it('walks past a non-matching shape to a later matching one', { timeout: 2000 }, (): void => {
       const graphics = createGraphics();
       graphics.beginFill(0xff0000);
       graphics.drawRect(0, 0, 10, 10);
@@ -38,33 +38,33 @@ describe('Graphics', () => {
       expect(graphics.containsPoint(new Point(105, 105), new Point())).toBe(true);
     });
 
-    it('ignores unfilled shapes', { timeout: 2000 }, () => {
+    it('ignores unfilled shapes', { timeout: 2000 }, (): void => {
       const graphics = createGraphics();
       graphics.lineStyle(1, 0x00ff00);
       graphics.drawRect(0, 0, 10, 10);
       expect(graphics.containsPoint(new Point(5, 5), new Point())).toBe(false);
     });
 
-    it('returns false when nothing has been drawn', { timeout: 2000 }, () => {
+    it('returns false when nothing has been drawn', { timeout: 2000 }, (): void => {
       expect(createGraphics().containsPoint(new Point(0, 0), new Point())).toBe(false);
     });
   });
 
-  describe('drawShape', () => {
-    it('records a polygon as the current path', () => {
+  describe('drawShape', (): void => {
+    it('records a polygon as the current path', (): void => {
       const graphics = createGraphics();
       const data = graphics.drawShape(new Polygon([0, 0, 10, 0, 10, 10]));
       expect(graphics.currentPath).toBe(data);
       expect(data.shape).toBeInstanceOf(Polygon);
     });
 
-    it('does not record a rectangle as the current path', () => {
+    it('does not record a rectangle as the current path', (): void => {
       const graphics = createGraphics();
       graphics.drawShape(new Rectangle(0, 0, 10, 10));
       expect(graphics.currentPath).toBeNull();
     });
 
-    it('carries the current fill and line style onto the data', () => {
+    it('carries the current fill and line style onto the data', (): void => {
       const graphics = createGraphics();
       graphics.lineStyle(4, 0x00ff00, 0.5);
       graphics.beginFill(0xff0000, 0.25);
@@ -77,15 +77,15 @@ describe('Graphics', () => {
       expect(data.fill).toBe(true);
     });
 
-    it('flattens a polygon so the builders see numbers', () => {
+    it('flattens a polygon so the builders see numbers', (): void => {
       const graphics = createGraphics();
       const data = graphics.drawShape(new Polygon([new Point(0, 0), new Point(10, 0), new Point(10, 10)]));
-      expect((data.shape as Polygon)._points.every((value) => typeof value === 'number')).toBe(true);
+      expect((data.shape as Polygon)._points.every((value): boolean => typeof value === 'number')).toBe(true);
     });
   });
 
-  describe('path building', () => {
-    it('accumulates points through moveTo and lineTo', () => {
+  describe('path building', (): void => {
+    it('accumulates points through moveTo and lineTo', (): void => {
       const graphics = createGraphics();
       graphics.moveTo(0, 0);
       graphics.lineTo(10, 0);
@@ -93,15 +93,15 @@ describe('Graphics', () => {
       expect(graphics.currentPath?.shape.points).toStrictEqual([0, 0, 10, 0, 10, 10]);
     });
 
-    it('starts a path at the origin when lineTo comes first', () => {
+    it('starts a path at the origin when lineTo comes first', (): void => {
       const graphics = createGraphics();
       graphics.lineTo(10, 10);
       expect(graphics.currentPath?.shape.points).toStrictEqual([0, 0, 10, 10]);
     });
   });
 
-  describe('endFill', () => {
-    it('stops filling subsequent shapes', () => {
+  describe('endFill', (): void => {
+    it('stops filling subsequent shapes', (): void => {
       const graphics = createGraphics();
       graphics.beginFill(0xff0000);
       graphics.endFill();
@@ -109,8 +109,58 @@ describe('Graphics', () => {
     });
   });
 
-  describe('clear', () => {
-    it('drops the recorded graphics data', () => {
+  describe('drawTriangle', (): void => {
+    it('records the triangle as a polygon', (): void => {
+      const graphics = createGraphics();
+      graphics.drawTriangle([new Point(0, 0), new Point(10, 0), new Point(0, 10)]);
+      expect(graphics.graphicsData).toHaveLength(1);
+      expect(graphics.graphicsData[0]?.shape).toBeInstanceOf(Polygon);
+    });
+
+    it('keeps a front-facing triangle when culling', (): void => {
+      const graphics = createGraphics();
+      graphics.drawTriangle([new Point(0, 0), new Point(10, 0), new Point(0, 10)], true);
+      graphics.drawTriangle([new Point(0, 0), new Point(0, 10), new Point(10, 0)], true);
+      expect(graphics.graphicsData).toHaveLength(1);
+    });
+
+    it('draws both windings when culling is off', (): void => {
+      const graphics = createGraphics();
+      graphics.drawTriangle([new Point(0, 0), new Point(10, 0), new Point(0, 10)]);
+      graphics.drawTriangle([new Point(0, 0), new Point(0, 10), new Point(10, 0)]);
+      expect(graphics.graphicsData).toHaveLength(2);
+    });
+  });
+
+  describe('drawTriangles', (): void => {
+    it('reads a flat coordinate list as triangles', (): void => {
+      const graphics = createGraphics();
+      graphics.drawTriangles([0, 0, 10, 0, 0, 10, 20, 20, 30, 20, 20, 30], null);
+      expect(graphics.graphicsData).toHaveLength(2);
+    });
+
+    it('reads a point list as triangles', (): void => {
+      const graphics = createGraphics();
+      graphics.drawTriangles([new Point(0, 0), new Point(10, 0), new Point(0, 10)], null);
+      expect(graphics.graphicsData).toHaveLength(1);
+    });
+
+    it('follows an index list over a flat coordinate list', (): void => {
+      const graphics = createGraphics();
+      graphics.drawTriangles([0, 0, 10, 0, 0, 10], [0, 1, 2]);
+      expect(graphics.graphicsData).toHaveLength(1);
+      expect((graphics.graphicsData[0]!.shape as Polygon).toNumberArray()).toStrictEqual([0, 0, 10, 0, 0, 10]);
+    });
+
+    it('follows an index list over a point list', (): void => {
+      const graphics = createGraphics();
+      graphics.drawTriangles([new Point(0, 0), new Point(10, 0), new Point(0, 10)], [0, 1, 2]);
+      expect(graphics.graphicsData).toHaveLength(1);
+    });
+  });
+
+  describe('clear', (): void => {
+    it('drops the recorded graphics data', (): void => {
       const graphics = createGraphics();
       graphics.beginFill(0xff0000);
       graphics.drawRect(0, 0, 10, 10);

package/src/phaser/display/graphics.ts

@@ -38,6 +38,22 @@ export type GraphicsWebGLBucket = {
   gl: IdentifiedWebGLRenderingContext;
 };
 
+/**
+ * Reports whether a triangle winds towards the viewer. In two dimensions the cross product is a
+ * scalar, so its sign alone says which way the face points.
+ * @param {Point[]} points - The three corners of the triangle, in order.
+ * @returns {boolean} True when the triangle faces the viewer.
+ */
+const isFrontFacing = (points: Point[]): boolean => {
+  const [a, b, c] = points;
+  if (!a || !b || !c) {
+    return true;
+  }
+  const ab = new Point(b.x - a.x, b.y - a.y);
+  const cb = new Point(b.x - c.x, b.y - c.y);
+  return cb.cross(ab) > 0;
+};
+
 export class Graphics extends DisplayObject {
   declare public type: number;
   declare public renderable: boolean;
@@ -327,19 +343,17 @@ export class Graphics extends DisplayObject {
     if (startAngle === endAngle) {
       return this;
     }
-    if (!anticlockwise && endAngle <= startAngle) {
-      endAngle += Math.PI * 2;
-    } else if (anticlockwise && startAngle <= endAngle) {
-      startAngle += Math.PI * 2;
-    }
-    const sweep = anticlockwise ? (startAngle - endAngle) * -1 : endAngle - startAngle;
+    const fullTurn = Math.PI * 2;
+    const from = anticlockwise && startAngle <= endAngle ? startAngle + fullTurn : startAngle;
+    const to = !anticlockwise && endAngle <= startAngle ? endAngle + fullTurn : endAngle;
+    const sweep = anticlockwise ? (from - to) * -1 : to - from;
     const segs = Math.ceil(Math.abs(sweep) / (Math.PI * 2)) * segments;
     //  Sweep check - moved here because we don't want to do the moveTo below if the arc fails
     if (sweep === 0) {
       return this;
     }
-    const startX = cx + Math.cos(startAngle) * radius;
-    const startY = cy + Math.sin(startAngle) * radius;
+    const startX = cx + Math.cos(from) * radius;
+    const startY = cy + Math.sin(from) * radius;
     if (anticlockwise && this.filling) {
       this.moveTo(cx, cy);
     } else {
@@ -355,7 +369,7 @@ export class Graphics extends DisplayObject {
     const remainder = (segMinus % 1) / segMinus;
     for (let i = 0; i <= segMinus; i += 1) {
       const real = i + remainder * i;
-      const angle = theta + startAngle + theta2 * real;
+      const angle = theta + from + theta2 * real;
       const c = Math.cos(angle);
       const s = -Math.sin(angle);
       points.push((cTheta * c + sTheta * s) * radius + cx, (cTheta * -s + sTheta * c) * radius + cy);
@@ -887,18 +901,10 @@ export class Graphics extends DisplayObject {
    */
   public drawTriangle(points: Point[], cull = false): void {
     const triangle = new Polygon(points);
-    if (cull) {
-      const [a, b, c] = points as [Point, Point, Point];
-      const cameraToFace = new Point(0 - a.x, 0 - a.y);
-      const ab = new Point(b.x - a.x, b.y - a.y);
-      const cb = new Point(b.x - c.x, b.y - c.y);
-      const faceNormal = cb.cross(ab);
-      if (cameraToFace.dot(faceNormal as any) > 0) {
-        this.drawPolygon(triangle);
-      }
-    } else {
-      this.drawPolygon(triangle);
+    if (cull && !isFrontFacing(points)) {
+      return;
     }
+    this.drawPolygon(triangle);
   }
 
   /**
@@ -907,43 +913,41 @@ export class Graphics extends DisplayObject {
    * @param {number[]} indices - The indices of the vertices to use.
    * @param {boolean} cull - Whether to perform backface culling.
    */
-  public drawTriangles(vertices: any, indices: number[], cull = false): void {
-    const point1 = new Point();
-    const point2 = new Point();
-    const point3 = new Point();
-    let points = [];
+  public drawTriangles(vertices: Point[] | number[], indices: number[] | null, cull = false): void {
+    let points: Point[] = [];
     let i;
-    if (!indices) {
+    if (indices === null) {
       if (vertices[0] instanceof Point) {
-        for (i = 0; i < vertices.length / 3; i += 1) {
-          this.drawTriangle([vertices[i * 3], vertices[i * 3 + 1], vertices[i * 3 + 2]], cull);
+        const corners = vertices as Point[];
+        for (i = 0; i < corners.length / 3; i += 1) {
+          this.drawTriangle([corners[i * 3]!, corners[i * 3 + 1]!, corners[i * 3 + 2]!], cull);
         }
       } else {
-        for (i = 0; i < vertices.length / 6; i += 1) {
-          point1.x = vertices[i * 6 + 0]!;
-          point1.y = vertices[i * 6 + 1]!;
-          point2.x = vertices[i * 6 + 2]!;
-          point2.y = vertices[i * 6 + 3]!;
-          point3.x = vertices[i * 6 + 4]!;
-          point3.y = vertices[i * 6 + 5]!;
-          this.drawTriangle([point1, point2, point3], cull);
+        const coordinates = vertices as number[];
+        for (i = 0; i < coordinates.length / 6; i += 1) {
+          this.drawTriangle(
+            [
+              new Point(coordinates[i * 6 + 0], coordinates[i * 6 + 1]),
+              new Point(coordinates[i * 6 + 2], coordinates[i * 6 + 3]),
+              new Point(coordinates[i * 6 + 4], coordinates[i * 6 + 5]),
+            ],
+            cull
+          );
         }
       }
     } else if (vertices[0] instanceof Point) {
+      const corners = vertices as Point[];
       for (i = 0; i < indices.length / 3; i += 1) {
-        points.push(vertices[indices[i * 3]!]);
-        points.push(vertices[indices[i * 3 + 1]!]);
-        points.push(vertices[indices[i * 3 + 2]!]);
+        points.push(corners[indices[i * 3]!]!, corners[indices[i * 3 + 1]!]!, corners[indices[i * 3 + 2]!]!);
         if (points.length === 3) {
           this.drawTriangle(points, cull);
           points = [];
         }
       }
     } else {
+      const coordinates = vertices as number[];
       for (i = 0; i < indices.length; i += 1) {
-        point1.x = vertices[indices[i]! * 2]!;
-        point1.y = vertices[indices[i]! * 2 + 1]!;
-        points.push(point1.copyTo({} as any));
+        points.push(new Point(coordinates[indices[i]! * 2], coordinates[indices[i]! * 2 + 1]));
         if (points.length === 3) {
           this.drawTriangle(points, cull);
           points = [];

package/src/phaser/display/group.ts

@@ -3,6 +3,7 @@ import { Signal } from '../core/signal.js';
 import { DisplayObject } from './display_object.js';
 import { Image } from './image.js';
 import type { Game } from '../core/game.js';
+import type { EventManager } from '../core/event_manager.js';
 
 export const SORT_ASCENDING = -1;
 export const SORT_DESCENDING = 1;
@@ -33,7 +34,7 @@ export class Group extends DisplayObject {
     super(game);
     /** @type {number} */
     this.type = GROUP;
-    parent ??= game.world;
+    const target = parent ?? game.world;
     /** @type {string} */
     this.name = name ?? 'group';
     /** @type {number} */
@@ -41,9 +42,9 @@ export class Group extends DisplayObject {
     if (addToStage) {
       this.game.stage.addChild(this);
       this.z = this.game.stage.children.length;
-    } else if (parent) {
-      parent.addChild(this);
-      this.z = parent.children.length;
+    } else if (target as DisplayObject | undefined) {
+      target.addChild(this);
+      this.z = target.children.length;
     }
     /** @type {boolean} */
     this.ignoreDestroy = false;
@@ -112,10 +113,10 @@ export class Group extends DisplayObject {
       this.updateZ();
     }
     const inputChild = child as T & { input?: unknown; inputEnabled?: boolean };
-    if (this.inputEnableChildren && (!inputChild.input || inputChild.inputEnabled)) {
+    if (this.inputEnableChildren && (inputChild.input === undefined || inputChild.inputEnabled === true)) {
       inputChild.inputEnabled = true;
     }
-    if (!silent && child.events) {
+    if (!silent && (child.events as EventManager | undefined)) {
       child.events.onAddedToGroup$dispatch(child, this);
     }
     this.cursor ??= child;
@@ -252,7 +253,7 @@ export class Group extends DisplayObject {
       this.destroy();
       return;
     }
-    if (!this.exists || !this.parent?.exists) {
+    if (!this.exists || this.parent?.exists !== true) {
       this.renderOrderID = -1;
       return;
     }
@@ -288,11 +289,11 @@ export class Group extends DisplayObject {
    * @param {boolean} silent - Whether to dispatch events.
    * @returns {boolean} True if the child was removed, false otherwise.
    */
-  public remove(child: any, destroy = true, silent = false): boolean {
+  public remove(child: DisplayObject, destroy = true, silent = false): boolean {
     if (this.children.length === 0 || !this.children.includes(child)) {
       return false;
     }
-    if (!silent && child.events && !child.destroyPhase) {
+    if (!silent && (child.events as EventManager | undefined)) {
       child.events.onRemovedFromGroup$dispatch(child, this);
     }
     const removed = this.removeChild(child);
@@ -301,7 +302,7 @@ export class Group extends DisplayObject {
       this.next();
     }
     if (destroy && removed) {
-      (removed as any).destroy(true);
+      removed.destroy(true);
     }
     return true;
   }
@@ -318,12 +319,12 @@ export class Group extends DisplayObject {
     }
     do {
       const first = this.children[0]!;
-      if (!silent && first.events) {
+      if (!silent && (first.events as EventManager | undefined)) {
         first.events.onRemovedFromGroup$dispatch(first, this);
       }
       const removed = this.removeChild(first);
       if (destroy && removed) {
-        (removed as any).destroy(true, destroyTexture);
+        removed.destroy(true, destroyTexture);
       }
     } while (this.children.length > 0);
     this.cursor = null;