isaacscript-common 84.0.1 → 84.1.1

package/dist/classes/features/other/extraConsoleCommands/subroutines.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warpNextToRoomType = exports.warpToRoomType = exports.spawnTrapdoorOrCrawlSpace = exports.movePlayer = exports.listGridEntities = exports.listEntities = exports.devilAngel = exports.addHeart = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../../../../core/cachedClasses");
+const HealthType_1 = require("../../../../enums/HealthType");
+const direction_1 = require("../../../../functions/direction");
+const gridEntities_1 = require("../../../../functions/gridEntities");
+const levelGrid_1 = require("../../../../functions/levelGrid");
+const logEntities_1 = require("../../../../functions/logEntities");
+const playerHealth_1 = require("../../../../functions/playerHealth");
+const roomData_1 = require("../../../../functions/roomData");
+const rooms_1 = require("../../../../functions/rooms");
+const types_1 = require("../../../../functions/types");
+const roomTypeNames_1 = require("../../../../objects/roomTypeNames");
+const DEFAULT_MOVE_UNITS = 0.5;
+function addHeart(params, healthType) {
+    let numHearts = healthType === HealthType_1.HealthType.MAX_HEARTS ? 2 : 1;
+    if (params !== "") {
+        const num = (0, types_1.parseIntSafe)(params);
+        if (num === undefined) {
+            print("That is an invalid amount of hearts to add.");
+            return;
+        }
+        numHearts = num;
+    }
+    const player = Isaac.GetPlayer();
+    (0, playerHealth_1.addPlayerHealthType)(player, healthType, numHearts);
+}
+exports.addHeart = addHeart;
+function devilAngel(useDevil) {
+    const level = cachedClasses_1.game.GetLevel();
+    const devilAngelRoomData = (0, roomData_1.getRoomData)(isaac_typescript_definitions_1.GridRoom.DEVIL);
+    if (devilAngelRoomData !== undefined) {
+        const roomType = devilAngelRoomData.Type;
+        const conflictingType = useDevil ? isaac_typescript_definitions_1.RoomType.ANGEL : isaac_typescript_definitions_1.RoomType.DEVIL;
+        if (roomType === conflictingType) {
+            // Delete the room data, which will allow the `Level.InitializeDevilAngelRoom` method to work.
+            const roomDescriptor = (0, roomData_1.getRoomDescriptor)(isaac_typescript_definitions_1.GridRoom.DEVIL);
+            roomDescriptor.Data = undefined;
+        }
+    }
+    if (useDevil) {
+        level.InitializeDevilAngelRoom(false, true);
+    }
+    else {
+        level.InitializeDevilAngelRoom(true, false);
+    }
+    (0, rooms_1.changeRoom)(isaac_typescript_definitions_1.GridRoom.DEVIL);
+}
+exports.devilAngel = devilAngel;
+function listEntities(params, includeBackgroundEffects) {
+    let entityTypeFilter;
+    if (params !== "") {
+        entityTypeFilter = (0, types_1.parseIntSafe)(params);
+        if (entityTypeFilter === undefined) {
+            print("That is an invalid entity type to filter by.");
+            return;
+        }
+    }
+    (0, logEntities_1.logAllEntities)(includeBackgroundEffects, entityTypeFilter);
+    print('Logged the entities in the room to the "log.txt" file.');
+}
+exports.listEntities = listEntities;
+function listGridEntities(params, includeWalls) {
+    let gridEntityTypeFilter;
+    if (params !== "") {
+        gridEntityTypeFilter = (0, types_1.parseIntSafe)(params);
+        if (gridEntityTypeFilter === undefined) {
+            print("That is an invalid grid entity type to filter by.");
+            return;
+        }
+    }
+    (0, logEntities_1.logAllGridEntities)(includeWalls, gridEntityTypeFilter);
+    print('Logged the grid entities in the room to the "log.txt" file.');
+}
+exports.listGridEntities = listGridEntities;
+function movePlayer(params, direction) {
+    let amount = DEFAULT_MOVE_UNITS;
+    if (params !== "") {
+        const num = (0, types_1.parseIntSafe)(params);
+        if (num === undefined) {
+            print("That is an invalid amount of units to move.");
+            return;
+        }
+        amount = num;
+    }
+    const player = Isaac.GetPlayer();
+    const vector = (0, direction_1.directionToVector)(direction);
+    const modifiedVector = vector.mul(amount);
+    player.Position = player.Position.add(modifiedVector);
+}
+exports.movePlayer = movePlayer;
+function spawnTrapdoorOrCrawlSpace(trapdoor) {
+    const room = cachedClasses_1.game.GetRoom();
+    const player = Isaac.GetPlayer();
+    const position = room.FindFreeTilePosition(player.Position, 0);
+    const gridEntityType = trapdoor
+        ? isaac_typescript_definitions_1.GridEntityType.TRAPDOOR
+        : isaac_typescript_definitions_1.GridEntityType.CRAWL_SPACE;
+    (0, gridEntities_1.spawnGridEntity)(gridEntityType, position);
+}
+exports.spawnTrapdoorOrCrawlSpace = spawnTrapdoorOrCrawlSpace;
+function warpToRoomType(roomType) {
+    const roomTypeName = roomTypeNames_1.ROOM_TYPE_NAMES[roomType];
+    const gridIndexes = (0, levelGrid_1.getRoomGridIndexesForType)(roomType);
+    const firstGridIndex = gridIndexes[0];
+    if (firstGridIndex === undefined) {
+        print(`There are no ${roomTypeName}s on this floor.`);
+        return;
+    }
+    (0, rooms_1.changeRoom)(firstGridIndex);
+    print(`Warped to room type: ${roomTypeName} (${roomType})`);
+}
+exports.warpToRoomType = warpToRoomType;
+function warpNextToRoomType(roomType) {
+    const roomTypeName = roomTypeNames_1.ROOM_TYPE_NAMES[roomType];
+    const gridIndexes = (0, levelGrid_1.getRoomGridIndexesForType)(roomType);
+    const firstGridIndex = gridIndexes[0];
+    if (firstGridIndex === undefined) {
+        print(`There are no ${roomTypeName}s on this floor.`);
+        return;
+    }
+    const adjacentRoomGridIndexes = (0, levelGrid_1.getRoomAdjacentGridIndexes)(firstGridIndex);
+    for (const [_doorSlot, roomGridIndex] of adjacentRoomGridIndexes) {
+        const roomData = (0, roomData_1.getRoomData)(roomGridIndex);
+        if (roomData !== undefined && roomData.Type === isaac_typescript_definitions_1.RoomType.DEFAULT) {
+            (0, rooms_1.changeRoom)(roomGridIndex);
+            print(`Warped next to room type: ${roomTypeName} (${roomType})`);
+            return;
+        }
+    }
+    print(`Failed to find the room next to room type: ${roomTypeName} (${roomType})`);
+}
+exports.warpNextToRoomType = warpNextToRoomType;

