isaacscript-common 73.1.1 → 75.0.0

package/dist/src/callbacks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"callbacks.d.ts","sourceRoot":"","sources":["../../src/callbacks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAKxC,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgKsB,CAAC;AAEzD,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,CAAC,IAAI,MAAM,OAAO,4BAA4B,GAAG,YAAY,CACrE,CAAC,OAAO,4BAA4B,CAAC,CAAC,CAAC,CAAC,CACzC;CACF,CAAC;AAEF,wBAAgB,YAAY,IAAI,wBAAwB,CASvD"}

package/dist/src/callbacks.lua

@@ -1,160 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local __TS__New = ____lualib.__TS__New
-local ____exports = {}
-local cc = require("src.callbackClasses")
-local ____ModCallbackCustom = require("src.enums.ModCallbackCustom")
-local ModCallbackCustom = ____ModCallbackCustom.ModCallbackCustom
-local ____enums = require("src.functions.enums")
-local getEnumValues = ____enums.getEnumValues
-local MOD_CALLBACK_CUSTOM_TO_CLASS = {
-    [ModCallbackCustom.ENTITY_TAKE_DMG_FILTER] = cc.EntityTakeDmgFilter,
-    [ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER] = cc.EntityTakeDmgPlayer,
-    [ModCallbackCustom.INPUT_ACTION_FILTER] = cc.InputActionFilter,
-    [ModCallbackCustom.INPUT_ACTION_PLAYER] = cc.InputActionPlayer,
-    [ModCallbackCustom.POST_AMBUSH_FINISHED] = cc.PostAmbushFinished,
-    [ModCallbackCustom.POST_AMBUSH_STARTED] = cc.PostAmbushStarted,
-    [ModCallbackCustom.POST_BOMB_EXPLODED] = cc.PostBombExploded,
-    [ModCallbackCustom.POST_BOMB_INIT_FILTER] = cc.PostBombInitFilter,
-    [ModCallbackCustom.POST_BOMB_INIT_LATE] = cc.PostBombInitLate,
-    [ModCallbackCustom.POST_BOMB_RENDER_FILTER] = cc.PostBombRenderFilter,
-    [ModCallbackCustom.POST_BOMB_UPDATE_FILTER] = cc.PostBombUpdateFilter,
-    [ModCallbackCustom.POST_BONE_SWING] = cc.PostBoneSwing,
-    [ModCallbackCustom.POST_COLLECTIBLE_EMPTY] = cc.PostCollectibleEmpty,
-    [ModCallbackCustom.POST_CURSED_TELEPORT] = cc.PostCursedTeleport,
-    [ModCallbackCustom.POST_CUSTOM_REVIVE] = cc.PostCustomRevive,
-    [ModCallbackCustom.POST_DICE_ROOM_ACTIVATED] = cc.PostDiceRoomActivated,
-    [ModCallbackCustom.POST_DOOR_RENDER] = cc.PostDoorRender,
-    [ModCallbackCustom.POST_DOOR_UPDATE] = cc.PostDoorUpdate,
-    [ModCallbackCustom.POST_EFFECT_INIT_FILTER] = cc.PostEffectInitFilter,
-    [ModCallbackCustom.POST_EFFECT_INIT_LATE] = cc.PostEffectInitLate,
-    [ModCallbackCustom.POST_EFFECT_RENDER_FILTER] = cc.PostEffectRenderFilter,
-    [ModCallbackCustom.POST_EFFECT_STATE_CHANGED] = cc.PostEffectStateChanged,
-    [ModCallbackCustom.POST_EFFECT_UPDATE_FILTER] = cc.PostEffectUpdateFilter,
-    [ModCallbackCustom.POST_ENTITY_KILL_FILTER] = cc.PostEntityKillFilter,
-    [ModCallbackCustom.POST_ESAU_JR] = cc.PostEsauJr,
-    [ModCallbackCustom.POST_FAMILIAR_INIT_FILTER] = cc.PostFamiliarInitFilter,
-    [ModCallbackCustom.POST_FAMILIAR_INIT_LATE] = cc.PostFamiliarInitLate,
-    [ModCallbackCustom.POST_FAMILIAR_RENDER_FILTER] = cc.PostFamiliarRenderFilter,
-    [ModCallbackCustom.POST_FAMILIAR_STATE_CHANGED] = cc.PostFamiliarStateChanged,
-    [ModCallbackCustom.POST_FAMILIAR_UPDATE_FILTER] = cc.PostFamiliarUpdateFilter,
-    [ModCallbackCustom.POST_FIRST_FLIP] = cc.PostFirstFlip,
-    [ModCallbackCustom.POST_FIRST_ESAU_JR] = cc.PostFirstEsauJr,
-    [ModCallbackCustom.POST_FLIP] = cc.PostFlip,
-    [ModCallbackCustom.POST_GAME_END_FILTER] = cc.PostGameEndFilter,
-    [ModCallbackCustom.POST_GAME_STARTED_REORDERED] = cc.PostGameStartedReordered,
-    [ModCallbackCustom.POST_GAME_STARTED_REORDERED_LAST] = cc.PostGameStartedReorderedLast,
-    [ModCallbackCustom.POST_GREED_MODE_WAVE] = cc.PostGreedModeWave,
-    [ModCallbackCustom.POST_GRID_ENTITY_BROKEN] = cc.PostGridEntityBroken,
-    [ModCallbackCustom.POST_GRID_ENTITY_COLLISION] = cc.PostGridEntityCollision,
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_BROKEN] = cc.PostGridEntityCustomBroken,
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_COLLISION] = cc.PostGridEntityCustomCollision,
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_INIT] = cc.PostGridEntityCustomInit,
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_REMOVE] = cc.PostGridEntityCustomRemove,
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_RENDER] = cc.PostGridEntityCustomRender,
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_STATE_CHANGED] = cc.PostGridEntityCustomStateChanged,
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_UPDATE] = cc.PostGridEntityCustomUpdate,
-    [ModCallbackCustom.POST_GRID_ENTITY_INIT] = cc.PostGridEntityInit,
-    [ModCallbackCustom.POST_GRID_ENTITY_REMOVE] = cc.PostGridEntityRemove,
-    [ModCallbackCustom.POST_GRID_ENTITY_RENDER] = cc.PostGridEntityRender,
-    [ModCallbackCustom.POST_GRID_ENTITY_STATE_CHANGED] = cc.PostGridEntityStateChanged,
-    [ModCallbackCustom.POST_GRID_ENTITY_UPDATE] = cc.PostGridEntityUpdate,
-    [ModCallbackCustom.POST_HOLY_MANTLE_REMOVED] = cc.PostHolyMantleRemoved,
-    [ModCallbackCustom.POST_ITEM_DISCHARGE] = cc.PostItemDischarge,
-    [ModCallbackCustom.POST_ITEM_PICKUP] = cc.PostItemPickup,
-    [ModCallbackCustom.POST_KEYBOARD_CHANGED] = cc.PostKeyboardPressed,
-    [ModCallbackCustom.POST_KNIFE_INIT_FILTER] = cc.PostKnifeInitFilter,
-    [ModCallbackCustom.POST_KNIFE_INIT_LATE] = cc.PostKnifeInitLate,
-    [ModCallbackCustom.POST_KNIFE_RENDER_FILTER] = cc.PostKnifeRenderFilter,
-    [ModCallbackCustom.POST_KNIFE_UPDATE_FILTER] = cc.PostKnifeUpdateFilter,
-    [ModCallbackCustom.POST_LASER_INIT_FILTER] = cc.PostLaserInitFilter,
-    [ModCallbackCustom.POST_LASER_INIT_LATE] = cc.PostLaserInitLate,
-    [ModCallbackCustom.POST_LASER_RENDER_FILTER] = cc.PostLaserRenderFilter,
-    [ModCallbackCustom.POST_LASER_UPDATE_FILTER] = cc.PostLaserUpdateFilter,
-    [ModCallbackCustom.POST_NEW_LEVEL_REORDERED] = cc.PostNewLevelReordered,
-    [ModCallbackCustom.POST_NEW_ROOM_EARLY] = cc.PostNewRoomEarly,
-    [ModCallbackCustom.POST_NEW_ROOM_REORDERED] = cc.PostNewRoomReordered,
-    [ModCallbackCustom.POST_NPC_DEATH_FILTER] = cc.PostNPCDeathFilter,
-    [ModCallbackCustom.POST_NPC_INIT_FILTER] = cc.PostNPCInitFilter,
-    [ModCallbackCustom.POST_NPC_INIT_LATE] = cc.PostNPCInitLate,
-    [ModCallbackCustom.POST_NPC_RENDER_FILTER] = cc.PostNPCRenderFilter,
-    [ModCallbackCustom.POST_NPC_STATE_CHANGED] = cc.PostNPCStateChanged,
-    [ModCallbackCustom.POST_NPC_UPDATE_FILTER] = cc.PostNPCUpdateFilter,
-    [ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED] = cc.PostPEffectUpdateReordered,
-    [ModCallbackCustom.POST_PICKUP_CHANGED] = cc.PostPickupChanged,
-    [ModCallbackCustom.POST_PICKUP_COLLECT] = cc.PostPickupCollect,
-    [ModCallbackCustom.POST_PICKUP_INIT_FILTER] = cc.PostPickupInitFilter,
-    [ModCallbackCustom.POST_PICKUP_INIT_FIRST] = cc.PostPickupInitFirst,
-    [ModCallbackCustom.POST_PICKUP_INIT_LATE] = cc.PostPickupInitLate,
-    [ModCallbackCustom.POST_PICKUP_RENDER_FILTER] = cc.PostPickupRenderFilter,
-    [ModCallbackCustom.POST_PICKUP_SELECTION_FILTER] = cc.PostPickupSelectionFilter,
-    [ModCallbackCustom.POST_PICKUP_STATE_CHANGED] = cc.PostPickupStateChanged,
-    [ModCallbackCustom.POST_PICKUP_UPDATE_FILTER] = cc.PostPickupUpdateFilter,
-    [ModCallbackCustom.POST_PIT_RENDER] = cc.PostPitRender,
-    [ModCallbackCustom.POST_PIT_UPDATE] = cc.PostPitUpdate,
-    [ModCallbackCustom.POST_PLAYER_CHANGE_HEALTH] = cc.PostPlayerChangeHealth,
-    [ModCallbackCustom.POST_PLAYER_CHANGE_STAT] = cc.PostPlayerChangeStat,
-    [ModCallbackCustom.POST_PLAYER_CHANGE_TYPE] = cc.PostPlayerChangeType,
-    [ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED] = cc.PostPlayerCollectibleAdded,
-    [ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED] = cc.PostPlayerCollectibleRemoved,
-    [ModCallbackCustom.POST_PLAYER_FATAL_DAMAGE] = cc.PostPlayerFatalDamage,
-    [ModCallbackCustom.POST_PLAYER_INIT_FIRST] = cc.PostPlayerInitFirst,
-    [ModCallbackCustom.POST_PLAYER_INIT_LATE] = cc.PostPlayerInitLate,
-    [ModCallbackCustom.POST_PLAYER_RENDER_REORDERED] = cc.PostPlayerRenderReordered,
-    [ModCallbackCustom.POST_PLAYER_UPDATE_REORDERED] = cc.PostPlayerUpdateReordered,
-    [ModCallbackCustom.POST_POOP_RENDER] = cc.PostPoopRender,
-    [ModCallbackCustom.POST_POOP_UPDATE] = cc.PostPoopUpdate,
-    [ModCallbackCustom.POST_PRESSURE_PLATE_RENDER] = cc.PostPressurePlateRender,
-    [ModCallbackCustom.POST_PRESSURE_PLATE_UPDATE] = cc.PostPressurePlateUpdate,
-    [ModCallbackCustom.POST_PROJECTILE_INIT_FILTER] = cc.PostProjectileInitFilter,
-    [ModCallbackCustom.POST_PROJECTILE_INIT_LATE] = cc.PostProjectileInitLate,
-    [ModCallbackCustom.POST_PROJECTILE_KILL] = cc.PostProjectileKill,
-    [ModCallbackCustom.POST_PROJECTILE_RENDER_FILTER] = cc.PostProjectileRenderFilter,
-    [ModCallbackCustom.POST_PROJECTILE_UPDATE_FILTER] = cc.PostProjectileUpdateFilter,
-    [ModCallbackCustom.POST_PURCHASE] = cc.PostPurchase,
-    [ModCallbackCustom.POST_ROCK_RENDER] = cc.PostRockRender,
-    [ModCallbackCustom.POST_ROCK_UPDATE] = cc.PostRockUpdate,
-    [ModCallbackCustom.POST_ROOM_CLEAR_CHANGED] = cc.PostRoomClearChanged,
-    [ModCallbackCustom.POST_SACRIFICE] = cc.PostSacrifice,
-    [ModCallbackCustom.POST_SLOT_ANIMATION_CHANGED] = cc.PostSlotAnimationChanged,
-    [ModCallbackCustom.POST_SLOT_COLLISION] = cc.PostSlotCollision,
-    [ModCallbackCustom.POST_SLOT_DESTROYED] = cc.PostSlotDestroyed,
-    [ModCallbackCustom.POST_SLOT_INIT] = cc.PostSlotInit,
-    [ModCallbackCustom.POST_SLOT_RENDER] = cc.PostSlotRender,
-    [ModCallbackCustom.POST_SLOT_UPDATE] = cc.PostSlotUpdate,
-    [ModCallbackCustom.POST_SPIKES_RENDER] = cc.PostSpikesRender,
-    [ModCallbackCustom.POST_SPIKES_UPDATE] = cc.PostSpikesUpdate,
-    [ModCallbackCustom.POST_TEAR_INIT_FILTER] = cc.PostTearInitFilter,
-    [ModCallbackCustom.POST_TEAR_INIT_LATE] = cc.PostTearInitLate,
-    [ModCallbackCustom.POST_TEAR_INIT_VERY_LATE] = cc.PostTearInitVeryLate,
-    [ModCallbackCustom.POST_TEAR_KILL] = cc.PostTearKill,
-    [ModCallbackCustom.POST_TEAR_RENDER_FILTER] = cc.PostTearRenderFilter,
-    [ModCallbackCustom.POST_TEAR_UPDATE_FILTER] = cc.PostTearUpdateFilter,
-    [ModCallbackCustom.POST_TNT_RENDER] = cc.PostTNTRender,
-    [ModCallbackCustom.POST_TNT_UPDATE] = cc.PostTNTUpdate,
-    [ModCallbackCustom.POST_TRANSFORMATION] = cc.PostTransformation,
-    [ModCallbackCustom.POST_TRINKET_BREAK] = cc.PostTrinketBreak,
-    [ModCallbackCustom.POST_USE_PILL_FILTER] = cc.PostUsePillFilter,
-    [ModCallbackCustom.PRE_BERSERK_DEATH] = cc.PreBerserkDeath,
-    [ModCallbackCustom.PRE_BOMB_COLLISION_FILTER] = cc.PreBombCollisionFilter,
-    [ModCallbackCustom.PRE_CUSTOM_REVIVE] = cc.PreCustomRevive,
-    [ModCallbackCustom.PRE_ENTITY_SPAWN_FILTER] = cc.PreEntitySpawnFilter,
-    [ModCallbackCustom.PRE_FAMILIAR_COLLISION_FILTER] = cc.PreFamiliarCollisionFilter,
-    [ModCallbackCustom.PRE_GET_PEDESTAL] = cc.PreGetPedestal,
-    [ModCallbackCustom.PRE_ITEM_PICKUP] = cc.PreItemPickup,
-    [ModCallbackCustom.PRE_KNIFE_COLLISION_FILTER] = cc.PreKnifeCollisionFilter,
-    [ModCallbackCustom.PRE_NEW_LEVEL] = cc.PreNewLevel,
-    [ModCallbackCustom.PRE_NPC_COLLISION_FILTER] = cc.PreNPCCollisionFilter,
-    [ModCallbackCustom.PRE_NPC_UPDATE_FILTER] = cc.PreNPCUpdateFilter,
-    [ModCallbackCustom.PRE_PROJECTILE_COLLISION_FILTER] = cc.PreProjectileCollisionFilter,
-    [ModCallbackCustom.PRE_ROOM_ENTITY_SPAWN_FILTER] = cc.PreRoomEntitySpawnFilter,
-    [ModCallbackCustom.PRE_TEAR_COLLISION_FILTER] = cc.PreTearCollisionFilter
-}
-function ____exports.getCallbacks(self)
-    local instantiatedClasses = {}
-    for ____, modCallbackCustom in ipairs(getEnumValues(nil, ModCallbackCustom)) do
-        local constructor = MOD_CALLBACK_CUSTOM_TO_CLASS[modCallbackCustom]
-        instantiatedClasses[modCallbackCustom] = __TS__New(constructor)
-    end
-    return instantiatedClasses
-end
-return ____exports

