isaacscript-common 87.5.1 → 87.6.1

package/src/classes/callbacks/PostEntityRemoveFilter.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import type { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { shouldFireEntity } from "../../shouldFire";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostEntityRemoveFilter extends CustomCallback<ModCallbackCustom.POST_ENTITY_REMOVE_FILTER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 67
+      [ModCallback.POST_ENTITY_REMOVE, this.postEntityRemove],
+    ];
+  }
+
+  protected override shouldFire = shouldFireEntity;
+
+  // ModCallback.POST_ENTITY_REMOVE (67)
+  private readonly postEntityRemove = (entity: Entity) => {
+    this.fire(entity);
+  };
+}

package/src/classes/callbacks/PostGridEntityCollision.ts

@@ -29,16 +29,16 @@ export class PostGridEntityCollision extends CustomCallback<T> {
     const gridEntityVariant = gridEntity.GetVariant();
 
     return (
-      (callbackGridEntityType === undefined ||
-        callbackGridEntityType === gridEntityType) &&
-      (callbackGridEntityVariant === undefined ||
-        callbackGridEntityVariant === gridEntityVariant) &&
-      (callbackEntityType === undefined ||
-        callbackEntityType === entity.Type) &&
-      (callbackEntityVariant === undefined ||
-        callbackEntityVariant === entity.Variant) &&
-      (callbackEntitySubType === undefined ||
-        callbackEntitySubType === entity.SubType)
+      (callbackGridEntityType === undefined
+        || callbackGridEntityType === gridEntityType)
+      && (callbackGridEntityVariant === undefined
+        || callbackGridEntityVariant === gridEntityVariant)
+      && (callbackEntityType === undefined
+        || callbackEntityType === entity.Type)
+      && (callbackEntityVariant === undefined
+        || callbackEntityVariant === entity.Variant)
+      && (callbackEntitySubType === undefined
+        || callbackEntitySubType === entity.SubType)
     );
   };
 }

package/src/classes/callbacks/PostGridEntityCustomCollision.ts

@@ -25,14 +25,14 @@ export class PostGridEntityCustomCollision extends CustomCallback<T> {
     ] = optionalArgs;
 
     return (
-      (callbackGridEntityTypeCustom === undefined ||
-        callbackGridEntityTypeCustom === gridEntityTypeCustom) &&
-      (callbackEntityType === undefined ||
-        callbackEntityType === entity.Type) &&
-      (callbackEntityVariant === undefined ||
-        callbackEntityVariant === entity.Variant) &&
-      (callbackEntitySubType === undefined ||
-        callbackEntitySubType === entity.SubType)
+      (callbackGridEntityTypeCustom === undefined
+        || callbackGridEntityTypeCustom === gridEntityTypeCustom)
+      && (callbackEntityType === undefined
+        || callbackEntityType === entity.Type)
+      && (callbackEntityVariant === undefined
+        || callbackEntityVariant === entity.Variant)
+      && (callbackEntitySubType === undefined
+        || callbackEntitySubType === entity.SubType)
     );
   };
 }

package/src/classes/callbacks/PostGridEntityCustomRemove.ts

@@ -20,8 +20,8 @@ export class PostGridEntityCustomRemove extends CustomCallback<T> {
     const [callbackGridEntityTypeCustom] = optionalArgs;
 
     return (
-      callbackGridEntityTypeCustom === undefined ||
-      callbackGridEntityTypeCustom === gridEntityTypeCustom
+      callbackGridEntityTypeCustom === undefined
+      || callbackGridEntityTypeCustom === gridEntityTypeCustom
     );
   };
 }

package/src/classes/callbacks/PostGridEntityRemove.ts

@@ -20,9 +20,9 @@ export class PostGridEntityRemove extends CustomCallback<T> {
     const [callbackGridEntityType, callbackVariant] = optionalArgs;
 
     return (
-      (callbackGridEntityType === undefined ||
-        callbackGridEntityType === gridEntityType) &&
-      (callbackVariant === undefined || callbackVariant === variant)
+      (callbackGridEntityType === undefined
+        || callbackGridEntityType === gridEntityType)
+      && (callbackVariant === undefined || callbackVariant === variant)
     );
   };
 }

