isaacscript-common 84.0.1 → 84.1.1

package/dist/functions/trinketGive.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.temporarilyRemoveTrinkets = exports.temporarilyRemoveTrinket = exports.smeltTrinkets = exports.smeltTrinket = exports.giveTrinketsBack = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const playerCollectibles_1 = require("./playerCollectibles");
+const trinkets_1 = require("./trinkets");
+const utils_1 = require("./utils");
+/**
+ * Helper function to restore the player's trinkets back to the way they were before the
+ * `temporarilyRemoveTrinket` function was used. It will re-smelt any smelted trinkets that were
+ * removed.
+ */
+function giveTrinketsBack(player, trinketSituation) {
+    // A trinket situation of undefined signifies that we did not have to remove the trinket. If this
+    // is the case, we do not have to give anything back.
+    if (trinketSituation === undefined) {
+        return;
+    }
+    const trinketType1 = player.GetTrinket(isaac_typescript_definitions_1.TrinketSlot.SLOT_1);
+    const trinketType2 = player.GetTrinket(isaac_typescript_definitions_1.TrinketSlot.SLOT_2);
+    // Remove any existing trinkets.
+    if (trinketType1 !== isaac_typescript_definitions_1.TrinketType.NULL) {
+        player.TryRemoveTrinket(trinketType1);
+    }
+    if (trinketType2 !== isaac_typescript_definitions_1.TrinketType.NULL) {
+        player.TryRemoveTrinket(trinketType2);
+    }
+    // First, add the smelted trinkets back.
+    (0, utils_1.repeat)(trinketSituation.numSmeltedTrinkets, () => {
+        player.AddTrinket(trinketSituation.trinketTypeRemoved, false);
+        (0, playerCollectibles_1.useActiveItemTemp)(player, isaac_typescript_definitions_1.CollectibleType.SMELTER);
+    });
+    // Second, add back the stored trinkets.
+    if (trinketSituation.trinketType1 !== isaac_typescript_definitions_1.TrinketType.NULL) {
+        player.AddTrinket(trinketSituation.trinketType1, false);
+    }
+    if (trinketSituation.trinketType2 !== isaac_typescript_definitions_1.TrinketType.NULL) {
+        player.AddTrinket(trinketSituation.trinketType2, false);
+    }
+}
+exports.giveTrinketsBack = giveTrinketsBack;
+/**
+ * Helper function to smelt a trinket. Before smelting, this function will automatically remove the
+ * trinkets that the player is holding, if any, and then give them back after the new trinket is
+ * smelted.
+ *
+ * @param player The player to smelt the trinkets to.
+ * @param trinketType The trinket type to smelt.
+ * @param numTrinkets Optional. If specified, will smelt the given number of trinkets. Use this to
+ *                    avoid calling this function multiple times. Default is 1.
+ */
+function smeltTrinket(player, trinketType, numTrinkets = 1) {
+    const trinketSituation = temporarilyRemoveTrinkets(player);
+    (0, utils_1.repeat)(numTrinkets, () => {
+        player.AddTrinket(trinketType);
+        (0, playerCollectibles_1.useActiveItemTemp)(player, isaac_typescript_definitions_1.CollectibleType.SMELTER);
+    });
+    giveTrinketsBack(player, trinketSituation);
+}
+exports.smeltTrinket = smeltTrinket;
+/**
+ * Helper function to smelt two or more different trinkets. If you want to smelt one trinket (or
+ * multiple copies of one trinket), then use the `smeltTrinket` helper function instead.
+ *
+ * This function is variadic, meaning that you can pass as many trinket types as you want to smelt.
+ *
+ * Before smelting, this function will automatically remove the trinkets that the player is holding,
+ * if any, and then give them back after the new trinket is smelted.
+ *
+ * @param player The player to smelt the trinkets to.
+ * @param trinketTypes The trinket types to smelt.
+ */
+function smeltTrinkets(player, ...trinketTypes) {
+    for (const trinketType of trinketTypes) {
+        smeltTrinket(player, trinketType);
+    }
+}
+exports.smeltTrinkets = smeltTrinkets;
+/**
+ * Helper function to temporarily remove a specific kind of trinket from the player. Use this in
+ * combination with the `giveTrinketsBack` function to take away and give back a trinket on the same
+ * frame. This function correctly handles multiple trinket slots and ensures that all copies of the
+ * trinket are removed, including smelted trinkets.
+ *
+ * Note that one smelted golden trinket is the same as two smelted normal trinkets.
+ *
+ * @returns Undefined if the player does not have the trinket, or TrinketSituation if they do.
+ */
+function temporarilyRemoveTrinket(player, trinketType) {
+    if (!player.HasTrinket(trinketType)) {
+        return undefined;
+    }
+    const trinketType1 = player.GetTrinket(isaac_typescript_definitions_1.TrinketSlot.SLOT_1);
+    const trinketType2 = player.GetTrinket(isaac_typescript_definitions_1.TrinketSlot.SLOT_2);
+    let numTrinkets = 0;
+    while (player.HasTrinket(trinketType)) {
+        player.TryRemoveTrinket(trinketType);
+        numTrinkets++;
+    }
+    let numSmeltedTrinkets = numTrinkets;
+    const trinketWasInSlot1 = trinketType1 === trinketType ||
+        trinketType1 === (0, trinkets_1.getGoldenTrinketType)(trinketType);
+    if (trinketWasInSlot1) {
+        numSmeltedTrinkets--;
+    }
+    const trinketWasInSlot2 = trinketType2 === trinketType ||
+        trinketType2 === (0, trinkets_1.getGoldenTrinketType)(trinketType);
+    if (trinketWasInSlot2) {
+        numSmeltedTrinkets--;
+    }
+    return {
+        trinketTypeRemoved: trinketType,
+        trinketType1,
+        trinketType2,
+        numSmeltedTrinkets,
+    };
+}
+exports.temporarilyRemoveTrinket = temporarilyRemoveTrinket;
+/**
+ * Helper function to temporarily removes a player's held trinkets, if any. This will not remove any
+ * smelted trinkets. Use this in combination with the `giveTrinketsBack` function to take away and
+ * give back trinkets on the same frame.
+ *
+ * @returns Undefined if the player does not have any trinkets, or TrinketSituation if they do.
+ */
+function temporarilyRemoveTrinkets(player) {
+    const trinketType1 = player.GetTrinket(isaac_typescript_definitions_1.TrinketSlot.SLOT_1);
+    const trinketType2 = player.GetTrinket(isaac_typescript_definitions_1.TrinketSlot.SLOT_2);
+    if (trinketType1 === isaac_typescript_definitions_1.TrinketType.NULL && trinketType2 === isaac_typescript_definitions_1.TrinketType.NULL) {
+        return undefined;
+    }
+    if (trinketType1 !== isaac_typescript_definitions_1.TrinketType.NULL) {
+        player.TryRemoveTrinket(trinketType1);
+    }
+    if (trinketType2 !== isaac_typescript_definitions_1.TrinketType.NULL) {
+        player.TryRemoveTrinket(trinketType2);
+    }
+    return {
+        trinketTypeRemoved: isaac_typescript_definitions_1.TrinketType.NULL,
+        trinketType1,
+        trinketType2,
+        numSmeltedTrinkets: 0,
+    };
+}
+exports.temporarilyRemoveTrinkets = temporarilyRemoveTrinkets;

