isaacscript-common 14.1.3 → 15.0.0

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

@@ -0,0 +1,34 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__Decorate = ____lualib.__TS__Decorate
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local ButtonAction = ____isaac_2Dtypescript_2Ddefinitions.ButtonAction
+local InputHook = ____isaac_2Dtypescript_2Ddefinitions.InputHook
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____decorators = require("src.decorators")
+local Exported = ____decorators.Exported
+local ____Feature = require("src.classes.private.Feature")
+local Feature = ____Feature.Feature
+____exports.ForgottenSwitch = __TS__Class()
+local ForgottenSwitch = ____exports.ForgottenSwitch
+ForgottenSwitch.name = "ForgottenSwitch"
+__TS__ClassExtends(ForgottenSwitch, Feature)
+function ForgottenSwitch.prototype.____constructor(self)
+    Feature.prototype.____constructor(self)
+    self.v = {run = {shouldSwitch = false}}
+    self.isActionTriggered = function(____, _entity, _inputHook, buttonAction)
+        if buttonAction == ButtonAction.DROP and self.v.run.shouldSwitch then
+            self.v.run.shouldSwitch = false
+            return true
+        end
+        return nil
+    end
+    self.callbacksUsed = {{ModCallback.INPUT_ACTION, {self.isActionTriggered, InputHook.IS_ACTION_TRIGGERED}}}
+end
+function ForgottenSwitch.prototype.forgottenSwitch(self)
+    self.v.run.shouldSwitch = true
+end
+__TS__Decorate({Exported}, ForgottenSwitch.prototype, "forgottenSwitch", true)
+return ____exports

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

@@ -0,0 +1,37 @@
+import { CollectibleType, ItemPoolType } from "isaac-typescript-definitions";
+import { Feature } from "../../private/Feature";
+export declare class ItemPoolDetection extends Feature {
+    private moddedElementSets;
+    /**
+     * Helper function to get the remaining collectibles in a given item pool. This function is
+     * expensive, so only use it in situations where the lag is acceptable.
+     */
+    getCollectiblesInItemPool(itemPoolType: ItemPoolType): CollectibleType[];
+    /**
+     * Helper function to see if the given collectible is still present in the given item pool.
+     *
+     * If the collectible is non-offensive, any Tainted Losts will be temporarily changed to Isaac and
+     * then changed back. (This is because Tainted Lost is not able to retrieve non-offensive
+     * collectibles from item pools).
+     *
+     * Under the hood, this function works by using the `ItemPool.AddRoomBlacklist` method to
+     * blacklist every collectible except for the one provided.
+     */
+    isCollectibleInItemPool(collectibleType: CollectibleType, itemPoolType: ItemPoolType): boolean;
+    /**
+     * Helper function to see if the given collectible is unlocked on the current save file. This
+     * requires providing the corresponding item pool that the collectible is normally located in.
+     *
+     * - If any player currently has the collectible, then it is assumed to be unlocked. (This is
+     *   because in almost all cases, when a collectible is added to a player's inventory, it is
+     *   subsequently removed from all pools.)
+     * - If the collectible is located in more than one item pool, then any item pool can be provided.
+     * - If the collectible is not located in any item pools, then this function will always return
+     *   false.
+     * - If the collectible is non-offensive, any Tainted Losts will be temporarily changed to Isaac
+     *   and then changed back. (This is because Tainted Lost is not able to retrieve non-offensive
+     *   collectibles from item pools).
+     */
+    isCollectibleUnlocked(collectibleType: CollectibleType, itemPoolType: ItemPoolType): boolean;
+}
+//# sourceMappingURL=ItemPoolDetection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ItemPoolDetection.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/ItemPoolDetection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAEf,YAAY,EAGb,MAAM,8BAA8B,CAAC;AAgBtC,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAehD,qBAAa,iBAAkB,SAAQ,OAAO;IAC5C,OAAO,CAAC,iBAAiB,CAAoB;IAW7C;;;OAGG;IAEI,yBAAyB,CAC9B,YAAY,EAAE,YAAY,GACzB,eAAe,EAAE;IAOpB;;;;;;;;;OASG;IAEI,uBAAuB,CAC5B,eAAe,EAAE,eAAe,EAChC,YAAY,EAAE,YAAY,GACzB,OAAO;IA+DV;;;;;;;;;;;;;OAaG;IAEI,qBAAqB,CAC1B,eAAe,EAAE,eAAe,EAChC,YAAY,EAAE,YAAY,GACzB,OAAO;CAOX"}

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