package/src/classes/callbacks/PostItemDischarge.ts

@@ -72,8 +72,8 @@ export class PostItemDischarge extends CustomCallback<T> {
     const [callbackCollectibleType] = optionalArgs;
 
     return (
-      callbackCollectibleType === undefined ||
-      callbackCollectibleType === collectibleType
+      callbackCollectibleType === undefined
+      || callbackCollectibleType === collectibleType
     );
   };
 

package/src/classes/callbacks/PostKeyboardChanged.ts

@@ -34,8 +34,8 @@ export class PostKeyboardChanged extends CustomCallback<T> {
     const [callbackKeyboard, callbackPressed] = optionalArgs;
 
     return (
-      (callbackKeyboard === undefined || callbackKeyboard === keyboard) &&
-      (callbackPressed === undefined || callbackPressed === pressed)
+      (callbackKeyboard === undefined || callbackKeyboard === keyboard)
+      && (callbackPressed === undefined || callbackPressed === pressed)
     );
   };
 

package/src/classes/callbacks/PostNewRoomEarly.ts

@@ -95,8 +95,8 @@ export class PostNewRoomEarly extends CustomCallback<ModCallbackCustom.POST_NEW_
     this.currentRoomTopLeftWallPtrHash2 = GetPtrHash(topLeftWall2);
 
     return (
-      oldTopLeftWallPtrHash !== this.currentRoomTopLeftWallPtrHash ||
-      oldTopLeftWallPtrHash2 !== this.currentRoomTopLeftWallPtrHash2
+      oldTopLeftWallPtrHash !== this.currentRoomTopLeftWallPtrHash
+      || oldTopLeftWallPtrHash2 !== this.currentRoomTopLeftWallPtrHash2
     );
   }
 }

package/src/classes/callbacks/PostPickupSelectionFilter.ts

@@ -29,9 +29,10 @@ export class PostPickupSelectionFilter extends CustomCallback<T> {
     const [callbackPickupVariant, callbackPickupSubType] = optionalArgs;
 
     return (
-      (callbackPickupVariant === undefined ||
-        callbackPickupVariant === pickupVariant) &&
-      (callbackPickupSubType === undefined || callbackPickupSubType === subType)
+      (callbackPickupVariant === undefined
+        || callbackPickupVariant === pickupVariant)
+      && (callbackPickupSubType === undefined
+        || callbackPickupSubType === subType)
     );
   };
 

package/src/classes/callbacks/PostPlayerChangeHealth.ts

