isaacscript-common 9.18.4 → 9.19.2

package/dist/core/constantsFirstLast.lua

@@ -1,66 +0,0 @@
-local ____exports = {}
-local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
-local CardType = ____isaac_2Dtypescript_2Ddefinitions.CardType
-local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
-local LevelStage = ____isaac_2Dtypescript_2Ddefinitions.LevelStage
-local PillColor = ____isaac_2Dtypescript_2Ddefinitions.PillColor
-local PillEffect = ____isaac_2Dtypescript_2Ddefinitions.PillEffect
-local PlayerType = ____isaac_2Dtypescript_2Ddefinitions.PlayerType
-local RoomType = ____isaac_2Dtypescript_2Ddefinitions.RoomType
-local TrinketType = ____isaac_2Dtypescript_2Ddefinitions.TrinketType
-local ____enums = require("functions.enums")
-local getEnumLength = ____enums.getEnumLength
-local getLastEnumValue = ____enums.getLastEnumValue
---- Equal to `CollectibleType.SAD_ONION`.
-____exports.FIRST_COLLECTIBLE_TYPE = CollectibleType.SAD_ONION
---- Calculated from the `CollectibleType` enum.
--- 
--- Note that this cannot be calculated from the length of the enum, because unlike all of the other
--- enums, collectible types are not contiguous.
-____exports.LAST_VANILLA_COLLECTIBLE_TYPE = getLastEnumValue(nil, CollectibleType)
---- Calculated from the `CollectibleType` enum. (`CollectibleType.NULL` is not included.)
-____exports.NUM_VANILLA_COLLECTIBLE_TYPES = getEnumLength(nil, CollectibleType) - 1
---- Equal to `TrinketType.SWALLOWED_PENNY`.
-____exports.FIRST_TRINKET_TYPE = TrinketType.SWALLOWED_PENNY
---- Calculated from the `TrinketType` enum.
-____exports.LAST_VANILLA_TRINKET_TYPE = getLastEnumValue(nil, TrinketType)
---- Calculated from the `TrinketType` enum. (`TrinketType.NULL` is not included.)
-____exports.NUM_VANILLA_TRINKET_TYPES = getEnumLength(nil, TrinketType) - 1
---- Equal to `Card.FOOL`.
-____exports.FIRST_CARD_TYPE = CardType.FOOL
---- Calculated from the `Card` enum.
-____exports.LAST_VANILLA_CARD_TYPE = getLastEnumValue(nil, CardType)
---- Calculated from the `Card` enum. `Card.NULL` is not included.
-____exports.NUM_VANILLA_CARD_TYPES = getEnumLength(nil, CardType) - 1
---- Equal to `PillEffect.BAD_GAS`.
-____exports.FIRST_PILL_EFFECT = PillEffect.BAD_GAS
---- Calculated from the `PillEffect` enum.
-____exports.LAST_VANILLA_PILL_EFFECT = getLastEnumValue(nil, PillEffect)
---- Calculated from the `PillEffect` enum.
--- 
--- (There is no `PillEffect.NULL` in the custom enum, so we do not have to subtract one here.)
-____exports.NUM_VANILLA_PILL_EFFECTS = getEnumLength(nil, PillEffect)
---- Equal to `PillColor.BLUE_BLUE`.
-____exports.FIRST_PILL_COLOR = PillColor.BLUE_BLUE
---- Equal to `PillColor.WHITE_YELLOW`.
--- 
--- Note that `PillColor.GOLD` is technically higher, but that is not considered for the purposes of
--- this constant.
-____exports.LAST_NORMAL_PILL_COLOR = PillColor.WHITE_YELLOW
---- Equal to `PillColor.HORSE_BLUE_BLUE`.
-____exports.FIRST_HORSE_PILL_COLOR = PillColor.HORSE_BLUE_BLUE
---- Equal to `PillColor.HORSE_WHITE_YELLOW`.
--- 
--- Note that `PillColor.HORSE_GOLD` is technically higher, but that is not considered for the
--- purposes of this constant.
-____exports.LAST_HORSE_PILL_COLOR = PillColor.HORSE_WHITE_YELLOW
-____exports.NUM_NORMAL_PILL_COLORS = ____exports.LAST_NORMAL_PILL_COLOR - ____exports.FIRST_PILL_COLOR
---- Equal to `PlayerType.ISAAC`.
-____exports.FIRST_CHARACTER = PlayerType.ISAAC
---- Calculated from the `PlayerType` enum.
-____exports.LAST_VANILLA_CHARACTER = getLastEnumValue(nil, PlayerType)
-____exports.FIRST_ROOM_TYPE = RoomType.DEFAULT
-____exports.LAST_ROOM_TYPE = getLastEnumValue(nil, RoomType)
-____exports.FIRST_STAGE = LevelStage.BASEMENT_1
-____exports.LAST_STAGE = getLastEnumValue(nil, LevelStage)
-return ____exports

