isaacscript-common 87.9.7 → 87.10.0

package/dist/functions/pocketItems.js

@@ -1,47 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getActivePocketItemSlot = getActivePocketItemSlot;
-exports.getFirstCard = getFirstCard;
-exports.getFirstCardOrPill = getFirstCardOrPill;
-exports.getFirstPill = getFirstPill;
-exports.getPocketItems = getPocketItems;
-exports.hasOpenPocketItemSlot = hasOpenPocketItemSlot;
-exports.isFirstSlotPocketActiveItem = isFirstSlotPocketActiveItem;
-exports.pocketItemsEquals = pocketItemsEquals;
-const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
-const cachedEnumValues_1 = require("../cachedEnumValues");
-const PocketItemType_1 = require("../enums/PocketItemType");
-const players_1 = require("./players");
+import { ActiveSlot, CardType, CollectibleType, PillColor, PlayerType, } from "isaac-typescript-definitions";
+import { POCKET_ITEM_SLOT_VALUES } from "../cachedEnumValues";
+import { PocketItemType } from "../enums/PocketItemType";
+import { isCharacter } from "./players";
 /**
  * Helper function to get the `PocketItemSlot` that the player's pocket active collectible item is
  * in, if any. Returns undefined if the player does not have a pocket active item.
  */
