isaacscript-common 84.0.1 → 84.1.0

package/dist/functions/input.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyboardToString = exports.isShootActionTriggeredOnAnyInput = exports.isShootActionTriggered = exports.isShootActionPressedOnAnyInput = exports.isShootActionPressed = exports.isShootAction = exports.isMoveActionTriggeredOnAnyInput = exports.isMoveActionTriggered = exports.isMoveActionPressedOnAnyInput = exports.isMoveActionPressed = exports.isMoveAction = exports.isModifierKeyPressed = exports.isKeyboardPressed = exports.isActionTriggeredOnAnyInput = exports.isActionTriggered = exports.isActionPressedOnAnyInput = exports.isActionPressed = exports.getShootButtonActions = exports.getMoveButtonActions = exports.controllerToString = exports.SHOOTING_BUTTON_ACTIONS_SET = exports.SHOOTING_BUTTON_ACTIONS = exports.MOVEMENT_BUTTON_ACTIONS_SET = exports.MOVEMENT_BUTTON_ACTIONS = exports.MODIFIER_KEYS = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedEnumValues_1 = require("../arrays/cachedEnumValues");
+const keyboardToStringMap_1 = require("../maps/keyboardToStringMap");
+const ReadonlySet_1 = require("../types/ReadonlySet");
+const string_1 = require("./string");
+exports.MODIFIER_KEYS = [
+    isaac_typescript_definitions_1.Keyboard.LEFT_SHIFT,
+    isaac_typescript_definitions_1.Keyboard.LEFT_CONTROL,
+    isaac_typescript_definitions_1.Keyboard.LEFT_ALT,
+    isaac_typescript_definitions_1.Keyboard.LEFT_SUPER,
+    isaac_typescript_definitions_1.Keyboard.RIGHT_SHIFT,
+    isaac_typescript_definitions_1.Keyboard.RIGHT_CONTROL,
+    isaac_typescript_definitions_1.Keyboard.RIGHT_ALT,
+    isaac_typescript_definitions_1.Keyboard.RIGHT_SUPER, // 347
+];
+exports.MOVEMENT_BUTTON_ACTIONS = [
+    isaac_typescript_definitions_1.ButtonAction.LEFT,
+    isaac_typescript_definitions_1.ButtonAction.RIGHT,
+    isaac_typescript_definitions_1.ButtonAction.UP,
+    isaac_typescript_definitions_1.ButtonAction.DOWN, // 3
+];
+exports.MOVEMENT_BUTTON_ACTIONS_SET = new ReadonlySet_1.ReadonlySet(exports.MOVEMENT_BUTTON_ACTIONS);
+exports.SHOOTING_BUTTON_ACTIONS = [
+    isaac_typescript_definitions_1.ButtonAction.SHOOT_LEFT,
+    isaac_typescript_definitions_1.ButtonAction.SHOOT_RIGHT,
+    isaac_typescript_definitions_1.ButtonAction.SHOOT_UP,
+    isaac_typescript_definitions_1.ButtonAction.SHOOT_DOWN, // 7
+];
+exports.SHOOTING_BUTTON_ACTIONS_SET = new ReadonlySet_1.ReadonlySet(exports.SHOOTING_BUTTON_ACTIONS);
+/**
+ * Helper function to get the enum name for the specified `Controller` value. Note that this will
+ * trim off the "BUTTON_" prefix.
+ *
+ * Returns undefined if the submitted controller value was not valid.
+ */
+function controllerToString(controller) {
+    const key = isaac_typescript_definitions_1.Controller[controller];
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (key === undefined) {
+        return undefined;
+    }
+    return (0, string_1.trimPrefix)(key, "BUTTON_");
+}
+exports.controllerToString = controllerToString;
+/**
+ * Helper function to get the movement actions that the specified `ControllerIndex` is currently
+ * pressing down. This returns an array because a player can be holding down more than one movement
+ * key at a time.
+ */
+function getMoveButtonActions(controllerIndex) {
+    return exports.MOVEMENT_BUTTON_ACTIONS.filter((buttonAction) => Input.IsActionPressed(buttonAction, controllerIndex));
+}
+exports.getMoveButtonActions = getMoveButtonActions;
+/**
+ * Helper function to get the shooting actions that the specified `ControllerIndex` is currently
+ * pressing down. This returns an array because a player can be holding down more than one shooting
+ * key at a time.
+ */
+function getShootButtonActions(controllerIndex) {
+    return exports.SHOOTING_BUTTON_ACTIONS.filter((buttonAction) => Input.IsActionPressed(buttonAction, controllerIndex));
+}
+exports.getShootButtonActions = getShootButtonActions;
+/**
+ * Helper function to check if a player is pressing a specific button (i.e. holding it down).
+ *
+ * This is a variadic version of `Input.IsActionPressed`, meaning that you can pass as many buttons
+ * as you want to check for. This function will return true if any of the buttons are pressed.
+ */
+function isActionPressed(controllerIndex, ...buttonActions) {
+    return buttonActions.some((buttonAction) => Input.IsActionPressed(buttonAction, controllerIndex));
+}
+exports.isActionPressed = isActionPressed;
+/**
+ * Helper function to iterate over all inputs to determine if a specific button is pressed (i.e.
+ * being held down).
+ *
+ * This function is variadic, meaning you can pass as many buttons as you want to check for. This
+ * function will return true if any of the buttons are pressed.
+ */
+function isActionPressedOnAnyInput(...buttonActions) {
+    return cachedEnumValues_1.CONTROLLER_INDEX_VALUES.some((controllerIndex) => isActionPressed(controllerIndex, ...buttonActions));
+}
+exports.isActionPressedOnAnyInput = isActionPressedOnAnyInput;
+/**
+ * Helper function to check if a player is triggering a specific button (i.e. pressing and releasing
+ * it).
+ *
+ * This is a variadic version of `Input.IsActionTriggered`, meaning that you can pass as many
+ * buttons as you want to check for. This function will return true if any of the buttons are
+ * triggered.
+ */
+function isActionTriggered(controllerIndex, ...buttonActions) {
+    return buttonActions.some((buttonAction) => Input.IsActionTriggered(buttonAction, controllerIndex));
+}
+exports.isActionTriggered = isActionTriggered;
+/**
+ * Iterates over all inputs to determine if a specific button is triggered (i.e. held down and then
+ * released).
+ *
+ * This function is variadic, meaning you can pass as many buttons as you want to check for. This
+ * function will return true if any of the buttons are pressed.
+ */
+function isActionTriggeredOnAnyInput(...buttonActions) {
+    return cachedEnumValues_1.CONTROLLER_INDEX_VALUES.some((controllerIndex) => isActionTriggered(controllerIndex, ...buttonActions));
+}
+exports.isActionTriggeredOnAnyInput = isActionTriggeredOnAnyInput;
+/**
+ * Helper function to see if a specific keyboard key is being held down by the player.
+ *
+ * This function is variadic, meaning you can pass as many keyboard values as you want to check for.
+ * This function will return true if any of the values are pressed.
+ */
+function isKeyboardPressed(...keys) {
+    return keys.some((key) => Input.IsButtonPressed(key, isaac_typescript_definitions_1.ControllerIndex.KEYBOARD));
+}
+exports.isKeyboardPressed = isKeyboardPressed;
+/**
+ * Helper function to check if one or more modifier keys are being pressed down on the keyboard.
+ *
+ * A modifier key is defined as shift, control, alt, or Windows.
+ */
+function isModifierKeyPressed() {
+    return isKeyboardPressed(...exports.MODIFIER_KEYS);
+}
+exports.isModifierKeyPressed = isModifierKeyPressed;
+function isMoveAction(buttonAction) {
+    return exports.MOVEMENT_BUTTON_ACTIONS_SET.has(buttonAction);
+}
+exports.isMoveAction = isMoveAction;
+function isMoveActionPressed(controllerIndex) {
+    return isActionPressed(controllerIndex, ...exports.MOVEMENT_BUTTON_ACTIONS);
+}
+exports.isMoveActionPressed = isMoveActionPressed;
+function isMoveActionPressedOnAnyInput() {
+    return exports.MOVEMENT_BUTTON_ACTIONS.some((moveAction) => isActionPressedOnAnyInput(moveAction));
+}
+exports.isMoveActionPressedOnAnyInput = isMoveActionPressedOnAnyInput;
+function isMoveActionTriggered(controllerIndex) {
+    return isActionTriggered(controllerIndex, ...exports.MOVEMENT_BUTTON_ACTIONS);
+}
+exports.isMoveActionTriggered = isMoveActionTriggered;
+function isMoveActionTriggeredOnAnyInput() {
+    return exports.MOVEMENT_BUTTON_ACTIONS.some((moveAction) => isActionTriggeredOnAnyInput(moveAction));
+}
+exports.isMoveActionTriggeredOnAnyInput = isMoveActionTriggeredOnAnyInput;
+function isShootAction(buttonAction) {
+    return exports.SHOOTING_BUTTON_ACTIONS_SET.has(buttonAction);
+}
+exports.isShootAction = isShootAction;
+function isShootActionPressed(controllerIndex) {
+    return isActionPressed(controllerIndex, ...exports.SHOOTING_BUTTON_ACTIONS);
+}
+exports.isShootActionPressed = isShootActionPressed;
+function isShootActionPressedOnAnyInput() {
+    return exports.SHOOTING_BUTTON_ACTIONS.some((shootAction) => isActionPressedOnAnyInput(shootAction));
+}
+exports.isShootActionPressedOnAnyInput = isShootActionPressedOnAnyInput;
+function isShootActionTriggered(controllerIndex) {
+    return isActionTriggered(controllerIndex, ...exports.SHOOTING_BUTTON_ACTIONS);
+}
+exports.isShootActionTriggered = isShootActionTriggered;
+function isShootActionTriggeredOnAnyInput() {
+    return exports.SHOOTING_BUTTON_ACTIONS.some((shootAction) => isActionTriggeredOnAnyInput(shootAction));
+}
+exports.isShootActionTriggeredOnAnyInput = isShootActionTriggeredOnAnyInput;
+/**
+ * Helper function to get the string that would be typed if someone pressed the corresponding key.
+ * This is useful for creating in-game chat.
+ *
+ * Note that this function will only work for the keyboard values that are printable. Thus, it will
+ * return undefined for e.g. `Keyboard.LEFT_SHIFT` (340). If all you want is the corresponding name
+ * of the key, then simply use the enum reverse mapping (e.g. `Keyboard[keyboard]`).
+ */
+function keyboardToString(keyboard, uppercase) {
+    const tuple = keyboardToStringMap_1.KEYBOARD_TO_STRING_MAP.get(keyboard);
+    if (tuple === undefined) {
+        return undefined;
+    }
+    const [lowercaseCharacter, uppercaseCharacter] = tuple;
+    return uppercase ? uppercaseCharacter : lowercaseCharacter;
+}
+exports.keyboardToString = keyboardToString;