@@ -47,8 +47,8 @@ export class PostPlayerChangeHealth extends CustomCallback<ModCallbackCustom.POS
       playerHealthMap.set(healthType, currentHealthValue);
 
       if (
-        storedHealthValue !== undefined &&
-        storedHealthValue !== currentHealthValue
+        storedHealthValue !== undefined
+        && storedHealthValue !== currentHealthValue
       ) {
         const difference = currentHealthValue - storedHealthValue;
         this.fire(

package/src/classes/callbacks/PostPurchase.ts

@@ -60,10 +60,10 @@ export class PostPurchase extends CustomCallback<T> {
     const [callbackPickupVariant, callbackPickupSubType] = optionalArgs;
 
     return (
-      (callbackPickupVariant === undefined ||
-        callbackPickupVariant === pickup.Variant) &&
-      (callbackPickupSubType === undefined ||
-        callbackPickupSubType === pickup.SubType)
+      (callbackPickupVariant === undefined
+        || callbackPickupVariant === pickup.Variant)
+      && (callbackPickupSubType === undefined
+        || callbackPickupSubType === pickup.SubType)
     );
   };
 
@@ -111,9 +111,9 @@ export class PostPurchase extends CustomCallback<T> {
     // Assume that if the player did not use an active item, card, or pill recently, then they
     // purchased an item.
     if (
-      !wasHoldingItemOnLastFrame &&
-      isHoldingItem &&
-      !this.playerUsedItemRecently(player)
+      !wasHoldingItemOnLastFrame
+      && isHoldingItem
+      && !this.playerUsedItemRecently(player)
     ) {
       this.playerPickedUpNewItem(player);
     }
@@ -126,8 +126,8 @@ export class PostPurchase extends CustomCallback<T> {
       player,
     );
     return (
-      gameFrameCount === usedCollectibleOnFrame ||
-      gameFrameCount === usedCollectibleOnFrame + 1
+      gameFrameCount === usedCollectibleOnFrame
+      || gameFrameCount === usedCollectibleOnFrame + 1
     );
   }
 

package/src/classes/callbacks/PostUsePillFilter.ts

@@ -76,8 +76,8 @@ export class PostUsePillFilter extends CustomCallback<ModCallbackCustom.POST_USE
           (pocketItem) => pocketItem.slot === PocketItemSlot.SLOT_1,
         );
         if (
-          oldPocketItemSlot1 !== undefined &&
-          oldPocketItemSlot1.type === PocketItemType.PILL
+          oldPocketItemSlot1 !== undefined
+          && oldPocketItemSlot1.type === PocketItemType.PILL
         ) {
           return oldPocketItemSlot1.subType;
         }

package/src/classes/callbacks/PreBerserkDeath.ts

@@ -36,10 +36,10 @@ export class PreBerserkDeath extends CustomCallback<ModCallbackCustom.PRE_BERSER
 
     // If the Berserk effect will end on the next frame and we have no hearts left.
     if (
-      berserkEffect !== undefined &&
-      berserkEffect.Cooldown === 1 &&
-      numHitsRemaining === 0 &&
-      !willPlayerRevive(player)
+      berserkEffect !== undefined
+      && berserkEffect.Cooldown === 1
+      && numHitsRemaining === 0
+      && !willPlayerRevive(player)
     ) {
       this.fire(player);
     }

package/src/classes/callbacks/PreEntitySpawnFilter.ts

@@ -24,9 +24,9 @@ export class PreEntitySpawnFilter extends CustomCallback<T> {
     const [callbackEntityType, callbackVariant, callbackSubType] = optionalArgs;
 
     return (
-      (callbackEntityType === undefined || callbackEntityType === entityType) &&
-      (callbackVariant === undefined || callbackVariant === variant) &&
-      (callbackSubType === undefined || callbackSubType === subType)
+      (callbackEntityType === undefined || callbackEntityType === entityType)
+      && (callbackVariant === undefined || callbackVariant === variant)
+      && (callbackSubType === undefined || callbackSubType === subType)
     );
   };
 

package/src/classes/callbacks/PreRoomEntitySpawnFilter.ts

@@ -31,11 +31,11 @@ export class PreRoomEntitySpawnFilter extends CustomCallback<T> {
     ] = optionalArgs;
 
     return (
-      (callbackEntityTypeOrGridEntityXMLType === undefined ||
-        callbackEntityTypeOrGridEntityXMLType ===
-          entityTypeOrGridEntityXMLType) &&
-      (callbackVariant === undefined || callbackVariant === variant) &&
-      (callbackSubType === undefined || callbackSubType === subType)
+      (callbackEntityTypeOrGridEntityXMLType === undefined
+        || callbackEntityTypeOrGridEntityXMLType
+          === entityTypeOrGridEntityXMLType)
+      && (callbackVariant === undefined || callbackVariant === variant)
+      && (callbackSubType === undefined || callbackSubType === subType)
     );
   };
 

package/src/classes/features/callbackLogic/EsauJrDetection.ts