package/dist/functions/trinkets.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trinketHasCacheFlag = exports.setTrinketSprite = exports.newTrinketSprite = exports.isVanillaTrinketType = exports.isValidTrinketType = exports.isModdedTrinketType = exports.isGoldenTrinketType = exports.getTrinketName = exports.getTrinketGfxFilename = exports.getTrinketDescription = exports.getNormalTrinketType = exports.getMysteriousPaperEffectForFrame = exports.getGoldenTrinketType = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../core/cachedClasses");
+const constants_1 = require("../core/constants");
+const constantsFirstLast_1 = require("../core/constantsFirstLast");
+const MysteriousPaperEffect_1 = require("../enums/MysteriousPaperEffect");
+const trinketDescriptions_1 = require("../objects/trinketDescriptions");
+const trinketNames_1 = require("../objects/trinketNames");
+const entities_1 = require("./entities");
+const enums_1 = require("./enums");
+const flag_1 = require("./flag");
+const pickupVariants_1 = require("./pickupVariants");
+const sprites_1 = require("./sprites");
+const types_1 = require("./types");
+/**
+ * Add this to a `TrinketType` to get the corresponding golden trinket type.
+ *
+ * Corresponds to the vanilla `PillColor.TRINKET_GOLDEN_FLAG` value.
+ *
+ * 1 << 15
+ */
+const GOLDEN_TRINKET_ADJUSTMENT = 32_768;
+const NUM_MYSTERIOUS_PAPER_EFFECTS = (0, enums_1.getEnumLength)(MysteriousPaperEffect_1.MysteriousPaperEffect);
+const TRINKET_ANM2_PATH = "gfx/005.350_trinket.anm2";
+const TRINKET_SPRITE_LAYER = 0;
+/**
+ * Helper function to get the corresponding golden trinket type from a normal trinket type.
+ *
+ * If the provided trinket type is already a golden trinket type, then the trinket type will be
+ * returned unmodified.
+ *
+ * For example, passing `TrinketType.SWALLOWED_PENNY` would result in 32769, which is the value that
+ * corresponds to the golden trinket sub-type for Swallowed Penny.
+ */
+function getGoldenTrinketType(trinketType) {
+    return isGoldenTrinketType(trinketType)
+        ? trinketType
+        : trinketType + GOLDEN_TRINKET_ADJUSTMENT;
+}
+exports.getGoldenTrinketType = getGoldenTrinketType;
+/**
+ * Helper function to get the current effect that the Mysterious Paper trinket is providing to the
+ * player. Returns undefined if the player does not have the Mysterious Paper trinket.
+ *
+ * The Mysterious Paper trinket has four different effects:
+ *
+ * - The Polaroid (collectible)
+ * - The Negative (collectible)
+ * - A Missing Page (trinket)
+ * - Missing Poster (trinket)
+ *
+ * It rotates between these four effects on every frame. Note that Mysterious Paper will cause the
+ * `EntityPlayer.HasCollectible` and `EntityPlayer.HasTrinket` methods to return true for the
+ * respective items on the particular frame, with the exception of the Missing Poster. (The player
+ * will never "have" the Missing Poster, even on the correct corresponding frame.)
+ *
+ * @param player The player to look at.
+ * @param frameCount Optional. The frame count that corresponds to time the effect will be active.
+ *                   Default is the current frame.
+ */
+function getMysteriousPaperEffectForFrame(player, frameCount) {
+    if (frameCount === undefined) {
+        frameCount = player.FrameCount;
+    }
+    if (!player.HasTrinket(isaac_typescript_definitions_1.TrinketType.MYSTERIOUS_PAPER)) {
+        return undefined;
+    }
+    return frameCount % NUM_MYSTERIOUS_PAPER_EFFECTS;
+}
+exports.getMysteriousPaperEffectForFrame = getMysteriousPaperEffectForFrame;
+/**
+ * Helper function to get the corresponding normal trinket type from a golden trinket type.
+ *
+ * If the provided trinket type is already a normal trinket type, then the trinket type will be
+ * returned unmodified.
+ */
+function getNormalTrinketType(trinketType) {
+    return isGoldenTrinketType(trinketType)
+        ? trinketType - GOLDEN_TRINKET_ADJUSTMENT
+        : trinketType;
+}
+exports.getNormalTrinketType = getNormalTrinketType;
+/**
+ * Helper function to get the in-game description for a trinket. Returns "Unknown" if the provided
+ * trinket type was not valid.
+ *
+ * This function works for both vanilla and modded trinkets.
+ */
+function getTrinketDescription(trinketType) {
+    // "ItemConfigItem.Description" is bugged with vanilla items on patch v1.7.6, so we use a
+    // hard-coded object as a workaround.
+    const trinketDescription = trinketDescriptions_1.TRINKET_DESCRIPTIONS[trinketType];
+    if (trinketDescription !== undefined) {
+        return trinketDescription;
+    }
+    const itemConfigItem = cachedClasses_1.itemConfig.GetTrinket(trinketType);
+    if (itemConfigItem !== undefined) {
+        return itemConfigItem.Description;
+    }
+    return trinketDescriptions_1.DEFAULT_TRINKET_DESCRIPTION;
+}
+exports.getTrinketDescription = getTrinketDescription;
+/**
+ * Helper function to get the path to a trinket PNG file. Returns the path to the question mark
+ * sprite (i.e. from Curse of the Blind) if the provided trinket type was not valid.
+ *
+ * Note that this does not return the file name, but the full path to the trinket's PNG file. The
+ * function is named "GfxFilename" to correspond to the associated `ItemConfigItem.GfxFileName`
+ * field.
+ */
+function getTrinketGfxFilename(trinketType) {
+    const itemConfigItem = cachedClasses_1.itemConfig.GetTrinket(trinketType);
+    if (itemConfigItem === undefined) {
+        return constants_1.BLIND_ITEM_PNG_PATH;
+    }
+    return itemConfigItem.GfxFileName;
+}
+exports.getTrinketGfxFilename = getTrinketGfxFilename;
+/**
+ * Helper function to get the name of a trinket. Returns "Unknown" if the provided trinket type is
+ * not valid.
+ *
+ * This function works for both vanilla and modded trinkets.
+ *
+ * For example, `getTrinketName(TrinketType.SWALLOWED_PENNY)` would return "Swallowed Penny".
+ */
+function getTrinketName(trinketType) {
+    // "ItemConfigItem.Name" is bugged with vanilla items on patch v1.7.6, so we use a hard-coded
+    // object as a workaround.
+    const trinketName = trinketNames_1.TRINKET_NAMES[trinketType];
+    if (trinketName !== undefined) {
+        return trinketName;
+    }
+    const itemConfigItem = cachedClasses_1.itemConfig.GetTrinket(trinketType);
+    if (itemConfigItem !== undefined) {
+        return itemConfigItem.Name;
+    }
+    return trinketNames_1.DEFAULT_TRINKET_NAME;
+}
+exports.getTrinketName = getTrinketName;
+function isGoldenTrinketType(trinketType) {
+    return (0, types_1.asNumber)(trinketType) > GOLDEN_TRINKET_ADJUSTMENT;
+}
+exports.isGoldenTrinketType = isGoldenTrinketType;
+function isModdedTrinketType(trinketType) {
+    return !isVanillaTrinketType(trinketType);
+}
+exports.isModdedTrinketType = isModdedTrinketType;
+function isValidTrinketType(trinketType) {
+    const potentialTrinketType = (0, types_1.asTrinketType)(trinketType);
+    const itemConfigItem = cachedClasses_1.itemConfig.GetTrinket(potentialTrinketType);
+    return itemConfigItem !== undefined;
+}
+exports.isValidTrinketType = isValidTrinketType;
+function isVanillaTrinketType(trinketType) {
+    return trinketType <= constantsFirstLast_1.LAST_VANILLA_TRINKET_TYPE;
+}
+exports.isVanillaTrinketType = isVanillaTrinketType;
+/**
+ * Helper function to generate a new sprite based on a collectible. If the provided collectible type
+ * is invalid, a sprite with a Curse of the Blind question mark will be returned.
+ */
+function newTrinketSprite(trinketType) {
+    const sprite = Sprite();
+    sprite.Load(TRINKET_ANM2_PATH, false);
+    const gfxFileName = getTrinketGfxFilename(trinketType);
+    sprite.ReplaceSpritesheet(TRINKET_SPRITE_LAYER, gfxFileName);
+    sprite.LoadGraphics();
+    const defaultAnimation = sprite.GetDefaultAnimation();
+    sprite.Play(defaultAnimation, true);
+    return sprite;
+}
+exports.newTrinketSprite = newTrinketSprite;
+/**
+ * Helper function to change the sprite of a trinket entity.
+ *
+ * For more information about removing the trinket sprite, see the documentation for the
+ * "clearSprite" helper function.
+ *
+ * @param trinket The trinket whose sprite you want to modify.
+ * @param pngPath Equal to either the spritesheet path to load (e.g.
+ *                "gfx/items/trinkets/trinket_001_swallowedpenny.png") or undefined. If undefined,
+ *                the sprite will be removed, making the trinket effectively invisible (except for
+ *                the shadow underneath it).
+ */
+function setTrinketSprite(trinket, pngPath) {
+    if (!(0, pickupVariants_1.isTrinket)(trinket)) {
+        const entityID = (0, entities_1.getEntityID)(trinket);
+        error(`The "setTrinketSprite" function was given a non-trinket: ${entityID}`);
+    }
+    const sprite = trinket.GetSprite();
+    if (pngPath === undefined) {
+        // We use `clearSpriteLayer` instead of `Sprite.Reset` to maintain parity with the
+        // `setCollectibleSprite` function.
+        (0, sprites_1.clearSprite)(sprite);
+    }
+    else {
+        sprite.ReplaceSpritesheet(TRINKET_SPRITE_LAYER, pngPath);
+        sprite.LoadGraphics();
+    }
+}
+exports.setTrinketSprite = setTrinketSprite;
+/** Helper function to check in the item config if a given trinket has a given cache flag. */
+function trinketHasCacheFlag(trinketType, cacheFlag) {
+    const itemConfigItem = cachedClasses_1.itemConfig.GetTrinket(trinketType);
+    if (itemConfigItem === undefined) {
+        return false;
+    }
+    return (0, flag_1.hasFlag)(itemConfigItem.CacheFlags, cacheFlag);
+}
+exports.trinketHasCacheFlag = trinketHasCacheFlag;

