isaacscript-common 87.2.1 → 87.3.0

package/dist/lualib_bundle.lua

@@ -588,6 +588,12 @@ local function __TS__ArrayWith(self, index, value)
     return copy
 end
 
+local function __TS__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(...)
+    return instance
+end
+
 local function __TS__InstanceOf(obj, classTbl)
     if type(classTbl) ~= "table" then
         error("Right-hand side of 'instanceof' is not an object", 0)
@@ -607,12 +613,6 @@ local function __TS__InstanceOf(obj, classTbl)
     return false
 end
 
-local function __TS__New(target, ...)
-    local instance = setmetatable({}, target.prototype)
-    instance:____constructor(...)
-    return instance
-end
-
 local function __TS__Class(self)
     local c = {prototype = {}}
     c.prototype.__index = c.prototype
@@ -620,35 +620,27 @@ local function __TS__Class(self)
     return c
 end
 
-local function __TS__FunctionBind(fn, ...)
-    local boundArgs = {...}
-    return function(____, ...)
-        local args = {...}
-        __TS__ArrayUnshift(
-            args,
-            __TS__Unpack(boundArgs)
-        )
-        return fn(__TS__Unpack(args))
-    end
-end
-
 local __TS__Promise
 do
-    local function promiseDeferred(self)
+    local function makeDeferredPromiseFactory()
         local resolve
         local reject
-        local promise = __TS__New(
-            __TS__Promise,
-            function(____, res, rej)
-                resolve = res
-                reject = rej
-            end
-        )
-        return {promise = promise, resolve = resolve, reject = reject}
+        local function executor(____, res, rej)
+            resolve = res
+            reject = rej
+        end
+        return function()
+            local promise = __TS__New(__TS__Promise, executor)
+            return promise, resolve, reject
+        end
+    end
+    local makeDeferredPromise = makeDeferredPromiseFactory()
+    local function isPromiseLike(value)
+        return __TS__InstanceOf(value, __TS__Promise)
     end
-    local function isPromiseLike(self, thing)
-        return __TS__InstanceOf(thing, __TS__Promise)
+    local function doNothing(self)
     end
+    local ____pcall = _G.pcall
     __TS__Promise = __TS__Class()
     __TS__Promise.name = "__TS__Promise"
     function __TS__Promise.prototype.____constructor(self, executor)
@@ -656,206 +648,176 @@ do
         self.fulfilledCallbacks = {}
         self.rejectedCallbacks = {}
         self.finallyCallbacks = {}
-        do
-            local function ____catch(e)
-                self:reject(e)
-            end
-            local ____try, ____hasReturned = pcall(function()
-                executor(
-                    nil,
-                    __TS__FunctionBind(self.resolve, self),
-                    __TS__FunctionBind(self.reject, self)
-                )
-            end)
-            if not ____try then
-                ____catch(____hasReturned)
-            end
+        local success, ____error = ____pcall(
+            executor,
+            nil,
+            function(____, v) return self:resolve(v) end,
+            function(____, err) return self:reject(err) end
+        )
+        if not success then
+            self:reject(____error)
         end
     end
-    function __TS__Promise.resolve(data)
-        local promise = __TS__New(
-            __TS__Promise,
-            function()
-            end
-        )
+    function __TS__Promise.resolve(value)
+        if __TS__InstanceOf(value, __TS__Promise) then
+            return value
+        end
+        local promise = __TS__New(__TS__Promise, doNothing)
         promise.state = 1
-        promise.value = data
+        promise.value = value
         return promise
     end
     function __TS__Promise.reject(reason)
-        local promise = __TS__New(
-            __TS__Promise,
-            function()
-            end
-        )
+        local promise = __TS__New(__TS__Promise, doNothing)
         promise.state = 2
         promise.rejectionReason = reason
         return promise
     end
     __TS__Promise.prototype["then"] = function(self, onFulfilled, onRejected)
