isaacscript-common 4.5.2 → 4.7.0

package/constants.d.ts

@@ -1,6 +1,3 @@
-/**
- * @module core/Constants
- */
 import { CollectibleType, ItemPoolType, LevelStage, RoomType } from "isaac-typescript-definitions";
 /**
  * The distance of the laser when Azazel does not have any range up items yet. For more info, see

package/constantsFirstLast.d.ts

@@ -1,6 +1,3 @@
-/**
- * @module Constants (First and Last)
- */
 import { Card, CollectibleType, PillColor, PillEffect, PlayerType, TrinketType } from "isaac-typescript-definitions";
 /** Equal to `CollectibleType.SAD_ONION`. */
 export declare const FIRST_COLLECTIBLE_TYPE = CollectibleType.SAD_ONION;

package/features/characterHealthConversion.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Easily create custom characters that have the same health mechanic as Blue Baby (red heart
+ * containers --> soul hearts) or Black Judas (red heart containers --> black hearts).
+ *
+ * @module
+ */
 import { HeartSubType, PlayerType } from "isaac-typescript-definitions";
 export declare type ConversionHeartSubType = HeartSubType.SOUL | HeartSubType.BLACK;
 /**

package/features/characterStats.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Easily create custom characters that have base stats different from that of Isaac.
+ *
+ * @module
+ */
 import { CacheFlag, PlayerType } from "isaac-typescript-definitions";
 /**
  * Helper function to manage the stats for a vanilla or custom character. Call this function once at

package/features/deployJSONRoom.lua

@@ -37,6 +37,7 @@ local removeAllBombs = ____entitySpecific.removeAllBombs
 local removeAllPickups = ____entitySpecific.removeAllPickups
 local ____gridEntity = require("functions.gridEntity")
 local convertXMLGridEntityType = ____gridEntity.convertXMLGridEntityType
+local getAllGridIndexes = ____gridEntity.getAllGridIndexes
 local getGridEntities = ____gridEntity.getGridEntities
 local removeAllGridExcept = ____gridEntity.removeAllGridExcept
 local removeGrid = ____gridEntity.removeGrid
@@ -59,8 +60,6 @@ local setRoomCleared = ____rooms.setRoomCleared
 local setRoomUncleared = ____rooms.setRoomUncleared
 local ____spawnCollectible = require("functions.spawnCollectible")
 local spawnCollectible = ____spawnCollectible.spawnCollectible
-local ____utils = require("functions.utils")
-local erange = ____utils.erange
 local ____runInNFrames = require("features.runInNFrames")
 local runNextGameFrame = ____runInNFrames.runNextGameFrame
 local ____exports = require("features.saveDataManager.exports")
@@ -182,10 +181,9 @@ function removeSpecificNPCs(self)
 end
 function fillRoomWithDecorations(self)
     local room = game:GetRoom()
-    local gridSize = room:GetGridSize()
     local roomListIndex = getRoomListIndex(nil)
     local decorationGridIndexes = v.level.roomToDecorationGridIndexesMap:getAndSetDefault(roomListIndex)
-    for ____, gridIndex in ipairs(erange(nil, gridSize)) do
+    for ____, gridIndex in ipairs(getAllGridIndexes(nil)) do
         do
             local existingGridEntity = room:GetGridEntity(gridIndex)
             if existingGridEntity ~= nil then

package/features/disableAllSound.d.ts

@@ -1,6 +1,3 @@
-/**
- * @module Disable All Sound
- */
 /**
  * Helper function to stop muting all sound effects and music.
  *

package/features/runInNFrames.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="isaac-typescript-definitions" />
 /**
- * Supply a function to run N game frames from now in the PostUpdate callback.
+ * Supply a function to run N game frames from now in the `POST_UPDATE` callback.
  *
  * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a similar
  * way.
@@ -11,7 +11,7 @@
  */
 export declare function runInNGameFrames(func: () => void, gameFrames: int): void;
 /**
- * Supply a function to run N render frames from now in the PostRender callback.
+ * Supply a function to run N render frames from now in the `POST_RENDER` callback.
  *
  * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a similar
  * way.
@@ -22,7 +22,7 @@ export declare function runInNGameFrames(func: () => void, gameFrames: int): voi
  */
 export declare function runInNRenderFrames(func: () => void, renderFrames: int): void;
 /**
- * Supply a function to run on the next PostUpdate callback.
+ * Supply a function to run on the next `POST_UPDATE` callback.
  *
  * For example:
  *
@@ -51,7 +51,7 @@ export declare function runInNRenderFrames(func: () => void, renderFrames: int):
  */
 export declare function runNextGameFrame(func: () => void): void;
 /**
- * Supply a function to run on the next PostRender callback.
+ * Supply a function to run on the next `POST_RENDER` callback.
  *
  * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a similar
  * way.
@@ -59,3 +59,37 @@ export declare function runNextGameFrame(func: () => void): void;
  * Note that this function will not handle saving and quitting.
  */
 export declare function runNextRenderFrame(func: () => void): void;