package/dist/functions/tstlClass.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newTSTLClass = exports.isTSTLSet = exports.isTSTLMap = exports.isTSTLClass = exports.isDefaultMap = exports.getTSTLClassName = exports.getTSTLClassConstructor = void 0;
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+/**
+ * Helper function to get the constructor from an instantiated TypeScriptToLua class, which is
+ * located on the metatable.
+ *
+ * Returns undefined if passed a non-table or if the provided table does not have a metatable.
+ */
+function getTSTLClassConstructor(object) {
+    if (!(0, types_1.isTable)(object)) {
+        return undefined;
+    }
+    const metatable = getmetatable(object);
+    if (metatable === undefined) {
+        return undefined;
+    }
+    return metatable.constructor;
+}
+exports.getTSTLClassConstructor = getTSTLClassConstructor;
+/**
+ * Helper function to get the name of a TypeScriptToLua class from the instantiated class object.
+ *
+ * TSTL classes are Lua tables created with the `__TS__Class` Lua function from the TSTL lualib.
+ * Their name is contained within "constructor.name" metatable key.
+ *
+ * For example, a `Map` class is has a name of "Map".
+ *
+ * Returns undefined if passed a non-table or if the provided table does not have a metatable.
+ */
+function getTSTLClassName(object) {
+    const constructor = getTSTLClassConstructor(object);
+    if (constructor === undefined) {
+        return undefined;
+    }
+    return constructor.name;
+}
+exports.getTSTLClassName = getTSTLClassName;
+/**
+ * Helper function to determine if a given object is a TypeScriptToLua `Map`.
+ *
+ * It is not reliable to use the `instanceof` operator to determine this because each Lua module has
+ * their own copies of the entire lualib and thus their own instantiated version of a `Map`.
+ */
+function isDefaultMap(object) {
+    const className = getTSTLClassName(object);
+    return className === "DefaultMap";
+}
+exports.isDefaultMap = isDefaultMap;
+/** Helper function to check if a given table is a class table created by TypeScriptToLua. */
+function isTSTLClass(object) {
+    const tstlClassName = getTSTLClassName(object);
+    return tstlClassName !== undefined;
+}
+exports.isTSTLClass = isTSTLClass;
+/**
+ * Helper function to determine if a given object is a TypeScriptToLua `Map`.
+ *
+ * It is not reliable to use the `instanceof` operator to determine this because each Lua module
+ * might have their own copy of the entire lualib and thus their own instantiated version of a
+ * `Map`.
+ */
+function isTSTLMap(object) {
+    const className = getTSTLClassName(object);
+    return className === "Map";
+}
+exports.isTSTLMap = isTSTLMap;
+/**
+ * Helper function to determine if a given object is a TypeScriptToLua `Set`.
+ *
+ * It is not reliable to use the `instanceof` operator to determine this because each Lua module
+ * might have their own copy of the entire lualib and thus their own instantiated version of a
+ * `Set`.
+ */
+function isTSTLSet(object) {
+    const className = getTSTLClassName(object);
+    return className === "Set";
+}
+exports.isTSTLSet = isTSTLSet;
+/**
+ * Initializes a new TypeScriptToLua class in the situation where you do not know what kind of class
+ * it is. This function requires that you provide an instantiated class of the same type, as it will
+ * use the class constructor that is present on the other object's metatable to initialize the new
+ * class.
+ */
+function newTSTLClass(oldClass) {
+    const constructor = getTSTLClassConstructor(oldClass);
+    (0, utils_1.assertDefined)(constructor, "Failed to instantiate a new TypeScriptToLua class since the provided old class does not have a metatable/constructor.");
+    // We re-implement some of the logic from the transpiled "__TS__New" function.
+    const newClass = new LuaMap();
+    const newClassMetatable = setmetatable(newClass, constructor.prototype);
+    newClassMetatable.____constructor();
+    return newClass;
+}
+exports.newTSTLClass = newTSTLClass;