-        local ____promiseDeferred_result_0 = promiseDeferred(nil)
-        local promise = ____promiseDeferred_result_0.promise
-        local resolve = ____promiseDeferred_result_0.resolve
-        local reject = ____promiseDeferred_result_0.reject
-        local isFulfilled = self.state == 1
-        local isRejected = self.state == 2
-        if onFulfilled then
-            local internalCallback = self:createPromiseResolvingCallback(onFulfilled, resolve, reject)
-            local ____self_fulfilledCallbacks_1 = self.fulfilledCallbacks
-            ____self_fulfilledCallbacks_1[#____self_fulfilledCallbacks_1 + 1] = internalCallback
-            if isFulfilled then
-                internalCallback(nil, self.value)
-            end
-        else
-            local ____self_fulfilledCallbacks_2 = self.fulfilledCallbacks
-            ____self_fulfilledCallbacks_2[#____self_fulfilledCallbacks_2 + 1] = function(____, v) return resolve(nil, v) end
-        end
-        if onRejected then
-            local internalCallback = self:createPromiseResolvingCallback(onRejected, resolve, reject)
-            local ____self_rejectedCallbacks_3 = self.rejectedCallbacks
-            ____self_rejectedCallbacks_3[#____self_rejectedCallbacks_3 + 1] = internalCallback
-            if isRejected then
-                internalCallback(nil, self.rejectionReason)
-            end
-        else
-            local ____self_rejectedCallbacks_4 = self.rejectedCallbacks
-            ____self_rejectedCallbacks_4[#____self_rejectedCallbacks_4 + 1] = function(____, err) return reject(nil, err) end
-        end
-        if isFulfilled then
-            resolve(nil, self.value)
+        local promise, resolve, reject = makeDeferredPromise()
+        self:addCallbacks(
+            onFulfilled and self:createPromiseResolvingCallback(onFulfilled, resolve, reject) or resolve,
+            onRejected and self:createPromiseResolvingCallback(onRejected, resolve, reject) or reject
+        )
+        return promise
+    end
+    function __TS__Promise.prototype.addCallbacks(self, fulfilledCallback, rejectedCallback)
+        if self.state == 1 then
+            return fulfilledCallback(nil, self.value)
         end
-        if isRejected then
-            reject(nil, self.rejectionReason)
+        if self.state == 2 then
+            return rejectedCallback(nil, self.rejectionReason)
         end
-        return promise
+        local ____self_fulfilledCallbacks_0 = self.fulfilledCallbacks
+        ____self_fulfilledCallbacks_0[#____self_fulfilledCallbacks_0 + 1] = fulfilledCallback
+        local ____self_rejectedCallbacks_1 = self.rejectedCallbacks
+        ____self_rejectedCallbacks_1[#____self_rejectedCallbacks_1 + 1] = rejectedCallback
     end
     function __TS__Promise.prototype.catch(self, onRejected)
         return self["then"](self, nil, onRejected)
     end
     function __TS__Promise.prototype.finally(self, onFinally)
         if onFinally then
-            local ____self_finallyCallbacks_5 = self.finallyCallbacks
-            ____self_finallyCallbacks_5[#____self_finallyCallbacks_5 + 1] = onFinally
+            local ____self_finallyCallbacks_2 = self.finallyCallbacks
+            ____self_finallyCallbacks_2[#____self_finallyCallbacks_2 + 1] = onFinally
             if self.state ~= 0 then
                 onFinally(nil)
             end
         end
         return self
     end
-    function __TS__Promise.prototype.resolve(self, data)
-        if __TS__InstanceOf(data, __TS__Promise) then
-            data["then"](
-                data,
+    function __TS__Promise.prototype.resolve(self, value)
+        if isPromiseLike(value) then
+            return value:addCallbacks(
                 function(____, v) return self:resolve(v) end,
                 function(____, err) return self:reject(err) end
             )
-            return
         end
         if self.state == 0 then
             self.state = 1
-            self.value = data
-            for ____, callback in ipairs(self.fulfilledCallbacks) do
-                callback(nil, data)
-            end
-            for ____, callback in ipairs(self.finallyCallbacks) do
-                callback(nil)
-            end
+            self.value = value
+            return self:invokeCallbacks(self.fulfilledCallbacks, value)
         end
     end
     function __TS__Promise.prototype.reject(self, reason)
         if self.state == 0 then
             self.state = 2
             self.rejectionReason = reason
-            for ____, callback in ipairs(self.rejectedCallbacks) do
-                callback(nil, reason)
+            return self:invokeCallbacks(self.rejectedCallbacks, reason)
+        end
+    end
+    function __TS__Promise.prototype.invokeCallbacks(self, callbacks, value)
+        local callbacksLength = #callbacks
+        local finallyCallbacks = self.finallyCallbacks
+        local finallyCallbacksLength = #finallyCallbacks
+        if callbacksLength ~= 0 then
+            for i = 1, callbacksLength - 1 do
+                callbacks[i](callbacks, value)
             end
-            for ____, callback in ipairs(self.finallyCallbacks) do
-                callback(nil)
+            if finallyCallbacksLength == 0 then
+                return callbacks[callbacksLength](callbacks, value)
             end
+            callbacks[callbacksLength](callbacks, value)
+        end
+        if finallyCallbacksLength ~= 0 then
+            for i = 1, finallyCallbacksLength - 1 do
+                finallyCallbacks[i](finallyCallbacks)
+            end
+            return finallyCallbacks[finallyCallbacksLength](finallyCallbacks)
         end
     end
     function __TS__Promise.prototype.createPromiseResolvingCallback(self, f, resolve, reject)
         return function(____, value)
-            do
-                local function ____catch(e)
-                    reject(nil, e)
-                end
-                local ____try, ____hasReturned = pcall(function()
-                    self:handleCallbackData(
-                        f(nil, value),
-                        resolve,
-                        reject
-                    )
-                end)
-                if not ____try then
-                    ____catch(____hasReturned)
-                end
+            local success, resultOrError = ____pcall(f, nil, value)
+            if not success then
+                return reject(nil, resultOrError)
             end
+            return self:handleCallbackValue(resultOrError, resolve, reject)
         end
     end
-    function __TS__Promise.prototype.handleCallbackData(self, data, resolve, reject)
-        if isPromiseLike(nil, data) then
-            local nextpromise = data
+    function __TS__Promise.prototype.handleCallbackValue(self, value, resolve, reject)
+        if isPromiseLike(value) then
+            local nextpromise = value
             if nextpromise.state == 1 then
-                resolve(nil, nextpromise.value)
+                return resolve(nil, nextpromise.value)
             elseif nextpromise.state == 2 then
-                reject(nil, nextpromise.rejectionReason)
+                return reject(nil, nextpromise.rejectionReason)
             else
-                data["then"](data, resolve, reject)
+                return nextpromise:addCallbacks(resolve, reject)
             end
         else
-            resolve(nil, data)
+            return resolve(nil, value)
         end
     end
 end
 
-local function __TS__AsyncAwaiter(generator)
-    return __TS__New(
-        __TS__Promise,
-        function(____, resolve, reject)
-            local adopt, fulfilled, step, resolved, asyncCoroutine
-            function adopt(self, value)
-                return __TS__InstanceOf(value, __TS__Promise) and value or __TS__Promise.resolve(value)
-            end
-            function fulfilled(self, value)
-                local success, resultOrError = coroutine.resume(asyncCoroutine, value)
-                if success then
-                    step(nil, resultOrError)
-                else
-                    reject(nil, resultOrError)
+local __TS__AsyncAwaiter, __TS__Await
+do
+    local cocreate = coroutine.create
+    local coresume = coroutine.resume
+    local costatus = coroutine.status
+    local coyield = coroutine.yield
+    function __TS__AsyncAwaiter(generator)
+        return __TS__New(
+            __TS__Promise,
+            function(____, resolve, reject)
+                local fulfilled, step, resolved, asyncCoroutine
+                function fulfilled(self, value)
+                    local success, resultOrError = coresume(asyncCoroutine, value)
+                    if success then
+                        return step(resultOrError)
+                    end
+                    return reject(nil, resultOrError)
                 end
-            end
-            function step(self, result)
-                if resolved then
-                    return
+                function step(result)
+                    if resolved then
+                        return
+                    end
+                    if costatus(asyncCoroutine) == "dead" then
+                        return resolve(nil, result)
+                    end
+                    return __TS__Promise.resolve(result):addCallbacks(fulfilled, reject)
                 end
-                if coroutine.status(asyncCoroutine) == "dead" then
-                    resolve(nil, result)
+                resolved = false
+                asyncCoroutine = cocreate(generator)
+                local success, resultOrError = coresume(
+                    asyncCoroutine,
+                    function(____, v)
+                        resolved = true
+                        return __TS__Promise.resolve(v):addCallbacks(resolve, reject)
+                    end
+                )
+                if success then
+                    return step(resultOrError)
                 else
-                    local ____self_0 = adopt(nil, result)
-                    ____self_0["then"](____self_0, fulfilled, reject)
+                    return reject(nil, resultOrError)
                 end
             end
-            resolved = false
-            asyncCoroutine = coroutine.create(generator)
-            local success, resultOrError = coroutine.resume(
-                asyncCoroutine,
-                function(____, v)
-                    resolved = true
-                    local ____self_1 = adopt(nil, v)
-                    ____self_1["then"](____self_1, resolve, reject)
-                end
-            )
-            if success then
-                step(nil, resultOrError)
-            else
-                reject(nil, resultOrError)
-            end
-        end
-    )
-end
-local function __TS__Await(thing)
-    return coroutine.yield(thing)
+        )
+    end
+    function __TS__Await(thing)
+        return coyield(thing)
+    end
 end
 
 local function __TS__ClassExtends(target, base)
@@ -953,20 +915,17 @@ local function __TS__ObjectGetOwnPropertyDescriptor(object, key)
     return rawget(metatable, "_descriptors")[key]
 end
 
-local __TS__SetDescriptor
+local __TS__DescriptorGet
 do
-    local function descriptorIndex(self, key)
-        local value = rawget(self, key)
-        if value ~= nil then
-            return value
-        end
-        local metatable = getmetatable(self)
+    local getmetatable = _G.getmetatable
+    local ____rawget = _G.rawget
+    function __TS__DescriptorGet(self, metatable, key)
         while metatable do
-            local rawResult = rawget(metatable, key)
+            local rawResult = ____rawget(metatable, key)
             if rawResult ~= nil then
                 return rawResult
             end
-            local descriptors = rawget(metatable, "_descriptors")
+            local descriptors = ____rawget(metatable, "_descriptors")
             if descriptors then
                 local descriptor = descriptors[key]
                 if descriptor ~= nil then
@@ -979,10 +938,16 @@ do
             metatable = getmetatable(metatable)
         end
     end
-    local function descriptorNewIndex(self, key, value)
-        local metatable = getmetatable(self)
+end
+
+local __TS__DescriptorSet
+do
+    local getmetatable = _G.getmetatable
+    local ____rawget = _G.rawget
+    local rawset = _G.rawset
+    function __TS__DescriptorSet(self, metatable, key, value)
         while metatable do
-            local descriptors = rawget(metatable, "_descriptors")
+            local descriptors = ____rawget(metatable, "_descriptors")
             if descriptors then
                 local descriptor = descriptors[key]
                 if descriptor ~= nil then
@@ -1004,6 +969,26 @@ do
         end
         rawset(self, key, value)
     end
+end
+
+local __TS__SetDescriptor
+do
+    local getmetatable = _G.getmetatable
+    local function descriptorIndex(self, key)
+        return __TS__DescriptorGet(
+            self,
+            getmetatable(self),
+            key
+        )
+    end
+    local function descriptorNewIndex(self, key, value)
+        return __TS__DescriptorSet(
+            self,
+            getmetatable(self),
+            key,
+            value
+        )
+    end
     function __TS__SetDescriptor(target, key, desc, isPrototype)
         if isPrototype == nil then
             isPrototype = false
@@ -1232,6 +1217,18 @@ local function __TS__DelegatedYield(iterable)
     end
 end
 
+local function __TS__FunctionBind(fn, ...)
+    local boundArgs = {...}
+    return function(____, ...)
+        local args = {...}
+        __TS__ArrayUnshift(
+            args,
+            __TS__Unpack(boundArgs)
+        )
+        return fn(__TS__Unpack(args))
+    end
+end
+
 local __TS__Generator
 do
     local function generatorIterator(self)
@@ -2551,6 +2548,8 @@ return {
   __TS__DecorateParam = __TS__DecorateParam,
   __TS__Delete = __TS__Delete,
   __TS__DelegatedYield = __TS__DelegatedYield,
+  __TS__DescriptorGet = __TS__DescriptorGet,
+  __TS__DescriptorSet = __TS__DescriptorSet,
   Error = Error,
   RangeError = RangeError,
   ReferenceError = ReferenceError,

package/dist/maps/defaultPlayerStatMap.d.ts

@@ -1,7 +1,3 @@
 /** The default fire delay is represented in the tear stat, not the `MaxFireDelay` value. */
-export declare const DEFAULT_PLAYER_STAT_MAP: ReadonlyMap<number & {
-    readonly __bitFlagBrand: symbol;
-} & {
-    readonly __cacheFlagBrand: symbol;
-}, number>;
+export declare const DEFAULT_PLAYER_STAT_MAP: ReadonlyMap<import("isaac-typescript-definitions").CacheFlag, number>;
 //# sourceMappingURL=defaultPlayerStatMap.d.ts.map

package/dist/maps/defaultPlayerStatMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defaultPlayerStatMap.d.ts","sourceRoot":"","sources":["../../src/maps/defaultPlayerStatMap.ts"],"names":[],"mappings":"AAMA,4FAA4F;AAC5F,eAAO,MAAM,uBAAuB;;;;UAUlC,CAAC"}
+{"version":3,"file":"defaultPlayerStatMap.d.ts","sourceRoot":"","sources":["../../src/maps/defaultPlayerStatMap.ts"],"names":[],"mappings":"AAMA,4FAA4F;AAC5F,eAAO,MAAM,uBAAuB,uEAUlC,CAAC"}

package/dist/objects/doorSlotToDoorSlotFlag.d.ts

@@ -1,49 +1,13 @@
 /// <reference types="isaac-typescript-definitions" />
 export declare const DOOR_SLOT_TO_DOOR_SLOT_FLAG: {
-    readonly [-1]: BitFlags<number & {
-        readonly __bitFlagBrand: symbol;
-    } & {
-        readonly __doorSlotFlagBrand: symbol;
-    }>;
-    readonly 0: number & {
-        readonly __bitFlagBrand: symbol;
-    } & {
-        readonly __doorSlotFlagBrand: symbol;
-    };
-    readonly 1: number & {
-        readonly __bitFlagBrand: symbol;
-    } & {
-        readonly __doorSlotFlagBrand: symbol;
-    };
-    readonly 2: number & {
-        readonly __bitFlagBrand: symbol;
-    } & {
-        readonly __doorSlotFlagBrand: symbol;
-    };
-    readonly 3: number & {
-        readonly __bitFlagBrand: symbol;
-    } & {
-        readonly __doorSlotFlagBrand: symbol;
-    };
-    readonly 4: number & {
-        readonly __bitFlagBrand: symbol;
-    } & {
-        readonly __doorSlotFlagBrand: symbol;
-    };
-    readonly 5: number & {
-        readonly __bitFlagBrand: symbol;
-    } & {
-        readonly __doorSlotFlagBrand: symbol;
-    };
-    readonly 6: number & {
-        readonly __bitFlagBrand: symbol;
-    } & {
-        readonly __doorSlotFlagBrand: symbol;
-    };
-    readonly 7: number & {
-        readonly __bitFlagBrand: symbol;
-    } & {
-        readonly __doorSlotFlagBrand: symbol;
-    };
+    readonly [-1]: BitFlags<import("isaac-typescript-definitions").DoorSlotFlag>;
+    readonly 0: import("isaac-typescript-definitions").DoorSlotFlag;
+    readonly 1: import("isaac-typescript-definitions").DoorSlotFlag;
+    readonly 2: import("isaac-typescript-definitions").DoorSlotFlag;
+    readonly 3: import("isaac-typescript-definitions").DoorSlotFlag;
+    readonly 4: import("isaac-typescript-definitions").DoorSlotFlag;
+    readonly 5: import("isaac-typescript-definitions").DoorSlotFlag;
+    readonly 6: import("isaac-typescript-definitions").DoorSlotFlag;
+    readonly 7: import("isaac-typescript-definitions").DoorSlotFlag;
 };
 //# sourceMappingURL=doorSlotToDoorSlotFlag.d.ts.map

package/dist/objects/doorSlotToDoorSlotFlag.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doorSlotToDoorSlotFlag.d.ts","sourceRoot":"","sources":["../../src/objects/doorSlotToDoorSlotFlag.ts"],"names":[],"mappings":";AAMA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUW,CAAC"}
+{"version":3,"file":"doorSlotToDoorSlotFlag.d.ts","sourceRoot":"","sources":["../../src/objects/doorSlotToDoorSlotFlag.ts"],"names":[],"mappings":";AAMA,eAAO,MAAM,2BAA2B;;;;;;;;;;CAUW,CAAC"}

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.39.4"
+      "packageVersion": "7.42.3"
     }
   ]
 }

package/dist/types/ObjectValues.d.ts

@@ -0,0 +1,2 @@
+export type ObjectValues<T> = T[keyof T];
+//# sourceMappingURL=ObjectValues.d.ts.map

package/dist/types/ObjectValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectValues.d.ts","sourceRoot":"","sources":["../../src/types/ObjectValues.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC"}

package/dist/types/ObjectValues.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ObjectValues.lua

@@ -0,0 +1,2 @@
+local ____exports = {}
+return ____exports

package/dist/types/TupleToIntersection.d.ts

@@ -1,5 +1,2 @@
-export type TupleToIntersection<T extends unknown[]> = T extends [
-    infer F,
-    ...infer R
-] ? F & TupleToIntersection<R> : unknown;
+export type TupleToIntersection<T extends readonly unknown[]> = T extends readonly [infer F, ...infer R] ? F & TupleToIntersection<R> : unknown;
 //# sourceMappingURL=TupleToIntersection.d.ts.map

package/dist/types/TupleToIntersection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TupleToIntersection.d.ts","sourceRoot":"","sources":["../../src/types/TupleToIntersection.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI,CAAC,SAAS;IAC/D,MAAM,CAAC;IACP,GAAG,MAAM,CAAC;CACX,GACG,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC"}
+{"version":3,"file":"TupleToIntersection.d.ts","sourceRoot":"","sources":["../../src/types/TupleToIntersection.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAC1D,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,GACpC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isaacscript-common",
-  "version": "87.2.1",
+  "version": "87.3.0",
   "description": "Helper functions and features for IsaacScript mods.",
   "keywords": [
     "isaac",
@@ -37,6 +37,6 @@
     "lint": "tsx --tsconfig ./scripts/tsconfig.json ./scripts/lint.mts"
   },
   "dependencies": {
-    "isaac-typescript-definitions": "^41.0.0"
+    "isaac-typescript-definitions": "^41.1.0"
   }
 }

package/src/functions/math.ts

@@ -21,7 +21,7 @@ export function getAngleDifference(angle1: float, angle2: float): float {
  * Useful for equally distributing things in a circle pattern.
  *
  * @param centerPos A position that represents the center of the center to get the points from.
- * @param radius The radius of the circle.
+ * @param radius The length of the radius of the circle.
  * @param numPoints The number of points on the circumference of the circle to get.
  * @param xMultiplier An optional multiplier to get the points around an oval. Default is 1.
  * @param yMultiplier An optional multiplier to get the points around an oval. Default is 1.

package/src/functions/pills.ts

@@ -229,7 +229,7 @@ export function isModdedPillEffect(pillEffect: PillEffect): boolean {
  * Under the hood, this checks using the `FIRST_PILL_COLOR` and `LAST_NORMAL_PILL_COLOR` constants.
  */
 export function isNormalPillColor(pillColor: PillColor): boolean {
-  return pillColor <= FIRST_PILL_COLOR && pillColor <= LAST_NORMAL_PILL_COLOR;
+  return pillColor >= FIRST_PILL_COLOR && pillColor <= LAST_NORMAL_PILL_COLOR;
 }
 
 export function isValidPillEffect(pillEffect: int): pillEffect is PillEffect {

package/src/functions/stats.ts

@@ -61,7 +61,7 @@ export function addPlayerStat(
 
     // 1 << 3
     case CacheFlag.RANGE: {
-      player.TearHeight += amount;
+      player.TearRange += amount;
       break;
     }