@@ -0,0 +1,147 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
+local __TS__Decorate = ____lualib.__TS__Decorate
+local Map = ____lualib.Map
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local removeItemsAndTrinketsThatAffectItemPools, restoreItemsAndTrinketsThatAffectItemPools, COLLECTIBLES_THAT_AFFECT_ITEM_POOLS, TRINKETS_THAT_AFFECT_ITEM_POOLS
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
+local ItemConfigTag = ____isaac_2Dtypescript_2Ddefinitions.ItemConfigTag
+local PlayerType = ____isaac_2Dtypescript_2Ddefinitions.PlayerType
+local TrinketType = ____isaac_2Dtypescript_2Ddefinitions.TrinketType
+local ____cachedClasses = require("src.core.cachedClasses")
+local game = ____cachedClasses.game
+local ____decorators = require("src.decorators")
+local Exported = ____decorators.Exported
+local ____ISCFeature = require("src.enums.ISCFeature")
+local ISCFeature = ____ISCFeature.ISCFeature
+local ____collectibleTag = require("src.functions.collectibleTag")
+local collectibleHasTag = ____collectibleTag.collectibleHasTag
+local ____playerDataStructures = require("src.functions.playerDataStructures")
+local mapGetPlayer = ____playerDataStructures.mapGetPlayer
+local mapSetPlayer = ____playerDataStructures.mapSetPlayer
+local ____playerIndex = require("src.functions.playerIndex")
+local getAllPlayers = ____playerIndex.getAllPlayers
+local ____players = require("src.functions.players")
+local anyPlayerHasCollectible = ____players.anyPlayerHasCollectible
+local getPlayersOfType = ____players.getPlayersOfType
+local ____utils = require("src.functions.utils")
+local ____repeat = ____utils["repeat"]
+local ____Feature = require("src.classes.private.Feature")
+local Feature = ____Feature.Feature
+function removeItemsAndTrinketsThatAffectItemPools(self)
+    local removedItemsMap = __TS__New(Map)
+    local removedTrinketsMap = __TS__New(Map)
+    for ____, player in ipairs(getAllPlayers(nil)) do
+        local removedItems = {}
+        for ____, itemToRemove in ipairs(COLLECTIBLES_THAT_AFFECT_ITEM_POOLS) do
+            local numCollectibles = player:GetCollectibleNum(itemToRemove)
+            ____repeat(
+                nil,
+                numCollectibles,
+                function()
+                    player:RemoveCollectible(itemToRemove)
+                    removedItems[#removedItems + 1] = itemToRemove
+                end
+            )
+        end
+        mapSetPlayer(nil, removedItemsMap, player, removedItems)
+        local removedTrinkets = {}
+        for ____, trinketToRemove in ipairs(TRINKETS_THAT_AFFECT_ITEM_POOLS) do
+            if player:HasTrinket(trinketToRemove) then
+                local numTrinkets = player:GetTrinketMultiplier(trinketToRemove)
+                ____repeat(
+                    nil,
+                    numTrinkets,
+                    function()
+                        player:TryRemoveTrinket(trinketToRemove)
+                        removedTrinkets[#removedTrinkets + 1] = trinketToRemove
+                    end
+                )
+            end
+        end
+        mapSetPlayer(nil, removedTrinketsMap, player, removedTrinkets)
+    end
+    return {removedItemsMap, removedTrinketsMap}
+end
+function restoreItemsAndTrinketsThatAffectItemPools(self, removedItemsMap, removedTrinketsMap)
+    for ____, player in ipairs(getAllPlayers(nil)) do
+        local removedItems = mapGetPlayer(nil, removedItemsMap, player)
+        if removedItems ~= nil then
+            for ____, collectibleType in ipairs(removedItems) do
+                player:AddCollectible(collectibleType, 0, false)
+            end
+        end
+        local removedTrinkets = mapGetPlayer(nil, removedTrinketsMap, player)
+        if removedTrinkets ~= nil then
+            for ____, trinketType in ipairs(removedTrinkets) do
+                player:AddTrinket(trinketType, false)
+            end
+        end
+    end
+end
+local COLLECTIBLE_TYPE_THAT_IS_NOT_IN_ANY_POOLS = CollectibleType.KEY_PIECE_1
+COLLECTIBLES_THAT_AFFECT_ITEM_POOLS = {CollectibleType.CHAOS, CollectibleType.SACRED_ORB, CollectibleType.TMTRAINER}
+TRINKETS_THAT_AFFECT_ITEM_POOLS = {TrinketType.NO}
+____exports.ItemPoolDetection = __TS__Class()
+local ItemPoolDetection = ____exports.ItemPoolDetection
+ItemPoolDetection.name = "ItemPoolDetection"
+__TS__ClassExtends(ItemPoolDetection, Feature)
+function ItemPoolDetection.prototype.____constructor(self, moddedElementSets)
+    Feature.prototype.____constructor(self)
+    self.featuresUsed = {ISCFeature.MODDED_ELEMENT_SETS}
+    self.moddedElementSets = moddedElementSets
+end
+function ItemPoolDetection.prototype.getCollectiblesInItemPool(self, itemPoolType)
+    local collectibleArray = self.moddedElementSets:getCollectibleArray()
+    return __TS__ArrayFilter(
+        collectibleArray,
+        function(____, collectibleType) return self:isCollectibleInItemPool(collectibleType, itemPoolType) end
+    )
+end
+function ItemPoolDetection.prototype.isCollectibleInItemPool(self, collectibleType, itemPoolType)
+    if collectibleType == COLLECTIBLE_TYPE_THAT_IS_NOT_IN_ANY_POOLS then
+        return false
+    end
+    local taintedLosts = getPlayersOfType(nil, PlayerType.LOST_B)
+    local isOffensive = collectibleHasTag(nil, collectibleType, ItemConfigTag.OFFENSIVE)
+    local changedPlayerTypes = false
+    if not isOffensive then
+        changedPlayerTypes = true
+        for ____, player in ipairs(taintedLosts) do
+            player:ChangePlayerType(PlayerType.ISAAC)
+        end
+    end
+    local removedItemsMap, removedTrinketsMap = table.unpack(removeItemsAndTrinketsThatAffectItemPools(nil))
+    local itemPool = game:GetItemPool()
+    itemPool:ResetRoomBlacklist()
+    for ____, collectibleTypeInSet in ipairs(self.moddedElementSets:getCollectibleArray()) do
+        if collectibleTypeInSet ~= collectibleType then
+            itemPool:AddRoomBlacklist(collectibleTypeInSet)
+        end
+    end
+    local seed = 1
+    local retrievedCollectibleType = itemPool:GetCollectible(itemPoolType, false, seed, COLLECTIBLE_TYPE_THAT_IS_NOT_IN_ANY_POOLS)
+    local collectibleUnlocked = retrievedCollectibleType == collectibleType
+    itemPool:ResetRoomBlacklist()
+    restoreItemsAndTrinketsThatAffectItemPools(nil, removedItemsMap, removedTrinketsMap)
+    if changedPlayerTypes then
+        for ____, player in ipairs(taintedLosts) do
+            player:ChangePlayerType(PlayerType.LOST_B)
+        end
+    end
+    return collectibleUnlocked
+end
+function ItemPoolDetection.prototype.isCollectibleUnlocked(self, collectibleType, itemPoolType)
+    if anyPlayerHasCollectible(nil, collectibleType) then
+        return true
+    end
+    return self:isCollectibleInItemPool(collectibleType, itemPoolType)
+end
+__TS__Decorate({Exported}, ItemPoolDetection.prototype, "getCollectiblesInItemPool", true)
+__TS__Decorate({Exported}, ItemPoolDetection.prototype, "isCollectibleInItemPool", true)
+__TS__Decorate({Exported}, ItemPoolDetection.prototype, "isCollectibleUnlocked", true)
+return ____exports

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

@@ -0,0 +1,223 @@
+import { CardType, CollectibleType, PillEffect, TrinketType } from "isaac-typescript-definitions";
+import { Feature } from "../../private/Feature";
+/**
+ * Mods can add extra things to the game (e.g. collectibles, trinkets, and so on). Since mods load
+ * in alphabetical order, the total number of things can't be properly be known until at least one
+ * callback fires (which indicates that all mods have been loaded).
+ *
+ * This feature gates all such functions behind a callback check. Subsequently, these functions will
+ * throw a runtime error if they are called in the menu, before any callbacks have occurred. This
+ * ensures that the proper values are always returned and allows you to get immediate feedback if
+ * you accidentally access them from the menu.
+ */
+export declare class ModdedElementDetection extends Feature {
+    private atLeastOneCallbackFired;
+    private postPlayerInit;
+    private errorIfNoCallbacksFired;
+    /**
+     * Returns the first modded collectible type, or undefined if there are no modded collectibles.
+     *
+     * 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).
+     */
+    getFirstModdedCollectibleType(): CollectibleType | undefined;
+    /**
+     * Will change depending on how many modded collectibles there are.
+     *
+     * Equal to `itemConfig.GetCollectibles().Size - 1`. (`Size` includes invalid collectibles, like
+     * 666. We subtract one to account for `CollectibleType.NULL`.)
+     *
+     * 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).
+     */
+    getLastCollectibleType(): CollectibleType;
+    /**
+     * Helper function to get an array that represents the all modded collectible types.
+     *
+     * 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).
+     */
+    getModdedCollectibleTypes(): 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).
+     */
+    getNumCollectibleTypes(): int;
+    /**
+     * Unlike vanilla collectible types, modded collectible types are always contiguous.
+     *
+     * 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).
+     */
+    getNumModdedCollectibleTypes(): int;
+    /**
+     * Returns the first modded trinket type, or undefined if there are no modded trinkets.
+     *
+     * 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).
+     */
+    getFirstModdedTrinketType(): TrinketType | undefined;
+    /**
+     * 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).
+     *
+     * 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).
+     */
+    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 collectible type objects. For most purposes, you
+     * should use the `getModdedCollectibleArray` or `getModdedCollectibleSet` helper function
+     * instead.
+     *
+     * 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).
+     */
+    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`.)
+     *
+     * 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).
+     */
+    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).
+     */
+    getNumModdedTrinketTypes(): int;
+    /**
+     * Helper function to get an array that contains every trinket type.
+     *
+     * 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).
+     */
+    getTrinketTypes(): TrinketType[];
+    /**
+     * 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).
+     */
+    getAllCardTypes(): CardType[];
+    /**
+     * Returns the first modded card sub-type, or undefined 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).
+     */
+    getFirstModdedCardType(): CardType | undefined;
+    /**
+     * Will change depending on how many modded cards there are.
+     *
+     * This is equal to the number of cards, since all card sub-types are contiguous (unlike
+     * collectibles).
+     *
+     * 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).
+     */
+    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).
+     */
+    getModdedCardTypes(): CardType[];
+    /**
+     * Will change depending on how many modded cards there are.
+     *
+     * Equal to `itemConfig.GetCards().Size - 1`. (We subtract one to account for `Card.NULL`.)
+     *
+     * 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).
+     */
+    getNumCardTypes(): 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).
+     */
+    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).
+     */
+    getAllPillEffects(): PillEffect[];
+    /**
+     * Returns the first modded pill effect, or undefined 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).
+     */
+    getFirstModdedPillEffect(): PillEffect | undefined;
+    /**
+     * Will change depending on how many modded pill effects there are.
+     *
+     * This is equal to the number of pill effects, since all pill effects are contiguous (unlike
+     * collectibles).
+     *
+     * 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).
+     */
+    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).
+     */
+    getModdedPillEffects(): PillEffect[];
+    /**
+     * Will change depending on how many modded pill effects there are.
+     *
+     * Equal to `itemConfig.GetPillEffects().Size`. (We do not have to subtract one, because the first
+     * pill effect has an ID of 0 and there is no `PillEffect.NULL`.)
+     *
+     * 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).
+     */
+    getNumPillEffects(): int;
+    /**
+     * 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).
+     */
+    getNumModdedPillEffects(): int;
+}
+//# sourceMappingURL=ModdedElementDetection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ModdedElementDetection.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/ModdedElementDetection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,eAAe,EAEf,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;IAYxC,OAAO,CAAC,cAAc,CAEpB;IAEF,OAAO,CAAC,uBAAuB;IAY/B;;;;;;OAMG;IAEI,6BAA6B,IAAI,eAAe,GAAG,SAAS;IAcnE;;;;;;;;;OASG;IAEI,sBAAsB,IAAI,eAAe;IAMhD;;;;;;;;;;;;;;;;OAgBG;IAEI,yBAAyB,IAAI,eAAe,EAAE;IAYrD;;;;OAIG;IAEI,sBAAsB,IAAI,GAAG;IAOpC;;;;;;OAMG;IAEI,4BAA4B,IAAI,GAAG;IAW1C;;;;;OAKG;IAEI,yBAAyB,IAAI,WAAW,GAAG,SAAS;IAU3D;;;;;;;;OAQG;IAEI,kBAAkB,IAAI,WAAW;IAOxC;;;;;;;;;;;OAWG;IAEI,qBAAqB,IAAI,WAAW,EAAE;IAY7C;;;;;;;;OAQG;IAEI,kBAAkB,IAAI,GAAG;IAMhC;;;OAGG;IAEI,wBAAwB,IAAI,GAAG;IAOtC;;;;;OAKG;IAEI,eAAe,IAAI,WAAW,EAAE;IAWvC;;;;;OAKG;IAEI,eAAe,IAAI,QAAQ,EAAE;IAOpC;;;;;OAKG;IAEI,sBAAsB,IAAI,QAAQ,GAAG,SAAS;IAUrD;;;;;;;;OAQG;IAEI,eAAe,IAAI,QAAQ;IAOlC;;;;;;;OAOG;IAEI,kBAAkB,IAAI,QAAQ,EAAE;IAYvC;;;;;;;OAOG;IAEI,eAAe,IAAI,GAAG;IAM7B;;;OAGG;IAEI,qBAAqB,IAAI,GAAG;IAWnC;;;;;;;OAOG;IAEI,iBAAiB,IAAI,UAAU,EAAE;IAOxC;;;;;;OAMG;IAEI,wBAAwB,IAAI,UAAU,GAAG,SAAS;IAczD;;;;;;;;;OASG;IAEI,iBAAiB,IAAI,UAAU;IAOtC;;;;;;;;OAQG;IAEI,oBAAoB,IAAI,UAAU,EAAE;IAY3C;;;;;;;;;OASG;IAEI,iBAAiB,IAAI,GAAG;IAM/B;;;;OAIG;IAEI,uBAAuB,IAAI,GAAG;CAMtC"}