package/dist/classes/features/other/extraConsoleCommands/v.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v = void 0;
+// This is registered in "ExtraConsoleCommands.ts".
+// eslint-disable-next-line isaacscript/require-v-registration
+exports.v = {
+    persistent: {
+        // Curses
+        darkness: false,
+        labyrinth: false,
+        lost: false,
+        unknown: false,
+        cursed: false,
+        maze: false,
+        blind: false,
+        giant: false,
+        disableCurses: false,
+        // Stats
+        damage: false,
+        damageAmount: 500,
+        speed: false,
+        speedAmount: 2,
+        tears: false,
+        tearsAmount: 1,
+        flight: false,
+        // Other
+        chaosCardTears: false,
+        spamBloodRights: false,
+    },
+};

package/dist/classes/features/other/saveDataManager/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAVE_DATA_MANAGER_DEBUG = void 0;
+exports.SAVE_DATA_MANAGER_DEBUG = false;

package/dist/classes/features/other/saveDataManager/glowingHourGlass.js

@@ -0,0 +1,106 @@
+"use strict";
+// The save data manager has a feature where certain variables will automatically be rolled back
+// when the Glowing Hourglass is used.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreGlowingHourGlassBackup = exports.makeGlowingHourGlassBackup = void 0;
+const SaveDataKey_1 = require("../../../../enums/SaveDataKey");
+const SerializationType_1 = require("../../../../enums/SerializationType");
+const deepCopy_1 = require("../../../../functions/deepCopy");
+const merge_1 = require("../../../../functions/merge");
+const table_1 = require("../../../../functions/table");
+const constants_1 = require("./constants");
+/**
+ * When the Glowing Hourglass is used, certain save data keys will automatically be restored to a
+ * backup.
+ */
+const GLOWING_HOUR_GLASS_BACKUP_KEYS = [
+    SaveDataKey_1.SaveDataKey.RUN,
+    SaveDataKey_1.SaveDataKey.LEVEL,
+];
+const IGNORE_GLOWING_HOUR_GLASS_KEY = "__ignoreGlowingHourGlass";
+const REWIND_WITH_GLOWING_HOUR_GLASS_KEY = "__rewindWithGlowingHourGlass";
+function makeGlowingHourGlassBackup(saveDataMap, saveDataConditionalFuncMap, saveDataGlowingHourGlassMap) {
+    (0, table_1.iterateTableInOrder)(saveDataMap, (subscriberName, saveData) => {
+        // We make the Glowing Hourglass backup using `SerializationType.SERIALIZE`, which means that
+        // we cannot operate on unserializable data, such as functions. Save data that utilizes
+        // unserializable data will typically be marked using a conditional function that evaluates to
+        // false, so we skip all save data that matches this criteria.
+        const conditionalFunc = saveDataConditionalFuncMap.get(subscriberName);
+        if (conditionalFunc !== undefined) {
+            const shouldSave = conditionalFunc();
+            if (!shouldSave) {
+                return;
+            }
+        }
+        for (const saveDataKey of getKeysToBackup(saveData)) {
+            const childTable = saveData[saveDataKey];
+            if (childTable === undefined) {
+                // This feature does not happen to store any variables on this particular child table.
+                continue;
+            }
+            // Ignore child tables that the end-user has explicitly annotated.
+            const childTableLuaMap = childTable;
+            if (childTableLuaMap.has(IGNORE_GLOWING_HOUR_GLASS_KEY)) {
+                continue;
+            }
+            let saveDataGlowingHourGlass = saveDataGlowingHourGlassMap.get(subscriberName);
+            if (saveDataGlowingHourGlass === undefined) {
+                saveDataGlowingHourGlass = new LuaMap();
+                saveDataGlowingHourGlassMap.set(subscriberName, saveDataGlowingHourGlass);
+            }
+            // We serialize the table so that we can use the `merge` function later on with no other
+            // modifications.
+            const copiedChildTable = (0, deepCopy_1.deepCopy)(childTable, SerializationType_1.SerializationType.SERIALIZE);
+            saveDataGlowingHourGlass[saveDataKey] = copiedChildTable;
+        }
+    }, constants_1.SAVE_DATA_MANAGER_DEBUG);
+}
+exports.makeGlowingHourGlassBackup = makeGlowingHourGlassBackup;
+function restoreGlowingHourGlassBackup(saveDataMap, saveDataConditionalFuncMap, saveDataGlowingHourGlassMap, classConstructors) {
+    (0, table_1.iterateTableInOrder)(saveDataMap, (subscriberName, saveData) => {
+        // We make the Glowing Hourglass backup using `SerializationType.SERIALIZE`, which means that
+        // we cannot operate on unserializable data, such as functions. Save data that utilizes
+        // unserializable data will typically be marked using a conditional function that evaluates to
+        // false, so we skip all save data that matches this criteria.
+        const conditionalFunc = saveDataConditionalFuncMap.get(subscriberName);
+        if (conditionalFunc !== undefined) {
+            const shouldSave = conditionalFunc();
+            if (!shouldSave) {
+                return;
+            }
+        }
+        for (const saveDataKey of getKeysToBackup(saveData)) {
+            const childTable = saveData[saveDataKey];
+            if (childTable === undefined) {
+                // This feature does not happen to store any variables on this particular child table.
+                continue;
+            }
+            // Ignore child tables that the end-user has explicitly annotated.
+            const childTableLuaMap = childTable;
+            if (childTableLuaMap.has(IGNORE_GLOWING_HOUR_GLASS_KEY)) {
+                continue;
+            }
+            const saveDataGlowingHourGlass = saveDataGlowingHourGlassMap.get(subscriberName);
+            if (saveDataGlowingHourGlass === undefined) {
+                // This should never happen.
+                continue;
+            }
+            const childTableBackup = saveDataGlowingHourGlass[saveDataKey];
+            if (childTableBackup === undefined) {
+                // This should never happen.
+                continue;
+            }
+            (0, merge_1.merge)(childTable, childTableBackup, 
+            // Append an arbitrary suffix for better error messages.
+            `${subscriberName}__glowingHourGlass`, classConstructors);
+        }
+    }, constants_1.SAVE_DATA_MANAGER_DEBUG);
+}
+exports.restoreGlowingHourGlassBackup = restoreGlowingHourGlassBackup;
+function getKeysToBackup(saveData) {
+    const shouldBackupPersistentObject = saveData.persistent !== undefined &&
+        saveData.persistent.has(REWIND_WITH_GLOWING_HOUR_GLASS_KEY);
+    return shouldBackupPersistentObject
+        ? [...GLOWING_HOUR_GLASS_BACKUP_KEYS, SaveDataKey_1.SaveDataKey.PERSISTENT]
+        : GLOWING_HOUR_GLASS_BACKUP_KEYS;
+}