-function getActivePocketItemSlot(player) {
+export function getActivePocketItemSlot(player) {
     const pocketItems = getPocketItems(player);
     for (const pocketItem of pocketItems) {
-        if (pocketItem.type === PocketItemType_1.PocketItemType.ACTIVE_ITEM) {
+        if (pocketItem.type === PocketItemType.ACTIVE_ITEM) {
             return pocketItem.slot;
         }
     }
     return undefined;
 }
 /** Helper item to get the first card that a player is holding in their pocket item slots. */
-function getFirstCard(player) {
+export function getFirstCard(player) {
     const pocketItems = getPocketItems(player);
-    return pocketItems.find((pocketItem) => pocketItem.type === PocketItemType_1.PocketItemType.CARD);
+    return pocketItems.find((pocketItem) => pocketItem.type === PocketItemType.CARD);
 }
 /**
  * Helper item to get the first card or pill that a player is holding in their pocket item slots.
  */
-function getFirstCardOrPill(player) {
+export function getFirstCardOrPill(player) {
     const pocketItems = getPocketItems(player);
-    return pocketItems.find((pocketItem) => pocketItem.type === PocketItemType_1.PocketItemType.CARD
-        || pocketItem.type === PocketItemType_1.PocketItemType.PILL);
+    return pocketItems.find((pocketItem) => pocketItem.type === PocketItemType.CARD
+        || pocketItem.type === PocketItemType.PILL);
 }
 /** Helper item to get the first pill that a player is holding in their pocket item slots. */
-function getFirstPill(player) {
+export function getFirstPill(player) {
     const pocketItems = getPocketItems(player);
-    return pocketItems.find((pocketItem) => pocketItem.type === PocketItemType_1.PocketItemType.PILL);
+    return pocketItems.find((pocketItem) => pocketItem.type === PocketItemType.PILL);
 }
 /**
  * Use this helper function as a workaround for the `EntityPlayer.GetPocketItem` method not working
@@ -53,29 +43,29 @@ function getFirstPill(player) {
  * cannot determine the identity of a particular slot, it will mark the type of the slot as
  * `PocketItemType.UNDETERMINABLE`.
  */
-function getPocketItems(player) {
-    const pocketItem = player.GetActiveItem(isaac_typescript_definitions_1.ActiveSlot.POCKET);
-    const hasPocketItem = pocketItem !== isaac_typescript_definitions_1.CollectibleType.NULL;
-    const pocketItem2 = player.GetActiveItem(isaac_typescript_definitions_1.ActiveSlot.POCKET_SINGLE_USE);
-    const hasPocketItem2 = pocketItem2 !== isaac_typescript_definitions_1.CollectibleType.NULL;
+export function getPocketItems(player) {
+    const pocketItem = player.GetActiveItem(ActiveSlot.POCKET);
+    const hasPocketItem = pocketItem !== CollectibleType.NULL;
+    const pocketItem2 = player.GetActiveItem(ActiveSlot.POCKET_SINGLE_USE);
+    const hasPocketItem2 = pocketItem2 !== CollectibleType.NULL;
     const maxPocketItems = player.GetMaxPocketItems();
     const pocketItems = [];
     let pocketItemIdentified = false;
     let pocketItem2Identified = false;
-    for (const slot of cachedEnumValues_1.POCKET_ITEM_SLOT_VALUES) {
+    for (const slot of POCKET_ITEM_SLOT_VALUES) {
         const cardType = player.GetCard(slot);
         const pillColor = player.GetPill(slot);
-        if (cardType !== isaac_typescript_definitions_1.CardType.NULL) {
+        if (cardType !== CardType.NULL) {
             pocketItems.push({
                 slot,
-                type: PocketItemType_1.PocketItemType.CARD,
+                type: PocketItemType.CARD,
                 subType: cardType,
             });
         }
-        else if (pillColor !== isaac_typescript_definitions_1.PillColor.NULL) {
+        else if (pillColor !== PillColor.NULL) {
             pocketItems.push({
                 slot,
-                type: PocketItemType_1.PocketItemType.PILL,
+                type: PocketItemType.PILL,
                 subType: pillColor,
             });
         }
@@ -83,7 +73,7 @@ function getPocketItems(player) {
             pocketItemIdentified = true;
             pocketItems.push({
                 slot,
-                type: PocketItemType_1.PocketItemType.ACTIVE_ITEM,
+                type: PocketItemType.ACTIVE_ITEM,
                 subType: pocketItem,
             });
         }
@@ -91,21 +81,21 @@ function getPocketItems(player) {
             pocketItem2Identified = true;
             pocketItems.push({
                 slot,
-                type: PocketItemType_1.PocketItemType.DICE_BAG_DICE,
+                type: PocketItemType.DICE_BAG_DICE,
                 subType: pocketItem2,
             });
         }
         else if (hasPocketItem && hasPocketItem2) {
             pocketItems.push({
                 slot,
-                type: PocketItemType_1.PocketItemType.UNDETERMINABLE,
+                type: PocketItemType.UNDETERMINABLE,
                 subType: 0,
             });
         }
         else {
             pocketItems.push({
                 slot,
-                type: PocketItemType_1.PocketItemType.EMPTY,
+                type: PocketItemType.EMPTY,
                 subType: 0,
             });
         }
@@ -123,27 +113,27 @@ function getPocketItems(player) {
  * If the player is the Tainted Soul, this always returns false, since that character cannot pick up
  * items. (Only Tainted Forgotten can pick up items.)
  */
-function hasOpenPocketItemSlot(player) {
-    if ((0, players_1.isCharacter)(player, isaac_typescript_definitions_1.PlayerType.SOUL_B)) {
+export function hasOpenPocketItemSlot(player) {
+    if (isCharacter(player, PlayerType.SOUL_B)) {
         return false;
     }
     const pocketItems = getPocketItems(player);
-    return pocketItems.some((pocketItem) => pocketItem.type === PocketItemType_1.PocketItemType.EMPTY);
+    return pocketItems.some((pocketItem) => pocketItem.type === PocketItemType.EMPTY);
 }
 /**
  * Helper function to determine whether the player's "active" pocket item slot is set to their
  * pocket active item.
  */
-function isFirstSlotPocketActiveItem(player) {
+export function isFirstSlotPocketActiveItem(player) {
     const pocketItems = getPocketItems(player);
     const firstPocketItem = pocketItems[0];
     if (firstPocketItem === undefined) {
         return false;
     }
-    return firstPocketItem.type === PocketItemType_1.PocketItemType.ACTIVE_ITEM;
+    return firstPocketItem.type === PocketItemType.ACTIVE_ITEM;
 }
 /** Helper function to see if two sets of pocket item descriptions are identical. */
-function pocketItemsEquals(pocketItems1, pocketItems2) {
+export function pocketItemsEquals(pocketItems1, pocketItems2) {
     if (pocketItems1.length !== pocketItems2.length) {
         return false;
     }

package/dist/functions/positionVelocity.js

@@ -1,21 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.anyEntityCloserThan = anyEntityCloserThan;
-exports.anyPlayerCloserThan = anyPlayerCloserThan;
-exports.findFreePosition = findFreePosition;
-exports.getEntityPositions = getEntityPositions;
-exports.getEntityVelocities = getEntityVelocities;
-exports.setEntityPositions = setEntityPositions;
-exports.setEntityVelocities = setEntityVelocities;
-const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
-const cachedClasses_1 = require("../core/cachedClasses");
-const constants_1 = require("../core/constants");
-const entities_1 = require("./entities");
-const entitiesSpecific_1 = require("./entitiesSpecific");
-const playerIndex_1 = require("./playerIndex");
-const players_1 = require("./players");
+import { EffectVariant, HeavenLightDoorSubType, } from "isaac-typescript-definitions";
+import { game } from "../core/cachedClasses";
+import { DISTANCE_OF_GRID_TILE } from "../core/constants";
+import { getEntities } from "./entities";
+import { getEffects } from "./entitiesSpecific";
+import { getPlayers } from "./playerIndex";
+import { getPlayerCloserThan } from "./players";
 const MAX_FIND_FREE_POSITION_ATTEMPTS = 100;
-function anyEntityCloserThan(entities, position, distance) {
+export function anyEntityCloserThan(entities, position, distance) {
     return entities.some((entity) => position.Distance(entity.Position) <= distance);
 }
 /**
@@ -24,8 +15,8 @@ function anyEntityCloserThan(entities, position, distance) {
  * Note that this function does not consider players with a non-undefined parent, since they are not
  * real players (e.g. the Strawman Keeper).
  */
-function anyPlayerCloserThan(position, distance) {
-    const players = (0, playerIndex_1.getPlayers)();
+export function anyPlayerCloserThan(position, distance) {
+    const players = getPlayers();
     return players.some((player) => player.Position.Distance(position) <= distance);
 }
 /**
@@ -41,16 +32,16 @@ function anyPlayerCloserThan(position, distance) {
  * @param minimumDistance Optional. If specified, will ensure that the randomly generated position
  *                        is equal to or greater than the distance provided.
  */
-function findFreePosition(startingPosition, avoidActiveEntities = false, minimumDistance) {
-    const room = cachedClasses_1.game.GetRoom();
-    const heavenDoors = (0, entitiesSpecific_1.getEffects)(isaac_typescript_definitions_1.EffectVariant.HEAVEN_LIGHT_DOOR, isaac_typescript_definitions_1.HeavenLightDoorSubType.HEAVEN_DOOR);
+export function findFreePosition(startingPosition, avoidActiveEntities = false, minimumDistance) {
+    const room = game.GetRoom();
+    const heavenDoors = getEffects(EffectVariant.HEAVEN_LIGHT_DOOR, HeavenLightDoorSubType.HEAVEN_DOOR);
     for (let initialStep = 0; initialStep < MAX_FIND_FREE_POSITION_ATTEMPTS; initialStep++) {
         const position = room.FindFreePickupSpawnPosition(startingPosition, initialStep, avoidActiveEntities);
-        const closePlayer = (0, players_1.getPlayerCloserThan)(position, constants_1.DISTANCE_OF_GRID_TILE);
+        const closePlayer = getPlayerCloserThan(position, DISTANCE_OF_GRID_TILE);
         if (closePlayer !== undefined) {
             continue;
         }
-        const isCloseHeavenDoor = anyEntityCloserThan(heavenDoors, position, constants_1.DISTANCE_OF_GRID_TILE);
+        const isCloseHeavenDoor = anyEntityCloserThan(heavenDoors, position, DISTANCE_OF_GRID_TILE);
         if (isCloseHeavenDoor) {
             continue;
         }
@@ -74,8 +65,8 @@ function findFreePosition(startingPosition, avoidActiveEntities = false, minimum
  *                 this with cached entities to avoid invoking the `Isaac.GetRoomEntities` method
  *                 multiple times.
  */
-function getEntityPositions(entities) {
-    entities ??= (0, entities_1.getEntities)();
+export function getEntityPositions(entities) {
+    entities ??= getEntities();
     const entityPositions = new Map();
     for (const entity of entities) {
         const ptrHash = GetPtrHash(entity);
@@ -92,8 +83,8 @@ function getEntityPositions(entities) {
  *                 this with cached entities to avoid invoking the `Isaac.GetRoomEntities` method
  *                 multiple times.
  */
-function getEntityVelocities(entities) {
-    entities ??= (0, entities_1.getEntities)();
+export function getEntityVelocities(entities) {
+    entities ??= getEntities();
     const entityVelocities = new Map();
     for (const entity of entities) {
         const ptrHash = GetPtrHash(entity);
@@ -114,8 +105,8 @@ function getEntityVelocities(entities) {
  *                 this with cached entities to avoid invoking the `Isaac.GetRoomEntities` method
  *                 multiple times.
  */
-function setEntityPositions(entityPositions, entities) {
-    entities ??= (0, entities_1.getEntities)();
+export function setEntityPositions(entityPositions, entities) {
+    entities ??= getEntities();
     for (const entity of entities) {
         const ptrHash = GetPtrHash(entity);
         const entityPosition = entityPositions.get(ptrHash);
@@ -137,8 +128,8 @@ function setEntityPositions(entityPositions, entities) {
  *                 this with cached entities to avoid invoking the `Isaac.GetRoomEntities` method
  *                 multiple times.
  */
-function setEntityVelocities(entityVelocities, entities) {
-    entities ??= (0, entities_1.getEntities)();
+export function setEntityVelocities(entityVelocities, entities) {
+    entities ??= getEntities();
     for (const entity of entities) {
         const ptrHash = GetPtrHash(entity);
         const entityVelocity = entityVelocities.get(ptrHash);

package/dist/functions/pressurePlate.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAllPressurePlatesPushed = isAllPressurePlatesPushed;
-const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
-const cachedClasses_1 = require("../core/cachedClasses");
-const gridEntitiesSpecific_1 = require("./gridEntitiesSpecific");
+import { PressurePlateState, PressurePlateVariant, } from "isaac-typescript-definitions";
+import { game } from "../core/cachedClasses";
+import { getPressurePlates } from "./gridEntitiesSpecific";
 /**
  * Helper function to check if all of the pressure plates in the room are pushed.
  *
@@ -14,12 +11,12 @@ const gridEntitiesSpecific_1 = require("./gridEntitiesSpecific");
  *
  * Returns true if there are no pressure plates in the room.
  */
-function isAllPressurePlatesPushed() {
-    const room = cachedClasses_1.game.GetRoom();
+export function isAllPressurePlatesPushed() {
+    const room = game.GetRoom();
     const hasPressurePlates = room.HasTriggerPressurePlates();
     if (!hasPressurePlates) {
         return true;
     }
-    const pressurePlates = (0, gridEntitiesSpecific_1.getPressurePlates)(isaac_typescript_definitions_1.PressurePlateVariant.PRESSURE_PLATE);
-    return pressurePlates.every((pressurePlate) => pressurePlate.State === isaac_typescript_definitions_1.PressurePlateState.PRESSURE_PLATE_PRESSED);
+    const pressurePlates = getPressurePlates(PressurePlateVariant.PRESSURE_PLATE);
+    return pressurePlates.every((pressurePlate) => pressurePlate.State === PressurePlateState.PRESSURE_PLATE_PRESSED);
 }

package/dist/functions/projectiles.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fireProjectiles = fireProjectiles;
-exports.fireProjectilesInCircle = fireProjectilesInCircle;
-const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
-const entities_1 = require("./entities");
-const entitiesSpecific_1 = require("./entitiesSpecific");
+import { EntityFlag, EntityType, ProjectilesMode, } from "isaac-typescript-definitions";
+import { getFilteredNewEntities } from "./entities";
+import { getProjectiles, spawnNPC } from "./entitiesSpecific";
 /**
  * Helper function to make an NPC fire one or more projectiles. Returns the fired projectile(s).
  *
@@ -22,22 +18,22 @@ const entitiesSpecific_1 = require("./entitiesSpecific");
  *                         `ProjectileParams()`.
  * @returns The fired projectile(s).
  */
-function fireProjectiles(npc, position, velocity, projectilesMode = isaac_typescript_definitions_1.ProjectilesMode.ONE_PROJECTILE, projectileParams = ProjectileParams()) {
-    const oldProjectiles = (0, entitiesSpecific_1.getProjectiles)(projectileParams.Variant);
+export function fireProjectiles(npc, position, velocity, projectilesMode = ProjectilesMode.ONE_PROJECTILE, projectileParams = ProjectileParams()) {
+    const oldProjectiles = getProjectiles(projectileParams.Variant);
     let spawnedFly = false;
     if (npc === undefined) {
         // Since the `EntityNPC.FireProjectiles` method is not static, we arbitrarily spawn a fly.
         spawnedFly = true;
-        npc = (0, entitiesSpecific_1.spawnNPC)(isaac_typescript_definitions_1.EntityType.FLY, 0, 0, position);
+        npc = spawnNPC(EntityType.FLY, 0, 0, position);
         npc.Visible = false;
-        npc.ClearEntityFlags(isaac_typescript_definitions_1.EntityFlag.APPEAR);
+        npc.ClearEntityFlags(EntityFlag.APPEAR);
     }
     npc.FireProjectiles(position, velocity, projectilesMode, projectileParams);
-    const newProjectiles = (0, entitiesSpecific_1.getProjectiles)(projectileParams.Variant);
+    const newProjectiles = getProjectiles(projectileParams.Variant);
     if (spawnedFly) {
         npc.Remove();
     }
-    return (0, entities_1.getFilteredNewEntities)(oldProjectiles, newProjectiles);
+    return getFilteredNewEntities(oldProjectiles, newProjectiles);
 }
 /**
  * Helper function to spawn projectiles in a circle around a position. Under the hood, this
@@ -50,7 +46,7 @@ function fireProjectiles(npc, position, velocity, projectilesMode = isaac_typesc
  * @param numProjectiles The amount of projectiles to spawn.
  * @returns The fired projectile(s).
  */
-function fireProjectilesInCircle(npc, position, speed, numProjectiles) {
+export function fireProjectilesInCircle(npc, position, speed, numProjectiles) {
     const velocity = Vector(speed, numProjectiles);
-    return fireProjectiles(npc, position, velocity, isaac_typescript_definitions_1.ProjectilesMode.N_PROJECTILES_IN_CIRCLE);
+    return fireProjectiles(npc, position, velocity, ProjectilesMode.N_PROJECTILES_IN_CIRCLE);
 }

package/dist/functions/random.js

@@ -1,10 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRandom = getRandom;
-exports.getRandomFloat = getRandomFloat;
-exports.getRandomInt = getRandomInt;
-const ReadonlySet_1 = require("../types/ReadonlySet");
-const rng_1 = require("./rng");
+import { ReadonlySet } from "../types/ReadonlySet";
+import { isRNG, newRNG } from "./rng";
 /**
  * Returns a random float between 0 and 1. It is inclusive on the low end, but exclusive on the high
  * end. (This is because the `RNG.RandomFloat` method will never return a value of exactly 1.)
@@ -16,8 +11,8 @@ const rng_1 = require("./rng");
  *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
  *                  a random seed.
  */
-function getRandom(seedOrRNG) {
-    const rng = (0, rng_1.isRNG)(seedOrRNG) ? seedOrRNG : (0, rng_1.newRNG)(seedOrRNG);
+export function getRandom(seedOrRNG) {
+    const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);
     return rng.RandomFloat();
 }
 /**
@@ -38,7 +33,7 @@ function getRandom(seedOrRNG) {
  *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
  *                  a random seed.
  */
-function getRandomFloat(min, max, seedOrRNG) {
+export function getRandomFloat(min, max, seedOrRNG) {
     if (min > max) {
         const oldMin = min;
         const oldMax = max;
@@ -70,8 +65,8 @@ function getRandomFloat(min, max, seedOrRNG) {
  *                   `[2]` would cause the function to return either 1, 3, or 4. Default is an empty
  *                   array.
  */
-function getRandomInt(min, max, seedOrRNG, exceptions = []) {
-    const rng = (0, rng_1.isRNG)(seedOrRNG) ? seedOrRNG : (0, rng_1.newRNG)(seedOrRNG);
+export function getRandomInt(min, max, seedOrRNG, exceptions = []) {
+    const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);
     min = Math.ceil(min);
     max = Math.floor(max);
     if (min > max) {
@@ -80,7 +75,7 @@ function getRandomInt(min, max, seedOrRNG, exceptions = []) {
         min = oldMax;
         max = oldMin;
     }
-    const exceptionsSet = new ReadonlySet_1.ReadonlySet(exceptions);
+    const exceptionsSet = new ReadonlySet(exceptions);
     let randomInt;
     do {
         randomInt = rng.RandomInt(max - min + 1) + min;

package/dist/functions/readOnly.js

@@ -1,15 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.newReadonlyColor = newReadonlyColor;
-exports.newReadonlyKColor = newReadonlyKColor;
-exports.newReadonlyVector = newReadonlyVector;
 /**
  * Helper function to create a read-only `Color` object. (Otherwise, you would have to manually
  * specify both the type and the constructor.)
  *
  * Note that read-only colors will be writable at run-time.
  */
-function newReadonlyColor(r, g, b, a, ro, go, bo) {
+export function newReadonlyColor(r, g, b, a, ro, go, bo) {
     return Color(r, g, b, a, ro, go, bo);
 }
 /**
@@ -18,7 +13,7 @@ function newReadonlyColor(r, g, b, a, ro, go, bo) {
  *
  * Note that read-only colors will be writable at run-time.
  */
-function newReadonlyKColor(r, g, b, a) {
+export function newReadonlyKColor(r, g, b, a) {
     return KColor(r, g, b, a);
 }
 /**
@@ -27,6 +22,6 @@ function newReadonlyKColor(r, g, b, a) {
  *
  * Note that read-only vectors will be writable at run-time.
  */
-function newReadonlyVector(x, y) {
+export function newReadonlyVector(x, y) {
     return Vector(x, y);
 }

package/dist/functions/render.js

@@ -1,10 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isReflectionRender = isReflectionRender;
-exports.renderScaledTextOnEntity = renderScaledTextOnEntity;
-exports.renderTextOnEntity = renderTextOnEntity;
-const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
-const cachedClasses_1 = require("../core/cachedClasses");
+import { RenderMode } from "isaac-typescript-definitions";
+import { game } from "../core/cachedClasses";
 /**
  * Helper function to see if the current render callback is rendering a water reflection.
  *
@@ -14,19 +9,19 @@ const cachedClasses_1 = require("../core/cachedClasses");
  *
  * This function is typically used to early return from a render function if it returns true.
  */
-function isReflectionRender() {
-    const room = cachedClasses_1.game.GetRoom();
+export function isReflectionRender() {
+    const room = game.GetRoom();
     const renderMode = room.GetRenderMode();
-    return renderMode === isaac_typescript_definitions_1.RenderMode.WATER_REFLECT;
+    return renderMode === RenderMode.WATER_REFLECT;
 }
-function renderScaledTextOnEntity(entity, text, scaleX, scaleY) {
+export function renderScaledTextOnEntity(entity, text, scaleX, scaleY) {
     if (isReflectionRender()) {
         return;
     }
     const position = Isaac.WorldToScreen(entity.Position);
     Isaac.RenderScaledText(text, position.X, position.Y, scaleX, scaleY, 1, 1, 1, 1);
 }
-function renderTextOnEntity(entity, text) {
+export function renderTextOnEntity(entity, text) {
     if (isReflectionRender()) {
         return;
     }

package/dist/functions/revive.js

@@ -1,34 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDamageToPlayerFatal = isDamageToPlayerFatal;
-exports.willMysteriousPaperRevive = willMysteriousPaperRevive;
-exports.willPlayerRevive = willPlayerRevive;
-exports.willReviveFromHeartbreak = willReviveFromHeartbreak;
-exports.willReviveFromSpiritShackles = willReviveFromSpiritShackles;
-const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
-const constants_1 = require("../core/constants");
-const MysteriousPaperEffect_1 = require("../enums/MysteriousPaperEffect");
-const characters_1 = require("./characters");
-const frames_1 = require("./frames");
-const playerHealth_1 = require("./playerHealth");
-const players_1 = require("./players");
-const sprites_1 = require("./sprites");
-const trinketGive_1 = require("./trinketGive");
-const trinkets_1 = require("./trinkets");
+import { CollectibleType, EntityType, NullItemID, PlayerType, TrinketType, } from "isaac-typescript-definitions";
+import { MAX_TAINTED_SAMSON_BERSERK_CHARGE, TAINTED_SAMSON_BERSERK_CHARGE_FROM_TAKING_DAMAGE, } from "../core/constants";
+import { MysteriousPaperEffect } from "../enums/MysteriousPaperEffect";
+import { getCharacterDeathAnimationName } from "./characters";
+import { onGameFrame } from "./frames";
+import { getPlayerMaxHeartContainers } from "./playerHealth";
+import { getPlayerNumHitsRemaining, hasLostCurse, isKeeper } from "./players";
+import { getLastFrameOfAnimation } from "./sprites";
+import { giveTrinketsBack, temporarilyRemoveTrinket } from "./trinketGive";
+import { getMysteriousPaperEffectForFrame } from "./trinkets";
 /**
  * Uses the player's current health and other miscellaneous things to determine if incoming damage
  * will be fatal.
  */
-function isDamageToPlayerFatal(player, amount, source, lastDamageGameFrame) {
+export function isDamageToPlayerFatal(player, amount, source, lastDamageGameFrame) {
     const character = player.GetPlayerType();
     // If we are Tainted Jacob and the damage source is Dark Esau, this will not be fatal damage
     // (because we will transform into Tainted Jacob's lost form).
-    if (character === isaac_typescript_definitions_1.PlayerType.JACOB_B
-        && source.Type === isaac_typescript_definitions_1.EntityType.DARK_ESAU) {
+    if (character === PlayerType.JACOB_B
+        && source.Type === EntityType.DARK_ESAU) {
         return false;
     }
     const effects = player.GetEffects();
-    const isBerserk = effects.HasCollectibleEffect(isaac_typescript_definitions_1.CollectibleType.BERSERK);
+    const isBerserk = effects.HasCollectibleEffect(CollectibleType.BERSERK);
     // If we are berserk, no damage is fatal. (The death is deferred until the end of the berserk
     // effect.)
     if (isBerserk) {
@@ -37,9 +30,9 @@ function isDamageToPlayerFatal(player, amount, source, lastDamageGameFrame) {
     // If we are playing Tainted Samson and the incoming hit will cause us to become Berserk, then
     // this will not be fatal damage.
     const berserkChargeAfterHit = player.SamsonBerserkCharge
-        + constants_1.TAINTED_SAMSON_BERSERK_CHARGE_FROM_TAKING_DAMAGE;
-    if (character === isaac_typescript_definitions_1.PlayerType.SAMSON_B
-        && berserkChargeAfterHit >= constants_1.MAX_TAINTED_SAMSON_BERSERK_CHARGE) {
+        + TAINTED_SAMSON_BERSERK_CHARGE_FROM_TAKING_DAMAGE;
+    if (character === PlayerType.SAMSON_B
+        && berserkChargeAfterHit >= MAX_TAINTED_SAMSON_BERSERK_CHARGE) {
         return false;
     }
     // If Spirit Shackles is activated, no damage is fatal.
@@ -48,14 +41,14 @@ function isDamageToPlayerFatal(player, amount, source, lastDamageGameFrame) {
     }
     // If we are Tainted Jacob in the Lost Form, we may have plenty of health left, but we will still
     // die in one hit to anything.
-    if (character === isaac_typescript_definitions_1.PlayerType.JACOB_2_B) {
+    if (character === PlayerType.JACOB_2_B) {
         return true;
     }
     // If we are in the "Lost Curse" form from touching a white fire, all damage will be fatal.
-    if ((0, players_1.hasLostCurse)(player)) {
+    if (hasLostCurse(player)) {
         return true;
     }
-    const playerNumAllHearts = (0, players_1.getPlayerNumHitsRemaining)(player);
+    const playerNumAllHearts = getPlayerNumHitsRemaining(player);
     if (amount < playerNumAllHearts) {
         return false;
     }
@@ -66,8 +59,8 @@ function isDamageToPlayerFatal(player, amount, source, lastDamageGameFrame) {
     }
     // This will not be fatal damage if we have Glass Cannon and this is the second time we are taking
     // damage on the same frame.
-    if (player.HasCollectible(isaac_typescript_definitions_1.CollectibleType.BROKEN_GLASS_CANNON)
-        && (0, frames_1.onGameFrame)(lastDamageGameFrame)) {
+    if (player.HasCollectible(CollectibleType.BROKEN_GLASS_CANNON)
+        && onGameFrame(lastDamageGameFrame)) {
         return false;
     }
     // This will not be fatal damage if we have two different kinds of hearts. For example, a bomb
@@ -92,29 +85,29 @@ function isDamageToPlayerFatal(player, amount, source, lastDamageGameFrame) {
  * Mysterious Paper rotates between the 4 items on every frame, in order. The formula for whether
  * Mysterious Paper be Missing Power is: `gameFrameCount % 4 === 3`
  */
-function willMysteriousPaperRevive(player) {
+export function willMysteriousPaperRevive(player) {
     const sprite = player.GetSprite();
     // We want to explicitly check the length of the death animation because we might be playing on a
     // modded character that has a custom death animation.
     const character = player.GetPlayerType();
-    const animation = (0, characters_1.getCharacterDeathAnimationName)(character);
-    const deathAnimationFrames = (0, sprites_1.getLastFrameOfAnimation)(sprite, animation);
+    const animation = getCharacterDeathAnimationName(character);
+    const deathAnimationFrames = getLastFrameOfAnimation(sprite, animation);
     const frameOfDeath = player.FrameCount + deathAnimationFrames;
-    const mysteriousPaperEffect = (0, trinkets_1.getMysteriousPaperEffectForFrame)(player, frameOfDeath);
+    const mysteriousPaperEffect = getMysteriousPaperEffectForFrame(player, frameOfDeath);
     if (mysteriousPaperEffect === undefined) {
         return false;
     }
-    return mysteriousPaperEffect === MysteriousPaperEffect_1.MysteriousPaperEffect.MISSING_POSTER;
+    return mysteriousPaperEffect === MysteriousPaperEffect.MISSING_POSTER;
 }
 /**
  * The `EntityPlayer.WillPlayerRevive` method does not properly account for Mysterious Paper, so use
  * this helper function instead for more robust revival detection.
  */
-function willPlayerRevive(player) {
-    const trinketSituation = (0, trinketGive_1.temporarilyRemoveTrinket)(player, isaac_typescript_definitions_1.TrinketType.MYSTERIOUS_PAPER);
+export function willPlayerRevive(player) {
+    const trinketSituation = temporarilyRemoveTrinket(player, TrinketType.MYSTERIOUS_PAPER);
     const willRevive = player.WillPlayerRevive()
         || (trinketSituation !== undefined && willMysteriousPaperRevive(player));
-    (0, trinketGive_1.giveTrinketsBack)(player, trinketSituation);
+    giveTrinketsBack(player, trinketSituation);
     return willRevive;
 }
 /**
@@ -122,12 +115,12 @@ function willPlayerRevive(player) {
  * take fatal damage. This is contingent on the character that they are playing as and the amount of
  * broken hearts that they already have.
  */
-function willReviveFromHeartbreak(player) {
-    if (!player.HasCollectible(isaac_typescript_definitions_1.CollectibleType.HEARTBREAK)) {
+export function willReviveFromHeartbreak(player) {
+    if (!player.HasCollectible(CollectibleType.HEARTBREAK)) {
         return false;
     }
-    const maxHeartContainers = (0, playerHealth_1.getPlayerMaxHeartContainers)(player);
-    const numBrokenHeartsThatWillBeAdded = (0, players_1.isKeeper)(player) ? 1 : 2;
+    const maxHeartContainers = getPlayerMaxHeartContainers(player);
+    const numBrokenHeartsThatWillBeAdded = isKeeper(player) ? 1 : 2;
     const brokenHearts = player.GetBrokenHearts();
     const numBrokenHeartsAfterRevival = numBrokenHeartsThatWillBeAdded + brokenHearts;
     return maxHeartContainers > numBrokenHeartsAfterRevival;
@@ -136,12 +129,12 @@ function willReviveFromHeartbreak(player) {
  * Helper function to determine if the Spirit Shackles item is in an enabled state. (It can be
  * either enabled or disabled.)
  */
-function willReviveFromSpiritShackles(player) {
-    if (!player.HasCollectible(isaac_typescript_definitions_1.CollectibleType.SPIRIT_SHACKLES)) {
+export function willReviveFromSpiritShackles(player) {
+    if (!player.HasCollectible(CollectibleType.SPIRIT_SHACKLES)) {
         return false;
     }
     const effects = player.GetEffects();
-    const spiritShacklesEnabled = !effects.HasNullEffect(isaac_typescript_definitions_1.NullItemID.SPIRIT_SHACKLES_DISABLED);
-    const playerInSoulForm = effects.HasNullEffect(isaac_typescript_definitions_1.NullItemID.SPIRIT_SHACKLES_SOUL);
+    const spiritShacklesEnabled = !effects.HasNullEffect(NullItemID.SPIRIT_SHACKLES_DISABLED);
+    const playerInSoulForm = effects.HasNullEffect(NullItemID.SPIRIT_SHACKLES_SOUL);
     return spiritShacklesEnabled && !playerInSoulForm;
 }