isaacscript-common 40.0.0 → 41.1.0

package/dist/lualib_bundle.lua

@@ -1067,6 +1067,9 @@ end
 local Error, RangeError, ReferenceError, SyntaxError, TypeError, URIError
 do
     local function getErrorStack(self, constructor)
+        if debug == nil then
+            return nil
+        end
         local level = 1
         while true do
             local info = debug.getinfo(level, "f")
@@ -1448,6 +1451,62 @@ local function __TS__NumberIsNaN(value)
     return value ~= value
 end
 
+local function __TS__StringSubstring(self, start, ____end)
+    if ____end ~= ____end then
+        ____end = 0
+    end
+    if ____end ~= nil and start > ____end then
+        start, ____end = ____end, start
+    end
+    if start >= 0 then
+        start = start + 1
+    else
+        start = 1
+    end
+    if ____end ~= nil and ____end < 0 then
+        ____end = 0
+    end
+    return string.sub(self, start, ____end)
+end
+
+local __TS__ParseInt
+do
+    local parseIntBasePattern = "0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTvVwWxXyYzZ"
+    function __TS__ParseInt(numberString, base)
+        if base == nil then
+            base = 10
+            local hexMatch = __TS__Match(numberString, "^%s*-?0[xX]")
+            if hexMatch ~= nil then
+                base = 16
+                numberString = (__TS__Match(hexMatch, "-")) and "-" .. __TS__StringSubstring(numberString, #hexMatch) or __TS__StringSubstring(numberString, #hexMatch)
+            end
+        end
+        if base < 2 or base > 36 then
+            return 0 / 0
+        end
+        local allowedDigits = base <= 10 and __TS__StringSubstring(parseIntBasePattern, 0, base) or __TS__StringSubstring(parseIntBasePattern, 0, 10 + 2 * (base - 10))
+        local pattern = ("^%s*(-?[" .. allowedDigits) .. "]*)"
+        local number = tonumber((__TS__Match(numberString, pattern)), base)
+        if number == nil then
+            return 0 / 0
+        end
+        if number >= 0 then
+            return math.floor(number)
+        else
+            return math.ceil(number)
+        end
+    end
+end
+
+local function __TS__ParseFloat(numberString)
+    local infinityMatch = __TS__Match(numberString, "^%s*(-?Infinity)")
+    if infinityMatch ~= nil then
+        return __TS__StringAccess(infinityMatch, 0) == "-" and -math.huge or math.huge
+    end
+    local number = tonumber((__TS__Match(numberString, "^%s*(-?%d+%.?%d*)")))
+    return number or 0 / 0
+end
+
 local __TS__NumberToString
 do
     local radixChars = "0123456789abcdefghijklmnopqrstuvwxyz"
@@ -1622,62 +1681,6 @@ local function __TS__ObjectValues(obj)
     return result
 end
 
-local function __TS__ParseFloat(numberString)
-    local infinityMatch = __TS__Match(numberString, "^%s*(-?Infinity)")
-    if infinityMatch ~= nil then
-        return __TS__StringAccess(infinityMatch, 0) == "-" and -math.huge or math.huge
-    end
-    local number = tonumber((__TS__Match(numberString, "^%s*(-?%d+%.?%d*)")))
-    return number or 0 / 0
-end
-
-local function __TS__StringSubstring(self, start, ____end)
-    if ____end ~= ____end then
-        ____end = 0
-    end
-    if ____end ~= nil and start > ____end then
-        start, ____end = ____end, start
-    end
-    if start >= 0 then
-        start = start + 1
-    else
-        start = 1
-    end
-    if ____end ~= nil and ____end < 0 then
-        ____end = 0
-    end
-    return string.sub(self, start, ____end)
-end
-
-local __TS__ParseInt
-do
-    local parseIntBasePattern = "0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTvVwWxXyYzZ"
-    function __TS__ParseInt(numberString, base)
-        if base == nil then
-            base = 10
-            local hexMatch = __TS__Match(numberString, "^%s*-?0[xX]")
-            if hexMatch ~= nil then
-                base = 16
-                numberString = (__TS__Match(hexMatch, "-")) and "-" .. __TS__StringSubstring(numberString, #hexMatch) or __TS__StringSubstring(numberString, #hexMatch)
-            end
-        end
-        if base < 2 or base > 36 then
-            return 0 / 0
-        end
-        local allowedDigits = base <= 10 and __TS__StringSubstring(parseIntBasePattern, 0, base) or __TS__StringSubstring(parseIntBasePattern, 0, 10 + 2 * (base - 10))
-        local pattern = ("^%s*(-?[" .. allowedDigits) .. "]*)"
-        local number = tonumber((__TS__Match(numberString, pattern)), base)
-        if number == nil then
-            return 0 / 0
-        end
-        if number >= 0 then
-            return math.floor(number)
-        else
-            return math.ceil(number)
-        end
-    end
-end
-
 local function __TS__PromiseAll(iterable)
     local results = {}
     local toResolve = {}
@@ -2545,6 +2548,8 @@ return {
   __TS__Number = __TS__Number,
   __TS__NumberIsFinite = __TS__NumberIsFinite,
   __TS__NumberIsNaN = __TS__NumberIsNaN,
+  __TS__ParseInt = __TS__ParseInt,
+  __TS__ParseFloat = __TS__ParseFloat,
   __TS__NumberToString = __TS__NumberToString,
   __TS__NumberToFixed = __TS__NumberToFixed,
   __TS__ObjectAssign = __TS__ObjectAssign,

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

@@ -24,13 +24,13 @@ function FlyingDetection.prototype.____constructor(self, moddedElementSets)
 end
 function FlyingDetection.prototype.hasFlyingTemporaryEffect(self, player)
     local effects = player:GetEffects()
-    local flyingCollectibles = self.moddedElementSets:getFlyingCollectibles(true)
+    local flyingCollectibles = self.moddedElementSets:getFlyingCollectibleTypes(true)
     for ____, collectibleType in __TS__Iterator(flyingCollectibles) do
         if effects:HasCollectibleEffect(collectibleType) then
             return true
         end
     end
-    local flyingTrinkets = self.moddedElementSets:getFlyingTrinkets()
+    local flyingTrinkets = self.moddedElementSets:getFlyingTrinketTypes()
     for ____, trinketType in __TS__Iterator(flyingTrinkets) do
         if effects:HasTrinketEffect(trinketType) then
             return true

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

@@ -96,7 +96,7 @@ function ItemPoolDetection.prototype.____constructor(self, moddedElementSets)
     self.moddedElementSets = moddedElementSets
 end
 function ItemPoolDetection.prototype.getCollectiblesInItemPool(self, itemPoolType)
-    local collectibleArray = self.moddedElementSets:getCollectibleArray()
+    local collectibleArray = self.moddedElementSets:getCollectibleTypes()
     return __TS__ArrayFilter(
         collectibleArray,
         function(____, collectibleType) return self:isCollectibleInItemPool(collectibleType, itemPoolType) end
@@ -121,7 +121,7 @@ function ItemPoolDetection.prototype.isCollectibleInItemPool(self, collectibleTy
     local removedTrinketsMap = ____removeItemsAndTrinketsThatAffectItemPools_result_0.removedTrinketsMap
     local itemPool = game:GetItemPool()
     itemPool:ResetRoomBlacklist()
-    for ____, collectibleTypeInSet in ipairs(self.moddedElementSets:getCollectibleArray()) do
+    for ____, collectibleTypeInSet in ipairs(self.moddedElementSets:getCollectibleTypes()) do
         if collectibleTypeInSet ~= collectibleType then
             itemPool:AddRoomBlacklist(collectibleTypeInSet)
         end

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

@@ -42,27 +42,6 @@ export declare class ModdedElementDetection extends Feature {
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
     getLastCollectibleType(): CollectibleType;
-    /**
-     * Helper function to get an array that represents every modded collectible type.
-     *
-     * Returns an empty array if there are no modded collectible 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 named differently from the `getVanillaCollectibleTypeRange` function because
-     * all modded collectible types are contiguous. Thus, each value represents a real
-     * `CollectibleType`.)
-     *
-     * 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).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    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
@@ -113,24 +92,6 @@ export declare class ModdedElementDetection extends Feature {
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
     getLastTrinketType(): TrinketType;
-    /**
-     * Helper function to get an array that represents every modded trinket type.
-     *
-     * Returns an empty array if there are no modded trinket types.
-     *
-     * 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).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getModdedTrinketTypes(): TrinketType[];
     /**
      * 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
@@ -153,16 +114,6 @@ export declare class ModdedElementDetection extends Feature {
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
     getNumModdedTrinketTypes(): int;
-    /**
-     * Helper function to get an array with every valid card sub-type. This includes modded cards.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all cards 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`.
-     */
-    getAllCardTypes(): CardType[];
     /**
      * Returns the first modded card sub-type, or undefined if there are no modded cards.
      *
@@ -186,18 +137,6 @@ export declare class ModdedElementDetection extends Feature {
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
     getLastCardType(): CardType;
-    /**
-     * Helper function to get an array with every modded card sub-type.
-     *
-     * Returns an empty array if there are no modded cards.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all cards 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`.
-     */
-    getModdedCardTypes(): CardType[];
     /**
      * Will change depending on how many modded cards there are.
      *
@@ -218,18 +157,6 @@ export declare class ModdedElementDetection extends Feature {
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
     getNumModdedCardTypes(): int;
-    /**
-     * Helper function to get an array with every valid pill effect. This includes modded pill
-     * effects.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all pill effects 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`.
-     */
-    getAllPillEffects(): PillEffect[];
     /**
      * Returns the first modded pill effect, or undefined if there are no modded pill effects.
      *
@@ -255,19 +182,6 @@ export declare class ModdedElementDetection extends Feature {
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
     getLastPillEffect(): PillEffect;
-    /**
-     * Helper function to get an array with every modded pill effect.
-     *
-     * Returns an empty array if there are no modded pill effects.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all pill effects 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`.
-     */
-    getModdedPillEffects(): PillEffect[];
     /**
      * Will change depending on how many modded pill effects there are.
      *

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;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"}
+{"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;AAqBtC,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;IAenE;;;;;;;;;;;;;;;OAeG;IAEI,sBAAsB,IAAI,eAAe;IAKhD;;;;;;;;;;;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;IAKxC;;;;;;;;;;OAUG;IAEI,kBAAkB,IAAI,GAAG;IAOhC;;;;;;;;OAQG;IAEI,wBAAwB,IAAI,GAAG;IAWtC;;;;;;;;OAQG;IAEI,sBAAsB,IAAI,QAAQ,GAAG,SAAS;IAWrD;;;;;;;;;;;OAWG;IAEI,eAAe,IAAI,QAAQ;IAOlC;;;;;;;;;;OAUG;IAEI,eAAe,IAAI,GAAG;IAK7B;;;;;;OAMG;IAEI,qBAAqB,IAAI,GAAG;IAWnC;;;;;;;;;OASG;IAEI,wBAAwB,IAAI,UAAU,GAAG,SAAS;IAezD;;;;;;;;;;;;OAYG;IAEI,iBAAiB,IAAI,UAAU;IAOtC;;;;;;;;;;;;OAYG;IAEI,iBAAiB,IAAI,GAAG;IAK/B;;;;;;;OAOG;IAEI,uBAAuB,IAAI,GAAG;CAMtC"}

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

@@ -8,8 +8,6 @@ local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
 local ____cachedClasses = require("src.core.cachedClasses")
 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 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
@@ -26,8 +24,6 @@ local asCollectibleType = ____types.asCollectibleType
 local asNumber = ____types.asNumber
 local asPillEffect = ____types.asPillEffect
 local asTrinketType = ____types.asTrinketType
-local ____utils = require("src.functions.utils")
-local iRange = ____utils.iRange
 local ____Feature = require("src.classes.private.Feature")
 local Feature = ____Feature.Feature
 --- Mods can add extra things to the game (e.g. collectibles, trinkets, and so on). Since mods load
@@ -45,7 +41,7 @@ __TS__ClassExtends(ModdedElementDetection, Feature)
 function ModdedElementDetection.prototype.____constructor(self)
     Feature.prototype.____constructor(self)
     self.atLeastOneCallbackFired = false
-    self.postPlayerInit = function(____, _player)
+    self.postPlayerInit = function()
         self.atLeastOneCallbackFired = true
     end
     self.callbacksUsed = {{ModCallback.POST_PLAYER_INIT, self.postPlayerInit}}
@@ -76,16 +72,6 @@ function ModdedElementDetection.prototype.getLastCollectibleType(self)
     return itemConfig:GetCollectibles().Size - 1
 end
 __TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getLastCollectibleType", true)
-function ModdedElementDetection.prototype.getModdedCollectibleTypes(self)
-    self:errorIfNoCallbacksFired("collectible")
-    local firstModdedCollectibleType = self:getFirstModdedCollectibleType()
-    if firstModdedCollectibleType == nil then
-        return {}
-    end
-    local lastCollectibleType = self:getLastCollectibleType()
-    return iRange(nil, firstModdedCollectibleType, lastCollectibleType)
-end
-__TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getModdedCollectibleTypes", true)
 function ModdedElementDetection.prototype.getNumCollectibleTypes(self)
     self:errorIfNoCallbacksFired("collectible")
     local numModdedCollectibleTypes = self:getNumModdedCollectibleTypes()
@@ -119,16 +105,6 @@ function ModdedElementDetection.prototype.getLastTrinketType(self)
     return itemConfig:GetTrinkets().Size - 1
 end
 __TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getLastTrinketType", true)
-function ModdedElementDetection.prototype.getModdedTrinketTypes(self)
-    self:errorIfNoCallbacksFired("trinket")
-    local firstModdedTrinketType = self:getFirstModdedTrinketType()
-    if firstModdedTrinketType == nil then
-        return {}
-    end
-    local lastTrinketType = self:getLastTrinketType()
-    return iRange(nil, firstModdedTrinketType, lastTrinketType)
-end
-__TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getModdedTrinketTypes", true)
 function ModdedElementDetection.prototype.getNumTrinketTypes(self)
     self:errorIfNoCallbacksFired("trinket")
     local numModdedTrinketTypes = self:getNumModdedTrinketTypes()
@@ -141,12 +117,6 @@ function ModdedElementDetection.prototype.getNumModdedTrinketTypes(self)
     return lastTrinketType - LAST_VANILLA_TRINKET_TYPE
 end
 __TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getNumModdedTrinketTypes", true)
-function ModdedElementDetection.prototype.getAllCardTypes(self)
-    self:errorIfNoCallbacksFired("card")
-    local lastCardType = self:getLastCardType()
-    return iRange(nil, FIRST_CARD_TYPE, lastCardType)
-end
-__TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getAllCardTypes", true)
 function ModdedElementDetection.prototype.getFirstModdedCardType(self)
     self:errorIfNoCallbacksFired("card")
     local firstModdedCardType = asCardType(
@@ -169,16 +139,6 @@ function ModdedElementDetection.prototype.getLastCardType(self)
     return asCardType(nil, numCards)
 end
 __TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getLastCardType", true)
-function ModdedElementDetection.prototype.getModdedCardTypes(self)
-    self:errorIfNoCallbacksFired("card")
-    local firstModdedCardType = self:getFirstModdedCardType()
-    if firstModdedCardType == nil then
-        return {}
-    end
-    local lastCardType = self:getLastCardType()
-    return iRange(nil, firstModdedCardType, lastCardType)
-end
-__TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getModdedCardTypes", true)
 function ModdedElementDetection.prototype.getNumCardTypes(self)
     self:errorIfNoCallbacksFired("card")
     return itemConfig:GetCards().Size - 1
@@ -190,12 +150,6 @@ function ModdedElementDetection.prototype.getNumModdedCardTypes(self)
     return numCardTypes - NUM_VANILLA_CARD_TYPES
 end
 __TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getNumModdedCardTypes", true)
-function ModdedElementDetection.prototype.getAllPillEffects(self)
-    self:errorIfNoCallbacksFired("pill")
-    local lastPillEffect = self:getLastPillEffect()
-    return iRange(nil, FIRST_PILL_EFFECT, lastPillEffect)
-end
-__TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getAllPillEffects", true)
 function ModdedElementDetection.prototype.getFirstModdedPillEffect(self)
     self:errorIfNoCallbacksFired("pill")
     local firstModdedPillEffect = asPillEffect(
@@ -218,16 +172,6 @@ function ModdedElementDetection.prototype.getLastPillEffect(self)
     return asPillEffect(nil, numPillEffects)
 end
 __TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getLastPillEffect", true)
-function ModdedElementDetection.prototype.getModdedPillEffects(self)
-    self:errorIfNoCallbacksFired("pill")
-    local firstModdedPillEffect = self:getFirstModdedPillEffect()
-    if firstModdedPillEffect == nil then
-        return {}
-    end
-    local lastPillEffect = self:getLastPillEffect()
-    return iRange(nil, firstModdedPillEffect, lastPillEffect)
-end
-__TS__DecorateLegacy({Exported}, ModdedElementDetection.prototype, "getModdedPillEffects", true)
 function ModdedElementDetection.prototype.getNumPillEffects(self)
     self:errorIfNoCallbacksFired("pill")
     return itemConfig:GetPillEffects().Size