package/dist/functions/isaacAPIClass.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isaacAPIClassEquals = exports.isTear = exports.isTNT = exports.isSpikes = exports.isRock = exports.isProjectile = exports.isPressurePlate = exports.isPoop = exports.isPlayer = exports.isPit = exports.isPickup = exports.isNPC = exports.isLaser = exports.isKnife = exports.isIsaacAPIClassOfType = exports.isIsaacAPIClass = exports.isGridEntity = exports.isFamiliar = exports.isEntity = exports.isEffect = exports.isDoor = exports.isBomb = exports.getIsaacAPIClassName = void 0;
+const string_1 = require("./string");
+const types_1 = require("./types");
+/**
+ * Helper function to get the name of a class from the Isaac API. This is contained within the
+ * "__type" metatable key.
+ *
+ * For example, a `Vector` class is has a name of "Vector".
+ *
+ * Returns undefined if the object is not of type `userdata` or if the "__type" metatable key does
+ * not exist.
+ *
+ * In some cases, Isaac classes can be a read-only. If this is the case, the "__type" field will be
+ * prepended with "const ". This function will always strip this prefix, if it exists. For example,
+ * the class name returned for "const Vector" will be "Vector".
+ */
+function getIsaacAPIClassName(object) {
+    if (!(0, types_1.isUserdata)(object)) {
+        return undefined;
+    }
+    const metatable = getmetatable(object);
+    if (metatable === undefined) {
+        return undefined;
+    }
+    const classType = metatable.get("__type");
+    if (!(0, types_1.isString)(classType)) {
+        return undefined;
+    }
+    return (0, string_1.trimPrefix)(classType, "const ");
+}
+exports.getIsaacAPIClassName = getIsaacAPIClassName;
+/** Helper function to detect if a variable is of type `EntityBomb`. */
+function isBomb(variable) {
+    return getIsaacAPIClassName(variable) === "EntityBomb";
+}
+exports.isBomb = isBomb;
+/** Helper function to detect if a variable is of type `GridEntityDoor`. */
+function isDoor(variable) {
+    return getIsaacAPIClassName(variable) === "GridEntityDoor";
+}
+exports.isDoor = isDoor;
+/** Helper function to detect if a variable is of type `EntityEffect`. */
+function isEffect(variable) {
+    return getIsaacAPIClassName(variable) === "EntityEffect";
+}
+exports.isEffect = isEffect;
+/**
+ * Helper function to detect if a variable is of type `Entity`. This will return false for child
+ * classes such as `EntityPlayer` or `EntityTear`.
+ */
+function isEntity(variable) {
+    return getIsaacAPIClassName(variable) === "Entity";
+}
+exports.isEntity = isEntity;
+/** Helper function to detect if a variable is of type `EntityFamiliar`. */
+function isFamiliar(variable) {
+    return getIsaacAPIClassName(variable) === "EntityEffect";
+}
+exports.isFamiliar = isFamiliar;
+/** Helper function to detect if a variable is of type `GridEntity`. */
+function isGridEntity(variable) {
+    return getIsaacAPIClassName(variable) === "GridEntity";
+}
+exports.isGridEntity = isGridEntity;
+/**
+ * Helper function to check if something is an instantiated class from the Isaac API. (All classes
+ * from the Isaac API have a type of "userdata" in Lua with a metatable key of "__type" equal to the
+ * name of the class.)
+ */
+function isIsaacAPIClass(object) {
+    const isaacAPIClassType = getIsaacAPIClassName(object);
+    return isaacAPIClassType !== undefined;
+}
+exports.isIsaacAPIClass = isIsaacAPIClass;
+function isIsaacAPIClassOfType(object, classType) {
+    const isaacAPIClassType = getIsaacAPIClassName(object);
+    return (isaacAPIClassType === classType ||
+        isaacAPIClassType === `const ${classType}`);
+}
+exports.isIsaacAPIClassOfType = isIsaacAPIClassOfType;
+/** Helper function to detect if a variable is of type `EntityKnife`. */
+function isKnife(variable) {
+    return getIsaacAPIClassName(variable) === "EntityKnife";
+}
+exports.isKnife = isKnife;
+/** Helper function to detect if a variable is of type `EntityLaser`. */
+function isLaser(variable) {
+    return getIsaacAPIClassName(variable) === "EntityLaser";
+}
+exports.isLaser = isLaser;
+/** Helper function to detect if a variable is of type `EntityNPC`. */
+function isNPC(variable) {
+    return getIsaacAPIClassName(variable) === "EntityNPC";
+}
+exports.isNPC = isNPC;
+/** Helper function to detect if a variable is of type `EntityPickup`. */
+function isPickup(variable) {
+    return getIsaacAPIClassName(variable) === "EntityPickup";
+}
+exports.isPickup = isPickup;
+/** Helper function to detect if a variable is of type `GridEntityPit`. */
+function isPit(variable) {
+    return getIsaacAPIClassName(variable) === "GridEntityPit";
+}
+exports.isPit = isPit;
+/** Helper function to detect if a variable is of type `EntityPlayer`. */
+function isPlayer(variable) {
+    return getIsaacAPIClassName(variable) === "EntityPlayer";
+}
+exports.isPlayer = isPlayer;
+/** Helper function to detect if a variable is of type `GridEntityPoop`. */
+function isPoop(variable) {
+    return getIsaacAPIClassName(variable) === "GridEntityPoop";
+}
+exports.isPoop = isPoop;
+/** Helper function to detect if a variable is of type `GridEntityPressurePlate`. */
+function isPressurePlate(variable) {
+    return getIsaacAPIClassName(variable) === "GridEntityPressurePlate";
+}
+exports.isPressurePlate = isPressurePlate;
+/** Helper function to detect if a variable is of type `EntityProjectile`. */
+function isProjectile(variable) {
+    return getIsaacAPIClassName(variable) === "EntityProjectile";
+}
+exports.isProjectile = isProjectile;
+/** Helper function to detect if a variable is of type `GridEntityRock`. */
+function isRock(variable) {
+    return getIsaacAPIClassName(variable) === "GridEntityRock";
+}
+exports.isRock = isRock;
+/** Helper function to detect if a variable is of type `GridEntitySpikes`. */
+function isSpikes(variable) {
+    return getIsaacAPIClassName(variable) === "GridEntitySpikes";
+}
+exports.isSpikes = isSpikes;
+/** Helper function to detect if a variable is of type `GridEntityTNT`. */
+function isTNT(variable) {
+    return getIsaacAPIClassName(variable) === "GridEntityTNT";
+}
+exports.isTNT = isTNT;
+/** Helper function to detect if a variable is of type `EntityTear`. */
+function isTear(variable) {
+    return getIsaacAPIClassName(variable) === "EntityTear";
+}
+exports.isTear = isTear;
+/**
+ * Helper function to check if an instantiated Isaac API class is equal to another one of the same
+ * type. You must provide the list of keys to check for.
+ */
+function isaacAPIClassEquals(object1, object2, keys) {
+    const table1 = object1;
+    const table2 = object2;
+    return keys.every((key) => table1.get(key) === table2.get(key));
+}
+exports.isaacAPIClassEquals = isaacAPIClassEquals;