package/dist/classes/features/other/saveDataManager/loadFromDisk.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFromDisk = void 0;
+const jsonHelpers_1 = require("../../../../functions/jsonHelpers");
+const log_1 = require("../../../../functions/log");
+const merge_1 = require("../../../../functions/merge");
+const table_1 = require("../../../../functions/table");
+const types_1 = require("../../../../functions/types");
+const constants_1 = require("./constants");
+const DEFAULT_MOD_DATA = "{}";
+function loadFromDisk(mod, oldSaveData, classConstructors) {
+    if (!mod.HasData()) {
+        // There is no "save#.dat" file for this save slot.
+        return;
+    }
+    // First, read the "save#.dat" file into a Lua table.
+    const jsonString = readSaveDatFile(mod);
+    const newSaveData = (0, jsonHelpers_1.jsonDecode)(jsonString);
+    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
+        (0, log_1.log)('Converted data from the "save#.dat" to a Lua table.');
+    }
+    // Second, iterate over all the fields of the new table.)
+    (0, table_1.iterateTableInOrder)(newSaveData, (subscriberName, saveData) => {
+        // All elements of loaded save data should have keys that are strings equal to the name of the
+        // subscriber/feature. Ignore elements with other types of keys.
+        if (!(0, types_1.isString)(subscriberName)) {
+            return;
+        }
+        // All elements of loaded save data should be tables that contain fields corresponding to the
+        // `SaveData` interface. Ignore elements that are not tables.
+        if (!(0, types_1.isTable)(saveData)) {
+            return;
+        }
+        // Ignore elements that represent subscriptions that no longer exist in the current save data.
+        const oldSaveDataForSubscriber = oldSaveData.get(subscriberName);
+        if (oldSaveDataForSubscriber === undefined) {
+            return;
+        }
+        if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
+            (0, log_1.log)(`Merging in stored data for feature: ${subscriberName}`);
+        }
+        // We do not want to blow away the child tables of the existing map, because save data could
+        // contain out-of-date fields. Instead, merge it one field at a time in a recursive way (and
+        // convert Lua tables back to TypeScriptToLua Maps, if necessary).
+        (0, merge_1.merge)(oldSaveDataForSubscriber, saveData, subscriberName, classConstructors);
+    }, constants_1.SAVE_DATA_MANAGER_DEBUG);
+    (0, log_1.log)(`The save data manager loaded data from the "save#.dat" file for mod: ${mod.Name}`);
+}
+exports.loadFromDisk = loadFromDisk;
+function readSaveDatFile(mod) {
+    const renderFrameCount = Isaac.GetFrameCount();
+    const [ok, jsonStringOrErrMsg] = pcall(tryLoadModData, mod);
+    if (!ok) {
+        (0, log_1.logError)(`Failed to read from the "save#.dat" file on render frame ${renderFrameCount}: ${jsonStringOrErrMsg}`);
+        return DEFAULT_MOD_DATA;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (jsonStringOrErrMsg === undefined) {
+        return DEFAULT_MOD_DATA;
+    }
+    const jsonStringTrimmed = jsonStringOrErrMsg.trim();
+    if (jsonStringTrimmed === "") {
+        return DEFAULT_MOD_DATA;
+    }
+    return jsonStringTrimmed;
+}
+function tryLoadModData(mod) {
+    return mod.LoadData();
+}

package/dist/classes/features/other/saveDataManager/restoreDefaults.js

@@ -0,0 +1,69 @@
+"use strict";
+// The save data manager has a feature where certain variables are automatically restored to default
+// values at certain times.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreDefaultForFeatureKey = exports.restoreDefaultsForAllFeaturesKey = exports.restoreDefaultsForAllFeaturesAndKeys = void 0;
+const SaveDataKey_1 = require("../../../../enums/SaveDataKey");
+const SerializationType_1 = require("../../../../enums/SerializationType");
+const deepCopy_1 = require("../../../../functions/deepCopy");
+const log_1 = require("../../../../functions/log");
+const table_1 = require("../../../../functions/table");
+const ReadonlySet_1 = require("../../../../types/ReadonlySet");
+const constants_1 = require("./constants");
+const RESETTABLE_SAVE_DATA_KEYS = new ReadonlySet_1.ReadonlySet([
+    SaveDataKey_1.SaveDataKey.RUN,
+    SaveDataKey_1.SaveDataKey.LEVEL,
+    SaveDataKey_1.SaveDataKey.ROOM,
+]);
+function restoreDefaultsForAllFeaturesAndKeys(saveDataMap, saveDataDefaultsMap) {
+    for (const saveDataKey of RESETTABLE_SAVE_DATA_KEYS) {
+        restoreDefaultsForAllFeaturesKey(saveDataMap, saveDataDefaultsMap, saveDataKey);
+    }
+}
+exports.restoreDefaultsForAllFeaturesAndKeys = restoreDefaultsForAllFeaturesAndKeys;
+function restoreDefaultsForAllFeaturesKey(saveDataMap, saveDataDefaultsMap, saveDataKey) {
+    (0, table_1.iterateTableInOrder)(saveDataMap, (subscriberName, saveData) => {
+        restoreDefaultForFeatureKey(saveDataDefaultsMap, subscriberName, saveData, saveDataKey);
+    }, constants_1.SAVE_DATA_MANAGER_DEBUG);
+}
+exports.restoreDefaultsForAllFeaturesKey = restoreDefaultsForAllFeaturesKey;
+function restoreDefaultForFeatureKey(saveDataDefaultsMap, subscriberName, saveData, saveDataKey) {
+    // Only allow certain save data keys to be reset.
+    if (!RESETTABLE_SAVE_DATA_KEYS.has(saveDataKey)) {
+        error(`Failed to restore default values for a save data key of "${saveDataKey}", since it is not on the allowed list of resettable save data keys.`);
+    }
+    const childTable = saveData[saveDataKey];
+    if (childTable === undefined) {
+        // This feature does not happen to store any variables on this particular child table.
+        return;
+    }
+    // Get the default values for this feature.
+    const saveDataDefaults = saveDataDefaultsMap.get(subscriberName);
+    if (saveDataDefaults === undefined) {
+        (0, log_1.logError)(`Failed to find the default copy of the save data for subscriber: ${subscriberName}`);
+        return;
+    }
+    // Get the default values for the specific sub-table of this feature.
+    const childTableDefaults = saveDataDefaults[saveDataKey];
+    if (childTableDefaults === undefined) {
+        (0, log_1.logError)(`Failed to find the default copy of the child table "${saveDataKey}" for subscriber "${subscriberName}". This error usually means that your mod-specific save data is out of date. You can try purging all of your mod-specific save data by deleting the following directory: C:\\Program Files (x86)\\Steam\\steamapps\\common\\The Binding of Isaac Rebirth\\data`);
+        return;
+    }
+    // Make a new copy of the default child table.
+    const childTableDefaultsCopy = (0, deepCopy_1.deepCopy)(childTableDefaults, SerializationType_1.SerializationType.NONE, `${subscriberName} --> ${saveDataKey}`);
+    // We do not want to blow away the existing child table because we do not want to break any
+    // existing references. Instead, empty the table and copy all of the elements from the copy of the
+    // defaults table.
+    clearAndCopyAllElements(childTable, childTableDefaultsCopy);
+}
+exports.restoreDefaultForFeatureKey = restoreDefaultForFeatureKey;
+/**
+ * Will empty the old table of all elements, and then shallow copy all the elements from the new
+ * table to the old table.
+ */
+function clearAndCopyAllElements(oldTable, newTable) {
+    (0, table_1.clearTable)(oldTable);
+    for (const [key, value] of newTable) {
+        oldTable.set(key, value);
+    }
+}

package/dist/classes/features/other/saveDataManager/saveToDisk.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveToDisk = void 0;
+const SerializationType_1 = require("../../../../enums/SerializationType");
+const deepCopy_1 = require("../../../../functions/deepCopy");
+const jsonHelpers_1 = require("../../../../functions/jsonHelpers");
+const log_1 = require("../../../../functions/log");
+const table_1 = require("../../../../functions/table");
+const constants_1 = require("./constants");
+function saveToDisk(mod, saveDataMap, saveDataConditionalFuncMap) {
+    const allSaveData = getAllSaveDataToWriteToDisk(saveDataMap, saveDataConditionalFuncMap);
+    const jsonString = (0, jsonHelpers_1.jsonEncode)(allSaveData);
+    mod.SaveData(jsonString);
+    (0, log_1.log)(`The save data manager wrote data to the "save#.dat" file for mod: ${mod.Name}`);
+}
+exports.saveToDisk = saveToDisk;
+function getAllSaveDataToWriteToDisk(saveDataMap, saveDataConditionalFuncMap) {
+    const allSaveData = new LuaMap();
+    (0, table_1.iterateTableInOrder)(saveDataMap, (subscriberName, saveData) => {
+        // Handle the feature of the save data manager where certain mod features can conditionally
+        // write their data to disk.
+        const conditionalFunc = saveDataConditionalFuncMap.get(subscriberName);
+        if (conditionalFunc !== undefined) {
+            const shouldSave = conditionalFunc();
+            if (!shouldSave) {
+                return;
+            }
+        }
+        // Strip out the room part of the save data (and any other arbitrary fields that they might
+        // have added).
+        const saveDataWithoutRoom = {
+            persistent: saveData.persistent,
+            run: saveData.run,
+            level: saveData.level,
+        };
+        // If there is no data, then we can move on to the next feature.
+        if ((0, table_1.isTableEmpty)(saveDataWithoutRoom)) {
+            return;
+        }
+        // We need to serialize TypeScriptToLua maps and Isaac API objects such as `Color`.
+        // Recursively convert all such objects to Lua tables.
+        const saveDataCopy = (0, deepCopy_1.deepCopy)(saveDataWithoutRoom, SerializationType_1.SerializationType.SERIALIZE, subscriberName);
+        allSaveData.set(subscriberName, saveDataCopy);
+    }, constants_1.SAVE_DATA_MANAGER_DEBUG);
+    return allSaveData;
+}

package/dist/classes/private/CustomCallback.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomCallback = void 0;
+const sort_1 = require("../../functions/sort");
+const Feature_1 = require("./Feature");
+/**
+ * The base class for a custom callback. Individual custom callbacks (and validation callbacks) will
+ * extend from this class.
+ */
+class CustomCallback extends Feature_1.Feature {
+    subscriptions = [];
+    addSubscriber(priority, callbackFunc, ...optionalArgs) {
+        const subscription = {
+            priority,
+            callbackFunc,
+            optionalArgs,
+        };
+        this.subscriptions.push(subscription);
+        // Sort the subscriptions by priority so that the callbacks with the lowest priority are first.
+        // By default, the `Array.sort` method is transpiled to using Lua's sort, which is not stable.
+        // We need to do a stable sort so that we preserve the subscription order.
+        this.subscriptions = (0, sort_1.stableSort)(this.subscriptions, (0, sort_1.sortObjectArrayByKey)("priority"));
+    }
+    /**
+     * If the submitted function does not match any of the existing subscriptions, this method will do
+     * nothing.
+     */
+    removeSubscriber(callback) {
+        const subscriptionIndexMatchingCallback = this.subscriptions.findIndex((subscription) => {
+            const subscriptionCallback = subscription.callbackFunc;
+            return callback === subscriptionCallback;
+        });
+        if (subscriptionIndexMatchingCallback !== -1) {
+            this.subscriptions.splice(subscriptionIndexMatchingCallback, 1);
+        }
+    }
+    fire = (...fireArgs) => {
+        for (const subscription of this.subscriptions) {
+            const { callbackFunc, optionalArgs } = subscription;
+            if (this.shouldFire(fireArgs, optionalArgs)) {
+                // - TypeScript is not smart enough to know that the arguments match the function, so we
+                //   must cast it to `AnyFunction`.
+                // - We cannot use `...fireArgs` here because it would fail to pass any arguments that exist
+                //   beyond `nil` elements.
+                const value = callbackFunc(fireArgs[0], fireArgs[1], fireArgs[2], fireArgs[3], fireArgs[4], fireArgs[5], fireArgs[6]);
+                if (value !== undefined) {
+                    return value;
+                }
+            }
+        }
+        return undefined;
+    };
+    /**
+     * This method needs to be overwritten for any callback that has optional filtration arguments.
+     * See "shouldFire.ts" for methods tailored to specific kinds of callbacks.
+     */
+    shouldFire = () => true;
+}
+exports.CustomCallback = CustomCallback;

package/dist/classes/private/Feature.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Feature = void 0;
+/**
+ * The IsaacScript standard library contains many optional features, such as the ability to create
+ * custom pickups. All features are optional and are only initialized when needed. This class
+ * contains elements to facilitate that.
+ *
+ * Additionally, all custom callbacks extend from this class.
+ */
+class Feature {
+    /**
+     * All features should only be instantiated once and are passed around to other features using
+     * dependency injection. We provide a run-time check in order to prevent the bug of any feature
+     * accidentally being instantiated twice.
+     */
+    static constructedClassNames = new Set();
+    /** @internal */
+    initialized = false;
+    /** @internal */
+    numConsumers = 0;
+    /** @internal */
+    v;
+    /** @internal */
+    vConditionalFunc;
+    /** @internal */
+    featuresUsed;
+    /** @internal */
+    callbacksUsed;
+    /** @internal */
+    customCallbacksUsed;
+    constructor() {
+        if (Feature.constructedClassNames.has(this.constructor.name)) {
+            error(`Failed to instantiate feature class "${this.constructor.name}" because it has already been instantiated once.`);
+        }
+        Feature.constructedClassNames.add(this.constructor.name);
+    }
+}
+exports.Feature = Feature;

package/dist/core/cachedClasses.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fonts = exports.sfxManager = exports.musicManager = exports.itemConfig = exports.game = void 0;
+/**
+ * A cached version of the class returned from the `Game()` constructor.
+ *
+ * Use this instead of invoking the constructor again for a miniscule performance increase.
+ *
+ * Caching the results of this constructor is safe, but caching other classes (like `Level` or
+ * `Room`) is not safe and can lead to the game crashing in certain situations.
+ */
+exports.game = Game();
+/**
+ * A cached version of the class returned from the `Isaac.GetItemConfig()` constructor.
+ *
+ * Use this instead of invoking the constructor again for a miniscule performance increase.
+ *
+ * Caching the results of this constructor is safe, but caching other classes (like `Level` or
+ * `Room`) is not safe and can lead to the game crashing in certain situations.
+ */
+exports.itemConfig = Isaac.GetItemConfig();
+/**
+ * A cached version of the class returned from the `MusicManager()` constructor.
+ *
+ * Use this instead of invoking the constructor again for a miniscule performance increase.
+ *
+ * Caching the results of this constructor is safe, but caching other classes (like `Level` or
+ * `Room`) is not safe and can lead to the game crashing in certain situations.
+ */
+exports.musicManager = MusicManager();
+/**
+ * A cached version of the class returned from the `SFXManager()` constructor.
+ *
+ * Use this instead of invoking the constructor again for a miniscule performance increase.
+ *
+ * Caching the results of this constructor is safe, but caching other classes (like `Level` or
+ * `Room`) is not safe and can lead to the game crashing in certain situations.
+ */
+exports.sfxManager = SFXManager();
+/**
+ * An object containing all 7 vanilla fonts that are pre-loaded and ready to use.
+ *
+ * For more information on the vanilla fonts and to see what they look like, see:
+ * https://wofsauge.github.io/IsaacDocs/rep/tutorials/Tutorial-Rendertext.html
+ */
+exports.fonts = {
+    droid: Font(),
+    pfTempestaSevenCondensed: Font(),
+    teamMeatFont10: Font(),
+    teamMeatFont12: Font(),
+    teamMeatFont16Bold: Font(),
+    terminus: Font(),
+    upheaval: Font(),
+};
+exports.fonts.droid.Load("font/droid.fnt");
+exports.fonts.pfTempestaSevenCondensed.Load("font/pftempestasevencondensed.fnt");
+exports.fonts.teamMeatFont10.Load("font/teammeatfont10.fnt");
+exports.fonts.teamMeatFont12.Load("font/teammeatfont12.fnt");
+exports.fonts.teamMeatFont16Bold.Load("font/teammeatfont16bold.fnt");
+exports.fonts.terminus.Load("font/terminus.fnt");
+exports.fonts.upheaval.Load("font/upheaval.fnt");