package/dist/core/upgradeMod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"upgradeMod.d.ts","sourceRoot":"","sources":["../../src/core/upgradeMod.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAWrD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,GAAG,GAAG,WAAW,CAwBvD"}

package/dist/core/upgradeMod.lua

@@ -1,52 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local __TS__New = ____lualib.__TS__New
-local ____exports = {}
-local ____postNewRoomEarly = require("callbacks.postNewRoomEarly")
-local postNewRoomEarlyCallbackInit = ____postNewRoomEarly.postNewRoomEarlyCallbackInit
-local ____ModUpgraded = require("classes.ModUpgraded")
-local ModUpgraded = ____ModUpgraded.ModUpgraded
-local ____main = require("features.saveDataManager.main")
-local saveDataManagerInit = ____main.saveDataManagerInit
-local ____featuresInitialized = require("featuresInitialized")
-local areFeaturesInitialized = ____featuresInitialized.areFeaturesInitialized
-local setFeaturesInitialized = ____featuresInitialized.setFeaturesInitialized
-local ____initCustomCallbacks = require("initCustomCallbacks")
-local initCustomCallbacks = ____initCustomCallbacks.initCustomCallbacks
-local ____initFeatures = require("initFeatures")
-local initFeatures = ____initFeatures.initFeatures
-local ____patchErrorFunctions = require("patchErrorFunctions")
-local patchErrorFunction = ____patchErrorFunctions.patchErrorFunction
-local ____shaderCrashFix = require("shaderCrashFix")
-local loadShaderCrashFix = ____shaderCrashFix.loadShaderCrashFix
---- Use this function to enable the custom callbacks and other optional features provided by
--- `isaacscript-common`.
--- 
--- For example:
--- 
--- ```ts
--- const modVanilla = RegisterMod("My Mod", 1);
--- const mod = upgradeMod(modVanilla);
--- 
--- // Subscribe to vanilla callbacks.
--- mod.AddCallback(ModCallback.POST_UPDATE, postUpdate);
--- 
--- // Subscribe to custom callbacks.
--- mod.AddCallbackCustom(ModCallbackCustom.POST_ITEM_PICKUP, postItemPickup);
--- ```
--- 
--- @param modVanilla The mod object returned by the `RegisterMod` function.
--- @returns The upgraded mod object.
-function ____exports.upgradeMod(self, modVanilla)
-    local mod = __TS__New(ModUpgraded, modVanilla)
-    if not areFeaturesInitialized(nil) then
-        setFeaturesInitialized(nil)
-        patchErrorFunction(nil)
-        loadShaderCrashFix(nil, modVanilla)
-        postNewRoomEarlyCallbackInit(nil, mod)
-        saveDataManagerInit(nil, mod)
-        initCustomCallbacks(nil, mod)
-        initFeatures(nil, mod)
-    end
-    return mod
-end
-return ____exports