package/dist/src/classes/DefaultMap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DefaultMap.d.ts","sourceRoot":"","sources":["../../../src/classes/DefaultMap.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,qBAAa,UAAU,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,SAAS,OAAO,EAAE,GAAG,EAAE,CAAE,SAAQ,GAAG,CAC1E,GAAG,EACH,KAAK,CACN;IACC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;IACjD,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAEtB;IAEd;;;OAGG;gBAED,6BAA6B,EAAE,KAAK,GAAG,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC,EACnE,gBAAgB,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAqB3C;;;;;OAKG;IACI,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK;IAWvD;;;OAGG;IACI,eAAe,CAAC,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK;IAY5C;;;OAGG;IACI,iBAAiB,IAAI,KAAK,GAAG,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC;CAWjE;AAGD;;;GAGG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,IAAI,SAAS,OAAO,EAAE,IAAI,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,CAAC,CAAC"}

package/dist/src/classes/DefaultMap.lua

@@ -1,170 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local __TS__Class = ____lualib.__TS__Class
-local Map = ____lualib.Map
-local __TS__ClassExtends = ____lualib.__TS__ClassExtends
-local __TS__TypeOf = ____lualib.__TS__TypeOf
-local __TS__New = ____lualib.__TS__New
-local ____exports = {}
-local ____types = require("src.functions.types")
-local isFunction = ____types.isFunction
-local isPrimitive = ____types.isPrimitive
---- `DefaultMap` is a data structure that makes working with default values easier. It extends a
--- `Map` and adds additional methods.
--- 
--- It is a common pattern to look up a value in a `Map`, and then, if the value does not exist, set
--- a default value for the key, and then return the default value. `DefaultMap` abstracts this
--- operation away by providing the `getAndSetDefault` method.
--- 
--- Using a `DefaultMap` is nice because it makes code more declarative, since you specify what the
--- default value is alongside the types of the keys/values.
--- 
--- When instantiating a new `DefaultMap`, you must specify default value as the first argument. (The
--- default value is the initial value that will be assigned to every new entry in the
--- `getAndSetDefault` method.) For example:
--- 
--- ```ts
--- // Initializes a new empty DefaultMap with a default value of "foo".
--- const defaultMapWithString = new DefaultMap<string, string>("foo");
--- 
--- const value = defaultMapWithString.getAndSetDefault("bar");
--- // value is now "foo" and an entry for "bar" is now set.
--- ```
--- 
--- Sometimes, instead of having a static initial value for every entry in the map, you will want a
--- dynamic initial value that is contingent upon the key or some other variable. In these cases, you
--- can instead specify that the `DefaultMap` should run a function that will return the initial
--- value. (This is referred to as a "factory function".) For example:
--- 
--- ```ts
--- // Initializes a new empty DefaultMap with a default value based on "someGlobalVariable".
--- const factoryFunction = () => someGlobalVariable ? 0 : 1;
--- const defaultMapWithFactoryFunction = new DefaultMap<string, string>(factoryFunction);
--- ```
--- 
--- Note that in TypeScript and Lua, booleans, numbers, and strings are "passed by value". This means
--- that when the `DefaultMap` creates a new entry, if the default value is one of these 3 types, the
--- values will be copied. On the other hand, arrays and maps and other complex data structures are
--- "passed by reference". This means that when the `DefaultMap` creates a new entry, if the default
--- value is an array, then it would not be copied. Instead, the same shared array would be assigned
--- to every entry. Thus, to solve this problem, any variable that is passed by reference must be
--- created using a factory function to ensure that each copy is unique. For example:
--- 
--- ```ts
--- // Initializes a new empty DefaultMap with a default value of a new empty array.
--- const factoryFunction = () => [];
--- const defaultMapWithArray = new DefaultMap<string, string[]>(factoryFunction);
--- ```
--- 
--- In the previous two examples, the factory functions did not have any arguments. But you can also
--- specify a factory function that takes one or more arguments:
--- 
--- ```ts
--- const factoryFunction = (arg: boolean) => arg ? 0 : 1;
--- const defaultMapWithArg = new DefaultMap<string, string, [arg: boolean]>(factoryFunction);
--- ```
--- 
--- Similar to a normal `Map`, you can also include an initializer list in the constructor as the
--- second argument:
--- 
--- ```ts
--- // Initializes a DefaultMap with a default value of "foo" and some initial values.
--- const defaultMapWithInitialValues = new DefaultMap<string, string>("foo", [
---   ["a1", "a2"],
---   ["b1", "b2"],
--- ], );
--- ```
--- 
--- Finally, note that `DefaultMap` has the following additional utility methods:
--- 
--- - `getAndSetDefault` - The method that is called inside the overridden `get` method. In most
---   cases, you can use the overridden `get` method instead of calling this function directly.
---   However, if a factory function was provided during instantiation, and the factory function has
---   one or more arguments, then you must call this method instead (and provide the corresponding
---   arguments).
--- - `getDefaultValue` - Returns the default value to be used for a new key. (If a factory function
---   was provided during instantiation, this will execute the factory function.)
--- - `getConstructorArg` - Helper method for cloning the map. Returns either the default value or
---   the reference to the factory function.
-____exports.DefaultMap = __TS__Class()
-local DefaultMap = ____exports.DefaultMap
-DefaultMap.name = "DefaultMap"
-__TS__ClassExtends(DefaultMap, Map)
-function DefaultMap.prototype.____constructor(self, defaultValueOrFactoryFunction, initializerArray)
-    local argIsPrimitive = isPrimitive(nil, defaultValueOrFactoryFunction)
-    local argIsFunction = isFunction(nil, defaultValueOrFactoryFunction)
-    if not argIsPrimitive and not argIsFunction then
-        error(("Failed to instantiate a DefaultMap since the provided default value was of type \"" .. __TS__TypeOf(defaultValueOrFactoryFunction)) .. "\". This error usually means that you are trying to use an array (or some other non-primitive data structure that is passed by reference) as the default value. Instead, return the data structure in a factory function, like \"() => []\". See the DefaultMap documentation for more details.")
-    end
-    Map.prototype.____constructor(self, initializerArray)
-    if argIsFunction then
-        self.defaultValue = nil
-        self.defaultValueFactory = defaultValueOrFactoryFunction
-    else
-        self.defaultValue = defaultValueOrFactoryFunction
-        self.defaultValueFactory = nil
-    end
-end
-function DefaultMap.prototype.getAndSetDefault(self, key, ...)
-    local value = Map.prototype.get(self, key)
-    if value ~= nil then
-        return value
-    end
-    local defaultValue = self:getDefaultValue(...)
-    self:set(key, defaultValue)
-    return defaultValue
-end
-function DefaultMap.prototype.getDefaultValue(self, ...)
-    if self.defaultValue ~= nil then
-        return self.defaultValue
-    end
-    if self.defaultValueFactory ~= nil then
-        return self:defaultValueFactory(...)
-    end
-    error("A DefaultMap was incorrectly instantiated.")
-end
-function DefaultMap.prototype.getConstructorArg(self)
-    if self.defaultValue ~= nil then
-        return self.defaultValue
-    end
-    if self.defaultValueFactory ~= nil then
-        return self.defaultValueFactory
-    end
-    error("A DefaultMap was incorrectly instantiated.")
-end
-local function test(self)
-    local myDefaultMapBoolean = __TS__New(____exports.DefaultMap, false)
-    local myDefaultMapBooleanFactory = __TS__New(
-        ____exports.DefaultMap,
-        function() return false end
-    )
-    local myDefaultMapBooleanWithoutParams = __TS__New(____exports.DefaultMap, false)
-    local myDefaultMapNumber = __TS__New(____exports.DefaultMap, 123)
-    local myDefaultMapNumberFactory = __TS__New(
-        ____exports.DefaultMap,
-        function() return 123 end
-    )
-    local myDefaultMapNumberWithoutParams = __TS__New(____exports.DefaultMap, 123)
-    local myDefaultMapString = __TS__New(____exports.DefaultMap, "foo")
-    local myDefaultMapStringFactory = __TS__New(
-        ____exports.DefaultMap,
-        function() return "foo" end
-    )
-    local myDefaultMapStringWithoutParams = __TS__New(____exports.DefaultMap, "foo")
-    local myDefaultMapArray = __TS__New(
-        ____exports.DefaultMap,
-        function() return {} end
-    )
-    local myDefaultMapArrayWithoutParams = __TS__New(
-        ____exports.DefaultMap,
-        function() return {} end
-    )
-    local myDefaultMapMap = __TS__New(
-        ____exports.DefaultMap,
-        function() return __TS__New(Map) end
-    )
-    local myDefaultMapMapWithoutParams = __TS__New(
-        ____exports.DefaultMap,
-        function() return __TS__New(Map) end
-    )
-end
-return ____exports