+/**
+ * Supply a function to be repeatedly run on an interval of N game frames in the `POST_UPDATE`
+ * callback. The function will continue to be fired until `false` is returned from the function.
+ *
+ * This is similar to the `setInterval` vanilla JavaScript function, except there is no
+ * corresponding `clearInterval` function. (Instead, the return value from the supplied function is
+ * used to stop the interval.)
+ *
+ * Note that this function will not handle saving and quitting. You must manually restart any
+ * intervals if the player saves and quits in the middle of a run.
+ *
+ * @param func The function to repeatedly run on an interval.
+ * @param gameFrames The amount of game frames to wait between each run.
+ * @param runImmediately Whether or not to execute the function right now before waiting for the
+ *                       interval.
+ */
+export declare function setIntervalGameFrames(func: () => boolean, gameFrames: int, runImmediately: boolean): void;
+/**
+ * Supply a function to be repeatedly run on an interval of N render frames in the `POST_RENDER`
+ * callback. The function will continue to be fired until `false` is returned from the function.
+ *
+ * This is similar to the `setInterval` vanilla JavaScript function, except there is no
+ * corresponding `clearInterval` function. (Instead, the return value from the supplied function is
+ * used to stop the interval.)
+ *
+ * Note that this function will not handle saving and quitting. You must manually restart any
+ * intervals if the player saves and quits in the middle of a run.
+ *
+ * @param func The function to repeatedly run on an interval.
+ * @param renderFrames The amount of game frames to wait between each run.
+ * @param runImmediately Whether or not to execute the function right now before waiting for the
+ *                       interval.
+ */
+export declare function setIntervalRenderFrames(func: () => boolean, renderFrames: int, runImmediately: boolean): void;

package/features/runInNFrames.lua

@@ -1,46 +1,67 @@
 local ____lualib = require("lualib_bundle")
 local __TS__ArrayForEach = ____lualib.__TS__ArrayForEach
-local __TS__ArraySplice = ____lualib.__TS__ArraySplice
 local ____exports = {}
-local postUpdate, postRender, checkExecuteQueuedFunctions, v
+local postUpdate, postRender, checkExecuteQueuedFunctions, checkExecuteIntervalFunctions, getFunctionsThatShouldFireOnThisFrame, v
 local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
 local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
 local ____cachedClasses = require("cachedClasses")
 local game = ____cachedClasses.game
 local ____featuresInitialized = require("featuresInitialized")
 local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____array = require("functions.array")
+local arrayRemoveIndexInPlace = ____array.arrayRemoveIndexInPlace
 local ____exports = require("features.saveDataManager.exports")
 local saveDataManager = ____exports.saveDataManager
 function postUpdate(self)
     local gameFrameCount = game:GetFrameCount()
     checkExecuteQueuedFunctions(nil, gameFrameCount, v.run.queuedGameFunctionTuples)
+    checkExecuteIntervalFunctions(nil, gameFrameCount, v.run.intervalGameFunctionTuples)
 end
 function postRender(self)
     local renderFrameCount = Isaac.GetFrameCount()
     checkExecuteQueuedFunctions(nil, renderFrameCount, v.run.queuedRenderFunctionTuples)