package/dist/enums/AmbushType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AmbushType.d.ts","sourceRoot":"","sources":["../../src/enums/AmbushType.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,oBAAY,UAAU;IACpB,cAAc,IAAA;IACd,SAAS,IAAA;CACV"}

package/dist/enums/CornerType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CornerType.d.ts","sourceRoot":"","sources":["../../src/enums/CornerType.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,oBAAY,UAAU;IACpB,QAAQ,IAAA;IACR,SAAS,IAAA;IACT,WAAW,IAAA;IACX,YAAY,IAAA;CACb"}

package/dist/enums/HealthType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HealthType.d.ts","sourceRoot":"","sources":["../../src/enums/HealthType.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,oBAAY,UAAU;IACpB,GAAG,IAAA;IACH,IAAI,IAAA;IACJ,OAAO,IAAA;IACP,KAAK,IAAA;IACL,MAAM,IAAA;IACN,IAAI,IAAA;IACJ,MAAM,IAAA;IACN,MAAM,IAAA;IACN,UAAU,IAAA;CACX"}

package/dist/enums/ModCallbackCustom.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ModCallbackCustom.d.ts","sourceRoot":"","sources":["../../src/enums/ModCallbackCustom.ts"],"names":[],"mappings":"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"}

package/dist/enums/PocketItemType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PocketItemType.d.ts","sourceRoot":"","sources":["../../src/enums/PocketItemType.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,oBAAY,cAAc;IACxB,KAAK,IAAA;IACL,IAAI,IAAA;IACJ,IAAI,IAAA;IACJ,WAAW,IAAA;IACX,aAAa,IAAA;IACb,cAAc,IAAA;CACf"}

package/dist/enums/RockAltType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RockAltType.d.ts","sourceRoot":"","sources":["../../src/enums/RockAltType.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,oBAAY,WAAW;IACrB,GAAG,IAAA;IACH,QAAQ,IAAA;IACR,KAAK,IAAA;IACL,KAAK,IAAA;IAEL;;;;OAIG;IACH,eAAe,IAAA;IAEf;;;;OAIG;IACH,YAAY,IAAA;CACb"}

package/dist/enums/SaveDataKey.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SaveDataKey.d.ts","sourceRoot":"","sources":["../../src/enums/SaveDataKey.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,WAAW;IACrB,UAAU,eAAe;IACzB,GAAG,QAAQ;IACX,KAAK,UAAU;IACf,IAAI,SAAS;CACd"}

package/dist/enums/SerializationType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SerializationType.d.ts","sourceRoot":"","sources":["../../src/enums/SerializationType.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,oBAAY,iBAAiB;IAC3B,IAAI,IAAA;IACJ,SAAS,IAAA;IACT,WAAW,IAAA;CACZ"}

package/dist/enums/SlotDestructionType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SlotDestructionType.d.ts","sourceRoot":"","sources":["../../src/enums/SlotDestructionType.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,oBAAY,mBAAmB;IAC7B,MAAM,IAAA;IACN,kBAAkB,IAAA;CACnB"}

package/dist/enums/StatType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StatType.d.ts","sourceRoot":"","sources":["../../src/enums/StatType.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,oBAAY,QAAQ;IAClB,4EAA4E;IAC5E,MAAM,IAAA;IAEN,sFAAsF;IACtF,UAAU,IAAA;IAEV,mFAAmF;IACnF,UAAU,IAAA;IAEV,+EAA+E;IAC/E,WAAW,IAAA;IAEX,8EAA8E;IAC9E,UAAU,IAAA;IAEV,4FAA4F;IAC5F,yBAAyB,IAAA;IAEzB,qFAAqF;IACrF,kBAAkB,IAAA;IAElB,8EAA8E;IAC9E,UAAU,IAAA;IAEV,kFAAkF;IAClF,SAAS,IAAA;IAET,mFAAmF;IACnF,UAAU,IAAA;IAEV,4EAA4E;IAC5E,MAAM,KAAA;IAKN,yEAAyE;IACzE,IAAI,KAAA;IAEJ,gFAAgF;IAChF,IAAI,KAAA;CAIL"}

