isaacscript-common 6.22.4 → 7.1.0

package/src/classes/DefaultMap.ts

@@ -5,9 +5,7 @@ import { isFunction, isPrimitive } from "../functions/types";
  * 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 type FactoryFunction<V, Args extends unknown[]> = (
-  ...extraArgs: Args
-) => V;
+export type FactoryFunction<V, Args extends unknown[]> = (...args: Args) => V;
 
 /**
  * `DefaultMap` is a data structure that makes working with default values easier.
@@ -127,13 +125,13 @@ export class DefaultMap<Key, Value, Args extends unknown[] = []> extends Map<
    * 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 {
+  getAndSetDefault(key: Key, ...args: Args): Value {
     const value = super.get(key);
     if (value !== undefined) {
       return value;
     }
 
-    const defaultValue = this.getDefaultValue(...extraArgs);
+    const defaultValue = this.getDefaultValue(...args);
     this.set(key, defaultValue);
     return defaultValue;
   }
@@ -142,13 +140,13 @@ export class DefaultMap<Key, Value, Args extends unknown[] = []> extends Map<
    * 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 {
+  getDefaultValue(...args: Args): Value {
     if (this.defaultValue !== undefined) {
       return this.defaultValue;
     }
 
     if (this.defaultValueFactory !== undefined) {
-      return this.defaultValueFactory(...extraArgs);
+      return this.defaultValueFactory(...args);
     }
 
     error("A DefaultMap was incorrectly instantiated.");
@@ -170,3 +168,34 @@ export class DefaultMap<Key, Value, Args extends unknown[] = []> extends Map<
     error("A DefaultMap was incorrectly instantiated.");
   }
 }
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+function test() {
+  // Boolean
+  const myDefaultMapBoolean = new DefaultMap<string, boolean>(false);
+  const myDefaultMapBooleanFactory = new DefaultMap<string, boolean>(
+    () => false,
+  );
+  const myDefaultMapBooleanWithoutParams = new DefaultMap(false);
+
+  // Number
+  const myDefaultMapNumber = new DefaultMap<string, number>(123);
+  const myDefaultMapNumberFactory = new DefaultMap<string, number>(() => 123);
+  const myDefaultMapNumberWithoutParams = new DefaultMap(123);
+
+  // String
+  const myDefaultMapString = new DefaultMap<string, string>("foo");
+  const myDefaultMapStringFactory = new DefaultMap<string, string>(() => "foo");
+  const myDefaultMapStringWithoutParams = new DefaultMap("foo");
+
+  // Array
+  const myDefaultMapArray = new DefaultMap<string, string[]>(() => []);
+  const myDefaultMapArrayWithoutParams = new DefaultMap(() => []);
+
+  // Map
+  const myDefaultMapMap = new DefaultMap<string, Map<string, string>>(
+    () => new Map(),
+  );
+  const myDefaultMapMapWithoutParams = new DefaultMap(() => new Map());
+}
+/* eslint-enable @typescript-eslint/no-unused-vars */

package/src/core/constants.ts

@@ -36,7 +36,7 @@ export const BLIND_ITEM_PNG_PATH = "gfx/items/collectibles/questionmark.png";
 /** Bombs explode when their frame count is equal to this value. */
 export const BOMB_EXPLODE_FRAME = 45;
 
-/** This is the initial value of the `EntityPickup.Wait` property after a collectible is spawned. */
+/** This is the initial value of the `EntityPickup.Wait` field after a collectible is spawned. */
 export const COLLECTIBLE_INITIAL_WAIT = 20;
 
 export const DEFAULT_ITEM_POOL_TYPE = ItemPoolType.TREASURE;

package/src/enums/ModCallbackCustom.ts

