isaacscript-common 38.0.1 → 39.0.1

package/dist/index.rollup.d.ts

@@ -12655,6 +12655,9 @@ declare class ModdedElementDetection extends Feature {
      * Equal to `itemConfig.GetCollectibles().Size - 1`. (`Size` includes invalid collectibles, like
      * 666. We subtract one to account for `CollectibleType.NULL`.)
      *
+     * If there are no mods present that add any custom items, this function will return
+     * `CollectibleType.MOMS_RING` (732).
+     *
      * This function can only be called if at least one callback has been executed. This is because
      * not all collectibles will necessarily be present when a mod first loads (due to mod load
      * order).
@@ -12664,7 +12667,7 @@ declare class ModdedElementDetection extends Feature {
      */
     getLastCollectibleType(): CollectibleType;
     /**
-     * Helper function to get an array that represents the all modded collectible types.
+     * Helper function to get an array that represents every modded collectible type.
      *
      * Returns an empty array if there are no modded collectible types.
      *
@@ -12685,6 +12688,10 @@ declare class ModdedElementDetection extends Feature {
      */
     getModdedCollectibleTypes(): CollectibleType[];
     /**
+     * Returns the total number of collectibles in the item config, including both vanilla and modded
+     * items. If you just need the number of vanilla collectible types, use the
+     * `NUM_VANILLA_COLLECTIBLE_TYPES` constant.
+     *
      * This function can only be called if at least one callback has been executed. This is because
      * not all collectibles will necessarily be present when a mod first loads (due to mod load
      * order).
@@ -12717,8 +12724,11 @@ declare class ModdedElementDetection extends Feature {
     /**
      * Will change depending on how many modded trinkets there are.
      *
-     * This is equal to the number of trinket types, since all trinket types are contiguous (unlike
-     * collectibles).
+     * Equal to `itemConfig.GetTrinkets().Size - 1`. (`Size` includes invalid trinkets, like 47. We
+     * subtract one to account for `TrinketType.NULL`.)
+     *
+     * If there are no mods present that add any custom trinkets, this function will return
+     * `TrinketType.SIGIL_OF_BAPHOMET` (189).
      *
      * This function can only be called if at least one callback has been executed. This is because
      * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
@@ -12732,9 +12742,11 @@ declare class ModdedElementDetection extends Feature {
      *
      * Returns an empty array if there are no modded trinket types.
      *
-     * This function is only useful when building collectible type objects. For most purposes, you
-     * should use the `getModdedCollectibleArray` or `getModdedCollectibleSet` helper function
-     * instead.
+     * This function is only useful when building trinket type objects. For most purposes, you should
+     * use the `getModdedTrinketArray` or `getModdedTrinketSet` helper function instead.
+     *
+     * (This function is named differently from the `getVanillaTrinketTypeRange` function because all
+     * modded trinket types are contiguous. Thus, each value represents a real `TrinketType`.)
      *
      * This function can only be called if at least one callback has been executed. This is because
      * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
@@ -12744,10 +12756,9 @@ declare class ModdedElementDetection extends Feature {
      */
     getModdedTrinketTypes(): TrinketType[];
     /**
-     * Will change depending on how many modded trinkets there are.
-     *
-     * Equal to `itemConfig.GetTrinkets().Size - 1`. (We subtract one to account for
-     * `TrinketType.NULL`.)
+     * Returns the total number of trinkets in the item config, including both vanilla and modded
+     * items. If you just need the number of vanilla trinket types, use the
+     * `NUM_VANILLA_TRINKET_TYPES` constant.
      *
      * This function can only be called if at least one callback has been executed. This is because
      * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
@@ -12757,15 +12768,7 @@ declare class ModdedElementDetection extends Feature {
      */
     getNumTrinketTypes(): int;
     /**
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getNumModdedTrinketTypes(): int;
-    /**
-     * Helper function to get an array that contains every trinket type.
+     * Unlike vanilla trinket types, modded trinket types are always contiguous.
      *
      * This function can only be called if at least one callback has been executed. This is because
      * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
@@ -12773,7 +12776,7 @@ declare class ModdedElementDetection extends Feature {
      * In order to use this function, you must upgrade your mod with
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
-    getTrinketTypes(): TrinketType[];
+    getNumModdedTrinketTypes(): int;
     /**
      * Helper function to get an array with every valid card sub-type. This includes modded cards.
      *
@@ -12915,6 +12918,7 @@ declare class ModdedElementDetection extends Feature {
 }
 
 declare class ModdedElementSets extends Feature {
+    private arraysInitialized;
     private readonly allCollectibleTypesArray;
     private readonly allCollectibleTypesSet;
     private readonly vanillaCollectibleTypesArray;
@@ -12950,6 +12954,7 @@ declare class ModdedElementSets extends Feature {
      */
     private readonly cardSet;
     private readonly moddedElementDetection;
+    private lazyInit;
     private lazyInitVanillaCollectibleTypes;
     private lazyInitModdedCollectibleTypes;
     private lazyInitVanillaTrinketTypes;

package/dist/isaacscript-common.lua

@@ -1,6 +1,6 @@
 --[[
 
-isaacscript-common 38.0.1
+isaacscript-common 39.0.1
 
 This is the "isaacscript-common" library, which was created with the IsaacScript tool.
 
@@ -38327,7 +38327,6 @@ local itemConfig = ____cachedClasses.itemConfig
 local ____constantsFirstLast = require("src.core.constantsFirstLast")
 local FIRST_CARD_TYPE = ____constantsFirstLast.FIRST_CARD_TYPE
 local FIRST_PILL_EFFECT = ____constantsFirstLast.FIRST_PILL_EFFECT
-local FIRST_TRINKET_TYPE = ____constantsFirstLast.FIRST_TRINKET_TYPE
 local LAST_VANILLA_CARD_TYPE = ____constantsFirstLast.LAST_VANILLA_CARD_TYPE
 local LAST_VANILLA_COLLECTIBLE_TYPE = ____constantsFirstLast.LAST_VANILLA_COLLECTIBLE_TYPE
 local LAST_VANILLA_PILL_EFFECT = ____constantsFirstLast.LAST_VANILLA_PILL_EFFECT
@@ -38426,8 +38425,7 @@ end
 __TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getFirstModdedTrinketType", true)
 function ModdedElementDetection.prototype.getLastTrinketType(self)
     self:errorIfNoCallbacksFired("trinket")
-    local numTrinketTypes = self:getNumTrinketTypes()
-    return asTrinketType(nil, numTrinketTypes)
+    return itemConfig:GetTrinkets().Size - 1
 end
 __TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getLastTrinketType", true)
 function ModdedElementDetection.prototype.getModdedTrinketTypes(self)
@@ -38442,21 +38440,16 @@ end
 __TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getModdedTrinketTypes", true)
 function ModdedElementDetection.prototype.getNumTrinketTypes(self)
     self:errorIfNoCallbacksFired("trinket")
-    return itemConfig:GetTrinkets().Size - 1
+    local numModdedTrinketTypes = self:getNumModdedTrinketTypes()
+    return NUM_VANILLA_TRINKET_TYPES + numModdedTrinketTypes
 end
 __TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getNumTrinketTypes", true)
 function ModdedElementDetection.prototype.getNumModdedTrinketTypes(self)
-    self:errorIfNoCallbacksFired("trinket")
-    local numTrinketTypes = self:getNumTrinketTypes()
-    return numTrinketTypes - NUM_VANILLA_TRINKET_TYPES
-end
-__TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getNumModdedTrinketTypes", true)
-function ModdedElementDetection.prototype.getTrinketTypes(self)
     self:errorIfNoCallbacksFired("trinket")
     local lastTrinketType = self:getLastTrinketType()
-    return iRange(nil, FIRST_TRINKET_TYPE, lastTrinketType)
+    return lastTrinketType - LAST_VANILLA_TRINKET_TYPE
 end
-__TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getTrinketTypes", true)
+__TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getNumModdedTrinketTypes", true)
 function ModdedElementDetection.prototype.getAllCardTypes(self)
     self:errorIfNoCallbacksFired("card")
     local lastCardType = self:getLastCardType()
@@ -38642,6 +38635,7 @@ ModdedElementSets.name = "ModdedElementSets"
 __TS__ClassExtends(ModdedElementSets, Feature)
 function ModdedElementSets.prototype.____constructor(self, moddedElementDetection)
     Feature.prototype.____constructor(self)
+    self.arraysInitialized = false
     self.allCollectibleTypesArray = {}
     self.allCollectibleTypesSet = __TS__New(Set)
     self.vanillaCollectibleTypesArray = {}
@@ -38673,10 +38667,26 @@ function ModdedElementSets.prototype.____constructor(self, moddedElementDetectio
     self.featuresUsed = {ISCFeature.MODDED_ELEMENT_DETECTION}
     self.moddedElementDetection = moddedElementDetection
 end
-function ModdedElementSets.prototype.lazyInitVanillaCollectibleTypes(self)
-    if #self.vanillaCollectibleTypesArray > 0 then
+function ModdedElementSets.prototype.lazyInit(self)
+    if self.arraysInitialized then
         return
     end
+    self.arraysInitialized = true
+    self:lazyInitVanillaCollectibleTypes()
+    self:lazyInitModdedCollectibleTypes()
+    self:lazyInitVanillaTrinketTypes()
+    self:lazyInitModdedTrinketTypes()
+    self:lazyInitVanillaCardTypes()
+    self:lazyInitModdedCardTypes()
+    self:lazyInitTagToCollectibleTypesMap()
+    self:lazyInitCacheFlagToCollectibleTypesMap()
+    self:lazyInitCacheFlagToTrinketTypesMap()
+    self:lazyInitFlyingCollectibleTypesSet()
+    self:lazyInitFlyingTrinketTypesSet()
+    self:lazyInitEdenCollectibleTypesSet()
+    self:lazyInitCardTypes()
+end
+function ModdedElementSets.prototype.lazyInitVanillaCollectibleTypes(self)
     local vanillaCollectibleTypeRange = getVanillaCollectibleTypeRange(nil)
     for ____, collectibleType in ipairs(vanillaCollectibleTypeRange) do
         local itemConfigItem = itemConfig:GetCollectible(collectibleType)
@@ -38688,10 +38698,6 @@ function ModdedElementSets.prototype.lazyInitVanillaCollectibleTypes(self)
     end
 end
 function ModdedElementSets.prototype.lazyInitModdedCollectibleTypes(self)
-    if #self.moddedCollectibleTypesArray > 0 then
-        return
-    end
-    self:lazyInitVanillaCollectibleTypes()
     for ____, collectibleType in ipairs(self.vanillaCollectibleTypesArray) do
         local ____self_allCollectibleTypesArray_1 = self.allCollectibleTypesArray
         ____self_allCollectibleTypesArray_1[#____self_allCollectibleTypesArray_1 + 1] = collectibleType
@@ -38711,9 +38717,6 @@ function ModdedElementSets.prototype.lazyInitModdedCollectibleTypes(self)
     end
 end
 function ModdedElementSets.prototype.lazyInitVanillaTrinketTypes(self)
-    if #self.vanillaTrinketTypesArray > 0 then
-        return
-    end
     local vanillaTrinketTypeRange = getVanillaTrinketTypeRange(nil)
     for ____, trinketType in ipairs(vanillaTrinketTypeRange) do
         local itemConfigItem = itemConfig:GetTrinket(trinketType)
@@ -38725,10 +38728,6 @@ function ModdedElementSets.prototype.lazyInitVanillaTrinketTypes(self)
     end
 end
 function ModdedElementSets.prototype.lazyInitModdedTrinketTypes(self)
-    if #self.moddedTrinketTypesArray > 0 then
-        return
-    end
-    self:lazyInitVanillaTrinketTypes()
     for ____, trinketType in ipairs(self.vanillaTrinketTypesArray) do
         local ____self_allTrinketTypesArray_5 = self.allTrinketTypesArray
         ____self_allTrinketTypesArray_5[#____self_allTrinketTypesArray_5 + 1] = trinketType
@@ -38748,9 +38747,6 @@ function ModdedElementSets.prototype.lazyInitModdedTrinketTypes(self)
     end
 end
 function ModdedElementSets.prototype.lazyInitVanillaCardTypes(self)
-    if #self.vanillaCardTypesArray > 0 then
-        return
-    end
     local vanillaCardTypes = getVanillaCardTypes(nil)
     for ____, cardType in ipairs(vanillaCardTypes) do
         local itemConfigCard = itemConfig:GetCard(cardType)
@@ -38762,10 +38758,6 @@ function ModdedElementSets.prototype.lazyInitVanillaCardTypes(self)
     end
 end
 function ModdedElementSets.prototype.lazyInitModdedCardTypes(self)
-    if #self.moddedCardTypesArray > 0 then
-        return
-    end
-    self:lazyInitVanillaCardTypes()
     for ____, cardType in ipairs(self.vanillaCardTypesArray) do
         local ____self_allCardTypesArray_9 = self.allCardTypesArray
         ____self_allCardTypesArray_9[#____self_allCardTypesArray_9 + 1] = cardType
@@ -38785,9 +38777,6 @@ function ModdedElementSets.prototype.lazyInitModdedCardTypes(self)
     end
 end
 function ModdedElementSets.prototype.lazyInitTagToCollectibleTypesMap(self)
-    if self.tagToCollectibleTypesMap.size > 0 then
-        return
-    end
     for ____, itemConfigTag in ipairs(ITEM_CONFIG_TAG_VALUES) do
         self.tagToCollectibleTypesMap:set(
             itemConfigTag,
@@ -38798,7 +38787,7 @@ function ModdedElementSets.prototype.lazyInitTagToCollectibleTypesMap(self)
         for ____, itemConfigTag in ipairs(ITEM_CONFIG_TAG_VALUES) do
             do
                 if not collectibleHasTag(nil, collectibleType, itemConfigTag) then
-                    goto __continue44
+                    goto __continue39
                 end
                 local collectibleTypesSet = self.tagToCollectibleTypesMap:get(itemConfigTag)
                 if collectibleTypesSet == nil then
@@ -38807,14 +38796,11 @@ function ModdedElementSets.prototype.lazyInitTagToCollectibleTypesMap(self)
                 end
                 collectibleTypesSet:add(collectibleType)
             end
-            ::__continue44::
+            ::__continue39::
         end
     end
 end
 function ModdedElementSets.prototype.lazyInitCacheFlagToCollectibleTypesMap(self)
-    if self.cacheFlagToCollectibleTypesMap.size > 0 then
-        return
-    end
     for ____, cacheFlag in ipairs(CACHE_FLAG_VALUES) do
         local collectiblesSet = __TS__New(Set)
         for ____, collectibleType in ipairs(self:getCollectibleArray()) do
@@ -38826,12 +38812,9 @@ function ModdedElementSets.prototype.lazyInitCacheFlagToCollectibleTypesMap(self
     end
 end
 function ModdedElementSets.prototype.lazyInitCacheFlagToTrinketTypesMap(self)
-    if self.cacheFlagToTrinketTypesMap.size > 0 then
-        return
-    end
     for ____, cacheFlag in ipairs(CACHE_FLAG_VALUES) do
         local trinketsSet = __TS__New(Set)
-        for ____, trinketType in ipairs(self.moddedElementDetection:getTrinketTypes()) do
+        for ____, trinketType in ipairs(self:getTrinketArray()) do
             if trinketHasCacheFlag(nil, trinketType, cacheFlag) then
                 trinketsSet:add(trinketType)
             end
@@ -38840,9 +38823,6 @@ function ModdedElementSets.prototype.lazyInitCacheFlagToTrinketTypesMap(self)
     end
 end
 function ModdedElementSets.prototype.lazyInitFlyingCollectibleTypesSet(self)
-    if self.flyingCollectibleTypesSet.size > 0 then
-        return
-    end
     self.flyingCollectibleTypesSet = copySet(
         nil,
         self:getCollectiblesWithCacheFlag(CacheFlag.FLYING)
@@ -38858,9 +38838,6 @@ function ModdedElementSets.prototype.lazyInitFlyingCollectibleTypesSet(self)
     end
 end
 function ModdedElementSets.prototype.lazyInitFlyingTrinketTypesSet(self)
-    if self.flyingTrinketTypesSet.size > 0 then
-        return
-    end
     self.flyingTrinketTypesSet = copySet(
         nil,
         self:getTrinketsWithCacheFlag(CacheFlag.FLYING)
@@ -38873,13 +38850,10 @@ function ModdedElementSets.prototype.lazyInitFlyingTrinketTypesSet(self)
     deleteSetsFromSet(nil, self.flyingTrinketTypesSet, trinketsWithAllCacheFlag)
 end
 function ModdedElementSets.prototype.lazyInitEdenCollectibleTypesSet(self)
-    if self.edenActiveCollectibleTypesSet.size > 0 then
-        return
-    end
     for ____, collectibleType in ipairs(self:getCollectibleArray()) do
         do
             if isHiddenCollectible(nil, collectibleType) or collectibleHasTag(nil, collectibleType, ItemConfigTag.NO_EDEN) then
-                goto __continue73
+                goto __continue63
             end
             if isActiveCollectible(nil, collectibleType) then
                 self.edenActiveCollectibleTypesSet:add(collectibleType)
@@ -38888,13 +38862,10 @@ function ModdedElementSets.prototype.lazyInitEdenCollectibleTypesSet(self)
                 self.edenPassiveCollectibleTypesSet:add(collectibleType)
             end
         end
-        ::__continue73::
+        ::__continue63::
     end
 end
 function ModdedElementSets.prototype.lazyInitCardTypes(self)
-    if self.itemConfigCardTypeToCardTypeMap.size > 0 then
-        return
-    end
     for ____, itemConfigCardType in ipairs(ITEM_CONFIG_CARD_TYPE_VALUES) do
         self.itemConfigCardTypeToCardTypeMap:set(
             itemConfigCardType,
@@ -38918,20 +38889,18 @@ function ModdedElementSets.prototype.lazyInitCardTypes(self)
     end
 end
 function ModdedElementSets.prototype.getCardArray(self)
-    self:lazyInitModdedCardTypes()
+    self:lazyInit()
     return self.allCardTypesArray
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getCardArray", true)
 function ModdedElementSets.prototype.getCardSet(self)
-    self:lazyInitModdedCardTypes()
+    self:lazyInit()
     return self.allCardTypesSet
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getCardSet", true)
 function ModdedElementSets.prototype.getCardTypesOfType(self, ...)
     local itemConfigCardTypes = {...}
-    if self.itemConfigCardTypeToCardTypeMap.size == 0 then
-        self:lazyInitCardTypes()
-    end
+    self:lazyInit()
     local matchingCardTypes = __TS__New(Set)
     for ____, itemConfigCardType in ipairs(itemConfigCardTypes) do
         local cardTypeSet = self.itemConfigCardTypeToCardTypeMap:get(itemConfigCardType)
@@ -38948,12 +38917,12 @@ function ModdedElementSets.prototype.getCardTypesOfType(self, ...)
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getCardTypesOfType", true)
 function ModdedElementSets.prototype.getCollectibleArray(self)
-    self:lazyInitModdedCollectibleTypes()
+    self:lazyInit()
     return self.allCollectibleTypesArray
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getCollectibleArray", true)
 function ModdedElementSets.prototype.getCollectibleSet(self)
-    self:lazyInitModdedCollectibleTypes()
+    self:lazyInit()
     return self.allCollectibleTypesSet
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getCollectibleSet", true)
@@ -38968,7 +38937,7 @@ function ModdedElementSets.prototype.getCollectiblesForTransformation(self, play
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getCollectiblesForTransformation", true)
 function ModdedElementSets.prototype.getCollectiblesWithCacheFlag(self, cacheFlag)
-    self:lazyInitCacheFlagToCollectibleTypesMap()
+    self:lazyInit()
     local collectiblesSet = self.cacheFlagToCollectibleTypesMap:get(cacheFlag)
     if collectiblesSet == nil then
         return __TS__New(ReadonlySet)
@@ -38977,7 +38946,7 @@ function ModdedElementSets.prototype.getCollectiblesWithCacheFlag(self, cacheFla
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getCollectiblesWithCacheFlag", true)
 function ModdedElementSets.prototype.getCollectiblesWithTag(self, itemConfigTag)
-    self:lazyInitTagToCollectibleTypesMap()
+    self:lazyInit()
     local collectibleTypes = self.tagToCollectibleTypesMap:get(itemConfigTag)
     assertDefined(
         nil,
@@ -38988,52 +38957,52 @@ function ModdedElementSets.prototype.getCollectiblesWithTag(self, itemConfigTag)
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getCollectiblesWithTag", true)
 function ModdedElementSets.prototype.getEdenActiveCollectibles(self)
-    self:lazyInitEdenCollectibleTypesSet()
+    self:lazyInit()
     return self.edenActiveCollectibleTypesSet
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getEdenActiveCollectibles", true)
 function ModdedElementSets.prototype.getEdenPassiveCollectibles(self)
-    self:lazyInitEdenCollectibleTypesSet()
+    self:lazyInit()
     return self.edenPassiveCollectibleTypesSet
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getEdenPassiveCollectibles", true)
 function ModdedElementSets.prototype.getFlyingCollectibles(self, includeConditionalItems)
-    self:lazyInitFlyingCollectibleTypesSet()
+    self:lazyInit()
     return includeConditionalItems and self.flyingCollectibleTypesSet or self.permanentFlyingCollectibleTypesSet
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getFlyingCollectibles", true)
 function ModdedElementSets.prototype.getFlyingTrinkets(self)
-    self:lazyInitFlyingTrinketTypesSet()
+    self:lazyInit()
     return self.flyingTrinketTypesSet
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getFlyingTrinkets", true)
 function ModdedElementSets.prototype.getModdedCardArray(self)
-    self:lazyInitModdedCardTypes()
+    self:lazyInit()
     return self.moddedCardTypesArray
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getModdedCardArray", true)
 function ModdedElementSets.prototype.getModdedCardSet(self)
-    self:lazyInitModdedCardTypes()
+    self:lazyInit()
     return self.moddedCardTypesSet
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getModdedCardSet", true)
 function ModdedElementSets.prototype.getModdedCollectibleArray(self)
-    self:lazyInitModdedCollectibleTypes()
+    self:lazyInit()
     return self.moddedCollectibleTypesArray
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getModdedCollectibleArray", true)
 function ModdedElementSets.prototype.getModdedCollectibleSet(self)
-    self:lazyInitModdedCollectibleTypes()
+    self:lazyInit()
     return self.moddedCollectibleTypesSet
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getModdedCollectibleSet", true)
 function ModdedElementSets.prototype.getModdedTrinketArray(self)
-    self:lazyInitModdedTrinketTypes()
+    self:lazyInit()
     return self.moddedTrinketTypesArray
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getModdedTrinketArray", true)
 function ModdedElementSets.prototype.getModdedTrinketSet(self)
-    self:lazyInitModdedTrinketTypes()
+    self:lazyInit()
     return self.moddedTrinketTypesSet
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getModdedTrinketSet", true)
@@ -39132,7 +39101,7 @@ function ModdedElementSets.prototype.getRandomCard(self, seedOrRNG, exceptions)
     if exceptions == nil then
         exceptions = {}
     end
-    self:lazyInitCardTypes()
+    self:lazyInit()
     return getRandomSetElement(nil, self.cardSet, seedOrRNG, exceptions)
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getRandomCard", true)
@@ -39166,7 +39135,7 @@ function ModdedElementSets.prototype.getRandomEdenActiveCollectible(self, seedOr
     if exceptions == nil then
         exceptions = {}
     end
-    self:lazyInitEdenCollectibleTypesSet()
+    self:lazyInit()
     return getRandomSetElement(nil, self.edenPassiveCollectibleTypesSet, seedOrRNG, exceptions)
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getRandomEdenActiveCollectible", true)
@@ -39177,22 +39146,22 @@ function ModdedElementSets.prototype.getRandomEdenPassiveCollectible(self, seedO
     if exceptions == nil then
         exceptions = {}
     end
-    self:lazyInitEdenCollectibleTypesSet()
+    self:lazyInit()
     return getRandomSetElement(nil, self.edenPassiveCollectibleTypesSet, seedOrRNG, exceptions)
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getRandomEdenPassiveCollectible", true)
 function ModdedElementSets.prototype.getTrinketArray(self)
-    self:lazyInitModdedTrinketTypes()
+    self:lazyInit()
     return self.allTrinketTypesArray
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getTrinketArray", true)
 function ModdedElementSets.prototype.getTrinketSet(self)
-    self:lazyInitModdedTrinketTypes()
+    self:lazyInit()
     return self.allTrinketTypesSet
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getTrinketSet", true)
 function ModdedElementSets.prototype.getTrinketsWithCacheFlag(self, cacheFlag)
-    self:lazyInitCacheFlagToTrinketTypesMap()
+    self:lazyInit()
     local trinketsSet = self.cacheFlagToTrinketTypesMap:get(cacheFlag)
     if trinketsSet == nil then
         return __TS__New(ReadonlySet)
@@ -39201,32 +39170,32 @@ function ModdedElementSets.prototype.getTrinketsWithCacheFlag(self, cacheFlag)
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getTrinketsWithCacheFlag", true)
 function ModdedElementSets.prototype.getVanillaCardArray(self)
-    self:lazyInitVanillaCardTypes()
+    self:lazyInit()
     return self.vanillaCardTypesArray
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getVanillaCardArray", true)
 function ModdedElementSets.prototype.getVanillaCardSet(self)
-    self:lazyInitVanillaCardTypes()
+    self:lazyInit()
     return self.vanillaCardTypesSet
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getVanillaCardSet", true)
 function ModdedElementSets.prototype.getVanillaCollectibleArray(self)
-    self:lazyInitVanillaCollectibleTypes()
+    self:lazyInit()
     return self.vanillaCollectibleTypesArray
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getVanillaCollectibleArray", true)
 function ModdedElementSets.prototype.getVanillaCollectibleSet(self)
-    self:lazyInitVanillaCollectibleTypes()
+    self:lazyInit()
     return self.vanillaCollectibleTypesSet
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getVanillaCollectibleSet", true)
 function ModdedElementSets.prototype.getVanillaTrinketArray(self)
-    self:lazyInitVanillaTrinketTypes()
+    self:lazyInit()
     return self.vanillaTrinketTypesArray
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getVanillaTrinketArray", true)
 function ModdedElementSets.prototype.getVanillaTrinketSet(self)
-    self:lazyInitVanillaTrinketTypes()
+    self:lazyInit()
     return self.vanillaTrinketTypesSet
 end
 __TS__DecorateLegacy({Exported}, ModdedElementSets.prototype, "getVanillaTrinketSet", true)

package/dist/src/classes/features/other/ModdedElementDetection.d.ts

@@ -31,6 +31,9 @@ export declare class ModdedElementDetection extends Feature {
      * Equal to `itemConfig.GetCollectibles().Size - 1`. (`Size` includes invalid collectibles, like
      * 666. We subtract one to account for `CollectibleType.NULL`.)
      *
+     * If there are no mods present that add any custom items, this function will return
+     * `CollectibleType.MOMS_RING` (732).
+     *
      * This function can only be called if at least one callback has been executed. This is because
      * not all collectibles will necessarily be present when a mod first loads (due to mod load
      * order).
@@ -40,7 +43,7 @@ export declare class ModdedElementDetection extends Feature {
      */
     getLastCollectibleType(): CollectibleType;
     /**
-     * Helper function to get an array that represents the all modded collectible types.
+     * Helper function to get an array that represents every modded collectible type.
      *
      * Returns an empty array if there are no modded collectible types.
      *
@@ -61,6 +64,10 @@ export declare class ModdedElementDetection extends Feature {
      */
     getModdedCollectibleTypes(): CollectibleType[];
     /**
+     * Returns the total number of collectibles in the item config, including both vanilla and modded
+     * items. If you just need the number of vanilla collectible types, use the
+     * `NUM_VANILLA_COLLECTIBLE_TYPES` constant.
+     *
      * This function can only be called if at least one callback has been executed. This is because
      * not all collectibles will necessarily be present when a mod first loads (due to mod load
      * order).
@@ -93,8 +100,11 @@ export declare class ModdedElementDetection extends Feature {
     /**
      * Will change depending on how many modded trinkets there are.
      *
-     * This is equal to the number of trinket types, since all trinket types are contiguous (unlike
-     * collectibles).
+     * Equal to `itemConfig.GetTrinkets().Size - 1`. (`Size` includes invalid trinkets, like 47. We
+     * subtract one to account for `TrinketType.NULL`.)
+     *
+     * If there are no mods present that add any custom trinkets, this function will return
+     * `TrinketType.SIGIL_OF_BAPHOMET` (189).
      *
      * This function can only be called if at least one callback has been executed. This is because
      * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
@@ -108,9 +118,11 @@ export declare class ModdedElementDetection extends Feature {
      *
      * Returns an empty array if there are no modded trinket types.
      *
-     * This function is only useful when building collectible type objects. For most purposes, you
-     * should use the `getModdedCollectibleArray` or `getModdedCollectibleSet` helper function
-     * instead.
+     * This function is only useful when building trinket type objects. For most purposes, you should
+     * use the `getModdedTrinketArray` or `getModdedTrinketSet` helper function instead.
+     *
+     * (This function is named differently from the `getVanillaTrinketTypeRange` function because all
+     * modded trinket types are contiguous. Thus, each value represents a real `TrinketType`.)
      *
      * This function can only be called if at least one callback has been executed. This is because
      * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
@@ -120,10 +132,9 @@ export declare class ModdedElementDetection extends Feature {
      */
     getModdedTrinketTypes(): TrinketType[];
     /**
-     * Will change depending on how many modded trinkets there are.
-     *
-     * Equal to `itemConfig.GetTrinkets().Size - 1`. (We subtract one to account for
-     * `TrinketType.NULL`.)
+     * Returns the total number of trinkets in the item config, including both vanilla and modded
+     * items. If you just need the number of vanilla trinket types, use the
+     * `NUM_VANILLA_TRINKET_TYPES` constant.
      *
      * This function can only be called if at least one callback has been executed. This is because
      * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
@@ -133,15 +144,7 @@ export declare class ModdedElementDetection extends Feature {
      */
     getNumTrinketTypes(): int;
     /**
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getNumModdedTrinketTypes(): int;
-    /**
-     * Helper function to get an array that contains every trinket type.
+     * Unlike vanilla trinket types, modded trinket types are always contiguous.
      *
      * This function can only be called if at least one callback has been executed. This is because
      * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
@@ -149,7 +152,7 @@ export declare class ModdedElementDetection extends Feature {
      * In order to use this function, you must upgrade your mod with
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
-    getTrinketTypes(): TrinketType[];
+    getNumModdedTrinketTypes(): int;
     /**
      * Helper function to get an array with every valid card sub-type. This includes modded cards.
      *

package/dist/src/classes/features/other/ModdedElementDetection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ModdedElementDetection.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/ModdedElementDetection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,eAAe,EACf,UAAU,EACV,WAAW,EACZ,MAAM,8BAA8B,CAAC;AAyBtC,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD;;;;;;;;;GASG;AACH,qBAAa,sBAAuB,SAAQ,OAAO;IACjD,OAAO,CAAC,uBAAuB,CAAS;IAaxC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAE7B;IAEF,OAAO,CAAC,uBAAuB;IAY/B;;;;;;;;;OASG;IAEI,6BAA6B,IAAI,eAAe,GAAG,SAAS;IAcnE;;;;;;;;;;;;OAYG;IAEI,sBAAsB,IAAI,eAAe;IAMhD;;;;;;;;;;;;;;;;;;;OAmBG;IAEI,yBAAyB,IAAI,eAAe,EAAE;IAYrD;;;;;;;OAOG;IAEI,sBAAsB,IAAI,GAAG;IAOpC;;;;;;;;;OASG;IAEI,4BAA4B,IAAI,GAAG;IAW1C;;;;;;;;OAQG;IAEI,yBAAyB,IAAI,WAAW,GAAG,SAAS;IAU3D;;;;;;;;;;;OAWG;IAEI,kBAAkB,IAAI,WAAW;IAOxC;;;;;;;;;;;;;;OAcG;IAEI,qBAAqB,IAAI,WAAW,EAAE;IAY7C;;;;;;;;;;;OAWG;IAEI,kBAAkB,IAAI,GAAG;IAMhC;;;;;;OAMG;IAEI,wBAAwB,IAAI,GAAG;IAOtC;;;;;;;;OAQG;IAEI,eAAe,IAAI,WAAW,EAAE;IAWvC;;;;;;;;OAQG;IAEI,eAAe,IAAI,QAAQ,EAAE;IAOpC;;;;;;;;OAQG;IAEI,sBAAsB,IAAI,QAAQ,GAAG,SAAS;IAUrD;;;;;;;;;;;OAWG;IAEI,eAAe,IAAI,QAAQ;IAOlC;;;;;;;;;;OAUG;IAEI,kBAAkB,IAAI,QAAQ,EAAE;IAYvC;;;;;;;;;;OAUG;IAEI,eAAe,IAAI,GAAG;IAM7B;;;;;;OAMG;IAEI,qBAAqB,IAAI,GAAG;IAWnC;;;;;;;;;;OAUG;IAEI,iBAAiB,IAAI,UAAU,EAAE;IAOxC;;;;;;;;;OASG;IAEI,wBAAwB,IAAI,UAAU,GAAG,SAAS;IAczD;;;;;;;;;;;;OAYG;IAEI,iBAAiB,IAAI,UAAU;IAOtC;;;;;;;;;;;OAWG;IAEI,oBAAoB,IAAI,UAAU,EAAE;IAY3C;;;;;;;;;;;;OAYG;IAEI,iBAAiB,IAAI,GAAG;IAM/B;;;;;;;OAOG;IAEI,uBAAuB,IAAI,GAAG;CAMtC"}
+{"version":3,"file":"ModdedElementDetection.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/ModdedElementDetection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,eAAe,EACf,UAAU,EACV,WAAW,EACZ,MAAM,8BAA8B,CAAC;AAwBtC,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD;;;;;;;;;GASG;AACH,qBAAa,sBAAuB,SAAQ,OAAO;IACjD,OAAO,CAAC,uBAAuB,CAAS;IAaxC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAE7B;IAEF,OAAO,CAAC,uBAAuB;IAY/B;;;;;;;;;OASG;IAEI,6BAA6B,IAAI,eAAe,GAAG,SAAS;IAcnE;;;;;;;;;;;;;;;OAeG;IAEI,sBAAsB,IAAI,eAAe;IAMhD;;;;;;;;;;;;;;;;;;;OAmBG;IAEI,yBAAyB,IAAI,eAAe,EAAE;IAYrD;;;;;;;;;;;OAWG;IAEI,sBAAsB,IAAI,GAAG;IAOpC;;;;;;;;;OASG;IAEI,4BAA4B,IAAI,GAAG;IAW1C;;;;;;;;OAQG;IAEI,yBAAyB,IAAI,WAAW,GAAG,SAAS;IAU3D;;;;;;;;;;;;;;OAcG;IAEI,kBAAkB,IAAI,WAAW;IAMxC;;;;;;;;;;;;;;;;OAgBG;IAEI,qBAAqB,IAAI,WAAW,EAAE;IAY7C;;;;;;;;;;OAUG;IAEI,kBAAkB,IAAI,GAAG;IAOhC;;;;;;;;OAQG;IAEI,wBAAwB,IAAI,GAAG;IAWtC;;;;;;;;OAQG;IAEI,eAAe,IAAI,QAAQ,EAAE;IAOpC;;;;;;;;OAQG;IAEI,sBAAsB,IAAI,QAAQ,GAAG,SAAS;IAUrD;;;;;;;;;;;OAWG;IAEI,eAAe,IAAI,QAAQ;IAOlC;;;;;;;;;;OAUG;IAEI,kBAAkB,IAAI,QAAQ,EAAE;IAYvC;;;;;;;;;;OAUG;IAEI,eAAe,IAAI,GAAG;IAM7B;;;;;;OAMG;IAEI,qBAAqB,IAAI,GAAG;IAWnC;;;;;;;;;;OAUG;IAEI,iBAAiB,IAAI,UAAU,EAAE;IAOxC;;;;;;;;;OASG;IAEI,wBAAwB,IAAI,UAAU,GAAG,SAAS;IAczD;;;;;;;;;;;;OAYG;IAEI,iBAAiB,IAAI,UAAU;IAOtC;;;;;;;;;;;OAWG;IAEI,oBAAoB,IAAI,UAAU,EAAE;IAY3C;;;;;;;;;;;;OAYG;IAEI,iBAAiB,IAAI,GAAG;IAM/B;;;;;;;OAOG;IAEI,uBAAuB,IAAI,GAAG;CAMtC"}