package/dist/enums/private/CopyableIsaacAPIClassType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CopyableIsaacAPIClassType.d.ts","sourceRoot":"","sources":["../../../src/enums/private/CopyableIsaacAPIClassType.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,yBAAyB;IACnC,WAAW,cAAc;IACzB,KAAK,UAAU;IACf,OAAO,WAAW;IAClB,GAAG,QAAQ;IACX,MAAM,WAAW;CAClB"}

package/dist/enums/private/SerializationBrand.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SerializationBrand.d.ts","sourceRoot":"","sources":["../../../src/enums/private/SerializationBrand.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,oBAAY,kBAAkB;IAE5B,WAAW,uBAAuB;IAClC,GAAG,eAAe;IAClB,GAAG,eAAe;IAGlB,WAAW,kBAAkB;IAC7B,KAAK,YAAY;IACjB,OAAO,cAAc;IACrB,GAAG,UAAU;IACb,MAAM,aAAa;IAEnB;;;OAGG;IACH,iBAAiB,6BAA6B;IAE9C;;;;;;;;;;OAUG;IACH,uBAAuB,mCAAmC;CAC3D"}

package/dist/enums/private/StageTravelState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StageTravelState.d.ts","sourceRoot":"","sources":["../../../src/enums/private/StageTravelState.ts"],"names":[],"mappings":"AAAA,oBAAY,gBAAgB;IAC1B,IAAI,IAAA;IACJ,oBAAoB,IAAA;IACpB,mBAAmB,IAAA;IACnB,mCAAmC,IAAA;IACnC,6CAA6C,IAAA;IAC7C,kBAAkB,IAAA;IAClB,mBAAmB,IAAA;CACpB"}

package/dist/enums/private/TrapdoorAnimation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TrapdoorAnimation.d.ts","sourceRoot":"","sources":["../../../src/enums/private/TrapdoorAnimation.ts"],"names":[],"mappings":"AAAA,oBAAY,iBAAiB;IAC3B,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,cAAc,mBAAmB;CAClC"}

package/dist/features/characterHealthConversion.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"characterHealthConversion.d.ts","sourceRoot":"","sources":["../../src/features/characterHealthConversion.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,YAAY,EAGZ,UAAU,EACX,MAAM,8BAA8B,CAAC;AAMtC,oBAAY,sBAAsB,GAAG,YAAY,CAAC,IAAI,GAAG,YAAY,CAAC,KAAK,CAAC;AAuF5E;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,UAAU,EACtB,sBAAsB,EAAE,sBAAsB,GAC7C,IAAI,CAUN"}

package/dist/features/characterHealthConversion.lua