@@ -798,8 +798,8 @@ export enum ModCallbackCustom {
   POST_PIT_UPDATE,
 
   /**
-   * Fires from the `POST_PEFFECT_UPDATE` callback when a player entity gains or loses any health
-   * (i.e. hearts). For more information, see the `PlayerHealth` enum.
+   * Fires from the `POST_PEFFECT_UPDATE` callback when a player's health (i.e. hearts) is different
+   * than what it was on the previous frame. For more information, see the `PlayerHealth` enum.
    *
    * - When registering the callback, takes an optional second argument that will make the callback
    *   only fire if the player matches the `PlayerVariant` provided.
@@ -811,15 +811,47 @@ export enum ModCallbackCustom {
    *   player: EntityPlayer,
    *   healthType: HealthType,
    *   difference: int,
+   *   oldValue: int,
+   *   newValue: int,
    * ): void {}
    * ```
    */
   POST_PLAYER_CHANGE_HEALTH,
 
+  /**
+   * Fires from the `POST_PEFFECT_UPDATE` callback when one of the player's stats change from what
+   * they were on the previous frame.
+   *
+   * The type of `oldValue` and `newValue` will depend on what kind of stat it is. For example,
+   * `StatType.FLYING` will be a boolean. (You can use the "Types" helper functions to narrow the
+   * type.)
+   *
+   * For `StatType.TEAR_FLAG`, `StatType.TEAR_COLOR`, `StatType.FLYING`, and `StatType.SIZE`, the
+   * `difference` argument will always be a value of 0, since the type of these stats are not
+   * numbers. (For these cases, you should examine the `oldValue` and `newValue` arguments
+   * accordingly.)
+   *
+   * - When registering the callback, takes an optional second argument that will make the callback
+   *   only fire if the player matches the `PlayerVariant` provided.
+   * - When registering the callback, takes an optional third argument that will make the callback
+   *   only fire if the player matches the `PlayerType` provided.
+   *
+   * ```ts
+   * function postPlayerChangeStat(
+   *   player: EntityPlayer,
+   *   statType: StatType,
+   *   difference: int,
+   *   oldValue: number | boolean | BitFlags<TearFlag> | Color | Vector,
+   *   newValue: number | boolean | BitFlags<TearFlag> | Color | Vector,
+   * ): void {}
+   * ```
+   */
+  POST_PLAYER_CHANGE_STAT,
+
   /**
    * Fires from the `POST_PEFFECT_UPDATE` callback when a player entity changes its player type
-   * (i.e. character). For example, it will fire after using Clicker, after dying with the Judas'
-   * Shadow collectible, etc.
+   * (i.e. character) from what it was on the previous frame. For example, it will fire after using
+   * Clicker, after dying with the Judas' Shadow collectible, etc.
    *
    * Notably, it does not fire after the player uses the Flip item or the Esau Jr. item, because
    * those items cause separate player entities to be created. Use the `POST_FLIP` and

package/src/enums/StatType.ts

@@ -0,0 +1,47 @@
+/** This represents the kinds of stats that a player can have. */
+export enum StatType {
+  /** Corresponds to `CacheFlag.DAMAGE` (1 << 0) and `EntityPlayer.Damage`. */
+  DAMAGE,
+
+  /** Corresponds to `CacheFlag.FIRE_DELAY` (1 << 1) and `EntityPlayer.MaxFireDelay`. */
+  FIRE_DELAY,
+
+  /** Corresponds to `CacheFlag.SHOT_SPEED` (1 << 2) and `EntityPlayer.ShotSpeed`. */
+  SHOT_SPEED,
+
+  /** Corresponds to `CacheFlag.RANGE` (1 << 3) and `EntityPlayer.TearHeight`. */
+  TEAR_HEIGHT,
+
+  /** Corresponds to `CacheFlag.RANGE` (1 << 3) and `EntityPlayer.TearRange`. */
+  TEAR_RANGE,
+
+  /** Corresponds to `CacheFlag.RANGE` (1 << 3) and `EntityPlayer.TearFallingAcceleration`. */
+  TEAR_FALLING_ACCELERATION,
+
+  /** Corresponds to `CacheFlag.RANGE` (1 << 3) and `EntityPlayer.TearFallingSpeed`. */
+  TEAR_FALLING_SPEED,
+
+  /** Corresponds to `CacheFlag.SPEED` (1 << 4) and `EntityPlayer.MoveSpeed`. */
+  MOVE_SPEED,
+
+  /** Corresponds to `CacheFlag.TEAR_FLAG` (1 << 5) and `EntityPlayer.TearFlags`. */
+  TEAR_FLAG,
+
+  /** Corresponds to `CacheFlag.TEAR_COLOR` (1 << 6) and `EntityPlayer.TearColor`. */
+  TEAR_COLOR,
+
+  /** Corresponds to `CacheFlag.FLYING` (1 << 7) and `EntityPlayer.CanFly`. */
+  FLYING,
+
+  // `CacheFlag.WEAPON` (1 << 8) does not have a corresponding `EntityPlayer` field.
+  // `CacheFlag.FAMILIARS` (1 << 9) does not have a corresponding `EntityPlayer` field.
+
+  /** Corresponds to `CacheFlag.LUCK` (1 << 10) and `EntityPlayer.Luck`. */
+  LUCK,
+
+  /** Corresponds to `CacheFlag.SIZE` (1 << 11) and `EntityPlayer.SizeMulti`. */
+  SIZE,
+
+  // `CacheFlag.COLOR` (1 << 12) does not have a corresponding `EntityPlayer` field.
+  // `CacheFlag.PICKUP_VISION` (1 << 13) does not have a corresponding `EntityPlayer` field.
+}

package/src/enums/index.ts

@@ -6,3 +6,4 @@ export * from "./PocketItemType";
 export * from "./RockAltType";
 export * from "./SerializationType";
 export * from "./SlotDestructionType";
+export * from "./StatType";

package/src/enums/indexTypeDoc.ts

@@ -6,3 +6,4 @@ export * as PocketItemType from "./PocketItemType";
 export * as RockAltType from "./RockAltType";
 export * as SerializationType from "./SerializationType";
 export * as SlotDestructionType from "./SlotDestructionType";
+export * as StatType from "./StatType";

package/src/enums/private/CopyableIsaacAPIClassType.ts

@@ -1,5 +1,9 @@
-/** This must match the enumeration in the JSDoc comments for `deepCopy` and `merge`. */
+/**
+ * - This must match the JSDoc comments for `deepCopy` and `merge`.
+ * - This must match the `SerializableIsaacAPIClass` type union.
+ */
 export enum CopyableIsaacAPIClassType {
+  BIT_SET_128 = "BitSet128",
   COLOR = "Color",
   K_COLOR = "KColor",
   RNG = "RNG",

package/src/enums/private/SerializationBrand.ts

@@ -12,6 +12,7 @@ export enum SerializationBrand {
   SET = "__TSTL_SET",
 
   // Specific Isaac API class brands:
+  BIT_SET_128 = "__BIT_SET_128",
   COLOR = "__COLOR",
   K_COLOR = "__K_COLOR",
   RNG = "__RNG",

package/src/features/customStage/versusScreen.ts

@@ -76,13 +76,13 @@ const versusScreenSprite = Sprite();
 
 /**
  * Unfortunately, we must split the background layer into an entirely different sprite so that we
- * can color it with the `Color` property.
+ * can color it with the `Color` field.
  */
 const versusScreenBackgroundSprite = Sprite();
 
 /**
  * Unfortunately, we must split the dirt layer into an entirely different sprite so that we can
- * color it with the `Color` property.
+ * color it with the `Color` field.
  */
 const versusScreenDirtSpotSprite = Sprite();
 

package/src/features/disableInputs.ts

@@ -12,16 +12,10 @@ const FEATURE_NAME = "disableInputs";
 const v = {
   run: {
     /** Indexed by the requesting feature key. */
-    disableInputsWithWhitelistMap: new Map<
-      string,
-      Set<ButtonAction> | ReadonlySet<ButtonAction>
-    >(),
+    disableInputsWithWhitelistMap: new Map<string, ReadonlySet<ButtonAction>>(),
 
     /** Indexed by the requesting feature key. */
-    enableInputsWithBlacklistMap: new Map<
-      string,
-      Set<ButtonAction> | ReadonlySet<ButtonAction>
-    >(),
+    enableInputsWithBlacklistMap: new Map<string, ReadonlySet<ButtonAction>>(),
   },
 };
 
@@ -154,7 +148,7 @@ export function enableAllInputsExceptFor(
  */
 export function disableAllInputsExceptFor(
   key: string,
-  whitelist: Set<ButtonAction>,
+  whitelist: Set<ButtonAction> | ReadonlySet<ButtonAction>,
 ): void {
   errorIfFeaturesNotInitialized(FEATURE_NAME);
 

package/src/features/runInNFrames.ts

@@ -31,7 +31,7 @@ const v = {
 };
 
 export function runInNFramesInit(mod: Mod): void {
-  saveDataManager(FEATURE_NAME, v, () => false); // Functions are not serializable.
+  saveDataManager(FEATURE_NAME, v, false); // Functions are not serializable.
 
   mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
   mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2

package/src/features/runNextRoom.ts

@@ -13,7 +13,7 @@ const v = {
 };
 
 export function runNextRoomInit(mod: ModUpgraded): void {
-  saveDataManager(FEATURE_NAME, v, () => false); // Functions are not serializable.
+  saveDataManager(FEATURE_NAME, v, false); // Functions are not serializable.
 
   mod.AddCallbackCustom(
     ModCallbackCustom.POST_NEW_ROOM_REORDERED,

package/src/features/saveDataManager/exports.ts

@@ -96,18 +96,30 @@ import { SAVE_DATA_MANAGER_FEATURE_NAME } from "./saveDataManagerConstants";
  *            manager. The save data manager will throw an error if the key is already registered.
  * @param v An object that corresponds to the `SaveData` interface. The object is conventionally
  *          called "v" for brevity. ("v" is short for "local variables").
- * @param conditionalFunc An optional function to run upon saving this key to disk. For example,
- *                        this allows features to only save data to disk if the feature is enabled.
- *                        Specify a value of `() => false` to completely disable saving this feature
- *                        to disk. Disabling saving to disk is useful if you are using data that is
- *                        not serializable. Alternatively, it could be useful if you want to use the
- *                        save data manager to automatically reset variables on run/level/room, but
- *                        not clutter the the "save#.dat" file with unnecessary keys.
+ * @param conditionalFunc Optional. A function to run to check if this save data should be written
+ *                        to disk. Default is `() => true`, meaning that this save data will always
+ *                        be written to disk. Use a conditional function for the situations when the
+ *                        local variables are for a feature that the end-user can disable. (If the
+ *                        feature is disabled, then there would be no point in writing any of the
+ *                        variables to the "save#.dat" file.) You can also specify `false` to this
+ *                        argument in order to completely disable saving data. (Specifying `false`
+ *                        will allow you to use non-serializable objects in your save data, such as
+ *                        `EntityPtr`.
  */
+export function saveDataManager<Persistent, Run, Level>(
+  key: string, // This is the overload for the standard case with serializable data.
+  v: SaveData<Persistent, Run, Level>,
+  conditionalFunc?: () => boolean,
+): void;
 export function saveDataManager(
-  key: string,
+  key: string, // This is the overload for the case when saving data is disabled.
   v: SaveData,
-  conditionalFunc?: () => boolean,
+  conditionalFunc: false,
+): void;
+export function saveDataManager<Persistent, Run, Level>(
+  key: string,
+  v: SaveData<Persistent, Run, Level>,
+  conditionalFunc?: (() => boolean) | false,
 ): void {
   errorIfFeaturesNotInitialized(SAVE_DATA_MANAGER_FEATURE_NAME);
 
@@ -126,6 +138,12 @@ export function saveDataManager(
   // Add the new save data to the map.
   saveDataMap.set(key, v);
 
+  // Convert the boolean to a function, if necessary. (Having the argument be a boolean is necessary
+  // in order for the overloads to work properly.)
+  if (conditionalFunc === false) {
+    conditionalFunc = () => false;
+  }
+
   // If the only key in the save data is "room", then we don't have to worry about saving this data
   // to disk (because the room would be reloaded upon resuming a continued run).
   const saveDataKeys = Object.keys(v);
@@ -135,7 +153,7 @@ export function saveDataManager(
 
   // Make a copy of the initial save data so that we can use it to restore the default values later
   // on.
-  const saveDataCopy = deepCopy(v, SerializationType.NONE, key) as SaveData;
+  const saveDataCopy = deepCopy(v, SerializationType.NONE, key) as typeof v;
   saveDataDefaultsMap.set(key, saveDataCopy);
 
   // Store the conditional function for later, if present.

package/src/features/saveDataManager/merge.ts

@@ -25,6 +25,7 @@ import { isSerializationBrand } from "./serializationBrands";
  * - TSTL `Set`
  * - TSTL classes
  * - `DefaultMap`
+ * - Isaac `BitSet128` objects
  * - Isaac `Color` objects
  * - Isaac `KColor` objects
  * - Isaac `RNG` objects

package/src/features/saveDataManager/save.ts

@@ -44,7 +44,8 @@ function getAllSaveDataToWriteToDisk(
         }
       }
 
-      // Strip out the room part of the save data.
+      // Strip out the room part of the save data (and any other arbitrary fields that they might
+      // have added).
       const saveDataWithoutRoom: SaveData = {
         persistent: saveData.persistent,
         run: saveData.run,

package/src/features/taintedLazarusPlayers.ts

@@ -31,10 +31,10 @@ const v = {
 };
 
 export function taintedLazarusPlayersInit(mod: ModUpgraded): void {
-  // `EntityPtr` is not serializable, so we cannot save data. However, this is inconsequential,
+  // `EntityPtr` is not serializable, so we cannot save the data. However, this is inconsequential,
   // since the `POST_PLAYER_INIT` callback will fire when a run is continued, which will repopulate
   // the `subPlayerMap`.
-  saveDataManager(FEATURE_NAME, v, () => false);
+  saveDataManager(FEATURE_NAME, v, false);
 
   mod.AddCallback(ModCallback.POST_PLAYER_INIT, postPlayerInit);
 }

package/src/functions/bitSet128.ts

@@ -0,0 +1,96 @@
+import { SerializationBrand } from "../enums/private/SerializationBrand";
+import { isIsaacAPIClassOfType } from "./isaacAPIClass";
+import { copyValuesToTable, getNumbersFromTable, tableHasKeys } from "./table";
+import { isTable } from "./types";
+
+export type SerializedBitSet128 = LuaMap<string, unknown> & {
+  readonly __serializedBitSet128Brand: symbol;
+};
+
+const OBJECT_NAME = "BitSet128";
+const KEYS = ["l", "h"];
+
+/** Helper function to copy a `BitSet128` Isaac API class. */
+export function copyBitSet128(bitSet128: BitSet128): BitSet128 {
+  if (!isBitSet128(bitSet128)) {
+    error(
+      `Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+    );
+  }
+
+  const lowBits = bitSet128.l;
+  const highBits = bitSet128.h;
+
+  return BitSet128(lowBits, highBits);
+}
+
+/**
+ * Helper function to convert a `SerializedBitSet128` object to a normal `BitSet128` object. (This
+ * is used by the save data manager when reading data from the "save#.dat" file.)
+ */
+export function deserializeBitSet128(
+  bitSet128: SerializedBitSet128,
+): BitSet128 {
+  if (!isTable(bitSet128)) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`,
+    );
+  }
+
+  const [l, h] = getNumbersFromTable(
+    bitSet128 as LuaMap<string, unknown>,
+    OBJECT_NAME,
+    ...KEYS,
+  );
+
+  if (l === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: l`,
+    );
+  }
+  if (h === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: h`,
+    );
+  }
+
+  return BitSet128(l, h);
+}
+
+/** Helper function to check if something is an instantiated `BitSet128` object. */
+export function isBitSet128(object: unknown): object is BitSet128 {
+  return isIsaacAPIClassOfType(object, OBJECT_NAME);
+}
+
+/**
+ * Used to determine is the given table is a serialized `BitSet128` object created by the save data
+ * manager and/or the `deepCopy` function.
+ */
+export function isSerializedBitSet128(
+  object: unknown,
+): object is SerializedBitSet128 {
+  if (!isTable(object)) {
+    return false;
+  }
+
+  return (
+    tableHasKeys(object, ...KEYS) && object.has(SerializationBrand.BIT_SET_128)
+  );
+}
+
+/**
+ * Helper function to convert a `BitSet128` object to a `SerializedBitSet128` object. (This is used
+ * by the save data manager when writing data from the "save#.dat" file.)
+ */
+export function serializeBitSet128(bitSet128: BitSet128): SerializedBitSet128 {
+  if (!isBitSet128(bitSet128)) {
+    error(
+      `Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+    );
+  }
+
+  const bitSet128Table = new LuaMap<string, unknown>();
+  copyValuesToTable(bitSet128, KEYS, bitSet128Table);
+  bitSet128Table.set(SerializationBrand.BIT_SET_128, "");
+  return bitSet128Table as SerializedBitSet128;
+}

package/src/functions/collectibles.ts

@@ -614,8 +614,8 @@ export function setCollectibleSprite(
 }
 
 /**
- * Helper function to change the collectible on a pedestal. Simply updating the `SubType` property
- * is not sufficient because the sprite will not change.
+ * Helper function to change the collectible on a pedestal. Simply updating the `SubType` field is
+ * not sufficient because the sprite will not change.
  */
 export function setCollectibleSubType(
   collectible: EntityPickup,

package/src/functions/color.ts

@@ -9,8 +9,8 @@ export type SerializedColor = LuaMap<string, unknown> & {
   readonly __serializedColorBrand: symbol;
 };
 
-const KEYS = ["R", "G", "B", "A", "RO", "GO", "BO"];
 const OBJECT_NAME = "Color";
+const KEYS = ["R", "G", "B", "A", "RO", "GO", "BO"];
 
 export function colorEquals(color1: Color, color2: Color): boolean {
   return isaacAPIClassEquals(color1, color2, KEYS);
@@ -91,7 +91,7 @@ export function getRandomColor(
   return Color(r, g, b, alpha);
 }
 
-/** Helper function to check if something is an instantiated Color object. */
+/** Helper function to check if something is an instantiated `Color` object. */
 export function isColor(object: unknown): object is Color {
   return isIsaacAPIClassOfType(object, OBJECT_NAME);
 }
@@ -107,6 +107,7 @@ export function isSerializedColor(object: unknown): object is SerializedColor {
 
   return tableHasKeys(object, ...KEYS) && object.has(SerializationBrand.COLOR);
 }
+
 /**
  * Helper function to convert a `Color` object to a `SerializedColor` object. (This is used by the
  * save data manager when writing data from the "save#.dat" file.)

package/src/functions/deepCopy.ts

@@ -42,6 +42,7 @@ const COPYABLE_ISAAC_API_CLASS_TYPES_SET = new Set<string>(
  * - TSTL `Set`
  * - TSTL classes
  * - `DefaultMap`
+ * - Isaac `BitSet128` objects
  * - Isaac `Color` objects
  * - Isaac `KColor` objects
  * - Isaac `RNG` objects
@@ -233,7 +234,7 @@ function deepCopyDefaultMap(
       // throw a run-time error to immediately alert the end-user that their data structure is
       // invalid.
       error(
-        'Failed to deep copy a DefaultMap because it was instantiated with a factory function and was also inside of another map. You cannot use a nested DefaultMap in this way because factory functions are not serializable. (In other words, there is no way to copy the function that you are using for the DefaultMap into the "save#.dat" file.) Instead, refactor your data structure so that the DefaultMap is not nested.',
+        "Failed to deep copy a DefaultMap because it was instantiated with a factory function and was also inside of an array, map, or set. For more information, see: https://isaacscript.github.io/main/gotchas#failed-to-deep-copy-a-defaultmap",
       );
     } else {
       // In most cases, the DefaultMap will be attached to a normal table element. In this case, if

package/src/functions/entities.ts

@@ -187,9 +187,9 @@ function setPrimitiveEntityFields(
     const indexKey = key as keyof typeof entity;
     const value = entity[indexKey];
     if (isPrimitive(value)) {
-      entityFields.set(indexKey, value);
+      entityFields.set(indexKey as string, value);
     } else if (isVector(value)) {
-      entityFields.set(indexKey, vectorToString(value));
+      entityFields.set(indexKey as string, vectorToString(value));
     }
   }
 }

package/src/functions/familiars.ts

@@ -11,8 +11,8 @@ import { getFamiliars } from "./entitiesSpecific";
  * specify an incorrect RNG object. (The vanilla method is bugged in that it does not increment the
  * RNG object; see the documentation of the method for more details.)
  *
- * This function is meant to be called in the EvaluateCache callback (when the cache flag is equal
- * to `CacheFlag.FAMILIARS`).
+ * This function is meant to be called in the `EVALUATE_CACHE` callback (when the cache flag is
+ * equal to `CacheFlag.FAMILIARS`).
  *
  * Note that this function is only meant to be used in special circumstances where the familiar
  * count is completely custom and does not correspond to the amount of collectibles. For the general
@@ -56,8 +56,8 @@ export function checkFamiliar(
  * Use this helper function instead of invoking the `EntityPlayer.CheckFamiliar` method directly so
  * that the target count is handled automatically.
  *
- * This function is meant to be called in the EvaluateCache callback (when the cache flag is equal
- * to `CacheFlag.FAMILIARS`).
+ * This function is meant to be called in the `EVALUATE_CACHE` callback (when the cache flag is
+ * equal to `CacheFlag.FAMILIARS`).
  *
  * Use this function when the amount of familiars should be equal to the amount of associated
  * collectibles that the player has (plus any extras from having used Box of Friends or Monster

package/src/functions/flag.ts

@@ -42,7 +42,7 @@ export function addFlag<T extends BitFlag | BitFlag128>(
  * Helper function for casting a flag enum value to a `BitFlags` object.
  *
  * This is useful because the compiler will prevent you from assigning a specific flag to a
- * `BitFlags` property. (It does this to ensure type safety, since `BitFlags` can represent a zero
+ * `BitFlags` field. (It does this to ensure type safety, since `BitFlags` can represent a zero
  * value or a composition of N flags.)
  *
  * For example:

package/src/functions/index.ts

@@ -3,6 +3,7 @@
 export * from "./ambush";
 export * from "./array";
 export * from "./benchmark";
+export * from "./bitSet128";
 export * from "./bitwise";
 export * from "./bombs";
 export * from "./bosses";
@@ -63,6 +64,7 @@ export * from "./playerDataStructures";
 export * from "./playerHealth";
 export * from "./playerIndex";
 export * from "./players";
+export * from "./playerStats";
 export * from "./pocketItems";
 export * from "./positionVelocity";
 export * from "./pressurePlate";

package/src/functions/indexTypeDoc.ts

@@ -3,6 +3,7 @@
 export * as Ambush from "./ambush";
 export * as Array from "./array";
 export * as Benchmark from "./benchmark";
+export * as BitSet128 from "./bitSet128";
 export * as Bitwise from "./bitwise";
 export * as Bombs from "./bombs";
 export * as Bosses from "./bosses";
@@ -63,6 +64,7 @@ export * as PlayerDataStructures from "./playerDataStructures";
 export * as PlayerHealth from "./playerHealth";
 export * as PlayerIndex from "./playerIndex";
 export * as Players from "./players";
+export * as PlayerStats from "./playerStats";
 export * as PocketItems from "./pocketItems";
 export * as PositionVelocity from "./positionVelocity";
 export * as PressurePlate from "./pressurePlate";

package/src/functions/isaacAPIClass.ts

@@ -1,4 +1,3 @@
-import { IsaacAPIClass } from "../types/IsaacAPIClass";
 import { trimPrefix } from "./string";
 import { isString, isUserdata } from "./types";