package/dist/functions/types.js

@@ -0,0 +1,225 @@
+"use strict";
+/**
+ * Consider the following code that uses a number enum:
+ *
+ * ```ts
+ * enum MyEnum {
+ *   Value1,
+ * }
+ *
+ * function asMyEnum(num: number): MyEnum {}
+ *
+ * declare const something: unknown;
+ *
+ * const foo = something as MyEnum; // no error
+ * const bar: MyEnum = something; // error
+ * const baz = asMyEnum(something); // error
+ * ```
+ *
+ * Here, using `as` does not give an error because TypeScript allows you to assert a type to a
+ * supertype or a subtype. Thus, using `as` to perform a type assertion is not as safe as using a
+ * variable declaration or a helper function. However, if we use a variable declaration, then the
+ * `isaacscript/strict-enums` rule is triggered, which requires suppressing the lint rule with a `//
+ * eslint-disable-next-line`. Thus, the safest and more concise way to do a type assertion is to use
+ * a helper function.
+ *
+ * This file contains helper functions for various number enums that might require type assertions.
+ * It also contains helper functions for run-time type checks.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIntSafe = exports.isUserdata = exports.isTable = exports.isString = exports.isPrimitive = exports.isNumber = exports.isInteger = exports.isFunction = exports.isBoolean = exports.asTrinketType = exports.asString = exports.asRoomType = exports.asPlayerType = exports.asPillEffect = exports.asPillColor = exports.asNumber = exports.asNPCState = exports.asLevelStage = exports.asInt = exports.asFloat = exports.asCollectibleType = exports.asCardType = void 0;
+/**
+ * Helper function to safely cast an `int` to a `CardType`. (This is better than using the `as`
+ * TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
+ *
+ * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
+ */
+function asCardType(num) {
+    return num;
+}
+exports.asCardType = asCardType;
+/**
+ * Helper function to safely cast an `int` to a `CollectibleType`. (This is better than using the
+ * `as` TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
+ *
+ * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
+ */
+function asCollectibleType(num) {
+    return num;
+}
+exports.asCollectibleType = asCollectibleType;
+/**
+ * Helper function to safely cast an enum to an `int`. (This is better than using the `as`
+ * TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
+ *
+ * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
+ */
+function asFloat(num) {
+    return num;
+}
+exports.asFloat = asFloat;
+/**
+ * Helper function to safely cast an enum to an `int`. (This is better than using the `as`
+ * TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
+ *
+ * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
+ */
+function asInt(num) {
+    return num;
+}
+exports.asInt = asInt;
+/**
+ * Helper function to safely cast an `int` to a `LevelStage`. (This is better than using the `as`
+ * TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
+ *
+ * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
+ */
+function asLevelStage(num) {
+    return num;
+}
+exports.asLevelStage = asLevelStage;
+/**
+ * Helper function to safely cast an `int` to a `NPCState`. (This is better than using the `as`
+ * TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
+ *
+ * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
+ */
+function asNPCState(num) {
+    return num;
+}
+exports.asNPCState = asNPCState;
+/**
+ * Helper function to safely cast an enum to a `number`. (This is better than using the `as`
+ * TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
+ *
+ * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
+ */
+function asNumber(num) {
+    return num;
+}
+exports.asNumber = asNumber;
+/**
+ * Helper function to safely cast an `int` to a `PillColor`. (This is better than using the `as`
+ * TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
+ *
+ * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
+ */
+function asPillColor(num) {
+    return num;
+}
+exports.asPillColor = asPillColor;
+/**
+ * Helper function to safely cast an `int` to a `PillEffect`. (This is better than using the `as`
+ * TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
+ *
+ * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
+ */
+function asPillEffect(num) {
+    return num;
+}
+exports.asPillEffect = asPillEffect;
+/**
+ * Helper function to safely cast an `int` to a `PlayerType`. (This is better than using the `as`
+ * TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
+ *
+ * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
+ */
+function asPlayerType(num) {
+    return num;
+}
+exports.asPlayerType = asPlayerType;
+/**
+ * Helper function to safely cast an `int` to a `RoomType`. (This is better than using the `as`
+ * TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
+ *
+ * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
+ */
+function asRoomType(num) {
+    return num;
+}
+exports.asRoomType = asRoomType;
+/**
+ * Helper function to safely cast an enum to a `string`. (This is better than using the `as`
+ * TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
+ *
+ * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
+ */
+function asString(str) {
+    return str;
+}
+exports.asString = asString;
+/**
+ * Helper function to safely cast an `int` to a `TrinketType`. (This is better than using the `as`
+ * TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
+ *
+ * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
+ */
+function asTrinketType(num) {
+    return num;
+}
+exports.asTrinketType = asTrinketType;
+function isBoolean(variable) {
+    return type(variable) === "boolean";
+}
+exports.isBoolean = isBoolean;
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isFunction(variable) {
+    return type(variable) === "function";
+}
+exports.isFunction = isFunction;
+function isInteger(variable) {
+    if (!isNumber(variable)) {
+        return false;
+    }
+    return variable === Math.floor(variable);
+}
+exports.isInteger = isInteger;
+function isNumber(variable) {
+    return type(variable) === "number";
+}
+exports.isNumber = isNumber;
+/** Helper function to detect if a variable is a boolean, number, or string. */
+function isPrimitive(variable) {
+    const variableType = type(variable);
+    return (variableType === "boolean" ||
+        variableType === "number" ||
+        variableType === "string");
+}
+exports.isPrimitive = isPrimitive;
+function isString(variable) {
+    return type(variable) === "string";
+}
+exports.isString = isString;
+function isTable(variable) {
+    return type(variable) === "table";
+}
+exports.isTable = isTable;
+function isUserdata(variable) {
+    return type(variable) === "userdata";
+}
+exports.isUserdata = isUserdata;
+/**
+ * Helper function to convert a string to an integer. Returns undefined if the string is not an
+ * integer.
+ *
+ * Under the hood, this uses the built-in `tonumber` and `math.floor` functions.
+ *
+ * This is named `parseIntSafe` in order to match the helper function in `isaacscript-common-ts`.
+ */
+function parseIntSafe(string) {
+    if (!isString(string)) {
+        return undefined;
+    }
+    // - The `tonumber` function correctly deals with leading and trailing whitespace.
+    // - The `tonumber` function correctly deals with a mix of numbers and letters. (e.g. `1a` returns
+    //   undefined.)
+    const number = tonumber(string);
+    if (number === undefined) {
+        return undefined;
+    }
+    const flooredNumber = math.floor(number);
+    return number === flooredNumber ? flooredNumber : undefined;
+}
+exports.parseIntSafe = parseIntSafe;