@@ -1,87 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local Map = ____lualib.Map
-local __TS__New = ____lualib.__TS__New
-local ____exports = {}
-local postPEffectUpdate, convertRedHeartContainers, removeRedHearts, prePickupCollisionHeart, characterHealthReplacementMap
-local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
-local HeartSubType = ____isaac_2Dtypescript_2Ddefinitions.HeartSubType
-local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
-local PickupVariant = ____isaac_2Dtypescript_2Ddefinitions.PickupVariant
-local ____featuresInitialized = require("featuresInitialized")
-local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
-local ____pickups = require("functions.pickups")
-local isRedHeart = ____pickups.isRedHeart
-function postPEffectUpdate(self, player)
-    local character = player:GetPlayerType()
-    local conversionHeartSubType = characterHealthReplacementMap:get(character)
-    if conversionHeartSubType == nil then
-        return
-    end
-    convertRedHeartContainers(nil, player, conversionHeartSubType)
-    removeRedHearts(nil, player)
-end
-function convertRedHeartContainers(self, player, heartSubType)
-    local maxHearts = player:GetMaxHearts()
-    if maxHearts == 0 then
-        return
-    end
-    player:AddMaxHearts(maxHearts * -1, false)
-    repeat
-        local ____switch7 = heartSubType
-        local ____cond7 = ____switch7 == HeartSubType.SOUL
-        if ____cond7 then
-            do
-                player:AddSoulHearts(maxHearts)
-                break
-            end
-        end
-        ____cond7 = ____cond7 or ____switch7 == HeartSubType.BLACK
-        if ____cond7 then
-            do
-                player:AddBlackHearts(maxHearts)
-                break
-            end
-        end
-    until true
-end
-function removeRedHearts(self, player)
-    local hearts = player:GetHearts()
-    if hearts > 0 then
-        player:AddHearts(hearts * -1)
-    end
-end
-function prePickupCollisionHeart(self, pickup, collider)
-    if not isRedHeart(nil, pickup) then
-        return nil
-    end
-    local player = collider:ToPlayer()
-    if player == nil then
-        return nil
-    end
-    local character = player:GetPlayerType()
-    local conversionHeartSubType = characterHealthReplacementMap:get(character)
-    if conversionHeartSubType == nil then
-        return nil
-    end
-    return false
-end
-local FEATURE_NAME = "characterHealthConversion"
-characterHealthReplacementMap = __TS__New(Map)
----
--- @internal
-function ____exports.characterHealthConversionInit(self, mod)
-    mod:AddCallback(ModCallback.POST_PEFFECT_UPDATE, postPEffectUpdate)
-    mod:AddCallback(ModCallback.PRE_PICKUP_COLLISION, prePickupCollisionHeart, PickupVariant.HEART)
-end
---- Helper function to make a character that has the same health mechanic as Blue Baby (red heart
--- containers --> soul hearts) or Dark Judas (red heart containers --> black hearts).
--- 
--- Call this function once at the beginning of your mod to declare the health conversion type.
-function ____exports.registerCharacterHealthConversion(self, playerType, conversionHeartSubType)
-    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
-    if characterHealthReplacementMap:has(playerType) then
-        error(("Failed to register a character of type " .. tostring(playerType)) .. " because there is already an existing registered character with that type.")
-    end
-    characterHealthReplacementMap:set(playerType, conversionHeartSubType)
-end
-return ____exports

package/dist/features/characterStats.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"characterStats.d.ts","sourceRoot":"","sources":["../../src/features/characterStats.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,SAAS,EAET,UAAU,EACX,MAAM,8BAA8B,CAAC;AAgCtC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,GAAG,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,GAC/D,IAAI,CAGN"}

package/dist/features/characterStats.lua

@@ -1,53 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local Map = ____lualib.Map
-local __TS__New = ____lualib.__TS__New
-local ____exports = {}
-local evaluateCache, charactersStatMap
-local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
-local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
-local ____featuresInitialized = require("featuresInitialized")
-local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
-local ____stats = require("functions.stats")
-local addStat = ____stats.addStat
-local getDefaultPlayerStat = ____stats.getDefaultPlayerStat
-function evaluateCache(self, player, cacheFlag)
-    local character = player:GetPlayerType()
-    local statMap = charactersStatMap:get(character)
-    if statMap == nil then
-        return
-    end
-    local stat = statMap:get(cacheFlag)
-    local defaultStat = getDefaultPlayerStat(nil, cacheFlag)
-    if stat == nil or defaultStat == nil then
-        return
-    end
-    local delta = stat - defaultStat
-    addStat(nil, player, cacheFlag, delta)
-end
-local FEATURE_NAME = "characterStats"
-charactersStatMap = __TS__New(Map)
----
--- @internal
-function ____exports.characterStatsInit(self, mod)
-    mod:AddCallback(ModCallback.EVALUATE_CACHE, evaluateCache)
-end
---- Helper function to manage the stats for a vanilla or custom character. Call this function once at
--- the beginning of your mod to declare the starting stats.
--- 
--- You must provide this function with a map of CacheFlag to the default stat amount. For example,
--- the default amount of damage is 3.5. To make a custom character start with 4.5 damage:
--- 
--- ```ts
--- const fooDefaultStats = new Map<CacheFlag, number>([
---   [CacheFlag.DAMAGE, 4.5],
--- ])
--- registerCharacterStats(PlayerTypeCustom.FOO, fooDefaultStats);
--- ```
--- 
--- Note that the format for the `CacheFlag.FIRE_DELAY` value should be in the tears stat format, not
--- the `MaxFireDelay` format.
-function ____exports.registerCharacterStats(self, playerType, statMap)
-    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
-    charactersStatMap:set(playerType, statMap)
-end
-return ____exports

