isaacscript-common 30.12.3 → 30.12.4

package/dist/index.rollup.d.ts

@@ -3,82 +3,82 @@
 /// <reference types="lua-types/5.3" />
 
 import { ActiveSlot } from 'isaac-typescript-definitions';
-import { BackdropType } from 'isaac-typescript-definitions';
-import { BatterySubType } from 'isaac-typescript-definitions';
-import { BombSubType } from 'isaac-typescript-definitions';
-import { BombVariant } from 'isaac-typescript-definitions';
-import { BossID } from 'isaac-typescript-definitions';
+import type { BackdropType } from 'isaac-typescript-definitions';
+import type { BatterySubType } from 'isaac-typescript-definitions';
+import type { BombSubType } from 'isaac-typescript-definitions';
+import type { BombVariant } from 'isaac-typescript-definitions';
+import type { BossID } from 'isaac-typescript-definitions';
 import { ButtonAction } from 'isaac-typescript-definitions';
 import { CacheFlag } from 'isaac-typescript-definitions';
 import { CallbackPriority } from 'isaac-typescript-definitions/dist/src/enums/CallbackPriority';
 import { CardType } from 'isaac-typescript-definitions';
-import { Challenge } from 'isaac-typescript-definitions';
-import { CoinSubType } from 'isaac-typescript-definitions';
-import { CollectiblePedestalType } from 'isaac-typescript-definitions';
+import type { Challenge } from 'isaac-typescript-definitions';
+import type { CoinSubType } from 'isaac-typescript-definitions';
+import type { CollectiblePedestalType } from 'isaac-typescript-definitions';
 import { CollectibleType } from 'isaac-typescript-definitions';
 import { Controller } from 'isaac-typescript-definitions';
 import { ControllerIndex } from 'isaac-typescript-definitions';
 import { CopyableIsaacAPIClassType } from 'isaac-typescript-definitions';
 import { CrawlSpaceVariant } from 'isaac-typescript-definitions';
 import { DamageFlag } from 'isaac-typescript-definitions';
-import { DiceFloorSubType } from 'isaac-typescript-definitions';
+import type { DiceFloorSubType } from 'isaac-typescript-definitions';
 import { Dimension } from 'isaac-typescript-definitions';
 import { Direction } from 'isaac-typescript-definitions';
 import { DisplayFlag } from 'isaac-typescript-definitions';
 import { DoorSlot } from 'isaac-typescript-definitions';
-import { DoorSlotFlag } from 'isaac-typescript-definitions';
+import type { DoorSlotFlag } from 'isaac-typescript-definitions';
 import { DoorVariant } from 'isaac-typescript-definitions';
-import { EffectVariant } from 'isaac-typescript-definitions';
+import type { EffectVariant } from 'isaac-typescript-definitions';
 import { EntityFlag } from 'isaac-typescript-definitions';
 import { EntityType } from 'isaac-typescript-definitions';
-import { FamiliarVariant } from 'isaac-typescript-definitions';
+import type { FamiliarVariant } from 'isaac-typescript-definitions';
 import { GridCollisionClass } from 'isaac-typescript-definitions';
 import { GridEntityType } from 'isaac-typescript-definitions';
-import { GridEntityXMLType } from 'isaac-typescript-definitions';
-import { HeartSubType } from 'isaac-typescript-definitions';
-import { InputHook } from 'isaac-typescript-definitions';
+import type { GridEntityXMLType } from 'isaac-typescript-definitions';
+import type { HeartSubType } from 'isaac-typescript-definitions';
+import type { InputHook } from 'isaac-typescript-definitions';
 import { ItemConfigCardType } from 'isaac-typescript-definitions';
 import { ItemConfigChargeType } from 'isaac-typescript-definitions';
-import { ItemConfigPillEffectClass } from 'isaac-typescript-definitions';
-import { ItemConfigPillEffectType } from 'isaac-typescript-definitions';
+import type { ItemConfigPillEffectClass } from 'isaac-typescript-definitions';
+import type { ItemConfigPillEffectType } from 'isaac-typescript-definitions';
 import { ItemConfigTag } from 'isaac-typescript-definitions';
 import { ItemPoolType } from 'isaac-typescript-definitions';
 import { ItemType } from 'isaac-typescript-definitions';
 import { Keyboard } from 'isaac-typescript-definitions';
-import { KeySubType } from 'isaac-typescript-definitions';
-import { KnifeVariant } from 'isaac-typescript-definitions';
-import { LaserVariant } from 'isaac-typescript-definitions';
-import { LevelCurse } from 'isaac-typescript-definitions';
+import type { KeySubType } from 'isaac-typescript-definitions';
+import type { KnifeVariant } from 'isaac-typescript-definitions';
+import type { LaserVariant } from 'isaac-typescript-definitions';
+import type { LevelCurse } from 'isaac-typescript-definitions';
 import { LevelStage } from 'isaac-typescript-definitions';
-import { MinibossID } from 'isaac-typescript-definitions';
+import type { MinibossID } from 'isaac-typescript-definitions';
 import { ModCallback } from 'isaac-typescript-definitions';
-import { Music } from 'isaac-typescript-definitions';
-import { NPCState } from 'isaac-typescript-definitions';
+import type { Music } from 'isaac-typescript-definitions';
+import type { NPCState } from 'isaac-typescript-definitions';
 import { PickupPrice } from 'isaac-typescript-definitions';
-import { PickupVariant } from 'isaac-typescript-definitions';
+import type { PickupVariant } from 'isaac-typescript-definitions';
 import { PillColor } from 'isaac-typescript-definitions';
 import { PillEffect } from 'isaac-typescript-definitions';
 import { PitVariant } from 'isaac-typescript-definitions';
 import { PlayerForm } from 'isaac-typescript-definitions';
 import { PlayerType } from 'isaac-typescript-definitions';
-import { PlayerVariant } from 'isaac-typescript-definitions';
-import { PocketItemSlot } from 'isaac-typescript-definitions';
+import type { PlayerVariant } from 'isaac-typescript-definitions';
+import type { PocketItemSlot } from 'isaac-typescript-definitions';
 import { PoopGridEntityVariant } from 'isaac-typescript-definitions';
 import { PressurePlateVariant } from 'isaac-typescript-definitions';
 import { ProjectileFlag } from 'isaac-typescript-definitions';
 import { ProjectilesMode } from 'isaac-typescript-definitions';