package/dist/functions/itemPool.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeTrinketFromPools = exports.removeCollectibleFromPools = exports.isCollectibleTypeInDefaultItemPool = exports.getRandomItemPool = exports.getItemPoolName = exports.getDefaultItemPoolsForCollectibleType = exports.getDefaultCollectibleTypesInItemPool = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedEnumValues_1 = require("../arrays/cachedEnumValues");
+const cachedClasses_1 = require("../core/cachedClasses");
+const itemPoolTypeToItemPoolName_1 = require("../maps/itemPoolTypeToItemPoolName");
+const itemPoolTypeToCollectibleTypesSet_1 = require("../objects/itemPoolTypeToCollectibleTypesSet");
+const array_1 = require("./array");
+const NORMAL_MODE_ONLY_ITEM_POOL_TYPES = [
+    isaac_typescript_definitions_1.ItemPoolType.TREASURE,
+    isaac_typescript_definitions_1.ItemPoolType.BOSS,
+    isaac_typescript_definitions_1.ItemPoolType.SHOP,
+    isaac_typescript_definitions_1.ItemPoolType.DEVIL,
+    isaac_typescript_definitions_1.ItemPoolType.ANGEL,
+    isaac_typescript_definitions_1.ItemPoolType.CURSE,
+    isaac_typescript_definitions_1.ItemPoolType.SECRET, // 5
+];
+const GREED_MODE_ONLY_ITEM_POOL_TYPES = [
+    isaac_typescript_definitions_1.ItemPoolType.GREED_TREASURE,
+    isaac_typescript_definitions_1.ItemPoolType.GREED_BOSS,
+    isaac_typescript_definitions_1.ItemPoolType.GREED_SHOP,
+    isaac_typescript_definitions_1.ItemPoolType.GREED_DEVIL,
+    isaac_typescript_definitions_1.ItemPoolType.GREED_ANGEL,
+    isaac_typescript_definitions_1.ItemPoolType.GREED_CURSE,
+    isaac_typescript_definitions_1.ItemPoolType.GREED_SECRET, // 22
+];
+const FAKE_ITEM_POOL_TYPES = [isaac_typescript_definitions_1.ItemPoolType.SHELL_GAME];
+const NORMAL_MODE_ITEM_POOL_TYPES = (0, array_1.arrayRemove)(cachedEnumValues_1.ITEM_POOL_TYPE_VALUES, ...GREED_MODE_ONLY_ITEM_POOL_TYPES, ...FAKE_ITEM_POOL_TYPES);
+const GREED_MODE_ITEM_POOL_TYPES = (0, array_1.arrayRemove)(cachedEnumValues_1.ITEM_POOL_TYPE_VALUES, ...NORMAL_MODE_ONLY_ITEM_POOL_TYPES, ...FAKE_ITEM_POOL_TYPES);
+/**
+ * Helper function to get the collectibles that are in a particular item pool at the beginning of a
+ * vanilla run.
+ */
+function getDefaultCollectibleTypesInItemPool(itemPoolType) {
+    return itemPoolTypeToCollectibleTypesSet_1.ITEM_POOL_TYPE_TO_COLLECTIBLE_TYPES_SET[itemPoolType];
+}
+exports.getDefaultCollectibleTypesInItemPool = getDefaultCollectibleTypesInItemPool;
+/**
+ * Helper function to get the item pools that a particular collectible starts in at the beginning of
+ * a vanilla run.
+ *
+ * This function will automatically account for Greed Mode. In other words, it will not return the
+ * "normal" item pools when playing in Greed Mode.
+ */
+function getDefaultItemPoolsForCollectibleType(collectibleType) {
+    const collectibleItemPoolTypes = [];
+    const itemPoolTypes = cachedClasses_1.game.IsGreedMode()
+        ? GREED_MODE_ITEM_POOL_TYPES
+        : NORMAL_MODE_ITEM_POOL_TYPES;
+    for (const itemPoolType of itemPoolTypes) {
+        const collectibleTypesSet = itemPoolTypeToCollectibleTypesSet_1.ITEM_POOL_TYPE_TO_COLLECTIBLE_TYPES_SET[itemPoolType];
+        if (collectibleTypesSet.has(collectibleType)) {
+            collectibleItemPoolTypes.push(itemPoolType);
+        }
+    }
+    return collectibleItemPoolTypes;
+}
+exports.getDefaultItemPoolsForCollectibleType = getDefaultItemPoolsForCollectibleType;
+/**
+ * Helper function to get the name for an item pool type as it appears in the "itempools.xml" file.
+ */
+function getItemPoolName(itemPoolType) {
+    return itemPoolTypeToItemPoolName_1.ITEM_POOL_TYPE_TO_ITEM_POOL_NAME[itemPoolType];
+}
+exports.getItemPoolName = getItemPoolName;
+/**
+ * Helper function to get a random item pool. This is not as simple as getting a random value from
+ * the `ItemPoolType` enum, since `ItemPoolType.SHELL_GAME` (7) is not a real item pool and the
+ * Greed Mode item pools should be excluded if not playing in Greed Mode.
+ *
+ * If you want to get an unseeded item pool, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
+ */
+function getRandomItemPool(seedOrRNG) {
+    const itemPoolTypes = cachedClasses_1.game.IsGreedMode()
+        ? GREED_MODE_ITEM_POOL_TYPES
+        : NORMAL_MODE_ITEM_POOL_TYPES;
+    return (0, array_1.getRandomArrayElement)(itemPoolTypes, seedOrRNG);
+}
+exports.getRandomItemPool = getRandomItemPool;
+/**
+ * Helper function to check if a particular collectibles is in a particular item pool at the
+ * beginning of a vanilla run.
+ */
+function isCollectibleTypeInDefaultItemPool(collectibleType, itemPoolType) {
+    const collectibleTypesSet = itemPoolTypeToCollectibleTypesSet_1.ITEM_POOL_TYPE_TO_COLLECTIBLE_TYPES_SET[itemPoolType];
+    return collectibleTypesSet.has(collectibleType);
+}
+exports.isCollectibleTypeInDefaultItemPool = isCollectibleTypeInDefaultItemPool;
+/**
+ * Helper function to remove one or more collectibles from all item pools.
+ *
+ * This function is variadic, meaning you can pass as many collectible types as you want to remove.
+ */
+function removeCollectibleFromPools(...collectibleTypes) {
+    const itemPool = cachedClasses_1.game.GetItemPool();
+    for (const collectibleType of collectibleTypes) {
+        itemPool.RemoveCollectible(collectibleType);
+    }
+}
+exports.removeCollectibleFromPools = removeCollectibleFromPools;
+/**
+ * Helper function to remove one or more trinkets from all item pools.
+ *
+ * This function is variadic, meaning you can pass as many trinket types as you want to remove.
+ */
+function removeTrinketFromPools(...trinketTypes) {
+    const itemPool = cachedClasses_1.game.GetItemPool();
+    for (const trinketType of trinketTypes) {
+        itemPool.RemoveTrinket(trinketType);
+    }
+}
+exports.removeTrinketFromPools = removeTrinketFromPools;

