isaacscript-common 6.6.1-dev.1 → 6.6.1-dev.5

package/dist/callbacks/subscriptions/preBerserkDeath.lua

@@ -0,0 +1,35 @@
+local ____exports = {}
+local subscriptions = {}
+---
+-- @internal
+function ____exports.preBerserkDeathHasSubscriptions(self)
+    return #subscriptions > 0
+end
+---
+-- @internal
+function ____exports.preBerserkDeathRegister(self, ...)
+    local args = {...}
+    subscriptions[#subscriptions + 1] = args
+end
+---
+-- @internal
+function ____exports.preBerserkDeathFire(self, player)
+    local character = player:GetPlayerType()
+    for ____, ____value in ipairs(subscriptions) do
+        local callback = ____value[1]
+        local playerVariant = ____value[2]
+        local callbackCharacter = ____value[3]
+        do
+            if playerVariant ~= nil and playerVariant ~= player.Variant then
+                goto __continue5
+            end
+            if callbackCharacter ~= nil and callbackCharacter ~= character then
+                goto __continue5
+            end
+            callback(nil, player)
+        end
+        ::__continue5::
+    end
+    return nil
+end
+return ____exports

package/dist/callbacks/subscriptions/preCustomRevive.d.ts

@@ -0,0 +1,7 @@
+import { PlayerType, PlayerVariant } from "isaac-typescript-definitions";
+export declare type PreCustomReviveRegisterParameters = [
+    callback: (player: EntityPlayer) => int | undefined,
+    playerVariant?: PlayerVariant,
+    character?: PlayerType
+];
+//# sourceMappingURL=preCustomRevive.d.ts.map

package/dist/callbacks/subscriptions/preCustomRevive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preCustomRevive.d.ts","sourceRoot":"","sources":["../../../../../../packages/isaacscript-common/src/callbacks/subscriptions/preCustomRevive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAEzE,oBAAY,iCAAiC,GAAG;IAC9C,QAAQ,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,GAAG,GAAG,SAAS;IACnD,aAAa,CAAC,EAAE,aAAa;IAC7B,SAAS,CAAC,EAAE,UAAU;CACvB,CAAC"}

package/dist/callbacks/subscriptions/preCustomRevive.lua

@@ -0,0 +1,38 @@
+local ____exports = {}
+local subscriptions = {}
+---
+-- @internal
+function ____exports.preCustomReviveHasSubscriptions(self)
+    return #subscriptions > 0
+end
+---
+-- @internal
+function ____exports.preCustomReviveRegister(self, ...)
+    local args = {...}
+    subscriptions[#subscriptions + 1] = args
+end
+---
+-- @internal
+function ____exports.preCustomReviveFire(self, player)
+    local character = player:GetPlayerType()
+    for ____, ____value in ipairs(subscriptions) do
+        local callback = ____value[1]
+        local playerVariant = ____value[2]
+        local callbackCharacter = ____value[3]
+        do
+            if playerVariant ~= nil and playerVariant ~= player.Variant then
+                goto __continue5
+            end
+            if callbackCharacter ~= nil and callbackCharacter ~= character then
+                goto __continue5
+            end
+            local revivalType = callback(nil, player)
+            if revivalType ~= nil then
+                return revivalType
+            end
+        end
+        ::__continue5::
+    end
+    return nil
+end
+return ____exports

package/dist/callbacks/subscriptions/preItemPickup.d.ts

@@ -0,0 +1,12 @@
+import { CollectibleType, ItemType, TrinketType } from "isaac-typescript-definitions";
+import { PickingUpItem, PickingUpItemCollectible, PickingUpItemTrinket } from "../../types/PickingUpItem";
+export declare type PreItemPickupRegisterParameters = [callback: (player: EntityPlayer, pickingUpItem: PickingUpItem) => void] | [
+    callback: (player: EntityPlayer, pickingUpItem: PickingUpItemCollectible) => void,
+    itemType: ItemType.PASSIVE | ItemType.ACTIVE | ItemType.FAMILIAR,
+    collectibleType?: CollectibleType
+] | [
+    callback: (player: EntityPlayer, pickingUpItem: PickingUpItemTrinket) => void,
+    itemType: ItemType.TRINKET,
+    trinketType?: TrinketType
+];
+//# sourceMappingURL=preItemPickup.d.ts.map

package/dist/callbacks/subscriptions/preItemPickup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preItemPickup.d.ts","sourceRoot":"","sources":["../../../../../../packages/isaacscript-common/src/callbacks/subscriptions/preItemPickup.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,QAAQ,EACR,WAAW,EACZ,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,aAAa,EACb,wBAAwB,EACxB,oBAAoB,EACrB,MAAM,2BAA2B,CAAC;AAEnC,oBAAY,+BAA+B,GACvC,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,aAAa,KAAK,IAAI,CAAC,GACxE;IACE,QAAQ,EAAE,CACR,MAAM,EAAE,YAAY,EACpB,aAAa,EAAE,wBAAwB,KACpC,IAAI;IACT,QAAQ,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC,QAAQ;IAChE,eAAe,CAAC,EAAE,eAAe;CAClC,GACD;IACE,QAAQ,EAAE,CACR,MAAM,EAAE,YAAY,EACpB,aAAa,EAAE,oBAAoB,KAChC,IAAI;IACT,QAAQ,EAAE,QAAQ,CAAC,OAAO;IAC1B,WAAW,CAAC,EAAE,WAAW;CAC1B,CAAC"}

package/dist/callbacks/subscriptions/preItemPickup.lua

@@ -0,0 +1,33 @@
+local ____exports = {}
+local subscriptions = {}
+---
+-- @internal
+function ____exports.preItemPickupHasSubscriptions(self)
+    return #subscriptions > 0
+end
+---
+-- @internal
+function ____exports.preItemPickupRegister(self, ...)
+    local args = {...}
+    subscriptions[#subscriptions + 1] = args
+end
+---
+-- @internal
+function ____exports.preItemPickupFire(self, player, pickingUpItem)
+    for ____, ____value in ipairs(subscriptions) do
+        local callback = ____value[1]
+        local itemType = ____value[2]
+        local subType = ____value[3]
+        do
+            if itemType ~= nil and itemType ~= pickingUpItem.itemType then
+                goto __continue5
+            end
+            if subType ~= nil and subType ~= pickingUpItem.subType then
+                goto __continue5
+            end
+            callback(nil, player, pickingUpItem)
+        end
+        ::__continue5::
+    end
+end
+return ____exports

package/dist/callbacks/subscriptions/preNewLevel.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="isaac-typescript-definitions" />
+export declare type PreNewLevelRegisterParameters = [
+    callback: (player: EntityPlayer) => void
+];
+//# sourceMappingURL=preNewLevel.d.ts.map

package/dist/callbacks/subscriptions/preNewLevel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preNewLevel.d.ts","sourceRoot":"","sources":["../../../../../../packages/isaacscript-common/src/callbacks/subscriptions/preNewLevel.ts"],"names":[],"mappings":";AAAA,oBAAY,6BAA6B,GAAG;IAC1C,QAAQ,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI;CACzC,CAAC"}

package/dist/callbacks/subscriptions/preNewLevel.lua

@@ -0,0 +1,22 @@
+local ____exports = {}
+local subscriptions = {}
+---
+-- @internal
+function ____exports.preNewLevelHasSubscriptions(self)
+    return #subscriptions > 0
+end
+---
+-- @internal
+function ____exports.preNewLevelRegister(self, ...)
+    local args = {...}
+    subscriptions[#subscriptions + 1] = args
+end
+---
+-- @internal
+function ____exports.preNewLevelFire(self, player)
+    for ____, ____value in ipairs(subscriptions) do
+        local callback = ____value[1]
+        callback(nil, player)
+    end
+end
+return ____exports

package/dist/classes/DefaultMap.d.ts

@@ -0,0 +1,110 @@
+/**
+ * A function that creates the default value for your `DefaultMap`. For example, if it was a
+ * `DefaultMap` containing maps, the factory function would be: `() => new Map()`
+ */
+export declare type FactoryFunction<V, Args extends unknown[]> = (...extraArgs: Args) => V;
+/**
+ * `DefaultMap` is a data structure that makes working with default values easier.
+ *
+ * It is a common pattern to look up a value in a `Map`, and then, if the value does not exist, set
+ * a default value for the key, and then return the default value. `DefaultMap` abstracts this
+ * operation away by providing the `getAndSetDefault` method.
+ *
+ * Using a `DefaultMap` is nice because it makes code more declarative, since you specify what the
+ * default value is alongside the types of the keys/values.
+ *
+ * When instantiating a new `DefaultMap`, you must specify default value as the first argument. (The
+ * default value is the initial value that will be assigned to every new entry in the
+ * `getAndSetDefault` method.) For example:
+ *
+ * ```ts
+ * // Initializes a new empty DefaultMap with a default value of "foo".
+ * const defaultMapWithString = new DefaultMap<string, string>("foo");
+ *
+ * const value = defaultMapWithString.getAndSetDefault("bar");
+ * // value is now "foo" and an entry for "bar" is now set.
+ * ```
+ *
+ * Sometimes, instead of having a static initial value for every entry in the map, you will want a
+ * dynamic initial value that is contingent upon the key or some other variable. In these cases, you
+ * can instead specify that the `DefaultMap` should run a function that will return the initial
+ * value. (This is referred to as a "factory function".) For example:
+ *
+ * ```ts
+ * // Initializes a new empty DefaultMap with a default value based on "someGlobalVariable".
+ * const factoryFunction = () => someGlobalVariable ? 0 : 1;
+ * const defaultMapWithFactoryFunction = new DefaultMap<string, string>(factoryFunction);
+ * ```
+ *
+ * Note that in TypeScript and Lua, booleans, numbers, and strings are "passed by value". This means
+ * that when the `DefaultMap` creates a new entry, if the default value is one of these 3 types, the
+ * values will be copied. On the other hand, arrays and maps and other complex data structures are
+ * "passed by reference". This means that when the `DefaultMap` creates a new entry, if the default
+ * value is an array, then it would not be copied. Instead, the same shared array would be assigned
+ * to every entry. Thus, to solve this problem, any variable that is passed by reference must be
+ * created using a factory function to ensure that each copy is unique. For example:
+ *
+ * ```ts
+ * // Initializes a new empty DefaultMap with a default value of a new empty array.
+ * const factoryFunction = () => [];
+ * const defaultMapWithArray = new DefaultMap<string, string[]>(factoryFunction);
+ * ```
+ *
+ * In the previous two examples, the factory functions did not have any arguments. But you can also
+ * specify a factory function that takes one or more arguments:
+ *
+ * ```ts
+ * const factoryFunction = (arg: boolean) => arg ? 0 : 1;
+ * const defaultMapWithArg = new DefaultMap<string, string, [arg: boolean]>(factoryFunction);
+ * ```
+ *
+ * Similar to a normal `Map`, you can also include an initializer list in the constructor as the
+ * second argument:
+ *
+ * ```ts
+ * // Initializes a DefaultMap with a default value of "foo" and some initial values.
+ * const defaultMapWithInitialValues = new DefaultMap<string, string>("foo", [
+ *   ["a1", "a2"],
+ *   ["b1", "b2"],
+ * ], );
+ * ```
+ *
+ * Finally, note that `DefaultMap` has the following additional utility methods:
+ *
+ * - `getAndSetDefault` - The method that is called inside the overridden `get` method. In most
+ *   cases, you can use the overridden `get` method instead of calling this function directly.
+ *   However, if a factory function was provided during instantiation, and the factory function has
+ *   one or more arguments, then you must call this method instead (and provide the corresponding
+ *   arguments).
+ * - `getWithoutDefault` - Calls the original `Map.get` function (without setting the default
+ *   value).
+ * - `getDefaultValue` - Returns the default value to be used for a new key. (If a factory function
+ *   was provided during instantiation, this will execute the factory function.)
+ * - `getConstructorArg` - Helper method for cloning the map. Returns either the default value or
+ *   the reference to the factory function.
+ */
+export declare class DefaultMap<Key, Value, Args extends unknown[] = []> extends Map<Key, Value> {
+    private defaultValue;
+    private defaultValueFactory;
+    /**
+     * See the main `DefaultMap` documentation:
+     * https://isaacscript.github.io/isaacscript-common/classes/classes_DefaultMap.DefaultMap
+     */
+    constructor(defaultValueOrFactoryFunction: Value | FactoryFunction<Value, Args>, initializerArray?: Iterable<[Key, Value]>);
+    /**
+     * If the key exists, this will return the same thing as the normal `Map.get` method. Otherwise,
+     * it will set a default value for the provided key, and then return the default value.
+     */
+    getAndSetDefault(key: Key, ...extraArgs: Args): Value;
+    /**
+     * Returns the default value to be used for a new key. (If a factory function was provided during
+     * instantiation, this will execute the factory function.)
+     */
+    getDefaultValue(...extraArgs: Args): Value;
+    /**
+     * Helper method for cloning the map. Returns either the default value or a reference to the
+     * factory function.
+     */
+    getConstructorArg(): Value | FactoryFunction<Value, Args>;
+}
+//# sourceMappingURL=DefaultMap.d.ts.map

package/dist/classes/DefaultMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultMap.d.ts","sourceRoot":"","sources":["../../../../../packages/isaacscript-common/src/classes/DefaultMap.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,oBAAY,eAAe,CAAC,CAAC,EAAE,IAAI,SAAS,OAAO,EAAE,IAAI,CACvD,GAAG,SAAS,EAAE,IAAI,KACf,CAAC,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AACH,qBAAa,UAAU,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,SAAS,OAAO,EAAE,GAAG,EAAE,CAAE,SAAQ,GAAG,CAC1E,GAAG,EACH,KAAK,CACN;IACC,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,mBAAmB,CAA2C;IAEtE;;;OAGG;gBAED,6BAA6B,EAAE,KAAK,GAAG,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC,EACnE,gBAAgB,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAqB3C;;;OAGG;IACH,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,SAAS,EAAE,IAAI,GAAG,KAAK;IAWrD;;;OAGG;IACH,eAAe,CAAC,GAAG,SAAS,EAAE,IAAI,GAAG,KAAK;IAY1C;;;OAGG;IACH,iBAAiB,IAAI,KAAK,GAAG,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC;CAW1D"}

package/dist/classes/DefaultMap.lua

@@ -0,0 +1,134 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local Map = ____lualib.Map
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__TypeOf = ____lualib.__TS__TypeOf
+local ____exports = {}
+local ____types = require("functions.types")
+local isFunction = ____types.isFunction
+local isPrimitive = ____types.isPrimitive
+--- `DefaultMap` is a data structure that makes working with default values easier.
+-- 
+-- It is a common pattern to look up a value in a `Map`, and then, if the value does not exist, set
+-- a default value for the key, and then return the default value. `DefaultMap` abstracts this
+-- operation away by providing the `getAndSetDefault` method.
+-- 
+-- Using a `DefaultMap` is nice because it makes code more declarative, since you specify what the
+-- default value is alongside the types of the keys/values.
+-- 
+-- When instantiating a new `DefaultMap`, you must specify default value as the first argument. (The
+-- default value is the initial value that will be assigned to every new entry in the
+-- `getAndSetDefault` method.) For example:
+-- 
+-- ```ts
+-- // Initializes a new empty DefaultMap with a default value of "foo".
+-- const defaultMapWithString = new DefaultMap<string, string>("foo");
+-- 
+-- const value = defaultMapWithString.getAndSetDefault("bar");
+-- // value is now "foo" and an entry for "bar" is now set.
+-- ```
+-- 
+-- Sometimes, instead of having a static initial value for every entry in the map, you will want a
+-- dynamic initial value that is contingent upon the key or some other variable. In these cases, you
+-- can instead specify that the `DefaultMap` should run a function that will return the initial
+-- value. (This is referred to as a "factory function".) For example:
+-- 
+-- ```ts
+-- // Initializes a new empty DefaultMap with a default value based on "someGlobalVariable".
+-- const factoryFunction = () => someGlobalVariable ? 0 : 1;
+-- const defaultMapWithFactoryFunction = new DefaultMap<string, string>(factoryFunction);
+-- ```
+-- 
+-- Note that in TypeScript and Lua, booleans, numbers, and strings are "passed by value". This means
+-- that when the `DefaultMap` creates a new entry, if the default value is one of these 3 types, the
+-- values will be copied. On the other hand, arrays and maps and other complex data structures are
+-- "passed by reference". This means that when the `DefaultMap` creates a new entry, if the default
+-- value is an array, then it would not be copied. Instead, the same shared array would be assigned
+-- to every entry. Thus, to solve this problem, any variable that is passed by reference must be
+-- created using a factory function to ensure that each copy is unique. For example:
+-- 
+-- ```ts
+-- // Initializes a new empty DefaultMap with a default value of a new empty array.
+-- const factoryFunction = () => [];
+-- const defaultMapWithArray = new DefaultMap<string, string[]>(factoryFunction);
+-- ```
+-- 
+-- In the previous two examples, the factory functions did not have any arguments. But you can also
+-- specify a factory function that takes one or more arguments:
+-- 
+-- ```ts
+-- const factoryFunction = (arg: boolean) => arg ? 0 : 1;
+-- const defaultMapWithArg = new DefaultMap<string, string, [arg: boolean]>(factoryFunction);
+-- ```
+-- 
+-- Similar to a normal `Map`, you can also include an initializer list in the constructor as the
+-- second argument:
+-- 
+-- ```ts
+-- // Initializes a DefaultMap with a default value of "foo" and some initial values.
+-- const defaultMapWithInitialValues = new DefaultMap<string, string>("foo", [
+--   ["a1", "a2"],
+--   ["b1", "b2"],
+-- ], );
+-- ```
+-- 
+-- Finally, note that `DefaultMap` has the following additional utility methods:
+-- 
+-- - `getAndSetDefault` - The method that is called inside the overridden `get` method. In most
+--   cases, you can use the overridden `get` method instead of calling this function directly.
+--   However, if a factory function was provided during instantiation, and the factory function has
+--   one or more arguments, then you must call this method instead (and provide the corresponding
+--   arguments).
+-- - `getWithoutDefault` - Calls the original `Map.get` function (without setting the default
+--   value).
+-- - `getDefaultValue` - Returns the default value to be used for a new key. (If a factory function
+--   was provided during instantiation, this will execute the factory function.)
+-- - `getConstructorArg` - Helper method for cloning the map. Returns either the default value or
+--   the reference to the factory function.
+____exports.DefaultMap = __TS__Class()
+local DefaultMap = ____exports.DefaultMap
+DefaultMap.name = "DefaultMap"
+__TS__ClassExtends(DefaultMap, Map)
+function DefaultMap.prototype.____constructor(self, defaultValueOrFactoryFunction, initializerArray)
+    local argIsPrimitive = isPrimitive(nil, defaultValueOrFactoryFunction)
+    local argIsFunction = isFunction(nil, defaultValueOrFactoryFunction)
+    if not argIsPrimitive and not argIsFunction then
+        error(("Failed to instantiate a DefaultMap since the provided default value was of type \"" .. __TS__TypeOf(defaultValueOrFactoryFunction)) .. "\". This error usually means that you are trying to use an array (or some other non-primitive data structure that is passed by reference) as the default value. Instead, return the data structure in a factory function, like \"() => []\". See the DefaultMap documentation for more details.")
+    end
+    Map.prototype.____constructor(self, initializerArray)
+    if argIsFunction then
+        self.defaultValue = nil
+        self.defaultValueFactory = defaultValueOrFactoryFunction
+    else
+        self.defaultValue = defaultValueOrFactoryFunction
+        self.defaultValueFactory = nil
+    end
+end
+function DefaultMap.prototype.getAndSetDefault(self, key, ...)
+    local value = Map.prototype.get(self, key)
+    if value ~= nil then
+        return value
+    end
+    local defaultValue = self:getDefaultValue(...)
+    self:set(key, defaultValue)
+    return defaultValue
+end
+function DefaultMap.prototype.getDefaultValue(self, ...)
+    if self.defaultValue ~= nil then
+        return self.defaultValue
+    end
+    if self.defaultValueFactory ~= nil then
+        return self:defaultValueFactory(...)
+    end
+    error("A DefaultMap was incorrectly instantiated.")
+end
+function DefaultMap.prototype.getConstructorArg(self)
+    if self.defaultValue ~= nil then
+        return self.defaultValue
+    end
+    if self.defaultValueFactory ~= nil then
+        return self.defaultValueFactory
+    end
+    error("A DefaultMap was incorrectly instantiated.")
+end
+return ____exports

package/dist/classes/ModUpgraded.d.ts

@@ -0,0 +1,28 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { AddCallbackParameterCustom } from "../interfaces/AddCallbackParameterCustom";
+/**
+ * `isaacscript-common` has many custom callbacks that you can use in your mods. Instead of
+ * hijacking the vanilla `Mod` object, we provide a `ModUpgraded` object for you to use, which
+ * extends the base class and adds a new method of `AddCallbackCustom`.
+ *
+ * To upgrade your mod, use the `upgradeMod` helper function.
+ */
+export declare class ModUpgraded implements Mod {
+    Name: string;
+    /** We store a copy of the original mod object so that we can re-implement its functions. */
+    Mod: Mod;
+    constructor(mod: Mod);
+    AddCallback<T extends ModCallback>(modCallback: T, ...args: AddCallbackParameter[T]): void;
+    HasData(): boolean;
+    LoadData(): string;
+    /**
+     * This method does not care about the tertiary argument. Regardless of the conditions of how you
+     * registered the callback, it will be removed.
+     */
+    RemoveCallback<T extends ModCallback>(modCallback: T, callback: AddCallbackParameter[T][0]): void;
+    RemoveData(): void;
+    SaveData(data: string): void;
+    AddCallbackCustom<T extends ModCallbackCustom>(modCallbackCustom: T, ...args: AddCallbackParameterCustom[T]): void;
+}
+//# sourceMappingURL=ModUpgraded.d.ts.map

package/dist/classes/ModUpgraded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModUpgraded.d.ts","sourceRoot":"","sources":["../../../../../packages/isaacscript-common/src/classes/ModUpgraded.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AAGtF;;;;;;GAMG;AACH,qBAAa,WAAY,YAAW,GAAG;IAKrC,IAAI,EAAE,MAAM,CAAC;IAMb,4FAA4F;IAC5F,GAAG,EAAE,GAAG,CAAC;gBAEG,GAAG,EAAE,GAAG;IAUpB,WAAW,CAAC,CAAC,SAAS,WAAW,EAC/B,WAAW,EAAE,CAAC,EACd,GAAG,IAAI,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAC/B,IAAI;IAIP,OAAO,IAAI,OAAO;IAIlB,QAAQ,IAAI,MAAM;IAIlB;;;OAGG;IACH,cAAc,CAAC,CAAC,SAAS,WAAW,EAClC,WAAW,EAAE,CAAC,EACd,QAAQ,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GACnC,IAAI;IAIP,UAAU,IAAI,IAAI;IAIlB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAS5B,iBAAiB,CAAC,CAAC,SAAS,iBAAiB,EAC3C,iBAAiB,EAAE,CAAC,EACpB,GAAG,IAAI,EAAE,0BAA0B,CAAC,CAAC,CAAC,GACrC,IAAI;CAKR"}

package/dist/classes/ModUpgraded.lua

@@ -0,0 +1,40 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local ____exports = {}
+local ____callbackRegisterFunctions = require("objects.callbackRegisterFunctions")
+local CALLBACK_REGISTER_FUNCTIONS = ____callbackRegisterFunctions.CALLBACK_REGISTER_FUNCTIONS
+--- `isaacscript-common` has many custom callbacks that you can use in your mods. Instead of
+-- hijacking the vanilla `Mod` object, we provide a `ModUpgraded` object for you to use, which
+-- extends the base class and adds a new method of `AddCallbackCustom`.
+-- 
+-- To upgrade your mod, use the `upgradeMod` helper function.
+____exports.ModUpgraded = __TS__Class()
+local ModUpgraded = ____exports.ModUpgraded
+ModUpgraded.name = "ModUpgraded"
+function ModUpgraded.prototype.____constructor(self, mod)
+    self.Name = mod.Name
+    self.Mod = mod
+end
+function ModUpgraded.prototype.AddCallback(self, modCallback, ...)
+    self.Mod:AddCallback(modCallback, ...)
+end
+function ModUpgraded.prototype.HasData(self)
+    return self.Mod:HasData()
+end
+function ModUpgraded.prototype.LoadData(self)
+    return self.Mod:LoadData()
+end
+function ModUpgraded.prototype.RemoveCallback(self, modCallback, callback)
+    self.Mod:RemoveCallback(modCallback, callback)
+end
+function ModUpgraded.prototype.RemoveData(self)
+    self.Mod:RemoveData()
+end
+function ModUpgraded.prototype.SaveData(self, data)
+    self.Mod:SaveData(data)
+end
+function ModUpgraded.prototype.AddCallbackCustom(self, modCallbackCustom, ...)
+    local callbackRegisterFunction = CALLBACK_REGISTER_FUNCTIONS[modCallbackCustom]
+    callbackRegisterFunction(nil, ...)
+end
+return ____exports

package/dist/constants.d.ts

@@ -0,0 +1,140 @@
+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
+ * the documentation for the `getAzazelBrimstoneDistance` function.
+ */
+export declare const AZAZEL_DEFAULT_BRIMSTONE_DISTANCE = 75.125;
+/**
+ * The path to the png file for collectible items during Curse of the Blind, making them appear with
+ * a red question mark.
+ */
+export declare const BLIND_ITEM_PNG_PATH = "gfx/items/collectibles/questionmark.png";
+/** Bombs explode when their frame count is equal to this value. */
+export declare const BOMB_EXPLODE_FRAME = 45;
+/** This is the initial value of the `EntityPickup.Wait` property after a collectible is spawned. */
+export declare const COLLECTIBLE_INITIAL_WAIT = 20;
+export declare const DEFAULT_ITEM_POOL_TYPE = ItemPoolType.TREASURE;
+/** This is also the distance that a player spawns from the door that they enter a room from. */
+export declare const DISTANCE_OF_GRID_TILE = 40;
+export declare const DOOR_HITBOX_RADIUS = 11;
+/**
+ * When Eggies take fatal damage, they go into NpcState.STATE_SUICIDE and spawn 14 Swarm Spiders
+ * while their StateFrame ticks upwards. The 14th spider appears when the StateFrame is at this
+ * value.
+ */
+export declare const EGGY_STATE_FRAME_OF_FINAL_SPIDER = 45;
+/**
+ * A non-existent or completely transparent PNG file for use in clearing sprites. For more
+ * information, see the documentation for the `clearSprite` helper function.
+ */
+export declare const EMPTY_PNG_PATH = "gfx/none.png";
+/**
+ * The random items that appear when the player has TMTRAINER are generated on the fly as they are
+ * encountered by the player. The first TMTRAINER item takes the final possible 32 bit number. The
+ * second TMTRAINER item subtracts one from that, and so on.
+ */
+export declare const FIRST_GLITCHED_COLLECTIBLE_TYPE: CollectibleType;
+/** Game frames are what is returned by the `Game.GetFrameCount` method. */
+export declare const GAME_FRAMES_PER_SECOND = 30;
+/** Render frames are what is returned by the `Isaac.GetFrameCount` method. */
+export declare const RENDER_FRAMES_PER_SECOND = 60;
+export declare const GRID_INDEX_CENTER_OF_1X1_ROOM = 67;
+/**
+ * The floor is represented by a 13x13 grid. Room indexes start at 0. The first column is
+ * represented by grid indexes 0, 13, 26, and so on.
+ */
+export declare const LEVEL_GRID_COLUMN_HEIGHT = 13;
+/**
+ * The floor is represented by a 13x13 grid. Room indexes start at 0. The first row is represented
+ * by grid indexes from 0 to 12. The second row is represented by grid indexes from 13 to 25, and so
+ * on.
+ */
+export declare const LEVEL_GRID_ROW_WIDTH = 13;
+/**
+ * The floor is represented by a 13x13 grid. Room indexes start at 0. The first row is represented
+ * by grid indexes from 0 to 12. The second row is represented by grid indexes from 13 to 25, and so
+ * on. The maximum room index possible is 168. (It is not 169 because we start at 0 instead of 1.)
+ */
+export declare const MAX_LEVEL_GRID_INDEX = 168;
+/**
+ * The game has a limit on the number of currently spawned familiars and will refuse to spawn any
+ * more if it reaches the limit. Blue flies and blue spiders have a lower priority and will be
+ * deleted to make room for other familiars.
+ */
+export declare const MAX_NUM_FAMILIARS = 64;
+/** The game can only handle up to four different players. */
+export declare const MAX_NUM_INPUTS = 4;
+/** With Birthright, it is possible for Magdalene to have 18 heart containers. */
+export declare const MAX_PLAYER_HEART_CONTAINERS = 18;
+/**
+ * As the player continues to move in a direction, they will accelerate. When going from one wall to
+ * another in a 2x2 room at 2.0 speed (the maximum that the speed stat can rise to), the amount of
+ * units moved per update frame will climb to around 9.797 as they hit the opposite wall. The
+ * constant specifies a value of 9.8 to be safe.
+ */
+export declare const MAX_PLAYER_SPEED_IN_UNITS = 9.8;
+export declare const MAX_PLAYER_TRINKET_SLOTS: number;
+/** If you set `EntityPlayer.ShotSpeed` lower than this value, it will have no effect. */
+export declare const MIN_PLAYER_SHOT_SPEED_STAT = 0.6;
+/** If you set `EntityPlayer.Speed` lower than this value, it will have no effect. */
+export declare const MIN_PLAYER_SPEED_STAT = 0.1;
+export declare const FIRST_ROOM_TYPE = RoomType.DEFAULT;
+export declare const LAST_ROOM_TYPE: RoomType;
+/**
+ * The maximum speed stat that a player can have. Any additional speed beyond this will not take
+ * effect.
+ */
+export declare const MAX_SPEED_STAT = 2;
+/** This is in the center of the room. */
+export declare const NEW_FLOOR_STARTING_POSITION_NORMAL_MODE: Vector;
+/** This is near the top door. */
+export declare const NEW_FLOOR_STARTING_POSITION_GREED_MODE: Vector;
+/**
+ * This is next to the bottom door. Presumably, the player does not start in the center of the room
+ * (like they do when getting to a new stage) so that the controls graphic is more visible.
+ */
+export declare const NEW_RUN_PLAYER_STARTING_POSITION: Vector;
+export declare const FIRST_STAGE = LevelStage.BASEMENT_1;
+export declare const LAST_STAGE: LevelStage;
+/** Corresponds to the maximum value for `EntityPlayer.SamsonBerserkCharge`. */
+export declare const MAX_TAINTED_SAMSON_BERSERK_CHARGE = 100000;
+export declare const NUM_DIMENSIONS: number;
+/**
+ * The pill pool for each run is comprised of one effect for each unique pill color (minus gold and
+ * horse pills.)
+ */
+export declare const NUM_PILLS_IN_POOL: number;
+export declare const SECOND_IN_MILLISECONDS = 1000;
+export declare const MINUTE_IN_MILLISECONDS: number;
+export declare const ONE_BY_ONE_ROOM_GRID_SIZE = 135;
+/** After taking damage, `EntityPlayer.SamsonBerserkCharge` is incremented by this amount. */
+export declare const TAINTED_SAMSON_BERSERK_CHARGE_FROM_TAKING_DAMAGE = 10000;
+/**
+ * This is the number of draw coordinates that each heart spans on the UI in the upper left hand
+ * corner.
+ */
+export declare const UI_HEART_WIDTH = 12;
+/**
+ * This is a safer version of the `Vector.One` constant. (Other mods can mutate `Vector.One`, so it
+ * is not safe to use.)
+ */
+export declare const VectorOne: Readonly<Vector>;
+/**
+ * This is a safer version of the `Vector.Zero` constant. (Other mods can mutate `Vector.Zero`, so
+ * it is not safe to use.)
+ */
+export declare const VectorZero: Readonly<Vector>;
+/**
+ * This is a safer version of the `Color.Default` constant. (Other mods can mutate `Color.Default`,
+ * so it is not safe to use.)
+ *
+ * If you need to mutate this, make a copy first with the `copyColor` helper function.
+ */
+export declare const ColorDefault: Readonly<Color>;
+/**
+ * Equal to `KColor(1, 1, 1, 1)`.
+ *
+ * If you need to mutate this, make a copy first with the `copyKColor` helper function.
+ */
+export declare const KColorDefault: Readonly<KColor>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../packages/isaacscript-common/src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAEf,YAAY,EACZ,UAAU,EACV,QAAQ,EAET,MAAM,8BAA8B,CAAC;AAItC;;;GAGG;AACH,eAAO,MAAM,iCAAiC,SAAS,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,4CAA4C,CAAC;AAE7E,mEAAmE;AACnE,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC,oGAAoG;AACpG,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C,eAAO,MAAM,sBAAsB,wBAAwB,CAAC;AAE5D,gGAAgG;AAChG,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,KAAK,CAAC;AAEnD;;;GAGG;AACH,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,iBACrB,CAAC;AAExB,2EAA2E;AAC3E,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,8EAA8E;AAC9E,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,6DAA6D;AAC7D,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,iFAAiF;AACjF,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,eAAO,MAAM,wBAAwB,QAA6B,CAAC;AAEnE,yFAAyF;AACzF,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAE9C,qFAAqF;AACrF,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,eAAO,MAAM,eAAe,mBAAmB,CAAC;AAChD,eAAO,MAAM,cAAc,UAA6B,CAAC;AAEzD;;;GAGG;AACH,eAAO,MAAM,cAAc,IAAM,CAAC;AAElC,yCAAyC;AACzC,eAAO,MAAM,uCAAuC,QAAmB,CAAC;AAExE,iCAAiC;AACjC,eAAO,MAAM,sCAAsC,QAAmB,CAAC;AAEvE;;;GAGG;AACH,eAAO,MAAM,gCAAgC,QAAmB,CAAC;AAEjE,eAAO,MAAM,WAAW,wBAAwB,CAAC;AACjD,eAAO,MAAM,UAAU,YAA+B,CAAC;AAEvD,+EAA+E;AAC/E,eAAO,MAAM,iCAAiC,SAAS,CAAC;AAExD,eAAO,MAAM,cAAc,QAA+B,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAAyB,CAAC;AAExD,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAC3C,eAAO,MAAM,sBAAsB,QAA8B,CAAC;AAElE,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,6FAA6F;AAC7F,eAAO,MAAM,gDAAgD,QAAQ,CAAC;AAEtE;;;GAGG;AACH,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAgB,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAgB,CAAC;AAEzD;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAkB,CAAC;AAE5D;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAsB,CAAC"}