-import { ProjectileVariant } from 'isaac-typescript-definitions';
+import type { ProjectileVariant } from 'isaac-typescript-definitions';
 import { RockVariant } from 'isaac-typescript-definitions';
 import { RoomShape } from 'isaac-typescript-definitions';
 import { RoomTransitionAnim } from 'isaac-typescript-definitions';
 import { RoomType } from 'isaac-typescript-definitions';
-import { SackSubType } from 'isaac-typescript-definitions';
-import { SlotVariant } from 'isaac-typescript-definitions';
-import { StageID } from 'isaac-typescript-definitions';
+import type { SackSubType } from 'isaac-typescript-definitions';
+import type { SlotVariant } from 'isaac-typescript-definitions';
+import type { StageID } from 'isaac-typescript-definitions';
 import { StageType } from 'isaac-typescript-definitions';
 import { TearFlag } from 'isaac-typescript-definitions';
-import { TearVariant } from 'isaac-typescript-definitions';
-import { TrapdoorVariant } from 'isaac-typescript-definitions';
+import type { TearVariant } from 'isaac-typescript-definitions';
+import type { TrapdoorVariant } from 'isaac-typescript-definitions';
 import { TrinketType } from 'isaac-typescript-definitions';
 import { UseFlag } from 'isaac-typescript-definitions';
 
