isaacscript-common 2.3.0 → 2.3.1

package/features/sirenHelpers.lua

@@ -0,0 +1,69 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ArrayFind = ____lualib.__TS__ArrayFind
+local ____exports = {}
+local postNPCInitSirenHelper, checkReturnFamiliarToPlayer, blacklistEntryExists, getSirenHelper, v
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local EntityType = ____isaac_2Dtypescript_2Ddefinitions.EntityType
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____featuresInitialized = require("featuresInitialized")
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____entity = require("functions.entity")
+local getEntities = ____entity.getEntities
+local ____exports = require("features.saveDataManager.exports")
+local saveDataManager = ____exports.saveDataManager
+function postNPCInitSirenHelper(self, npc)
+    checkReturnFamiliarToPlayer(nil, npc)
+end
+function checkReturnFamiliarToPlayer(self, npc)
+    if npc.Target == nil then
+        return
+    end
+    local familiar = npc.Target:ToFamiliar()
+    if familiar == nil then
+        return
+    end
+    if blacklistEntryExists(nil, familiar.Variant, familiar.SubType) then
+        npc:Remove()
+        familiar:AddToFollowers()
+    end
+end
+function blacklistEntryExists(self, incomingFamiliarVariant, incomingFamiliarSubType)
+    for ____, ____value in ipairs(v.run.familiarBlacklist) do
+        local familiarVariant = ____value[1]
+        local familiarSubType = ____value[2]
+        if incomingFamiliarVariant == familiarVariant and familiarSubType == incomingFamiliarSubType then
+            return true
+        end
+        if incomingFamiliarVariant == familiarVariant and familiarSubType == nil then
+            return true
+        end
+    end
+    return false
+end
+function getSirenHelper(self, familiar)
+    local familiarPtrHash = GetPtrHash(familiar)
+    local sirenHelpers = getEntities(nil, EntityType.SIREN_HELPER)
+    return __TS__ArrayFind(
+        sirenHelpers,
+        function(____, sirenHelper) return sirenHelper.Target ~= nil and GetPtrHash(sirenHelper.Target) == familiarPtrHash end
+    )
+end
+local FEATURE_NAME = "siren helpers"
+v = {run = {familiarBlacklist = {}}}
+function ____exports.sirenHelpersInit(self, mod)
+    saveDataManager(nil, "sirenHelpers", v)
+    mod:AddCallback(ModCallback.POST_NPC_INIT, postNPCInitSirenHelper, EntityType.SIREN_HELPER)
+end
+function ____exports.setFamiliarNoSirenSteal(self, familiarVariant, familiarSubType)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    if blacklistEntryExists(nil, familiarVariant, familiarSubType) then
+        return
+    end
+    local ____v_run_familiarBlacklist_0 = v.run.familiarBlacklist
+    ____v_run_familiarBlacklist_0[#____v_run_familiarBlacklist_0 + 1] = {familiarVariant, familiarSubType}
+end
+function ____exports.hasSirenStolenFamiliar(self, familiar)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    return getSirenHelper(nil, familiar) ~= nil
+end
+return ____exports

package/features/taintedLazarusPlayers.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="isaac-typescript-definitions" />
+/**
+ * Helper function to get the other version of Tainted Lazarus.
+ *
+ * - On Tainted Lazarus, returns the player object for Dead Tainted Lazarus.
+ * - On Dead Tainted Lazarus, returns the player object for Tainted Lazarus.
+ * - Returns undefined if player object retrieval failed for any reason.
+ *
+ * If you call the `EntityPlayer.Exists` method on the returned object, it will return false.
+ * However, you can still call the other methods like you normally would (e.g.
+ * `EntityPlayer.AddCollectible`).
+ */
+export declare function getTaintedLazarusSubPlayer(player: EntityPlayer): EntityPlayer | undefined;

package/features/taintedLazarusPlayers.lua

@@ -0,0 +1,74 @@
+local ____lualib = require("lualib_bundle")
+local Map = ____lualib.Map
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local postPlayerInit, checkDequeue, v
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local PlayerType = ____isaac_2Dtypescript_2Ddefinitions.PlayerType
+local ____featuresInitialized = require("featuresInitialized")
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____exports = require("features.saveDataManager.exports")
+local saveDataManager = ____exports.saveDataManager
+function postPlayerInit(self, player)
+    local entityPtr = EntityPtr(player)
+    local character = player:GetPlayerType()
+    if character == PlayerType.LAZARUS_B then
+        local ____v_run_queuedTaintedLazarus_0 = v.run.queuedTaintedLazarus
+        ____v_run_queuedTaintedLazarus_0[#____v_run_queuedTaintedLazarus_0 + 1] = entityPtr
+    elseif character == PlayerType.LAZARUS_2_B then
+        local ____v_run_queuedDeadTaintedLazarus_1 = v.run.queuedDeadTaintedLazarus
+        ____v_run_queuedDeadTaintedLazarus_1[#____v_run_queuedDeadTaintedLazarus_1 + 1] = entityPtr
+    else
+        return
+    end
+    checkDequeue(nil)
+end
+function checkDequeue(self)
+    if #v.run.queuedTaintedLazarus == 0 or #v.run.queuedDeadTaintedLazarus == 0 then
+        return
+    end
+    local taintedLazarusPtr = table.remove(v.run.queuedTaintedLazarus, 1)
+    local deadTaintedLazarusPtr = table.remove(v.run.queuedDeadTaintedLazarus, 1)
+    if taintedLazarusPtr == nil or deadTaintedLazarusPtr == nil then
+        return
+    end
+    local taintedLazarus = taintedLazarusPtr.Ref
+    local deadTaintedLazarus = deadTaintedLazarusPtr.Ref
+    if taintedLazarus == nil or deadTaintedLazarus == nil then
+        return
+    end
+    local taintedLazarusPtrHash = GetPtrHash(taintedLazarus)
+    local deadTaintedLazarusPtrHash = GetPtrHash(deadTaintedLazarus)
+    v.run.subPlayerMap:set(taintedLazarusPtrHash, deadTaintedLazarusPtr)
+    v.run.subPlayerMap:set(deadTaintedLazarusPtrHash, taintedLazarusPtr)
+end
+local FEATURE_NAME = "Tainted Lazarus entity finder"
+v = {run = {
+    queuedTaintedLazarus = {},
+    queuedDeadTaintedLazarus = {},
+    subPlayerMap = __TS__New(Map)
+}}
+function ____exports.taintedLazarusPlayersInit(self, mod)
+    saveDataManager(
+        nil,
+        "taintedLazarusPlayers",
+        v,
+        function() return false end
+    )
+    mod:AddCallback(ModCallback.POST_PLAYER_INIT, postPlayerInit)
+end
+function ____exports.getTaintedLazarusSubPlayer(self, player)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    local ptrHash = GetPtrHash(player)
+    local entityPtr = v.run.subPlayerMap:get(ptrHash)
+    if entityPtr == nil then
+        return nil
+    end
+    local entity = entityPtr.Ref
+    if entity == nil then
+        return nil
+    end
+    return entity:ToPlayer()
+end
+return ____exports

package/featuresInitialized.d.ts

@@ -0,0 +1 @@
+export {};

package/featuresInitialized.lua

@@ -0,0 +1,14 @@
+local ____exports = {}
+local featuresInitialized = false
+function ____exports.areFeaturesInitialized(self)
+    return featuresInitialized
+end
+function ____exports.errorIfFeaturesNotInitialized(self, featureName)
+    if not ____exports.areFeaturesInitialized(nil) then
+        error(("The " .. featureName) .. " is not initialized. You must first upgrade your mod object by calling the \"upgradeMod\" function.")
+    end
+end
+function ____exports.setFeaturesInitialized(self)
+    featuresInitialized = true
+end
+return ____exports

package/functions/array.d.ts

@@ -0,0 +1,141 @@
+/// <reference types="isaac-typescript-definitions" />
+/**
+ * Helper function for determining if two arrays contain the exact same elements. Note that this
+ * only performs a shallow comparison.
+ */
+export declare function arrayEquals<T>(array1: T[] | readonly T[], array2: T[] | readonly T[]): boolean;
+/**
+ * Shallow copies and removes the specified element(s) from the array. Returns the copied array. If
+ * the specified element(s) are not found in the array, it will simply return a shallow copy of the
+ * array.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ */
+export declare function arrayRemove<T>(originalArray: T[] | readonly T[], ...elementsToRemove: T[]): T[];
+/**
+ * Removes the specified element(s) from the array. If the specified element(s) are not found in the
+ * array, this function will do nothing. Returns whether or not one or more elements were removed.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ */
+export declare function arrayRemoveInPlace<T>(array: T[], ...elementsToRemove: T[]): boolean;
+/**
+ * Shallow copies and removes the elements at the specified indexes from the array. Returns the
+ * copied array. If the specified indexes are not found in the array, it will simply return a
+ * shallow copy of the array.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ */
+export declare function arrayRemoveIndex<T>(originalArray: T[] | readonly T[], ...indexesToRemove: int[]): T[];
+/**
+ * Removes the elements at the specified indexes from the array. If the specified indexes are not
+ * found in the array, this function will do nothing. Returns whether or not one or more elements
+ * were removed.
+ *
+ * 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;
+/**
+ * Helper function to combine two or more arrays. Returns a new array that is the composition of all
+ * of the specified arrays.
+ *
+ * This function is variadic, meaning that you can specify N arguments to combine N arrays. Note
+ * that this will only perform a shallow copy of the array elements.
+ */
+export declare function combineArrays<T>(...arrays: Array<T[] | readonly T[]>): T[];
+/**
+ * Helper function to perform a shallow copy.
+ *
+ * @param oldArray The array to copy.
+ * @param numElements Optional. If specified, will only copy the first N elements. By default, the
+ *                    entire array will be copied.
+ */
+export declare function copyArray<T>(oldArray: T[] | readonly T[], numElements?: int): T[];
+export declare function emptyArray<T>(array: T[]): void;
+/**
+ * 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]`.
+ */
+export declare function getArrayIndexes<T>(array: T[] | readonly T[]): int[];
+/**
+ * Helper function to return the last element of an array.
+ *
+ * If the array is empty, this will return undefined.
+ */
+export declare function getLastElement<T>(array: T[]): T | undefined;
+/**
+ * Helper function to get a random element from the provided array.
+ *
+ * @param array The array to get an element from.
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param exceptions Optional. An array of elements to skip over if selected.
+ */
+export declare function getRandomArrayElement<T>(array: T[] | readonly T[], seedOrRNG?: Seed | RNG, exceptions?: T[] | readonly T[]): T;
+/**
+ * Helper function to get a random element from the provided array. Once the random element is
+ * decided, it is then removed from the array (in-place).
+ *
+ * @param array The array to get an element from.
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param exceptions Optional. An array of elements to skip over if selected.
+ */
+export declare function getRandomArrayElementAndRemove<T>(array: T[], seedOrRNG?: Seed | RNG, exceptions?: T[] | readonly T[]): T;
+/**
+ * Helper function to get a random index from the provided array.
+ *
+ * @param array The array to get the index from.
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ */
+export declare function getRandomArrayIndex<T>(array: T[] | readonly T[], seedOrRNG?: Seed | RNG): int;
+/**
+ * Initializes an array with all elements containing the specified default value.
+ *
+ * For example:
+ *
+ * ```ts
+ * const playerTransformations = initArray(false, PlayerForm.NUM_PLAYER_FORMS - 1);
+ * ```
+ */
+export declare function initArray<T>(defaultValue: T, size: int): T[];
+/**
+ * Since Lua uses tables for every non-primitive data structure, it is non-trivial to determine if a
+ * particular table is being used as an array. `isArray` returns true if:
+ *
+ * - the table contains all numerical indexes that are contiguous, starting at 1
+ * - the table has no keys (i.e. an "empty" table)
+ */
+export declare function isArray(object: unknown): object is unknown[];
+/**
+ * Helper function to see if every element in the array is N + 1.
+ *
+ * For example, `[2, 3, 4]` would return true, and `[2, 3, 5]` would return false.
+ */
+export declare function isArrayContiguous(array: int[]): boolean;
+/** Checks if an array is in the provided 2-dimensional array. */
+export declare function isArrayInArray<T>(arrayToMatch: T[] | readonly T[], parentArray: Array<T[] | readonly T[]>): boolean;
+/**
+ * Shallow copies and shuffles the array using the Fisher-Yates algorithm. Returns the copied array.
+ *
+ * From: https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
+ *
+ * @param originalArray The array to shuffle.
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ */
+export declare function shuffleArray<T>(originalArray: T[] | readonly T[], seedOrRNG?: Seed | RNG): T[];
+/**
+ * Shuffles the provided array in-place using the Fisher-Yates algorithm.
+ *
+ * From: https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
+ *
+ * @param array The array to shuffle.
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ */
+export declare function shuffleArrayInPlace<T>(array: T[], seedOrRNG?: Seed | RNG): void;
+export declare function sumArray(array: number[] | readonly number[]): number;

package/functions/array.lua

@@ -0,0 +1,269 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ArrayEvery = ____lualib.__TS__ArrayEvery
+local Set = ____lualib.Set
+local __TS__New = ____lualib.__TS__New
+local __TS__ArrayIndexOf = ____lualib.__TS__ArrayIndexOf
+local __TS__ArraySplice = ____lualib.__TS__ArraySplice
+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__ArraySome = ____lualib.__TS__ArraySome
+local __TS__ArrayReduce = ____lualib.__TS__ArrayReduce
+local ____exports = {}
+local ____random = require("functions.random")
+local getRandomInt = ____random.getRandomInt
+local ____rng = require("functions.rng")
+local getRandomSeed = ____rng.getRandomSeed
+local isRNG = ____rng.isRNG
+local newRNG = ____rng.newRNG
+local ____utils = require("functions.utils")
+local erange = ____utils.erange
+local ____repeat = ____utils["repeat"]
+function ____exports.getRandomArrayIndex(self, array, seedOrRNG)
+    if seedOrRNG == nil then
+        seedOrRNG = getRandomSeed(nil)
+    end
+    if #array == 0 then
+        error("Failed to get a random array index since the provided array is empty.")
+    end
+    return getRandomInt(nil, 0, #array - 1, seedOrRNG)
+end
+function ____exports.shuffleArrayInPlace(self, array, seedOrRNG)
+    if seedOrRNG == nil then
+        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]
+    end
+end
+function ____exports.arrayEquals(self, array1, array2)
+    if #array1 ~= #array2 then
+        return false
+    end
+    return __TS__ArrayEvery(
+        array1,
+        function(____, array1Element, i)
+            local array2Element = array2[i + 1]
+            return array1Element == array2Element
+        end
+    )
+end
+function ____exports.arrayRemove(self, originalArray, ...)
+    local elementsToRemove = {...}
+    local elementsToRemoveSet = __TS__New(Set, elementsToRemove)
+    local array = {}
+    for ____, element in ipairs(originalArray) do
+        if not elementsToRemoveSet:has(element) then
+            array[#array + 1] = element
+        end
+    end
+    return array
+end
+function ____exports.arrayRemoveInPlace(self, array, ...)
+    local elementsToRemove = {...}
+    local removedOneOrMoreElements = false
+    for ____, element in ipairs(elementsToRemove) do
+        local index = __TS__ArrayIndexOf(array, element)
+        if index > -1 then
+            removedOneOrMoreElements = true
+            __TS__ArraySplice(array, index, 1)
+        end
+    end
+    return removedOneOrMoreElements
+end
+function ____exports.arrayRemoveIndex(self, originalArray, ...)
+    local indexesToRemove = {...}
+    local indexesToRemoveSet = __TS__New(Set, indexesToRemove)
+    local array = {}
+    __TS__ArrayForEach(
+        originalArray,
+        function(____, element, i)
+            if not indexesToRemoveSet:has(i) then
+                array[#array + 1] = element
+            end
+        end
+    )
+    return array
+end
+function ____exports.arrayRemoveIndexInPlace(self, array, ...)
+    local indexesToRemove = {...}
+    local legalIndexes = __TS__ArrayFilter(
+        indexesToRemove,
+        function(____, i) return i >= 0 and i < #array end
+    )
+    __TS__ArraySort(legalIndexes)
+    if #legalIndexes == 0 then
+        return false
+    end
+    do
+        local i = #array - 1
+        while i >= 0 do
+            __TS__ArraySplice(array, i, 1)
+            i = i - 1
+        end
+    end
+    return true
+end
+function ____exports.arrayToString(self, array)
+    if #array == 0 then
+        return "[]"
+    end
+    local strings = __TS__ArrayMap(
+        array,
+        function(____, element) return tostring(element) end
+    )
+    local commaSeparatedStrings = table.concat(strings, ", ")
+    return ("[" .. commaSeparatedStrings) .. "]"
+end
+function ____exports.combineArrays(self, ...)
+    local arrays = {...}
+    local elements = {}
+    for ____, array in ipairs(arrays) do
+        for ____, element in ipairs(array) do
+            elements[#elements + 1] = element
+        end
+    end
+    return elements
+end
+function ____exports.copyArray(self, oldArray, numElements)
+    if numElements == nil then
+        numElements = #oldArray
+    end
+    local newArray = {}
+    do
+        local i = 0
+        while i < numElements do
+            local oldElement = oldArray[i + 1]
+            if oldElement ~= nil then
+                newArray[#newArray + 1] = oldElement
+            end
+            i = i + 1
+        end
+    end
+    return newArray
+end
+function ____exports.emptyArray(self, array)
+    __TS__ArraySplice(array, 0, #array)
+end
+function ____exports.getArrayIndexes(self, array)
+    return erange(nil, #array)
+end
+function ____exports.getLastElement(self, array)
+    return array[#array]
+end
+function ____exports.getRandomArrayElement(self, array, seedOrRNG, exceptions)
+    if seedOrRNG == nil then
+        seedOrRNG = getRandomSeed(nil)
+    end
+    if exceptions == nil then
+        exceptions = {}
+    end
+    if #array == 0 then
+        error("Failed to get a random array element since the provided array is empty.")
+    end
+    local arrayWithoutExceptions = ____exports.arrayRemove(
+        nil,
+        array,
+        table.unpack(exceptions)
+    )
+    local randomIndex = ____exports.getRandomArrayIndex(nil, arrayWithoutExceptions, seedOrRNG)
+    local randomElement = arrayWithoutExceptions[randomIndex + 1]
+    if randomElement == nil then
+        error(("Failed to get a random array element since the random index of " .. tostring(randomIndex)) .. " was not valid.")
+    end
+    return randomElement
+end
+function ____exports.getRandomArrayElementAndRemove(self, array, seedOrRNG, exceptions)
+    if seedOrRNG == nil then
+        seedOrRNG = getRandomSeed(nil)
+    end
+    if exceptions == nil then
+        exceptions = {}
+    end
+    local randomArrayElement = ____exports.getRandomArrayElement(nil, array, seedOrRNG, exceptions)
+    ____exports.arrayRemoveInPlace(nil, array, randomArrayElement)
+    return randomArrayElement
+end
+function ____exports.initArray(self, defaultValue, size)
+    local array = {}
+    ____repeat(
+        nil,
+        size,
+        function()
+            array[#array + 1] = defaultValue
+        end
+    )
+    return array
+end
+function ____exports.isArray(self, object)
+    if type(object) ~= "table" then
+        return false
+    end
+    local ____table = object
+    local metatable = getmetatable(____table)
+    if metatable ~= nil then
+        return false
+    end
+    local numEntries = 0
+    for key in pairs(____table) do
+        numEntries = numEntries + 1
+        if type(key) ~= "number" then
+            return false
+        end
+    end
+    if numEntries == 0 then
+        return true
+    end
+    do
+        local i = 1
+        while i <= numEntries do
+            local element = ____table[i]
+            if element == nil then
+                return false
+            end
+            i = i + 1
+        end
+    end
+    return true
+end
+function ____exports.isArrayContiguous(self, array)
+    local lastValue
+    for ____, element in ipairs(array) do
+        if lastValue == nil then
+            lastValue = element - 1
+        end
+        if element ~= lastValue - 1 then
+            return false
+        end
+    end
+    return true
+end
+function ____exports.isArrayInArray(self, arrayToMatch, parentArray)
+    return __TS__ArraySome(
+        parentArray,
+        function(____, element) return ____exports.arrayEquals(nil, element, arrayToMatch) end
+    )
+end
+function ____exports.shuffleArray(self, originalArray, seedOrRNG)
+    if seedOrRNG == nil then
+        seedOrRNG = getRandomSeed(nil)
+    end
+    local array = ____exports.copyArray(nil, originalArray)
+    ____exports.shuffleArrayInPlace(nil, array, seedOrRNG)
+    return array
+end
+function ____exports.sumArray(self, array)
+    return __TS__ArrayReduce(
+        array,
+        function(____, accumulator, element) return accumulator + element end
+    )
+end
+return ____exports

package/functions/benchmark.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="isaac-typescript-definitions" />
+/**
+ * Helper function to benchmark the performance of a function.
+ *
+ * This function is variadic, which means that you can supply as many as you want to benchmark.
+ *
+ * @returns An array containing the average time in milliseconds for each function. (This will also
+ *          be printed to the log.)
+ */
+export declare function benchmark(numTrials: int, ...functions: Array<() => void>): int[];

package/functions/benchmark.lua

@@ -0,0 +1,32 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ArrayForEach = ____lualib.__TS__ArrayForEach
+local ____exports = {}
+local ____log = require("functions.log")
+local log = ____log.log
+function ____exports.benchmark(self, numTrials, ...)
+    local functions = {...}
+    log(((("Benchmarking " .. tostring(#functions)) .. " function(s) with ") .. tostring(numTrials)) .. " trials.")
+    local averages = {}
+    __TS__ArrayForEach(
+        functions,
+        function(____, func, i)
+            local totalTimeMilliseconds = 0
+            do
+                local j = 0
+                while j < numTrials do
+                    local startTimeMilliseconds = Isaac.GetTime()
+                    func(nil)
+                    local endTimeMilliseconds = Isaac.GetTime()
+                    local elapsedTimeMilliseconds = endTimeMilliseconds - startTimeMilliseconds
+                    totalTimeMilliseconds = totalTimeMilliseconds + elapsedTimeMilliseconds
+                    j = j + 1
+                end
+            end
+            local averageTimeMilliseconds = totalTimeMilliseconds / numTrials
+            log(((("The average time of the function at index " .. tostring(i)) .. " is: ") .. tostring(averageTimeMilliseconds)) .. " milliseconds")
+            averages[#averages + 1] = averageTimeMilliseconds
+        end
+    )
+    return averages
+end
+return ____exports

package/functions/bitwise.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="isaac-typescript-definitions" />
+export declare function countSetBits(n: int): int;
+export declare function getKBitOfN(k: int, n: int): int;
+export declare function getNumBitsOfN(n: int): int;

package/functions/bitwise.lua

@@ -0,0 +1,21 @@
+local ____exports = {}
+function ____exports.countSetBits(self, n)
+    local count = 0
+    while n > 0 do
+        n = n & n - 1
+        count = count + 1
+    end
+    return count
+end
+function ____exports.getKBitOfN(self, k, n)
+    return n >> k & 1
+end
+function ____exports.getNumBitsOfN(self, n)
+    local numBits = 0
+    while n > 0 do
+        numBits = numBits + 1
+        n = n >> 1
+    end
+    return numBits
+end
+return ____exports