@@ -45,8 +45,8 @@ export class EsauJrDetection extends Feature {
 
     // Check to see if it is the frame after the player has used Esau Jr.
     if (
-      v.run.usedEsauJrFrame === null ||
-      gameFrameCount < v.run.usedEsauJrFrame + 1
+      v.run.usedEsauJrFrame === null
+      || gameFrameCount < v.run.usedEsauJrFrame + 1
     ) {
       return;
     }

package/src/classes/features/callbackLogic/GameReorderedCallbacks.ts

@@ -162,11 +162,11 @@ export class GameReorderedCallbacks extends Feature {
     }
 
     if (
-      (onGameFrame(0) ||
-        onRenderFrame(this.renderFrameRunStarted) ||
-        this.currentStage !== stage ||
-        this.currentStageType !== stageType) &&
-      !this.forceNewRoom
+      (onGameFrame(0)
+        || onRenderFrame(this.renderFrameRunStarted)
+        || this.currentStage !== stage
+        || this.currentStageType !== stageType)
+      && !this.forceNewRoom
     ) {
       return;
     }

package/src/classes/features/callbackLogic/GridEntityUpdateDetection.ts

@@ -115,8 +115,8 @@ export class GridEntityUpdateDetection extends Feature {
       const [storedGridEntityType, storedGridEntityVariant] = gridEntityTuple;
       const gridEntity = gridEntitiesMap.get(gridIndex);
       if (
-        gridEntity === undefined ||
-        gridEntity.GetType() !== storedGridEntityType
+        gridEntity === undefined
+        || gridEntity.GetType() !== storedGridEntityType
       ) {
         v.room.initializedGridEntities.delete(gridIndex);
 
@@ -182,8 +182,8 @@ export class GridEntityUpdateDetection extends Feature {
     const gridEntityTuple = v.room.initializedGridEntities.get(gridIndex);
 
     if (
-      gridEntityTuple === undefined ||
-      gridEntityTuple[0] !== gridEntityType
+      gridEntityTuple === undefined
+      || gridEntityTuple[0] !== gridEntityType
     ) {
       this.updateTupleInMap(gridEntity);
 

package/src/classes/features/callbackLogic/ItemPickupDetection.ts

@@ -66,8 +66,8 @@ export class ItemPickupDetection extends Feature {
 
   private queueEmpty(player: EntityPlayer, pickingUpItem: PickingUpItem) {
     if (
-      pickingUpItem.itemType === ItemType.NULL ||
-      asNumber(pickingUpItem.subType) === 0
+      pickingUpItem.itemType === ItemType.NULL
+      || asNumber(pickingUpItem.subType) === 0
     ) {
       return;
     }
@@ -84,8 +84,8 @@ export class ItemPickupDetection extends Feature {
     }
 
     if (
-      queuedItem.Type !== pickingUpItem.itemType ||
-      queuedItem.ID !== pickingUpItem.subType
+      queuedItem.Type !== pickingUpItem.itemType
+      || queuedItem.ID !== pickingUpItem.subType
     ) {
       // Record which item we are picking up.
       pickingUpItem.itemType = queuedItem.Type;

package/src/classes/features/callbackLogic/PlayerCollectibleDetection.ts

@@ -200,8 +200,8 @@ export class PlayerCollectibleDetection extends Feature {
     pickingUpItem: PickingUpItem,
   ) => {
     if (
-      pickingUpItem.itemType === ItemType.TRINKET ||
-      pickingUpItem.itemType === ItemType.NULL
+      pickingUpItem.itemType === ItemType.TRINKET
+      || pickingUpItem.itemType === ItemType.NULL
     ) {
       return;
     }

package/src/classes/features/other/CustomTrapdoors.ts

@@ -220,8 +220,8 @@ export class CustomTrapdoors extends Feature {
 
   private checkPixelationToBlackComplete() {
     if (
-      v.run.state !== StageTravelState.PIXELATION_TO_BLACK ||
-      v.run.stateRenderFrame === null
+      v.run.state !== StageTravelState.PIXELATION_TO_BLACK
+      || v.run.stateRenderFrame === null
     ) {
       return;
     }
@@ -310,9 +310,9 @@ export class CustomTrapdoors extends Feature {
 
   private checkSecondPixelationHalfWay() {
     if (
-      v.run.state !==
-        StageTravelState.WAITING_FOR_SECOND_PIXELATION_TO_GET_HALF_WAY ||
-      v.run.stateRenderFrame === null
+      v.run.state
+        !== StageTravelState.WAITING_FOR_SECOND_PIXELATION_TO_GET_HALF_WAY
+      || v.run.stateRenderFrame === null
     ) {
       return;
     }
@@ -378,9 +378,9 @@ export class CustomTrapdoors extends Feature {
 
   private drawBlackSprite(): void {
     if (
-      v.run.state !== StageTravelState.WAITING_FOR_FIRST_PIXELATION_TO_END &&
-      v.run.state !==
-        StageTravelState.WAITING_FOR_SECOND_PIXELATION_TO_GET_HALF_WAY
+      v.run.state !== StageTravelState.WAITING_FOR_FIRST_PIXELATION_TO_END
+      && v.run.state
+        !== StageTravelState.WAITING_FOR_SECOND_PIXELATION_TO_GET_HALF_WAY
     ) {
       return;
     }
@@ -443,9 +443,9 @@ export class CustomTrapdoors extends Feature {
     const roomClear = room.IsClear();
 
     return (
-      !anyPlayerCloserThan(gridEntity.Position, TRAPDOOR_OPEN_DISTANCE) &&
-      !this.isPlayerCloseAfterBoss(gridEntity.Position) &&
-      !shouldBeClosedFromStartingInRoomWithEnemies(firstSpawn, roomClear)
+      !anyPlayerCloserThan(gridEntity.Position, TRAPDOOR_OPEN_DISTANCE)
+      && !this.isPlayerCloseAfterBoss(gridEntity.Position)
+      && !shouldBeClosedFromStartingInRoomWithEnemies(firstSpawn, roomClear)
     );
   }
 
@@ -457,9 +457,11 @@ export class CustomTrapdoors extends Feature {
     // In order to prevent a player from accidentally entering a freshly-spawned trapdoor after
     // killing the boss of the floor, we use a wider open distance for a short amount of frames.
     if (
-      roomType !== RoomType.BOSS ||
-      roomClearGameFrame === undefined ||
-      onOrAfterRenderFrame(roomClearGameFrame + TRAPDOOR_BOSS_REACTION_FRAMES)
+      roomType !== RoomType.BOSS
+      || roomClearGameFrame === undefined
+      || onOrAfterRenderFrame(
+        roomClearGameFrame + TRAPDOOR_BOSS_REACTION_FRAMES,
+      )
     ) {
       return false;
     }
@@ -492,9 +494,9 @@ export class CustomTrapdoors extends Feature {
 
       if (
         // We don't want a Pony dash to transition to a new floor or a crawl space.
-        !this.ponyDetection.isPlayerUsingPony(player) &&
-        !isChildPlayer(player) &&
-        canPlayerInteractWithTrapdoor(player)
+        !this.ponyDetection.isPlayerUsingPony(player)
+        && !isChildPlayer(player)
+        && canPlayerInteractWithTrapdoor(player)
       ) {
         this.playerTouchedCustomTrapdoor(
           gridEntity,
@@ -754,8 +756,8 @@ export class CustomTrapdoors extends Feature {
     spawnOpen?: boolean,
   ): GridEntity {
     if (
-      destinationName !== undefined &&
-      !this.destinationFuncMap.has(destinationName)
+      destinationName !== undefined
+      && !this.destinationFuncMap.has(destinationName)
     ) {
       error(
         `Failed to spawn a custom trapdoor with a destination of "${destinationName}" since a destination with that name has not been registered with the "registerCustomTrapdoorDestination" function. (If you are trying to go to a custom stage, the custom stage library should automatically do this for you when your mod first boots.)`,
@@ -831,8 +833,8 @@ function canPlayerInteractWithTrapdoor(player: EntityPlayer) {
   const sprite = player.GetSprite();
   const animation = sprite.GetAnimation();
   return (
-    !player.IsHoldingItem() &&
-    !ANIMATIONS_THAT_PREVENT_STAGE_TRAVEL.has(animation)
+    !player.IsHoldingItem()
+    && !ANIMATIONS_THAT_PREVENT_STAGE_TRAVEL.has(animation)
   );
 }
 

package/src/classes/features/other/DeployJSONRoom.ts

@@ -161,9 +161,9 @@ export class DeployJSONRoom extends Feature {
 
     let entity: Entity;
     if (
-      entityType === EntityType.PICKUP &&
+      entityType === EntityType.PICKUP
       // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
-      variant === PickupVariant.COLLECTIBLE
+      && variant === PickupVariant.COLLECTIBLE
     ) {
       const collectibleType = asCollectibleType(subType);
       const options = roomType === RoomType.ANGEL;
@@ -174,9 +174,9 @@ export class DeployJSONRoom extends Feature {
 
     // For some reason, Pitfalls do not spawn with the correct collision classes.
     if (
-      entityType === EntityType.PITFALL &&
+      entityType === EntityType.PITFALL
       // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
-      variant === PitfallVariant.PITFALL
+      && variant === PitfallVariant.PITFALL
     ) {
       entity.EntityCollisionClass = EntityCollisionClass.ENEMIES;
       entity.GridCollisionClass = EntityGridCollisionClass.WALLS;

package/src/classes/features/other/DisableInputs.ts

@@ -122,9 +122,9 @@ export class DisableInputs extends Feature {
   @Exported
   public areInputsEnabled(): boolean {
     return (
-      v.run.disableInputs.size === 0 &&
-      v.run.enableAllInputsWithBlacklistMap.size === 0 &&
-      v.run.disableAllInputsWithWhitelistMap.size === 0
+      v.run.disableInputs.size === 0
+      && v.run.enableAllInputsWithBlacklistMap.size === 0
+      && v.run.disableAllInputsWithWhitelistMap.size === 0
     );
   }
 

package/src/classes/features/other/ModdedElementSets.ts

@@ -411,8 +411,8 @@ export class ModdedElementSets extends Feature {
   private lazyInitEdenCollectibleTypesSet() {
     for (const collectibleType of this.getCollectibleTypes()) {
       if (
-        isHiddenCollectible(collectibleType) ||
-        collectibleHasTag(collectibleType, ItemConfigTag.NO_EDEN)
+        isHiddenCollectible(collectibleType)
+        || collectibleHasTag(collectibleType, ItemConfigTag.NO_EDEN)
       ) {
         continue;
       }

package/src/classes/features/other/NoSirenSteal.ts

@@ -59,16 +59,16 @@ export class NoSirenSteal extends Feature {
       const [familiarVariant, familiarSubType] = familiarTuple;
 
       if (
-        familiarVariant === incomingFamiliarVariant &&
-        familiarSubType === incomingFamiliarSubType
+        familiarVariant === incomingFamiliarVariant
+        && familiarSubType === incomingFamiliarSubType
       ) {
         // There is an entry that matches the variant and sub-type exactly.
         return true;
       }
 
       if (
-        familiarVariant === incomingFamiliarVariant &&
-        familiarSubType === undefined
+        familiarVariant === incomingFamiliarVariant
+        && familiarSubType === undefined
       ) {
         // There is an entry that matches all sub-types for this variant.
         return true;

package/src/classes/features/other/PickupIndexCreation.ts

@@ -95,9 +95,9 @@ export class PickupIndexCreation extends Feature {
     const room = game.GetRoom();
     const isFirstVisit = room.IsFirstVisit();
     if (
-      pickupIndexFromLevelData !== undefined &&
-      !isFirstVisit &&
-      onOrBeforeRoomFrame(0)
+      pickupIndexFromLevelData !== undefined
+      && !isFirstVisit
+      && onOrBeforeRoomFrame(0)
     ) {
       v.room.pickupIndexes.set(ptrHash, pickupIndexFromLevelData);
       return;
@@ -282,8 +282,8 @@ function getStoredPickupIndex(
 ): PickupIndex | undefined {
   for (const [pickupIndex, pickupDescription] of pickupDescriptions) {
     if (
-      vectorEquals(pickupDescription.position, pickup.Position) &&
-      pickupDescription.initSeed === pickup.InitSeed
+      vectorEquals(pickupDescription.position, pickup.Position)
+      && pickupDescription.initSeed === pickup.InitSeed
     ) {
       return pickupIndex;
     }

package/src/classes/features/other/PonyDetection.ts

@@ -44,8 +44,8 @@ export class PonyDetection extends Feature {
     const effects = player.GetEffects();
     const entityFlags = player.GetEntityFlags();
     const hasPonyCollectibleEffect =
-      effects.HasCollectibleEffect(CollectibleType.PONY) ||
-      effects.HasCollectibleEffect(CollectibleType.WHITE_PONY);
+      effects.HasCollectibleEffect(CollectibleType.PONY)
+      || effects.HasCollectibleEffect(CollectibleType.WHITE_PONY);
     const isPonyActiveOnPreviousFrame = setHasPlayer(
       v.run.playersIsPonyActive,
       player,

package/src/classes/features/other/PressInput.ts

@@ -55,8 +55,8 @@ export class PressInput extends Feature {
       const pair = v.run.buttonActionPairs[i]!;
 
       if (
-        pair.playerIndex === playerIndex &&
-        pair.buttonAction === buttonAction
+        pair.playerIndex === playerIndex
+        && pair.buttonAction === buttonAction
       ) {
         v.run.buttonActionPairs.splice(i);
         return true;

package/src/classes/features/other/PreventChildEntities.ts

@@ -25,12 +25,12 @@ export class PreventChildEntities extends Feature {
   // ModCallback.POST_NPC_INIT (27)
   private readonly postNPCInit = (npc: EntityNPC) => {
     const spawnerEntityMatch =
-      npc.SpawnerEntity !== undefined &&
-      v.room.preventingEntities.has(GetPtrHash(npc.SpawnerEntity));
+      npc.SpawnerEntity !== undefined
+      && v.room.preventingEntities.has(GetPtrHash(npc.SpawnerEntity));
 
     const parentMatch =
-      npc.Parent !== undefined &&
-      v.room.preventingEntities.has(GetPtrHash(npc.Parent));
+      npc.Parent !== undefined
+      && v.room.preventingEntities.has(GetPtrHash(npc.Parent));
 
     if (spawnerEntityMatch || parentMatch) {
       npc.Remove();

package/src/classes/features/other/RoomHistory.ts

@@ -192,11 +192,11 @@ export class RoomHistory extends Feature {
     }
 
     return (
-      startSeedString !== latestRoomDescription.startSeedString ||
-      stage !== latestRoomDescription.stage ||
-      stageType !== latestRoomDescription.stageType ||
-      roomListIndex !== latestRoomDescription.roomListIndex ||
-      roomVisitedCount !== latestRoomDescription.roomVisitedCount
+      startSeedString !== latestRoomDescription.startSeedString
+      || stage !== latestRoomDescription.stage
+      || stageType !== latestRoomDescription.stageType
+      || roomListIndex !== latestRoomDescription.roomListIndex
+      || roomVisitedCount !== latestRoomDescription.roomVisitedCount
     );
   }
 }

package/src/classes/features/other/SaveDataManager.ts

@@ -393,8 +393,8 @@ export class SaveDataManager extends Feature {
   private storeClassConstructorsFromObject(luaMap: LuaMap<AnyNotNil, unknown>) {
     const tstlClassName = getTSTLClassName(luaMap);
     if (
-      tstlClassName !== undefined &&
-      !NON_USER_DEFINED_CLASS_NAMES.has(tstlClassName)
+      tstlClassName !== undefined
+      && !NON_USER_DEFINED_CLASS_NAMES.has(tstlClassName)
     ) {
       this.classConstructors.set(tstlClassName, luaMap as unknown as AnyClass);
     }

package/src/classes/features/other/StageHistory.ts

@@ -323,8 +323,8 @@ export class StageHistory extends Feature {
 
     return v.run.stageHistory.some(
       (stageHistoryEntry) =>
-        stageHistoryEntry.stage === stage &&
-        stageHistoryEntry.stageType === stageType,
+        stageHistoryEntry.stage === stage
+        && stageHistoryEntry.stageType === stageType,
     );
   }
 }

package/src/classes/features/other/StartAmbush.ts

@@ -60,8 +60,8 @@ export class StartAmbush extends Feature {
       const coins = getCoins();
       const coinsFromSack = coins.filter(
         (pickup) =>
-          pickup.SpawnerEntity !== undefined &&
-          GetPtrHash(pickup.SpawnerEntity) === sackPtrHash,
+          pickup.SpawnerEntity !== undefined
+          && GetPtrHash(pickup.SpawnerEntity) === sackPtrHash,
       );
       removeEntities(coinsFromSack);
     });