package/dist/src/classes/ModFeature.d.ts

@@ -1,79 +0,0 @@
-import type { ModCallback } from "isaac-typescript-definitions";
-import type { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import type { ModUpgraded } from "./ModUpgraded";
-export declare const MOD_FEATURE_CALLBACKS_KEY = "__callbacks";
-export declare const MOD_FEATURE_CUSTOM_CALLBACKS_KEY = "__customCallbacks";
-/**
- * Helper class for mods that want to represent their individual features as classes. Extend your
- * mod features from this class in order to enable the `@Callback` and `@CustomCallback` decorators
- * that automatically subscribe to callbacks.
- *
- * It is recommended that you use the `initModFeatures` helper function to instantiate all of your
- * mod classes (instead of instantiating them yourself). This is so that any attached `v` objects
- * are properly registered with the save data manager; see below.
- *
- * If you are manually instantiating a mod feature yourself, then:
- *
- * - You must pass your upgraded mod as the first argument to the constructor.
- * - In almost all cases, you will want the callback functions to be immediately subscribed after
- *   instantiating the class. However, if this is not the case, you can pass `false` as the optional
- *   second argument to the constructor.
- *
- * If your mod feature has a property called `v`, it will be assumed that these are variables that
- * should be managed by the save data manager. Unfortunately, due to technical limitations with
- * classes, this registration will only occur if you initialize the class with the `initModFeatures`
- * helper function. (This is because the parent class does not have access to the child's properties
- * upon first construction.)
- */
-export declare class ModFeature {
-    private readonly mod;
-    /**
-     * An optional method that allows for conditional callback execution. If specified, any class
-     * method that is annotated with a `@Callback` or `@CallbackCustom` decorator will only be fired
-     * if the executed conditional function returns true.
-     *
-     * This property is used to easily turn entire mod features on and off (rather than repeating
-     * conditional logic and early returning at the beginning of every callback function).
-     *
-     * Since the specific information for the firing callback is passed as arguments into the
-     * conditional method, you can also write logic that would only apply to a specific type of
-     * callback.
-     *
-     * By default, this is set to null, which means that all callback methods will fire
-     * unconditionally. Override this property in your class if you need to use it.
-     *
-     * The function has the following signature:
-     *
-     * ```ts
-     * <T extends boolean>(
-     *   vanilla: T, // Whether this is a vanilla or custom callback.
-     *   modCallback: T extends true ? ModCallback : ModCallbackCustom,
-     *   ...callbackArgs: unknown[] // This would be e.g. `pickup: EntityPickup` for the `POST_PICKUP_INIT` callback.
-     * ) => boolean;
-     * ```
-     */
-    protected shouldCallbackMethodsFire: (<T extends boolean>(vanilla: T, modCallback: T extends true ? ModCallback : ModCallbackCustom, ...callbackArgs: unknown[]) => boolean) | null;
-    /**
-     * Whether the feature has registered its callbacks yet.
-     *
-     * This will almost always be equal to true unless you explicitly passed `false` to the second
-     * argument of the constructor.
-     */
-    initialized: boolean;
-    constructor(mod: ModUpgraded, init?: boolean);
-    /**
-     * Runs the `Mod.AddCallback` and `ModUpgraded.AddCallbackCustom` methods for all of the decorated
-     * callbacks.
-     *
-     * @param init Optional. Whether to initialize or uninitialize. Default is true.
-     */
-    init(init?: boolean): void;
-    /**
-     * Runs the `Mod.RemoveCallback` and `ModUpgraded.RemoveCallbackCustom` methods for all of the
-     * decorated callbacks.
-     *
-     * This is just an alias for `ModFeature.init(false)`.
-     */
-    uninit(): void;
-}
-//# sourceMappingURL=ModFeature.d.ts.map

package/dist/src/classes/ModFeature.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ModFeature.d.ts","sourceRoot":"","sources":["../../../src/classes/ModFeature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAUpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,eAAO,MAAM,yBAAyB,gBAAgB,CAAC;AACvD,eAAO,MAAM,gCAAgC,sBAAsB,CAAC;AAyBpE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAc;IAElC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SAAS,CAAC,yBAAyB,EAC/B,CAAC,CAAC,CAAC,SAAS,OAAO,EACjB,OAAO,EAAE,CAAC,EACV,WAAW,EAAE,CAAC,SAAS,IAAI,GAAG,WAAW,GAAG,iBAAiB,EAC7D,GAAG,YAAY,EAAE,OAAO,EAAE,KACvB,OAAO,CAAC,GACb,IAAI,CAAQ;IAEhB;;;;;OAKG;IACI,WAAW,UAAS;gBAEf,GAAG,EAAE,WAAW,EAAE,IAAI,UAAO;IAQzC;;;;;OAKG;IACI,IAAI,CAAC,IAAI,UAAO,GAAG,IAAI;IAuB9B;;;;;OAKG;IACI,MAAM,IAAI,IAAI;CAGtB"}

package/dist/src/classes/ModFeature.lua

@@ -1,229 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local __TS__Class = ____lualib.__TS__Class
-local Map = ____lualib.Map
-local __TS__New = ____lualib.__TS__New
-local ____exports = {}
-local initDecoratedCallbacks, addCallback, removeCallback, initSaveDataManager, WRAPPED_CALLBACK_METHODS_KEY, WRAPPED_CUSTOM_CALLBACK_METHODS_KEY
-local ____array = require("src.functions.array")
-local isArray = ____array.isArray
-local ____tstlClass = require("src.functions.tstlClass")
-local getTSTLClassConstructor = ____tstlClass.getTSTLClassConstructor
-local getTSTLClassName = ____tstlClass.getTSTLClassName
-local ____types = require("src.functions.types")
-local isFunction = ____types.isFunction
-local isInteger = ____types.isInteger
-local isTable = ____types.isTable
-local ____utils = require("src.functions.utils")
-local assertDefined = ____utils.assertDefined
-function initDecoratedCallbacks(self, modFeature, constructor, tstlClassName, vanilla, init)
-    local modFeatureConstructor = constructor
-    local callbackTuplesKey = vanilla and ____exports.MOD_FEATURE_CALLBACKS_KEY or ____exports.MOD_FEATURE_CUSTOM_CALLBACKS_KEY
-    local callbackTuples = modFeatureConstructor[callbackTuplesKey]
-    if callbackTuples == nil then
-        return
-    end
-    if not isArray(nil, callbackTuples) then
-        error((("Failed to initialize/uninitialize the decorated callbacks on a mod feature since the callback arguments on the key of \"" .. callbackTuplesKey) .. "\" was not an array and was instead of type: ") .. type(callbackTuples))
-    end
-    for ____, callbackTuple in ipairs(callbackTuples) do
-        if not isArray(nil, callbackTuple) then
-            error((("Failed to initialize/uninitialize the decorated callbacks on a mod feature since one of the callback arguments on the key of \"" .. callbackTuplesKey) .. "\" was not an array and was instead of type: ") .. type(callbackTuple))
-        end
-        local modCallback = callbackTuple[1]
-        if not isInteger(nil, modCallback) then
-            error("Failed to get the callback number from the callback tuple for class: " .. tstlClassName)
-        end
-        local priority = callbackTuple[2]
-        if not isInteger(nil, priority) then
-            error("Failed to get the callback priority from the callback tuple for class: " .. tstlClassName)
-        end
-        local callback = callbackTuple[3]
-        if not isFunction(nil, callback) then
-            error("Failed to get the callback function from the callback tuple for class: " .. tstlClassName)
-        end
-        local parameters = callbackTuple[4]
-        if not isArray(nil, parameters, false) then
-            error("Failed to get the callback parameters from the callback tuple for class: " .. tstlClassName)
-        end
-        local mod = modFeature.mod
-        if init then
-            addCallback(
-                nil,
-                modFeature,
-                modFeatureConstructor,
-                mod,
-                modCallback,
-                priority,
-                callback,
-                parameters,
-                vanilla
-            )
-        else
-            removeCallback(
-                nil,
-                modFeatureConstructor,
-                mod,
-                modCallback,
-                vanilla
-            )
-        end
-    end
-end
-function addCallback(self, modFeature, modFeatureConstructor, mod, modCallback, priority, callback, parameters, vanilla)
-    local function wrappedCallback(____, ...)
-        local conditionalFunc = modFeature.shouldCallbackMethodsFire
-        if conditionalFunc ~= nil then
-            local shouldRun = conditionalFunc(nil, vanilla, modCallback, ...)
-            if not shouldRun then
-                return nil
-            end
-        end
-        local castedCallback = callback
-        return castedCallback(modFeature, ...)
-    end
-    if vanilla then
-        local modCallbackVanilla = modCallback
-        local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY]
-        if wrappedMethodsMap == nil then
-            wrappedMethodsMap = __TS__New(Map)
-            modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY] = wrappedMethodsMap
-        end
-        wrappedMethodsMap:set(modCallbackVanilla, wrappedCallback)
-    else
-        local modCallbackCustom = modCallback
-        local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY]
-        if wrappedMethodsMap == nil then
-            wrappedMethodsMap = __TS__New(Map)
-            modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY] = wrappedMethodsMap
-        end
-        wrappedMethodsMap:set(modCallbackCustom, wrappedCallback)
-    end
-    if vanilla then
-        mod:AddPriorityCallback(
-            modCallback,
-            priority,
-            wrappedCallback,
-            table.unpack(parameters)
-        )
-    else
-        mod:AddPriorityCallbackCustom(
-            modCallback,
-            priority,
-            wrappedCallback,
-            table.unpack(parameters)
-        )
-    end
-end
-function removeCallback(self, modFeatureConstructor, mod, modCallback, vanilla)
-    if vanilla then
-        local modCallbackVanilla = modCallback
-        local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY]
-        if wrappedMethodsMap == nil then
-            return
-        end
-        local wrappedCallback = wrappedMethodsMap:get(modCallbackVanilla)
-        mod:RemoveCallback(modCallback, wrappedCallback)
-    else
-        local modCallbackCustom = modCallback
-        local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY]
-        if wrappedMethodsMap == nil then
-            return
-        end
-        local wrappedCallback = wrappedMethodsMap:get(modCallbackCustom)
-        mod:RemoveCallbackCustom(modCallback, wrappedCallback)
-    end
-end
-function initSaveDataManager(self, modFeature, tstlClassName, init)
-    local ____modFeature_0 = modFeature
-    local v = ____modFeature_0.v
-    if v == nil then
-        return
-    end
-    if not isTable(nil, v) then
-        error("Failed to initialize a mod feature class due to having a \"v\" property that is not an object. (The \"v\" property is supposed to be an object that holds the variables for the class, managed by the save data manager.)")
-    end
-    local mod = modFeature.mod
-    local saveDataManagerMethodName = init and "saveDataManager" or "saveDataManagerRemove"
-    local saveDataManagerMethod = mod[saveDataManagerMethodName]
-    assertDefined(nil, saveDataManagerMethod, "Failed to initialize a mod feature class due to having a \"v\" object and not having the save data manager initialized. You must pass \"ISCFeature.SAVE_DATA_MANAGER\" to the \"upgradeMod\" function.")
-    if type(saveDataManagerMethod) ~= "function" then
-        error(("The \"" .. saveDataManagerMethodName) .. "\" property of the \"ModUpgraded\" object was not a function.")
-    end
-    if init then
-        saveDataManagerMethod(nil, tstlClassName, v)
-    else
-        saveDataManagerMethod(nil, tstlClassName)
-    end
-end
-____exports.MOD_FEATURE_CALLBACKS_KEY = "__callbacks"
-____exports.MOD_FEATURE_CUSTOM_CALLBACKS_KEY = "__customCallbacks"
-WRAPPED_CALLBACK_METHODS_KEY = "__wrappedCallbackMethods"
-WRAPPED_CUSTOM_CALLBACK_METHODS_KEY = "__wrappedCustomCallbacksMethods"
---- Helper class for mods that want to represent their individual features as classes. Extend your
--- mod features from this class in order to enable the `@Callback` and `@CustomCallback` decorators
--- that automatically subscribe to callbacks.
--- 
--- It is recommended that you use the `initModFeatures` helper function to instantiate all of your
--- mod classes (instead of instantiating them yourself). This is so that any attached `v` objects
--- are properly registered with the save data manager; see below.
--- 
--- If you are manually instantiating a mod feature yourself, then:
--- 
--- - You must pass your upgraded mod as the first argument to the constructor.
--- - In almost all cases, you will want the callback functions to be immediately subscribed after
---   instantiating the class. However, if this is not the case, you can pass `false` as the optional
---   second argument to the constructor.
--- 
--- If your mod feature has a property called `v`, it will be assumed that these are variables that
--- should be managed by the save data manager. Unfortunately, due to technical limitations with
--- classes, this registration will only occur if you initialize the class with the `initModFeatures`
--- helper function. (This is because the parent class does not have access to the child's properties
--- upon first construction.)
-____exports.ModFeature = __TS__Class()
-local ModFeature = ____exports.ModFeature
-ModFeature.name = "ModFeature"
-function ModFeature.prototype.____constructor(self, mod, init)
-    if init == nil then
-        init = true
-    end
-    self.shouldCallbackMethodsFire = nil
-    self.initialized = false
-    self.mod = mod
-    if init then
-        self:init()
-    end
-end
-function ModFeature.prototype.init(self, init)
-    if init == nil then
-        init = true
-    end
-    if self.initialized == init then
-        return
-    end
-    self.initialized = init
-    local constructor = getTSTLClassConstructor(nil, self)
-    assertDefined(nil, constructor, "Failed to get the TSTL class constructor for a mod feature.")
-    local tstlClassName = getTSTLClassName(nil, self)
-    assertDefined(nil, tstlClassName, "Failed to get the TSTL class name for a mod feature.")
-    initDecoratedCallbacks(
-        nil,
-        self,
-        constructor,
-        tstlClassName,
-        true,
-        init
-    )
-    initDecoratedCallbacks(
-        nil,
-        self,
-        constructor,
-        tstlClassName,
-        false,
-        init
-    )
-    initSaveDataManager(nil, self, tstlClassName, init)
-end
-function ModFeature.prototype.uninit(self)
-    self:init(false)
-end
-return ____exports