package/dist/features/collectibleItemPoolType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"collectibleItemPoolType.d.ts","sourceRoot":"","sources":["../../src/features/collectibleItemPoolType.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,YAAY,EAGb,MAAM,8BAA8B,CAAC;AAqCtC;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,YAAY,GACxB,YAAY,CAad"}

package/dist/features/collectibleItemPoolType.lua

@@ -1,48 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local Map = ____lualib.Map
-local __TS__New = ____lualib.__TS__New
-local ____exports = {}
-local postPickupInitCollectible, v
-local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
-local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
-local PickupVariant = ____isaac_2Dtypescript_2Ddefinitions.PickupVariant
-local ____cachedClasses = require("core.cachedClasses")
-local game = ____cachedClasses.game
-local ____featuresInitialized = require("featuresInitialized")
-local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
-local ____entities = require("functions.entities")
-local getEntityID = ____entities.getEntityID
-local ____pickupVariants = require("functions.pickupVariants")
-local isCollectible = ____pickupVariants.isCollectible
-local ____rooms = require("functions.rooms")
-local getRoomItemPoolType = ____rooms.getRoomItemPoolType
-local ____exports = require("features.saveDataManager.exports")
-local saveDataManager = ____exports.saveDataManager
-function postPickupInitCollectible(self, pickup)
-    local itemPool = game:GetItemPool()
-    local ptrHash = GetPtrHash(pickup)
-    local lastItemPoolType = itemPool:GetLastPool()
-    v.run.collectibleItemPoolTypeMap:set(ptrHash, lastItemPoolType)
-end
-local FEATURE_NAME = "collectibleItemPoolType"
-v = {run = {collectibleItemPoolTypeMap = __TS__New(Map)}}
----
--- @internal
-function ____exports.collectibleItemPoolTypeInit(self, mod)
-    saveDataManager(nil, FEATURE_NAME, v)
-    mod:AddCallback(ModCallback.POST_PICKUP_INIT, postPickupInitCollectible, PickupVariant.COLLECTIBLE)
-end
---- Helper function to get the item pool type that a given collectible came from. Since there is no
--- native method in the API to get this, we listen in the `PRE_GET_COLLECTIBLE` callback for item
--- pool types, and then assume that the next spawned collectible will match.
-function ____exports.getCollectibleItemPoolType(self, collectible)
-    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
-    if not isCollectible(nil, collectible) then
-        local entityID = getEntityID(nil, collectible)
-        error("The \"getCollectibleItemPoolType\" function was given a non-collectible: " .. entityID)
-    end
-    local ptrHash = GetPtrHash(collectible)
-    local itemPoolType = v.run.collectibleItemPoolTypeMap:get(ptrHash)
-    return itemPoolType == nil and getRoomItemPoolType(nil) or itemPoolType
-end
-return ____exports

package/dist/features/customDoor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"customDoor.d.ts","sourceRoot":"","sources":["../../src/features/customDoor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAKvE,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,WAAW,EAChB,aAAa,EAAE,aAAa,GAC3B,IAAI,CAEN;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAC7B,aAAa,EAAE,aAAa,EAC5B,QAAQ,EAAE,QAAQ,GACjB,YAAY,CAEd"}

package/dist/features/customDoor.lua

