isaacscript-common 38.0.1 → 39.0.0

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.
      *

package/dist/isaacscript-common.lua

@@ -1,6 +1,6 @@
 --[[
 
-isaacscript-common 38.0.1
+isaacscript-common 39.0.0
 
 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()
@@ -38831,7 +38824,7 @@ function ModdedElementSets.prototype.lazyInitCacheFlagToTrinketTypesMap(self)
     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

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"}

package/dist/src/classes/features/other/ModdedElementDetection.lua

@@ -10,7 +10,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
@@ -117,8 +116,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)
@@ -133,21 +131,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()

package/dist/src/classes/features/other/ModdedElementSets.lua

@@ -271,7 +271,7 @@ function ModdedElementSets.prototype.lazyInitCacheFlagToTrinketTypesMap(self)
     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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isaacscript-common",
-  "version": "38.0.1",
+  "version": "39.0.0",
   "description": "Helper functions and features for IsaacScript mods.",
   "keywords": [
     "isaac",

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

@@ -9,7 +9,6 @@ import { itemConfig } from "../../../core/cachedClasses";
 import {
   FIRST_CARD_TYPE,
   FIRST_PILL_EFFECT,
-  FIRST_TRINKET_TYPE,
   LAST_VANILLA_CARD_TYPE,
   LAST_VANILLA_COLLECTIBLE_TYPE,
   LAST_VANILLA_PILL_EFFECT,
@@ -101,6 +100,9 @@ export 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).
@@ -116,7 +118,7 @@ export class ModdedElementDetection extends Feature {
   }
 
   /**
-   * 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.
    *
@@ -149,6 +151,10 @@ export class ModdedElementDetection extends Feature {
   }
 
   /**
+   * 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).
@@ -209,8 +215,11 @@ export 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).
@@ -222,8 +231,7 @@ export class ModdedElementDetection extends Feature {
   public getLastTrinketType(): TrinketType {
     this.errorIfNoCallbacksFired("trinket");
 
-    const numTrinketTypes = this.getNumTrinketTypes();
-    return asTrinketType(numTrinketTypes);
+    return itemConfig.GetTrinkets().Size - 1;
   }
 
   /**
@@ -231,9 +239,11 @@ export 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).
@@ -255,10 +265,9 @@ export class ModdedElementDetection extends Feature {
   }
 
   /**
-   * 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).
@@ -270,26 +279,12 @@ export class ModdedElementDetection extends Feature {
   public getNumTrinketTypes(): int {
     this.errorIfNoCallbacksFired("trinket");
 
-    return itemConfig.GetTrinkets().Size - 1;
-  }
-
-  /**
-   * 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`.
-   */
-  @Exported
-  public getNumModdedTrinketTypes(): int {
-    this.errorIfNoCallbacksFired("trinket");
-
-    const numTrinketTypes = this.getNumTrinketTypes();
-    return numTrinketTypes - NUM_VANILLA_TRINKET_TYPES;
+    const numModdedTrinketTypes = this.getNumModdedTrinketTypes();
+    return NUM_VANILLA_TRINKET_TYPES + numModdedTrinketTypes;
   }
 
   /**
-   * 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).
@@ -298,11 +293,11 @@ export class ModdedElementDetection extends Feature {
    * `ISCFeature.MODDED_ELEMENT_DETECTION`.
    */
   @Exported
-  public getTrinketTypes(): TrinketType[] {
+  public getNumModdedTrinketTypes(): int {
     this.errorIfNoCallbacksFired("trinket");
 
     const lastTrinketType = this.getLastTrinketType();
-    return iRange(FIRST_TRINKET_TYPE, lastTrinketType);
+    return lastTrinketType - LAST_VANILLA_TRINKET_TYPE;
   }
 
   // -----

package/src/classes/features/other/ModdedElementSets.ts

@@ -333,7 +333,7 @@ export class ModdedElementSets extends Feature {
     for (const cacheFlag of CACHE_FLAG_VALUES) {
       const trinketsSet = new Set<TrinketType>();
 
-      for (const trinketType of this.moddedElementDetection.getTrinketTypes()) {
+      for (const trinketType of this.getTrinketArray()) {
         if (trinketHasCacheFlag(trinketType, cacheFlag)) {
           trinketsSet.add(trinketType);
         }