+    checkExecuteIntervalFunctions(nil, renderFrameCount, v.run.intervalRenderFunctionTuples)
 end
 function checkExecuteQueuedFunctions(self, frameCount, functionTuples)
-    local functionsToFire = {}
-    local indexesToRemove = {}
+    local firingFunctions = getFunctionsThatShouldFireOnThisFrame(nil, frameCount, functionTuples)
+    for ____, ____value in ipairs(firingFunctions) do
+        local i = ____value[1]
+        local func = ____value[2]
+        func(nil)
+        arrayRemoveIndexInPlace(nil, functionTuples, i)
+    end
+end
+function checkExecuteIntervalFunctions(self, frameCount, functionTuples)
+    local firingFunctions = getFunctionsThatShouldFireOnThisFrame(nil, frameCount, functionTuples)
+    for ____, ____value in ipairs(firingFunctions) do
+        local i = ____value[1]
+        local func = ____value[2]
+        local numIntervalFrames = ____value[3]
+        local returnValue = func(nil)
+        arrayRemoveIndexInPlace(nil, functionTuples, i)
+        if numIntervalFrames ~= nil and returnValue == false then
+            local nextFireFrame = frameCount + numIntervalFrames
+            local tuple = {nextFireFrame, func, numIntervalFrames}
+            functionTuples[#functionTuples + 1] = tuple
+        end
+    end
+end
+function getFunctionsThatShouldFireOnThisFrame(self, frameCount, functionTuples)
+    local firingFunctionTuples = {}
     __TS__ArrayForEach(
         functionTuples,
         function(____, functionTuple, i)
-            local frame, func = table.unpack(functionTuple)
-            if frameCount >= frame then
-                functionsToFire[#functionsToFire + 1] = func
-                indexesToRemove[#indexesToRemove + 1] = i
+            local frameCountToFire, func, numIntervalFrames = table.unpack(functionTuple)
+            if frameCount >= frameCountToFire then
+                local firingFunctionTuple = {i, func, numIntervalFrames}
+                firingFunctionTuples[#firingFunctionTuples + 1] = firingFunctionTuple
             end
         end
     )
-    for ____, indexToRemove in ipairs(indexesToRemove) do
-        __TS__ArraySplice(functionTuples, indexToRemove, 1)
-    end
-    for ____, func in ipairs(functionsToFire) do
-        func(nil)
-    end
+    return firingFunctionTuples
 end
 local FEATURE_NAME = "runInNFrames"
-v = {run = {queuedGameFunctionTuples = {}, queuedRenderFunctionTuples = {}}}
+v = {run = {queuedGameFunctionTuples = {}, queuedRenderFunctionTuples = {}, intervalGameFunctionTuples = {}, intervalRenderFunctionTuples = {}}}
 ---
 -- @internal
 function ____exports.runInNFramesInit(self, mod)
@@ -53,7 +74,7 @@ function ____exports.runInNFramesInit(self, mod)
     mod:AddCallback(ModCallback.POST_UPDATE, postUpdate)
     mod:AddCallback(ModCallback.POST_RENDER, postRender)
 end
---- Supply a function to run N game frames from now in the PostUpdate callback.
+--- Supply a function to run N game frames from now in the `POST_UPDATE` callback.
 -- 
 -- For a usage example, see the documentation for the `runNextGameFrame`, which is used in a similar
 -- way.
@@ -69,7 +90,7 @@ function ____exports.runInNGameFrames(self, func, gameFrames)
     local ____v_run_queuedGameFunctionTuples_0 = v.run.queuedGameFunctionTuples
     ____v_run_queuedGameFunctionTuples_0[#____v_run_queuedGameFunctionTuples_0 + 1] = tuple
 end
---- Supply a function to run N render frames from now in the PostRender callback.
+--- Supply a function to run N render frames from now in the `POST_RENDER` callback.
 -- 
 -- For a usage example, see the documentation for the `runNextGameFrame`, which is used in a similar
 -- way.
@@ -85,7 +106,7 @@ function ____exports.runInNRenderFrames(self, func, renderFrames)
     local ____v_run_queuedRenderFunctionTuples_1 = v.run.queuedRenderFunctionTuples
     ____v_run_queuedRenderFunctionTuples_1[#____v_run_queuedRenderFunctionTuples_1 + 1] = tuple
 end
---- Supply a function to run on the next PostUpdate callback.
+--- Supply a function to run on the next `POST_UPDATE` callback.
 -- 
 -- For example:
 -- 
@@ -115,7 +136,7 @@ function ____exports.runNextGameFrame(self, func)
     errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
     ____exports.runInNGameFrames(nil, func, 1)
 end
---- Supply a function to run on the next PostRender callback.
+--- Supply a function to run on the next `POST_RENDER` callback.
 -- 
 -- For a usage example, see the documentation for the `runNextGameFrame`, which is used in a similar
 -- way.
@@ -125,4 +146,54 @@ function ____exports.runNextRenderFrame(self, func)
     errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
     ____exports.runInNRenderFrames(nil, func, 1)
 end
+--- Supply a function to be repeatedly run on an interval of N game frames in the `POST_UPDATE`
+-- callback. The function will continue to be fired until `false` is returned from the function.
+-- 
+-- This is similar to the `setInterval` vanilla JavaScript function, except there is no
+-- corresponding `clearInterval` function. (Instead, the return value from the supplied function is
+-- used to stop the interval.)
+-- 
+-- Note that this function will not handle saving and quitting. You must manually restart any
+-- intervals if the player saves and quits in the middle of a run.
+-- 
+-- @param func The function to repeatedly run on an interval.
+-- @param gameFrames The amount of game frames to wait between each run.
+-- @param runImmediately Whether or not to execute the function right now before waiting for the
+-- interval.
+function ____exports.setIntervalGameFrames(self, func, gameFrames, runImmediately)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    local gameFrameCount = game:GetFrameCount()
+    local functionFireFrame = gameFrameCount + gameFrames
+    local tuple = {functionFireFrame, func, gameFrames}
+    local ____v_run_intervalGameFunctionTuples_2 = v.run.intervalGameFunctionTuples
+    ____v_run_intervalGameFunctionTuples_2[#____v_run_intervalGameFunctionTuples_2 + 1] = tuple
+    if runImmediately then
+        func(nil)
+    end
+end
+--- Supply a function to be repeatedly run on an interval of N render frames in the `POST_RENDER`
+-- callback. The function will continue to be fired until `false` is returned from the function.
+-- 
+-- This is similar to the `setInterval` vanilla JavaScript function, except there is no
+-- corresponding `clearInterval` function. (Instead, the return value from the supplied function is
+-- used to stop the interval.)
+-- 
+-- Note that this function will not handle saving and quitting. You must manually restart any
+-- intervals if the player saves and quits in the middle of a run.
+-- 
+-- @param func The function to repeatedly run on an interval.
+-- @param renderFrames The amount of game frames to wait between each run.
+-- @param runImmediately Whether or not to execute the function right now before waiting for the
+-- interval.
+function ____exports.setIntervalRenderFrames(self, func, renderFrames, runImmediately)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    local renderFrameCount = Isaac.GetFrameCount()
+    local functionFireFrame = renderFrameCount + renderFrames
+    local tuple = {functionFireFrame, func, renderFrames}
+    local ____v_run_intervalGameFunctionTuples_3 = v.run.intervalGameFunctionTuples
+    ____v_run_intervalGameFunctionTuples_3[#____v_run_intervalGameFunctionTuples_3 + 1] = tuple
+    if runImmediately then
+        func(nil)
+    end
+end
 return ____exports

package/functions/array.d.ts

@@ -37,7 +37,7 @@ export declare function arrayRemoveIndex<T>(originalArray: T[] | readonly T[], .
  * This function is variadic, meaning that you can specify N arguments to remove N elements.
  */
 export declare function arrayRemoveIndexInPlace<T>(array: T[], ...indexesToRemove: int[]): boolean;
-export declare function arrayToString<T>(array: T[]): string;
+export declare function arrayToString<T>(array: T[] | readonly T[]): string;
 /**
  * Helper function to combine two or more arrays. Returns a new array that is the composition of all
  * of the specified arrays.
@@ -56,6 +56,30 @@ export declare function combineArrays<T>(...arrays: Array<T[] | readonly T[]>):
 export declare function copyArray<T>(oldArray: T[] | readonly T[], numElements?: int): T[];
 /** Helper function to remove all of the elements in an array in-place. */
 export declare function emptyArray<T>(array: T[]): void;
+/**
+ * Helper function to get all possible combinations of the given array. This includes the
+ * combination of an empty array.
+ *
+ * For example, if this function is provided an array containing 1, 2, and 3, then it will return an
+ * array containing the following arrays:
+ *
+ * - []
+ * - [1]
+ * - [2]
+ * - [3]
+ * - [1, 2]
+ * - [1, 3]
+ * - [2, 3]
+ * - [1, 2, 3]
+ *
+ * From: https://github.com/firstandthird/combinations/blob/master/index.js
+ *
+ * @param array The array to get the combinations of.
+ * @param min Optional. The minimum number of elements to include in each combination. Default is 1.
+ * @param max Optional. The maximum number of elements to include in each combination. Default is
+ *            the length of the array.
+ */
+export declare function getArrayCombinations<T>(array: T[] | readonly T[], min?: int, max?: int): ReadonlyArray<readonly T[]>;
 /**
  * Helper function to get an array containing the indexes of an array.
  *
@@ -141,4 +165,9 @@ export declare function shuffleArray<T>(originalArray: T[] | readonly T[], seedO
  *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
  */
 export declare function shuffleArrayInPlace<T>(array: T[], seedOrRNG?: Seed | RNG): void;
+/** Helper function to sum every value in an array together. */
 export declare function sumArray(array: number[] | readonly number[]): number;
+/**
+ * Helper function to swap two different array elements. (The elements will be swapped in-place.)
+ */
+export declare function swapArrayElements<T>(array: T[], i: number, j: number): void;

package/functions/array.lua

@@ -8,6 +8,9 @@ local __TS__ArrayForEach = ____lualib.__TS__ArrayForEach
 local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
 local __TS__ArraySort = ____lualib.__TS__ArraySort
 local __TS__ArrayMap = ____lualib.__TS__ArrayMap
+local __TS__ArraySlice = ____lualib.__TS__ArraySlice
+local __TS__ArrayConcat = ____lualib.__TS__ArrayConcat
+local __TS__ArrayUnshift = ____lualib.__TS__ArrayUnshift
 local __TS__ObjectKeys = ____lualib.__TS__ObjectKeys
 local __TS__ArraySome = ____lualib.__TS__ArraySome
 local __TS__ArrayReduce = ____lualib.__TS__ArrayReduce
@@ -50,16 +53,20 @@ function ____exports.shuffleArrayInPlace(self, array, seedOrRNG)
         seedOrRNG = getRandomSeed(nil)
     end
     local currentIndex = #array
-    local randomIndex
     local rng = isRNG(nil, seedOrRNG) and seedOrRNG or newRNG(nil, seedOrRNG)
     while currentIndex > 0 do
         currentIndex = currentIndex - 1
-        randomIndex = ____exports.getRandomArrayIndex(nil, array, rng)
-        local ____temp_0 = {array[randomIndex + 1], array[currentIndex + 1]}
-        array[currentIndex + 1] = ____temp_0[1]
-        array[randomIndex + 1] = ____temp_0[2]
+        local randomIndex = ____exports.getRandomArrayIndex(nil, array, rng)
+        ____exports.swapArrayElements(nil, array, currentIndex, randomIndex)
     end
 end
+--- Helper function to swap two different array elements. (The elements will be swapped in-place.)
+function ____exports.swapArrayElements(self, array, i, j)
+    local value1 = array[i + 1]
+    local value2 = array[j + 1]
+    array[i + 1] = value2
+    array[j + 1] = value1
+end
 --- Helper function for determining if two arrays contain the exact same elements. Note that this
 -- only performs a shallow comparison.
 function ____exports.arrayEquals(self, array1, array2)
@@ -201,6 +208,77 @@ end
 function ____exports.emptyArray(self, array)
     __TS__ArraySplice(array, 0, #array)
 end
+--- Helper function to get all possible combinations of the given array. This includes the
+-- combination of an empty array.
+-- 
+-- For example, if this function is provided an array containing 1, 2, and 3, then it will return an
+-- array containing the following arrays:
+-- 
+-- - []
+-- - [1]
+-- - [2]
+-- - [3]
+-- - [1, 2]
+-- - [1, 3]
+-- - [2, 3]
+-- - [1, 2, 3]
+-- 
+-- From: https://github.com/firstandthird/combinations/blob/master/index.js
+-- 
+-- @param array The array to get the combinations of.
+-- @param min Optional. The minimum number of elements to include in each combination. Default is 1.
+-- @param max Optional. The maximum number of elements to include in each combination. Default is
+-- the length of the array.
+function ____exports.getArrayCombinations(self, array, min, max)
+    if min == nil or min <= 0 then
+        min = 1
+    end
+    if max == nil or max <= 0 then
+        max = #array
+    end
+    local addCombinations
+    addCombinations = function(____, n, src, got, all)
+        if n == 0 then
+            if #got > 0 then
+                all[#all + 1] = got
+            end
+            return
+        end
+        do
+            local j = 0
+            while j < #src do
+                local value = src[j + 1]
+                addCombinations(
+                    nil,
+                    n - 1,
+                    __TS__ArraySlice(src, j + 1),
+                    __TS__ArrayConcat(got, {value}),
+                    all
+                )
+                j = j + 1
+            end
+        end
+    end
+    local all = {}
+    do
+        local i = min
+        while i < #array do
+            addCombinations(
+                nil,
+                i,
+                array,
+                {},
+                all
+            )
+            i = i + 1
+        end
+    end
+    if #array == max then
+        all[#all + 1] = array
+    end
+    __TS__ArrayUnshift(all, {})
+    return all
+end
 --- Helper function to get an array containing the indexes of an array.
 -- 
 -- For example, an array of `["Apple", "Banana"]` would return an array of `[0, 1]`.
@@ -351,6 +429,7 @@ function ____exports.shuffleArray(self, originalArray, seedOrRNG)
     ____exports.shuffleArrayInPlace(nil, array, seedOrRNG)
     return array
 end
+--- Helper function to sum every value in an array together.
 function ____exports.sumArray(self, array)
     return __TS__ArrayReduce(
         array,

package/functions/bitwise.d.ts

@@ -1,4 +1,21 @@
 /// <reference types="isaac-typescript-definitions" />
+/// <reference types="isaac-typescript-definitions" />
+/// <reference types="isaac-typescript-definitions" />
+/// <reference types="isaac-typescript-definitions" />
+/** Helper function to convert a set of flags to a single `BitFlags` object. */
+export declare function arrayToBitFlags<T extends BitFlag | BitFlag128>(array: T[] | readonly T[]): BitFlags<T>;
+/** Helper function to convert an array of bits to the resulting decimal number. */
+export declare function convertBinaryToDecimal(bits: int[]): number;
+/** Helper function to convert a number to an array of bits. */
+export declare function convertDecimalToBinary(number: number): int[];
+/**
+ * Helper function to count the number of bits that are set to 1 in a binary representation of a
+ * number.
+ */
 export declare function countSetBits(n: int): int;
+/** Helper function to get the value of a specific but in a binary representation of a number. */
 export declare function getKBitOfN(k: int, n: int): int;
+/** Helper function to get the number of bits in a binary representation of a number. */
 export declare function getNumBitsOfN(n: int): int;
+/** Helper function to convert a set of flags to a single `BitFlags` object. */
+export declare function setToBitFlags<T extends BitFlag | BitFlag128>(set: Set<T> | ReadonlySet<T>): BitFlags<T>;

package/functions/bitwise.lua

@@ -1,4 +1,35 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ParseInt = ____lualib.__TS__ParseInt
+local __TS__Iterator = ____lualib.__TS__Iterator
 local ____exports = {}
+local ____flag = require("functions.flag")
+local addFlag = ____flag.addFlag
+--- Helper function to convert a set of flags to a single `BitFlags` object.
+function ____exports.arrayToBitFlags(self, array)
+    local flags = 0
+    for ____, flag in ipairs(array) do
+        flags = addFlag(nil, flags, flag)
+    end
+    return flags
+end
+--- Helper function to convert an array of bits to the resulting decimal number.
+function ____exports.convertBinaryToDecimal(self, bits)
+    local bitsString = table.concat(bits, "")
+    return __TS__ParseInt(bitsString, 2)
+end
+--- Helper function to convert a number to an array of bits.
+function ____exports.convertDecimalToBinary(self, number)
+    local bits = {}
+    local i = 0
+    while number > 0 do
+        bits[i + 1] = number % 2
+        number = math.floor(number / 2)
+        i = i + 1
+    end
+    return bits
+end
+--- Helper function to count the number of bits that are set to 1 in a binary representation of a
+-- number.
 function ____exports.countSetBits(self, n)
     local count = 0
     while n > 0 do
@@ -7,9 +38,11 @@ function ____exports.countSetBits(self, n)
     end
     return count
 end
+--- Helper function to get the value of a specific but in a binary representation of a number.
 function ____exports.getKBitOfN(self, k, n)
     return n >> k & 1
 end
+--- Helper function to get the number of bits in a binary representation of a number.
 function ____exports.getNumBitsOfN(self, n)
     local numBits = 0
     while n > 0 do
@@ -18,4 +51,12 @@ function ____exports.getNumBitsOfN(self, n)
     end
     return numBits
 end
+--- Helper function to convert a set of flags to a single `BitFlags` object.
+function ____exports.setToBitFlags(self, set)
+    local flags = 0
+    for ____, flag in __TS__Iterator(set:values()) do
+        flags = addFlag(nil, flags, flag)
+    end
+    return flags
+end
 return ____exports

package/functions/color.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="typescript-to-lua/language-extensions" />
 import { SerializationType } from "../enums/SerializationType";
 declare type SerializedColor = LuaTable<string, unknown> & {
-    readonly __serializedColorBrand: unique symbol;
+    readonly __serializedColorBrand: symbol;
 };
 interface CopyColorReturn {
     [SerializationType.NONE]: Color;

package/functions/doors.d.ts

@@ -7,6 +7,7 @@ export declare function closeAllDoors(): void;
 export declare function closeDoorFast(door: GridEntityDoor): void;
 export declare function doorSlotFlagToDoorSlot(doorSlotFlag: DoorSlotFlag): DoorSlot;
 export declare function doorSlotToDirection(doorSlot: DoorSlot): Direction;
+export declare function doorSlotToDoorSlotFlag(doorSlot: DoorSlot): DoorSlotFlag;
 export declare function getAngelRoomDoor(): GridEntityDoor | undefined;
 export declare function getDevilRoomDoor(): GridEntityDoor | undefined;
 /**
@@ -30,6 +31,11 @@ export declare function getDoorEnterPosition(door: GridEntityDoor): Vector;
  * amount of units.
  */
 export declare function getDoorEnterPositionOffset(doorSlot: DoorSlot): Vector;
+/**
+ * Helper function to convert an array of door slots or a set of door slots to the resulting bit
+ * flag number.
+ */
+export declare function getDoorSlotFlags(doorSlots: DoorSlot[] | readonly DoorSlot[] | Set<DoorSlot> | ReadonlySet<DoorSlot>): BitFlags<DoorSlotFlag>;
 /** Helper function to get the possible door slots that can exist for a given room shape. */
 export declare function getDoorSlotsForRoomShape(roomShape: RoomShape): ReadonlySet<DoorSlot>;
 /**