@@ -1,53 +0,0 @@
-local ____exports = {}
-local ____postCustomDoorEnter = require("callbacks.postCustomDoorEnter")
-local initCustomDoorInternal = ____postCustomDoorEnter.initCustomDoorInternal
-local spawnCustomDoorInternal = ____postCustomDoorEnter.spawnCustomDoorInternal
---- `isaacscript-common` provides custom doors that can be spawned where any wall segment is. If you
--- use this feature, you must first call this initialization function at the beginning of your mod.
--- 
--- Each kind of custom door that you create must have an entry in the "content/entities2.xml" file,
--- like so:
--- 
--- ```xml
--- <entity id="1000" name="Foo Custom Door" anm2path="grid/door_foo.anm2" />
--- ```
--- 
--- (Custom door entities must have an id of "1000", which corresponds to an effect. If you do not
--- specify the variant, then the game will automatically assign it.)
--- 
--- Next, pass the variant into this function:
--- 
--- ```ts
--- const modVanilla = RegisterMod("My Mod", 1);
--- const mod = upgradeMod(modVanilla);
--- const fooEffectVariant = Isaac.GetEntityVariantByName("Foo Custom Door");
--- initCustomDoor(mod, fooEffectVariant);
--- ```
--- 
--- Also see the `spawnCustomDoor` function.
-function ____exports.initCustomDoor(self, mod, effectVariant)
-    initCustomDoorInternal(nil, mod, effectVariant)
-end
---- Helper function to spawn a custom door. This is intended to be called from the `POST_NEW_ROOM`
--- callback when the player enters a room that should have a custom door. (You could also call it
--- from another callback if you want the door to appear e.g. after clearing all enemies.)
--- 
--- Like other entities, the door is not persistent, so you must spawn it every time when re-entering
--- the room.
--- 
--- Handle when a player enters the door by hooking the custom `POST_CUSTOM_DOOR_ENTER` callback.
--- 
--- The custom door is an `EntityEffect`. You can manually open or close the door by modifying its
--- state. (The values to use correspond to the `DoorState` enum.)
--- 
--- This function will throw a run-time error if:
--- - the door slot already has a vanilla door
--- - the door slot already has a custom door
--- - the tile at the door slot does not have a wall
--- 
--- Before using this function, you must first initialize the effect/door variant with the
--- `initCustomDoor` function.
-function ____exports.spawnCustomDoor(self, effectVariant, doorSlot)
-    return spawnCustomDoorInternal(nil, effectVariant, doorSlot)
-end
-return ____exports

package/dist/features/customGridEntity.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"customGridEntity.d.ts","sourceRoot":"","sources":["../../src/features/customGridEntity.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,kBAAkB,EAClB,cAAc,EAGf,MAAM,8BAA8B,CAAC;AAgBtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAyH1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,wBAAgB,qBAAqB,CACnC,oBAAoB,EAAE,cAAc,EACpC,mBAAmB,EAAE,GAAG,GAAG,MAAM,EACjC,kBAAkB,CAAC,EAAE,kBAAkB,EACvC,QAAQ,CAAC,EAAE,MAAM,EACjB,gBAAgB,CAAC,EAAE,MAAM,EACzB,kBAAkB,iBAA4B,EAC9C,qBAAqB,SAAI,GACxB,UAAU,CA8CZ;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,+BAA+B,EAAE,GAAG,GAAG,MAAM,GAAG,UAAU,EAC1D,UAAU,UAAO,GAChB,UAAU,GAAG,SAAS,CAuCxB;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,KAAK,CAC5C;IAAC,UAAU,EAAE,UAAU;IAAE,IAAI,EAAE,oBAAoB;CAAC,CACrD,CAqBA;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,qBAAqB,EAAE,UAAU,GAAG,GAAG,GACtC,cAAc,GAAG,SAAS,CAsB5B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,qBAAqB,EAAE,UAAU,GAAG,GAAG,GACtC,OAAO,CAOT"}