@@ -1343,9 +1343,9 @@ export declare function characterCanTakeFreeDevilDeals(character: PlayerType): b
 export declare function characterGetsBlackHeartFromEternalHeart(character: PlayerType): boolean;
 
 declare class CharacterHealthConversion extends Feature {
-    private characterHealthReplacementMap;
-    private prePickupCollisionHeart;
-    private postPEffectUpdateReordered;
+    private readonly characterHealthReplacementMap;
+    private readonly prePickupCollisionHeart;
+    private readonly postPEffectUpdateReordered;
     /**
      * Helper function to make a character that has the same health mechanic as Blue Baby (red heart
      * containers --> soul hearts) or Dark Judas (red heart containers --> black hearts).
@@ -1368,8 +1368,8 @@ export declare function characterStartsWithActiveItem(character: PlayerType): bo
 
 /** Easily create custom characters that have base stats different from that of Isaac. */
 declare class CharacterStats extends Feature {
-    private charactersStatMap;
-    private evaluateCache;
+    private readonly charactersStatMap;
+    private readonly evaluateCache;
     /**
      * Helper function to manage the stats for a vanilla or custom character. Call this function once
      * at the beginning of your mod to declare the starting stats.
@@ -1542,8 +1542,8 @@ export declare function collectibleHasCacheFlag(collectibleOrCollectibleType: En
 export declare function collectibleHasTag(collectibleType: CollectibleType, tag: ItemConfigTag): boolean;
 
 declare class CollectibleItemPoolType extends Feature {
-    private pickupIndexCreation;
-    private postPickupInitCollectible;
+    private readonly pickupIndexCreation;
+    private readonly postPickupInitCollectible;
     /**
      * Helper function to get the item pool type that a given collectible came from. Since there is no
      * native method in the API to get this, we listen in the `POST_PICKUP_INIT` callback for
@@ -1756,9 +1756,9 @@ declare abstract class CustomCallback<T extends ModCallbackCustom> extends Featu
 }
 
 declare class CustomGridEntities extends Feature {
-    private runInNFrames;
-    private preUseItemWeNeedToGoDeeper;
-    private postNewRoomReordered;
+    private readonly runInNFrames;
+    private readonly preUseItemWeNeedToGoDeeper;
+    private readonly postNewRoomReordered;
     /**
      * Helper function to spawn a custom grid entity. Custom grid entities are persistent in that they
      * will reappear if the player leaves and re-enters the room. (It will be manually respawned in
@@ -1894,14 +1894,14 @@ declare class CustomHotkeys extends Feature {
      * The keys are the keyboard keys that trigger the hotkey. The values are the functions that
      * contain the arbitrary code to run.
      */
-    private staticHotkeyFunctionMap;
+    private readonly staticHotkeyFunctionMap;
     /**
      * The keys are the functions that determine what the hotkey key is. The values are the functions
      * that contain the arbitrary code to run.
      */
-    private dynamicHotkeyFunctionMap;
-    private keyPressedMap;
-    private postRender;
+    private readonly dynamicHotkeyFunctionMap;
+    private readonly keyPressedMap;
+    private readonly postRender;
     private checkIfTriggered;
     /**
      * Helper function to run arbitrary code when you press and release a specific keyboard key.
@@ -1958,7 +1958,7 @@ declare class CustomHotkeys extends Feature {
 }
 
 declare class CustomItemPools extends Feature {
-    private postGameStartedReorderedFalse;
+    private readonly postGameStartedReorderedFalse;
     /**
      * Helper function to register a custom item pool. Use this function once when your mod first
      * loads to declare the items that you want to be in the item pools. Then, in the middle of a run,
@@ -2016,9 +2016,9 @@ declare class CustomItemPools extends Feature {
 
 declare class CustomPickups extends Feature {
     /** Indexed by entity ID. */
-    private customPickupFunctionsMap;
-    private prePickupCollision;
-    private postEffectRenderPickupEffect;
+    private readonly customPickupFunctionsMap;
+    private readonly prePickupCollision;
+    private readonly postEffectRenderPickupEffect;
     /**
      * Helper function to register a custom pickup with the IsaacScript standard library. Use this
      * feature for custom pickups that are intended to be picked up by the player, like bombs and
@@ -2056,17 +2056,17 @@ declare class CustomRevive extends Feature {
             dyingPlayerIndex: PlayerIndex | null;
         };
     };
-    private preCustomRevive;
-    private postCustomRevive;
-    private runInNFrames;
+    private readonly preCustomRevive;
+    private readonly postCustomRevive;
+    private readonly runInNFrames;
     constructor(preCustomRevive: PreCustomRevive, postCustomRevive: PostCustomRevive, runInNFrames: RunInNFrames);
-    private postRender;
-    private postFamiliarInitOneUp;
-    private postNewRoomReordered;
-    private postPEffectUpdateReordered;
+    private readonly postRender;
+    private readonly postFamiliarInitOneUp;
+    private readonly postNewRoomReordered;
+    private readonly postPEffectUpdateReordered;
     private checkWaitingForItemAnimation;
-    private postPlayerFatalDamage;
-    private preBerserkDeath;
+    private readonly postPlayerFatalDamage;
+    private readonly preBerserkDeath;
     /**
      * The player is about to die, which will immediately delete the save data for the run. To prevent
      * this from happening, we grant the 1-Up item.
@@ -2171,25 +2171,25 @@ export declare interface CustomStageRoomMetadata {
 
 declare class CustomStages extends Feature {
     /** Indexed by custom stage name. */
-    private customStagesMap;
+    private readonly customStagesMap;
     /** Indexed by room variant. */
-    private customStageCachedRoomData;
-    private customGridEntities;
-    private customTrapdoors;
-    private disableAllSound;
-    private gameReorderedCallbacks;
-    private pause;
-    private runInNFrames;
+    private readonly customStageCachedRoomData;
+    private readonly customGridEntities;
+    private readonly customTrapdoors;
+    private readonly disableAllSound;
+    private readonly gameReorderedCallbacks;
+    private readonly pause;
+    private readonly runInNFrames;
     private initCustomStageMetadata;
     private initRoomTypeMap;
     private initCustomTrapdoorDestination;
-    private goToCustomStage;
-    private postRender;
-    private postCurseEval;
-    private getShaderParams;
-    private postGridEntityBrokenRockAlt;
-    private postGridEntityInit;
-    private postNewRoomReordered;
+    private readonly goToCustomStage;
+    private readonly postRender;
+    private readonly postCurseEval;
+    private readonly getShaderParams;
+    private readonly postGridEntityBrokenRockAlt;
+    private readonly postGridEntityInit;
+    private readonly postNewRoomReordered;
     /** Pick a custom room for each vanilla room. */
     private setStageRoomsData;
     /**
@@ -2672,22 +2672,22 @@ export declare interface CustomStageTSConfig {
 
 declare class CustomTrapdoors extends Feature {
     /** Indexed by custom trapdoor ID. */
-    private destinationFuncMap;
+    private readonly destinationFuncMap;
     /**
      * In order to represent a black sprite, we just use the first frame of the boss versus screen
      * animation. However, we must lazy load the sprite in order to prevent issues with mods that
      * replace the vanilla files. (For some reason, loading the sprites will cause the overwrite to no
      * longer apply on the second and subsequent runs.)
      */
-    private blackSprite;
-    private customGridEntities;
-    private disableInputs;
-    private ponyDetection;
-    private roomClearFrame;
-    private runInNFrames;
-    private runNextRoom;
-    private stageHistory;
-    private postRender;
+    private readonly blackSprite;
+    private readonly customGridEntities;
+    private readonly disableInputs;
+    private readonly ponyDetection;
+    private readonly roomClearFrame;
+    private readonly runInNFrames;
+    private readonly runNextRoom;
+    private readonly stageHistory;
+    private readonly postRender;
     private checkAllPlayersJumpComplete;
     private checkPixelationToBlackComplete;
     private goToCustomTrapdoorDestination;
@@ -2695,7 +2695,7 @@ declare class CustomTrapdoors extends Feature {
     private checkSecondPixelationHalfWay;
     private checkAllPlayersLayingDownComplete;
     private drawBlackSprite;
-    private postGridEntityCustomUpdateTrapdoor;
+    private readonly postGridEntityCustomUpdateTrapdoor;
     private checkCustomTrapdoorOpenClose;
     private shouldTrapdoorOpen;
     private isPlayerCloseAfterBoss;
@@ -2703,7 +2703,7 @@ declare class CustomTrapdoors extends Feature {
     private playerTouchedCustomTrapdoor;
     private startDelayedJump;
     private adjustPlayerPositionToTrapdoor;
-    private postPEffectUpdateReordered;
+    private readonly postPEffectUpdateReordered;
     private checkJumpComplete;
     private shouldTrapdoorSpawnOpen;
     private logStateChanged;
@@ -2769,25 +2769,25 @@ declare class CustomTrapdoors extends Feature {
 }
 
 declare class DebugDisplay extends Feature {
-    private mod;
-    private player;
-    private tear;
-    private familiar;
-    private bomb;
-    private pickup;
-    private slot;
-    private laser;
-    private knife;
-    private projectile;
-    private effect;
-    private npc;
-    private rock;
-    private pit;
-    private spikes;
-    private tnt;
-    private poop;
-    private door;
-    private pressurePlate;
+    private readonly mod;
+    private readonly player;
+    private readonly tear;
+    private readonly familiar;
+    private readonly bomb;
+    private readonly pickup;
+    private readonly slot;
+    private readonly laser;
+    private readonly knife;
+    private readonly projectile;
+    private readonly effect;
+    private readonly npc;
+    private readonly rock;
+    private readonly pit;
+    private readonly spikes;
+    private readonly tnt;
+    private readonly poop;
+    private readonly door;
+    private readonly pressurePlate;
     /**
      * If the "togglePlayerDisplay" function is called, text will be drawn on the screen next to each
      * player. Use this function to specify a callback function that returns the string that should be
@@ -3312,8 +3312,8 @@ export declare const DEFAULT_ITEM_POOL_TYPE = ItemPoolType.TREASURE;
  *   the reference to the factory function.
  */
 export declare class DefaultMap<Key, Value, Args extends unknown[] = []> extends Map<Key, Value> {
-    private defaultValue;
-    private defaultValueFactory;
+    private readonly defaultValue;
+    private readonly defaultValueFactory;
     /**
      * See the main `DefaultMap` documentation:
      * https://isaacscript.github.io/isaacscript-common/other/classes/DefaultMap
@@ -3424,8 +3424,8 @@ export declare function defaultMapSetPlayer<V>(map: Map<PlayerIndex, V>, player:
 export declare function deleteSetsFromSet<T>(mainSet: Set<T>, ...setsToRemove: Array<Set<T> | ReadonlySet<T>>): void;
 
 declare class DeployJSONRoom extends Feature {
-    private preventGridEntityRespawn;
-    private spawnCollectible;
+    private readonly preventGridEntityRespawn;
+    private readonly spawnCollectible;
     private spawnAllEntities;
     private spawnNormalEntityForJSONRoom;
     /**
@@ -3525,7 +3525,7 @@ export declare function directionToVector(direction: Direction): Readonly<Vector
 
 declare class DisableAllSound extends Feature {
     private musicWasEnabled;
-    private postRender;
+    private readonly postRender;
     /**
      * Helper function to stop muting all sound effects and music.
      *
@@ -3555,9 +3555,9 @@ declare class DisableAllSound extends Feature {
 }
 
 declare class DisableInputs extends Feature {
-    private isActionPressed;
-    private isActionTriggered;
-    private getActionValue;
+    private readonly isActionPressed;
+    private readonly isActionTriggered;
+    private readonly getActionValue;
     private getReturnValue;
     /**
      * Helper function to check if the `ISCFeature.DISABLE_INPUTS` feature is turned on in some
@@ -3978,7 +3978,7 @@ declare class EdenStartingStats extends Feature {
      * We must use the `POST_PLAYER_INIT` callback since the two random collectibles have not been
      * granted yet.
      */
-    private postPlayerInit;
+    private readonly postPlayerInit;
     /**
      * Helper function to get the value of the randomized starting stat for Eden. (At the beginning of
      * a run, Eden starts with randomized stats.)
@@ -4060,11 +4060,11 @@ declare class EsauJrDetection extends Feature {
             usedEsauJrAtLeastOnce: boolean;
         };
     };
-    private postEsauJr;
-    private postFirstEsauJr;
+    private readonly postEsauJr;
+    private readonly postFirstEsauJr;
     constructor(postEsauJr: PostEsauJr, postFirstEsauJr: PostFirstEsauJr);
-    private postUpdate;
-    private postUseItemEsauJr;
+    private readonly postUpdate;
+    private readonly postUseItemEsauJr;
 }
 
 /**
@@ -4085,16 +4085,16 @@ declare class EsauJrDetection extends Feature {
 export declare function every<T>(array: T[], func: (value: T, index: number, array: T[]) => boolean): boolean;
 
 declare class ExtraConsoleCommands extends Feature {
-    private commandFunctionMap;
-    private postUpdate;
-    private evaluateCacheDamage;
-    private evaluateCacheFireDelay;
-    private evaluateCacheSpeed;
-    private evaluateCacheFlying;
-    private postCurseEval;
-    private executeCmd;
-    private postFireTear;
-    private entityTakeDmgPlayer;
+    private readonly commandFunctionMap;
+    private readonly postUpdate;
+    private readonly evaluateCacheDamage;
+    private readonly evaluateCacheFireDelay;
+    private readonly evaluateCacheSpeed;
+    private readonly evaluateCacheFlying;
+    private readonly postCurseEval;
+    private readonly executeCmd;
+    private readonly postFireTear;
+    private readonly entityTakeDmgPlayer;
     /**
      * Helper function to add a custom console command.
      *
@@ -4127,7 +4127,7 @@ export declare type FactoryFunction<V, Args extends unknown[]> = (...args: Args)
 
 declare class FadeInRemover extends Feature {
     private enabled;
-    private postGameStartedReordered;
+    private readonly postGameStartedReordered;
     /**
      * Removes the fade-in that occurs at the beginning of a run. If this behavior is desired, call
      * this function once at the beginning of your mod.
@@ -4150,7 +4150,7 @@ declare class FadeInRemover extends Feature {
 
 declare class FastReset extends Feature {
     private enabled;
-    private postRender;
+    private readonly postRender;
     /**
      * Enables the fast-reset feature, which allows you to restart the game instantaneously. If this
      * behavior is desired, call this function once at the beginning of your mod.
@@ -4184,7 +4184,7 @@ declare abstract class Feature {
      * dependency injection. We provide a run-time check in order to prevent the bug of any feature
      * accidentally being instantiated twice.
      */
-    private static constructedClassNames;
+    private static readonly constructedClassNames;
     constructor();
 }
 
@@ -4296,14 +4296,14 @@ declare class FlipDetection extends Feature {
             usedFlipAtLeastOnce: boolean;
         };
     };
-    private postFlip;
-    private postFirstFlip;
+    private readonly postFlip;
+    private readonly postFirstFlip;
     constructor(postFlip: PostFlip, postFirstFlip: PostFirstFlip);
-    private postUseItemFlip;
+    private readonly postUseItemFlip;
 }
 
 declare class FlyingDetection extends Feature {
-    private moddedElementSets;
+    private readonly moddedElementSets;
     /**
      * Helper function to see if the player currently has flying from a temporary effect such as
      * Hanged Man, Bat Wing, and so on.
@@ -4337,7 +4337,7 @@ export declare const fonts: {
 export declare function forEach<T>(array: T[], func: (value: T, index: number, array: T[]) => void): void;
 
 declare class ForgottenSwitch extends Feature {
-    private pressInput;
+    private readonly pressInput;
     /**
      * When used on The Forgotten, switches to The Soul. When used on The Soul, switches to The
      * Forgotten. This takes 1 game frame to take effect.
@@ -4391,16 +4391,16 @@ declare class GameReorderedCallbacks extends Feature {
     private usedGlowingHourGlass;
     private forceNewLevel;
     private forceNewRoom;
-    private postGameStartedReordered;
-    private postNewLevelReordered;
-    private postNewRoomReordered;
-    private postGameStartedReorderedLast;
-    private postUseItemGlowingHourGlass;
-    private postPlayerInit;
-    private postGameStarted;
-    private preGameExit;
-    private postNewLevel;
-    private postNewRoom;
+    private readonly postGameStartedReordered;
+    private readonly postNewLevelReordered;
+    private readonly postNewRoomReordered;
+    private readonly postGameStartedReorderedLast;
+    private readonly postUseItemGlowingHourGlass;
+    private readonly postPlayerInit;
+    private readonly postGameStarted;
+    private readonly preGameExit;
+    private readonly postNewLevel;
+    private readonly postNewRoom;
     private recordCurrentStage;
     /**
      * Helper function to tell the `POST_NEW_LEVEL_REORDERED` callback that it should always fire on
@@ -6645,7 +6645,7 @@ export declare function getRoomShapeAdjacentGridIndexDeltas(roomShape: RoomShape
  *
  * @param safeRoomGridIndex This must be the room safe grid index (i.e. the top-left room grid index
  *                          for the respective room).
- * @param roomShape The shape of the room.
+ * @param roomShape The shape of the hypothetical room.
  * @returns A map of `DoorSlot` to the corresponding room grid index.
  */
 export declare function getRoomShapeAdjacentGridIndexes(safeRoomGridIndex: int, roomShape: RoomShape): ReadonlyMap<DoorSlot, int>;
@@ -7214,11 +7214,11 @@ declare class GridEntityCollisionDetection extends Feature {
             collidingEntitiesMap: DefaultMap<PtrHash, Set<PtrHash>, []>;
         };
     };
-    private postGridEntityCollision;
-    private postGridEntityCustomCollision;
-    private customGridEntities;
+    private readonly postGridEntityCollision;
+    private readonly postGridEntityCustomCollision;
+    private readonly customGridEntities;
     constructor(postGridEntityCollision: PostGridEntityCollision, postGridEntityCustomCollision: PostGridEntityCustomCollision, customGridEntities: CustomGridEntities);
-    private postUpdate;
+    private readonly postUpdate;
 }
 
 /**
@@ -7251,11 +7251,11 @@ export declare type GridEntityID = string & {
 };
 
 declare class GridEntityRenderDetection extends Feature {
-    private postGridEntityRender;
-    private postGridEntityCustomRender;
-    private customGridEntities;
+    private readonly postGridEntityRender;
+    private readonly postGridEntityCustomRender;
+    private readonly customGridEntities;
     constructor(postGridEntityRender: PostGridEntityRender, postGridEntityCustomRender: PostGridEntityCustomRender, customGridEntities: CustomGridEntities);
-    private postRender;
+    private readonly postRender;
 }
 
 declare type GridEntityTuple = [
@@ -7271,24 +7271,24 @@ declare class GridEntityUpdateDetection extends Feature {
             initializedGridEntities: Map<number, GridEntityTuple>;
         };
     };
-    private postGridEntityInit;
-    private postGridEntityCustomInit;
-    private postGridEntityUpdate;
-    private postGridEntityCustomUpdate;
-    private postGridEntityRemove;
-    private postGridEntityCustomRemove;
-    private postGridEntityStateChanged;
-    private postGridEntityCustomStateChanged;
-    private postGridEntityBroken;
-    private postGridEntityCustomBroken;
-    private customGridEntities;
+    private readonly postGridEntityInit;
+    private readonly postGridEntityCustomInit;
+    private readonly postGridEntityUpdate;
+    private readonly postGridEntityCustomUpdate;
+    private readonly postGridEntityRemove;
+    private readonly postGridEntityCustomRemove;
+    private readonly postGridEntityStateChanged;
+    private readonly postGridEntityCustomStateChanged;
+    private readonly postGridEntityBroken;
+    private readonly postGridEntityCustomBroken;
+    private readonly customGridEntities;
     constructor(postGridEntityInit: PostGridEntityInit, postGridEntityCustomInit: PostGridEntityCustomInit, postGridEntityUpdate: PostGridEntityUpdate, postGridEntityCustomUpdate: PostGridEntityCustomUpdate, postGridEntityRemove: PostGridEntityRemove, postGridEntityCustomRemove: PostGridEntityCustomRemove, postGridEntityStateChanged: PostGridEntityStateChanged, postGridEntityCustomStateChanged: PostGridEntityCustomStateChanged, postGridEntityBroken: PostGridEntityBroken, postGridEntityCustomBroken: PostGridEntityCustomBroken, customGridEntities: CustomGridEntities);
-    private postUpdate;
+    private readonly postUpdate;
     private checkGridEntitiesRemoved;
     private checkGridEntityStateChanged;
     private checkNewGridEntity;
     private updateTupleInMap;
-    private postNewRoomReordered;
+    private readonly postNewRoomReordered;
 }
 
 /**
@@ -8783,16 +8783,16 @@ declare class ItemPickupDetection extends Feature {
             playersPickingUpItemMap: DefaultMap<PlayerIndex, PickingUpItem, []>;
         };
     };
-    private postItemPickup;
-    private preItemPickup;
+    private readonly postItemPickup;
+    private readonly preItemPickup;
     constructor(postItemPickup: PostItemPickup, preItemPickup: PreItemPickup);
-    private postPEffectUpdateReordered;
+    private readonly postPEffectUpdateReordered;
     private queueEmpty;
     private queueNotEmpty;
 }
 
 declare class ItemPoolDetection extends Feature {
-    private moddedElementSets;
+    private readonly moddedElementSets;
     /**
      * Helper function to get the remaining collectibles in a given item pool. This function is
      * expensive, so only use it in situations where the lag is acceptable.
@@ -12036,7 +12036,7 @@ export declare enum ModCallbackCustom {
  */
 declare class ModdedElementDetection extends Feature {
     private atLeastOneCallbackFired;
-    private postPlayerInit;
+    private readonly postPlayerInit;
     private errorIfNoCallbacksFired;
     /**
      * Returns the first modded collectible type, or undefined if there are no modded collectibles.
@@ -12315,41 +12315,41 @@ declare class ModdedElementDetection extends Feature {
 }
 
 declare class ModdedElementSets extends Feature {
-    private allCollectibleTypesArray;
-    private allCollectibleTypesSet;
-    private vanillaCollectibleTypesArray;
-    private vanillaCollectibleTypesSet;
-    private moddedCollectibleTypesArray;
-    private moddedCollectibleTypesSet;
-    private allTrinketTypesArray;
-    private allTrinketTypesSet;
-    private vanillaTrinketTypesArray;
-    private vanillaTrinketTypesSet;
-    private moddedTrinketTypesArray;
-    private moddedTrinketTypesSet;
-    private allCardTypesArray;
-    private allCardTypesSet;
-    private vanillaCardTypesArray;
-    private vanillaCardTypesSet;
-    private moddedCardTypesArray;
-    private moddedCardTypesSet;
-    private tagToCollectibleTypesMap;
-    private cacheFlagToCollectibleTypesMap;
-    private cacheFlagToTrinketTypesMap;
+    private readonly allCollectibleTypesArray;
+    private readonly allCollectibleTypesSet;
+    private readonly vanillaCollectibleTypesArray;
+    private readonly vanillaCollectibleTypesSet;
+    private readonly moddedCollectibleTypesArray;
+    private readonly moddedCollectibleTypesSet;
+    private readonly allTrinketTypesArray;
+    private readonly allTrinketTypesSet;
+    private readonly vanillaTrinketTypesArray;
+    private readonly vanillaTrinketTypesSet;
+    private readonly moddedTrinketTypesArray;
+    private readonly moddedTrinketTypesSet;
+    private readonly allCardTypesArray;
+    private readonly allCardTypesSet;
+    private readonly vanillaCardTypesArray;
+    private readonly vanillaCardTypesSet;
+    private readonly moddedCardTypesArray;
+    private readonly moddedCardTypesSet;
+    private readonly tagToCollectibleTypesMap;
+    private readonly cacheFlagToCollectibleTypesMap;
+    private readonly cacheFlagToTrinketTypesMap;
     private flyingCollectibleTypesSet;
-    private permanentFlyingCollectibleTypesSet;
+    private readonly permanentFlyingCollectibleTypesSet;
     private flyingTrinketTypesSet;
-    private edenActiveCollectibleTypesSet;
-    private edenPassiveCollectibleTypesSet;
-    private itemConfigCardTypeToCardTypeMap;
+    private readonly edenActiveCollectibleTypesSet;
+    private readonly edenPassiveCollectibleTypesSet;
+    private readonly itemConfigCardTypeToCardTypeMap;
     /**
      * The set of cards that are not:
      *
      * - ItemConfigCardType.RUNE
      * - ItemConfigCardType.SPECIAL_OBJECT
      */
-    private cardSet;
-    private moddedElementDetection;
+    private readonly cardSet;
+    private readonly moddedElementDetection;
     private lazyInitVanillaCollectibleTypes;
     private lazyInitModdedCollectibleTypes;
     private lazyInitVanillaTrinketTypes;
@@ -12835,7 +12835,7 @@ declare class ModdedElementSets extends Feature {
  * properties upon first construction.)
  */
 export declare class ModFeature {
-    private mod;
+    private readonly mod;
     /**
      * An optional method that allows for conditional callback execution. If specified, any class
      * method that is annotated with a `@Callback` or `@CallbackCustom` decorator will only be fired
@@ -12900,11 +12900,11 @@ export declare class ModFeature {
 export declare class ModUpgraded implements Mod {
     Name: string;
     /** We store a copy of the original mod object so that we can re-implement its functions. */
-    private mod;
-    private debug;
-    private timeThreshold;
-    private callbacks;
-    private features;
+    private readonly mod;
+    private readonly debug;
+    private readonly timeThreshold;
+    private readonly callbacks;
+    private readonly features;
     constructor(mod: Mod, debug: boolean, timeThreshold?: float);
     AddCallback<T extends keyof AddCallbackParameters | string>(modCallback: T, ...args: T extends keyof AddCallbackParameters ? AddCallbackParameters[T] : unknown[]): void;
     AddPriorityCallback<T extends keyof AddCallbackParameters | string>(modCallback: T, priority: CallbackPriority | int, ...args: T extends keyof AddCallbackParameters ? AddCallbackParameters[T] : unknown[]): void;
@@ -13148,7 +13148,7 @@ export declare function newTSTLClass(oldClass: TSTLClass): TSTLClass;
 export declare function nextSeed(seed: Seed): Seed;
 
 declare class NoSirenSteal extends Feature {
-    private postNPCInitSirenHelper;
+    private readonly postNPCInitSirenHelper;
     private checkReturnFamiliarToPlayer;
     private blacklistEntryExists;
     /**
@@ -13335,10 +13335,10 @@ export declare function parseEntityID(entityID: string): [entityType: EntityType
 export declare function parseEntityTypeVariantString(entityTypeVariantString: string): [entityType: EntityType, variant: int] | undefined;
 
 declare class Pause extends Feature {
-    private disableInputs;
-    private postUpdate;
+    private readonly disableInputs;
+    private readonly postUpdate;
     private stopTearsAndProjectilesFromMoving;
-    private inputActionGetActionValue;
+    private readonly inputActionGetActionValue;
     isPaused(): boolean;
     /**
      * Helper function to emulate what happens when the player pauses the game. Use the `unpause`
@@ -13361,14 +13361,14 @@ declare class Pause extends Feature {
 }
 
 declare class PersistentEntities extends Feature {
-    private roomHistory;
-    private postEntityRemove;
+    private readonly roomHistory;
+    private readonly postEntityRemove;
     /**
      * The persistent entity is despawning because the player is in the process of leaving the room.
      * Keep track of the position for later.
      */
     private trackDespawningPickupPosition;
-    private postNewRoomReordered;
+    private readonly postNewRoomReordered;
     private spawnAndTrack;
     /**
      * Helper function to stop an entity spawned with the `spawnPersistentEntity` helper function from
@@ -13440,10 +13440,10 @@ declare class PickupChangeDetection extends Feature {
             pickupSubTypes: Map<PickupIndex, number>;
         };
     };
-    private postPickupChanged;
-    private pickupIndexCreation;
+    private readonly postPickupChanged;
+    private readonly pickupIndexCreation;
     constructor(postPickupChanged: PostPickupChanged, pickupIndexCreation: PickupIndexCreation);
-    private postPickupUpdate;
+    private readonly postPickupUpdate;
 }
 
 /**
@@ -13465,12 +13465,12 @@ export declare type PickupIndex = int & {
 };
 
 declare class PickupIndexCreation extends Feature {
-    private roomHistory;
-    private saveDataManager;
-    private postPickupInit;
+    private readonly roomHistory;
+    private readonly saveDataManager;
+    private readonly postPickupInit;
     private setPickupIndex;
     private getPickupIndexFromPreviousData;
-    private postEntityRemovePickup;
+    private readonly postEntityRemovePickup;
     private checkDespawningFromPlayerLeavingRoom;
     /**
      * This is a pickup that is despawning because the player is in the process of leaving the room.
@@ -13528,10 +13528,10 @@ declare class PlayerCollectibleDetection extends Feature {
             playersActiveItemMap: DefaultMap<PlayerIndex, Map<ActiveSlot, CollectibleType>, []>;
         };
     };
-    private postPlayerCollectibleAdded;
-    private postPlayerCollectibleRemoved;
-    private moddedElementSets;
-    private runInNFrames;
+    private readonly postPlayerCollectibleAdded;
+    private readonly postPlayerCollectibleRemoved;
+    private readonly moddedElementSets;
+    private readonly runInNFrames;
     constructor(postPlayerCollectibleAdded: PostPlayerCollectibleAdded, postPlayerCollectibleRemoved: PostPlayerCollectibleRemoved, moddedElementSets: ModdedElementSets, runInNFrames: RunInNFrames);
     /**
      * This is called when the collectible count changes and in situations where the entire build is
@@ -13546,15 +13546,15 @@ declare class PlayerCollectibleDetection extends Feature {
      *                               rerolled.
      */
     private updateCollectibleMapAndFire;
-    private postUseItemD4;
+    private readonly postUseItemD4;
     /** We need to handle the case of Tainted Eden taking damage. */
-    private entityTakeDmgPlayer;
+    private readonly entityTakeDmgPlayer;
     /**
      * We need to handle TMTRAINER collectibles, since they do not cause the player's collectible
      * count to change.
      */
-    private postItemPickup;
-    private postPEffectUpdateReordered;
+    private readonly postItemPickup;
+    private readonly postPEffectUpdateReordered;
     /**
      * Checking for collectible count will work to detect when a player swaps their active item for
      * another active item. This is because the collectible count will decrement by 1 when the item is
@@ -13615,8 +13615,8 @@ export declare type PlayerIndex = int & {
 };
 
 declare class PlayerInventory extends Feature {
-    private postCollectibleAdded;
-    private postCollectibleRemoved;
+    private readonly postCollectibleAdded;
+    private readonly postCollectibleRemoved;
     /**
      * Helper function to get all of the collectibles that the player has gotten so far on this run,
      * in order.
@@ -13660,14 +13660,14 @@ declare class PlayerReorderedCallbacks extends Feature {
             postPlayerRenderQueue: QueueElement[];
         };
     };
-    private postPEffectUpdateReordered;
-    private postPlayerRenderReordered;
-    private postPlayerUpdateReordered;
+    private readonly postPEffectUpdateReordered;
+    private readonly postPlayerRenderReordered;
+    private readonly postPlayerUpdateReordered;
     constructor(postPEffectUpdateReordered: PostPEffectUpdateReordered, postPlayerRenderReordered: PostPlayerRenderReordered, postPlayerUpdateReordered: PostPlayerUpdateReordered);
-    private postPEffectUpdate;
-    private postPlayerUpdate;
-    private postPlayerRender;
-    private postGameStartedReorderedLast;
+    private readonly postPEffectUpdate;
+    private readonly postPlayerUpdate;
+    private readonly postPlayerRender;
+    private readonly postGameStartedReorderedLast;
 }
 
 /** This represents the kinds of stats that a player can have. */
@@ -13741,7 +13741,7 @@ export declare enum PocketItemType {
 }
 
 declare class PonyDetection extends Feature {
-    private postPEffectUpdateReordered;
+    private readonly postPEffectUpdateReordered;
     /**
      * Helper function to see if the player is under the effects of A Pony or White Pony charge.
      * Detecting this is difficult, as the temporary effect will disappear upon entering a new room.
@@ -13926,7 +13926,7 @@ declare class PreItemPickup extends CustomCallback<ModCallbackCustom.PRE_ITEM_PI
 }
 
 declare class PressInput extends Feature {
-    private isActionTriggered;
+    private readonly isActionTriggered;
     /**
      * Helper function to press an arbitrary `ButtonAction` on the next possible input poll. In most
      * cases, this will be equivalent to if the first player pressed the corresponding input. It
@@ -13938,7 +13938,7 @@ declare class PressInput extends Feature {
 }
 
 declare class PreventChildEntities extends Feature {
-    private postNPCInit;
+    private readonly postNPCInit;
     /**
      * Helper function to prevent an entity from spawning any other entities. Meant to be used on NPCs
      * like Squirts. This behavior will only last for the current room.
@@ -13954,16 +13954,16 @@ declare class PreventChildEntities extends Feature {
 }
 
 declare class PreventCollectibleRotation extends Feature {
-    private pickupIndexCreation;
-    private runInNFrames;
-    private preUseItem;
+    private readonly pickupIndexCreation;
+    private readonly runInNFrames;
+    private readonly preUseItem;
     /**
      * Soul of Isaac causes items to flip. We assume that the player deliberately wants to roll a
      * quest item, so we delete all tracked items in the current room.
      */
-    private postUseCardSoulOfIsaac;
-    private postDiceRoomActivated;
-    private postPickupChanged;
+    private readonly postUseCardSoulOfIsaac;
+    private readonly postDiceRoomActivated;
+    private readonly postPickupChanged;
     /**
      * Helper function to prevent a collectible from being affected by Tainted Isaac's rotation
      * mechanic. (This mechanic also happens from Glitched Crown and Binge Eater.) This is useful
@@ -13980,9 +13980,9 @@ declare class PreventCollectibleRotation extends Feature {
 }
 
 declare class PreventGridEntityRespawn extends Feature {
-    private runInNFrames;
-    private preUseItemWeNeedToGoDeeper;
-    private postNewRoomReordered;
+    private readonly runInNFrames;
+    private readonly preUseItemWeNeedToGoDeeper;
+    private readonly postNewRoomReordered;
     /**
      * Every time we re-enter the room, the sprites for all of the decorations will come back, so we
      * have to remove them again.
@@ -14779,7 +14779,7 @@ export declare enum RockAltType {
 export declare const ROOM_NAME_TO_TYPE_MAP: ReadonlyMap<string, RoomType>;
 
 declare class RoomClearFrame extends Feature {
-    private postRoomClearChangedTrue;
+    private readonly postRoomClearChangedTrue;
     /**
      * Helper function to get the game frame (i.e. `Game.GetFrameCount`) of the last time that this
      * room was cleared. Returns undefined if the room has never been cleared.
@@ -14832,7 +14832,7 @@ export declare function roomExists(roomGridIndex: int): boolean;
 export declare function roomGridIndexToVector(roomGridIndex: int): Readonly<Vector>;
 
 declare class RoomHistory extends Feature {
-    private postNewRoomEarly;
+    private readonly postNewRoomEarly;
     /**
      * Helper function to manually delete the last room description from the internal array. This is
      * useful if a mod needs to send the player to a room temporarily and the room should not count as
@@ -14916,9 +14916,9 @@ export declare function runDeepCopyTests(): void;
 
 declare class RunInNFrames extends Feature {
     vConditionalFunc: () => boolean;
-    private roomHistory;
-    private postUpdate;
-    private postRender;
+    private readonly roomHistory;
+    private readonly postUpdate;
+    private readonly postRender;
     /**
      * Helper function to restart on the next render frame. Useful because it is impossible to restart
      * the game inside of the `POST_NEW_ROOM`, `POST_NEW_LEVEL`, or `POST_GAME_STARTED` callbacks when
@@ -15068,7 +15068,7 @@ export declare function runMergeTests(): void;
 
 declare class RunNextRoom extends Feature {
     vConditionalFunc: () => boolean;
-    private postNewRoomReordered;
+    private readonly postNewRoomReordered;
     /**
      * Supply a function to run on the next `POST_NEW_ROOM` callback.
      *
@@ -15125,23 +15125,23 @@ declare class SaveDataManager extends Feature {
      * We store a local reference to the mod object so that we can access the corresponding methods
      * that read and write to the "save#.dat" file.
      */
-    private mod;
+    private readonly mod;
     /**
      * The save data map is indexed by subscriber name. We use Lua tables instead of TypeScriptToLua
      * Maps for the master map so that we can access the variables via the in-game console when
      * debugging. (TSTL Maps don't expose the map keys as normal keys.)
      */
-    private saveDataMap;
+    private readonly saveDataMap;
     /**
      * When mod feature data is initialized, we copy the initial values into a separate map so that we
      * can restore them later on.
      */
-    private saveDataDefaultsMap;
+    private readonly saveDataDefaultsMap;
     /**
      * Each mod feature can optionally provide a function that can control whether or not the save
      * data is written to disk.
      */
-    private saveDataConditionalFuncMap;
+    private readonly saveDataConditionalFuncMap;
     /**
      * We backup some save data keys on every new room for the purposes of restoring it when Glowing
      * Hour Glass is used.
@@ -15149,19 +15149,19 @@ declare class SaveDataManager extends Feature {
      * Note that the save data is backed up in serialized form so that we can use the `merge` function
      * to restore it.
      */
-    private saveDataGlowingHourGlassMap;
+    private readonly saveDataGlowingHourGlassMap;
     /**
      * End-users can register their classes with the save data manager for proper serialization when
      * contained in nested maps, sets, and arrays.
      */
-    private classConstructors;
+    private readonly classConstructors;
     private inARun;
     private restoreGlowingHourGlassDataOnNextRoom;
-    private postUseItemGlowingHourGlass;
-    private postPlayerInit;
-    private preGameExit;
-    private postNewLevel;
-    private postNewRoomEarly;
+    private readonly postUseItemGlowingHourGlass;
+    private readonly postPlayerInit;
+    private readonly preGameExit;
+    private readonly postNewLevel;
+    private readonly postNewRoomEarly;
     /**
      * This is the entry point to the save data manager, a system which provides two major features:
      *
@@ -15889,13 +15889,13 @@ declare class SlotDestroyedDetection extends Feature {
             destroyedSlotSet: Set<PtrHash>;
         };
     };
-    private postSlotDestroyed;
-    private roomHistory;
+    private readonly postSlotDestroyed;
+    private readonly roomHistory;
     constructor(postSlotDestroyed: PostSlotDestroyed, roomHistory: RoomHistory);
-    private postEntityRemoveSlot;
+    private readonly postEntityRemoveSlot;
     private postEntityRemoveSlotMachine;
     private postEntityRemoveBeggar;
-    private postSlotUpdate;
+    private readonly postSlotUpdate;
     /**
      * Slots normally have an entity collision class of `EntityCollisionClass.ALL` (4) and a grid
      * collision class of `EntityGridCollisionClass.NONE` (0). When they are destroyed with a bomb,
@@ -15931,10 +15931,10 @@ declare class SlotRenderDetection extends Feature {
             brokenSlots: Set<PtrHash>;
         };
     };
-    private postSlotRender;
-    private postSlotAnimationChanged;
+    private readonly postSlotRender;
+    private readonly postSlotAnimationChanged;
     constructor(postSlotRender: PostSlotRender, postSlotAnimationChanged: PostSlotAnimationChanged);
-    private postRender;
+    private readonly postRender;
     private checkSlotAnimationChanged;
 }
 
@@ -15944,11 +15944,11 @@ declare class SlotUpdateDetection extends Feature {
             initializedSlots: Set<PtrHash>;
         };
     };
-    private postSlotInit;
-    private postSlotUpdate;
+    private readonly postSlotInit;
+    private readonly postSlotUpdate;
     constructor(postSlotInit: PostSlotInit, postSlotUpdate: PostSlotUpdate);
-    private postUpdate;
-    private postNewRoomReordered;
+    private readonly postUpdate;
+    private readonly postNewRoomReordered;
     private checkNewEntity;
 }
 
@@ -16111,7 +16111,7 @@ export declare function spawnCoin(coinSubType: CoinSubType, positionOrGridIndex:
 export declare function spawnCoinWithSeed(coinSubType: CoinSubType, positionOrGridIndex: Vector | int, seedOrRNG: Seed | RNG, velocity?: Vector, spawner?: Entity | undefined): EntityPickupCoin;
 
 declare class SpawnCollectible extends Feature {
-    private preventCollectibleRotation;
+    private readonly preventCollectibleRotation;
     /**
      * Helper function to spawn a collectible.
      *
@@ -16352,7 +16352,7 @@ export declare function spawnProjectileWithSeed(projectileVariant: ProjectileVar
 export declare function spawnRock(gridIndexOrPosition: int | Vector): GridEntityRock | undefined;
 
 declare class SpawnRockAltRewards extends Feature {
-    private itemPoolDetection;
+    private readonly itemPoolDetection;
     /**
      * Helper function for emulating what happens when a vanilla `GridEntityType.ROCK_ALT` grid entity
      * breaks.
@@ -16538,7 +16538,7 @@ export declare function spriteEquals(sprite1: Sprite, sprite2: Sprite, layerID:
 export declare function stableSort<T>(array: T[], sortFunc?: (a: T, b: T) => -1 | 0 | 1): T[];
 
 declare class StageHistory extends Feature {
-    private postNewLevelReordered;
+    private readonly postNewLevelReordered;
     /**
      * Helper function to get the stage type that a trapdoor or heaven door would take the player to,
      * based on the current stage, room, and game state flags.
@@ -16598,7 +16598,7 @@ export declare interface StageHistoryEntry {
 export declare function stageTypeToLetter(stageType: StageType): string;
 
 declare class StartAmbush extends Feature {
-    private runInNFrames;
+    private readonly runInNFrames;
     /**
      * Helper function to start a Challenge Room or the Boss Rush.
      *
@@ -16672,7 +16672,7 @@ export declare const TAINTED_SAMSON_BERSERK_CHARGE_FROM_TAKING_DAMAGE = 10000;
  */
 declare class TaintedLazarusPlayers extends Feature {
     vConditionalFunc: () => boolean;
-    private postPlayerInit;
+    private readonly postPlayerInit;
     /**
      * Indexes are the `PtrHash`, values are the `EntityPtr` of the *other* Lazarus.
      *