package/dist/functions/jsonHelpers.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonEncode = exports.jsonDecode = void 0;
+const jsonLua = __importStar(require("../lib/jsonLua"));
+const log_1 = require("./log");
+function tryDecode(jsonString) {
+    return jsonLua.decode(jsonString);
+}
+function tryEncode(luaTable) {
+    return jsonLua.encode(luaTable);
+}
+/**
+ * Converts a JSON string to a Lua table.
+ *
+ * In most cases, this function will be used for reading data from a "save#.dat" file. If decoding
+ * fails, it will return a blank Lua table instead of throwing an error. (This allows execution to
+ * continue in cases where users have no current save data or have manually removed their existing
+ * save data.)
+ *
+ * Under the hood, this uses a custom JSON parser that was measured to be 11.8 times faster than the
+ * vanilla JSON parser.
+ */
+function jsonDecode(jsonString) {
+    const [ok, luaTableOrErrMsg] = pcall(tryDecode, jsonString);
+    if (!ok) {
+        // Instead of throwing an error, continue execution of the callback.
+        (0, log_1.logError)(`Failed to convert the JSON string to a Lua table: ${jsonString}`);
+        return new LuaMap();
+    }
+    return luaTableOrErrMsg;
+}
+exports.jsonDecode = jsonDecode;
+/**
+ * Converts a Lua table to a JSON string.
+ *
+ * In most cases, this function will be used for writing data to a "save#.dat" file. If encoding
+ * fails, it will throw an error to prevent writing a blank string or corrupted data to a user's
+ * "save#.dat" file.
+ *
+ * Under the hood, this uses a custom JSON parser that was measured to be 11.8 times faster than the
+ * vanilla JSON parser.
+ */
+function jsonEncode(luaTable) {
+    const [ok, jsonStringOrErrMsg] = pcall(tryEncode, luaTable);
+    if (!ok) {
+        error(`Failed to convert the Lua table to JSON: ${jsonStringOrErrMsg}`);
+    }
+    return jsonStringOrErrMsg;
+}
+exports.jsonEncode = jsonEncode;