isaacscript-common 6.8.0 → 6.10.1

package/src/functions/array.ts

@@ -443,9 +443,7 @@ export function isArray(object: unknown): object is unknown[] {
     return false;
   }
 
-  // Third, handle the case of an "empty" table. We cannot use the "LuaTable.length" method to
-  // determine this, since that will not actually return the number of keys. (It will only work
-  // properly for tables that are being used as arrays, which is not necessarily the case here.)
+  // Third, handle the case of an "empty" table.
   const tableLength = Object.keys(object).length;
   if (tableLength === 0) {
     return true;
@@ -453,7 +451,7 @@ export function isArray(object: unknown): object is unknown[] {
 
   // Third, check for non-contiguous elements. (Lua tables start at an index of 1.)
   for (let i = 1; i <= tableLength; i++) {
-    const element = object.get(i) as unknown;
+    const element = object.get(i);
     if (element === undefined) {
       return false;
     }

package/src/functions/color.ts

@@ -4,7 +4,7 @@ import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
 import { copyValuesToTable, getNumbersFromTable, tableHasKeys } from "./table";
 import { isTable } from "./types";
 
-type SerializedColor = LuaTable<string, unknown> & {
+type SerializedColor = LuaMap<string, unknown> & {
   readonly __serializedColorBrand: symbol;
 };
 
@@ -65,7 +65,7 @@ export function copyColor(
         );
       }
 
-      const colorTable = new LuaTable<string, unknown>();
+      const colorTable = new LuaMap<string, unknown>();
       copyValuesToTable(color, KEYS, colorTable);
       colorTable.set(SerializationBrand.COLOR, "");
       return colorTable as SerializedColor;
@@ -79,7 +79,7 @@ export function copyColor(
       }
 
       const [r, g, b, a, ro, go, bo] = getNumbersFromTable(
-        color as LuaTable<string, unknown>,
+        color as LuaMap<string, unknown>,
         OBJECT_NAME,
         ...KEYS,
       );

package/src/functions/deepCopy.ts

@@ -3,12 +3,12 @@ import { CopyableIsaacAPIClassType } from "../enums/private/CopyableIsaacAPIClas
 import { SerializationBrand } from "../enums/private/SerializationBrand";
 import { SerializationType } from "../enums/SerializationType";
 import { SAVE_DATA_MANAGER_DEBUG } from "../features/saveDataManager/saveDataManagerConstants";
-import { isSerializationBrand } from "../features/saveDataManager/serializationBrand";
+import { isSerializationBrand } from "../features/saveDataManager/serializationBrands";
 import { TSTLClass } from "../types/private/TSTLClass";
 import { isArray } from "./array";
 import { getEnumValues } from "./enums";
 import { getIsaacAPIClassName } from "./isaacAPIClass";
-import { log, logTable } from "./log";
+import { log } from "./log";
 import {
   copyIsaacAPIClass,
   deserializeIsaacAPIClass,
@@ -36,7 +36,7 @@ const COPYABLE_ISAAC_API_CLASS_TYPES_SET = new Set<string>(
  * It supports the following object types:
  *
  * - Primitives (i.e. strings, numbers, and booleans)
- * - `LuaTable` / basic TSTL objects
+ * - Basic TSTL objects / tables
  * - TSTL `Map`
  * - TSTL `Set`
  * - TSTL classes
@@ -101,9 +101,9 @@ export function deepCopy(
     }
 
     case "table": {
-      const luaTable = value as LuaTable<AnyNotNil, unknown>;
+      const luaMap = value as LuaMap<AnyNotNil, unknown>;
       return deepCopyTable(
-        luaTable,
+        luaMap,
         serializationType,
         traversalDescription,
         insideMap,
@@ -117,40 +117,40 @@ export function deepCopy(
 }
 
 function deepCopyTable(
-  luaTable: LuaTable<AnyNotNil, unknown>,
+  luaMap: LuaMap<AnyNotNil, unknown>,
   serializationType: SerializationType,
   traversalDescription: string,
   insideMap: boolean,
 ) {
   // First, handle the cases of TSTL classes or serialized TSTL classes.
-  if (isDefaultMap(luaTable) || luaTable.has(SerializationBrand.DEFAULT_MAP)) {
+  if (isDefaultMap(luaMap) || luaMap.has(SerializationBrand.DEFAULT_MAP)) {
     return deepCopyDefaultMap(
-      luaTable,
+      luaMap,
       serializationType,
       traversalDescription,
       insideMap,
     );
   }
 
-  if (isTSTLMap(luaTable) || luaTable.has(SerializationBrand.MAP)) {
+  if (isTSTLMap(luaMap) || luaMap.has(SerializationBrand.MAP)) {
     return deepCopyMap(
-      luaTable,
+      luaMap,
       serializationType,
       traversalDescription,
       insideMap,
     );
   }
 
-  if (isTSTLSet(luaTable) || luaTable.has(SerializationBrand.SET)) {
+  if (isTSTLSet(luaMap) || luaMap.has(SerializationBrand.SET)) {
     return deepCopySet(
-      luaTable,
+      luaMap,
       serializationType,
       traversalDescription,
       insideMap,
     );
   }
 
-  const className = getTSTLClassName(luaTable);
+  const className = getTSTLClassName(luaMap);
 
   if (className === "WeakMap") {
     error(
@@ -164,9 +164,9 @@ function deepCopyTable(
     );
   }
 
-  if (isUserDefinedTSTLClass(luaTable)) {
+  if (isUserDefinedTSTLClass(luaMap)) {
     return deepCopyTSTLClass(
-      luaTable,
+      luaMap,
       serializationType,
       traversalDescription,
       insideMap,
@@ -174,20 +174,20 @@ function deepCopyTable(
   }
 
   // This is not a TSTL Map/Set/class. If it has a metatable, abort.
-  checkMetatable(luaTable, traversalDescription);
+  checkMetatable(luaMap, traversalDescription);
 
   // Handle the special case of serialized Isaac API classes.
   if (
-    isSerializedIsaacAPIClass(luaTable) &&
+    isSerializedIsaacAPIClass(luaMap) &&
     serializationType === SerializationType.DESERIALIZE
   ) {
-    return deserializeIsaacAPIClass(luaTable);
+    return deserializeIsaacAPIClass(luaMap);
   }
 
   // Handle the special case of an array.
-  if (isArray(luaTable)) {
+  if (isArray(luaMap)) {
     return deepCopyArray(
-      luaTable,
+      luaMap,
       serializationType,
       traversalDescription,
       insideMap,
@@ -196,7 +196,7 @@ function deepCopyTable(
 
   // Base case: copy a normal Lua table
   return deepCopyNormalLuaTable(
-    luaTable,
+    luaMap,
     serializationType,
     traversalDescription,
     insideMap,
@@ -204,11 +204,16 @@ function deepCopyTable(
 }
 
 function deepCopyDefaultMap(
-  defaultMap: DefaultMap<AnyNotNil, unknown> | LuaTable<AnyNotNil, unknown>,
+  defaultMap: DefaultMap<AnyNotNil, unknown> | LuaMap<AnyNotNil, unknown>,
   serializationType: SerializationType,
   traversalDescription: string,
   insideMap: boolean,
 ) {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (SAVE_DATA_MANAGER_DEBUG) {
+    log("deepCopy is copying a DefaultMap.");
+  }
+
   const constructorArg = isDefaultMap(defaultMap)
     ? defaultMap.getConstructorArg()
     : undefined; // The undefined case is handled explicitly in the "getNewDefaultMap" function.
@@ -287,11 +292,11 @@ function deepCopyDefaultMap(
  * whether we are serializing or not.
  */
 function getNewDefaultMap(
-  defaultMap: DefaultMap<AnyNotNil, unknown> | LuaTable<AnyNotNil, unknown>,
+  defaultMap: DefaultMap<AnyNotNil, unknown> | LuaMap<AnyNotNil, unknown>,
   serializationType: SerializationType,
   traversalDescription: string,
   constructorArg: unknown,
-) {
+): DefaultMap<AnyNotNil, unknown> | LuaMap<AnyNotNil, unknown> {
   switch (serializationType) {
     case SerializationType.NONE: {
       // eslint-disable-next-line isaacscript/no-invalid-default-map
@@ -301,7 +306,7 @@ function getNewDefaultMap(
     case SerializationType.SERIALIZE: {
       // Since we are serializing, the new object will be a Lua table. (At this point, we already
       // handled the special case of a DefaultMap instantiated with a factory function.)
-      const newDefaultMap = new LuaTable<AnyNotNil, unknown>();
+      const newDefaultMap = new LuaMap<AnyNotNil, unknown>();
       newDefaultMap.set(SerializationBrand.DEFAULT_MAP, "");
       newDefaultMap.set(SerializationBrand.DEFAULT_MAP_VALUE, constructorArg);
 
@@ -331,15 +336,20 @@ function getNewDefaultMap(
 }
 
 function deepCopyMap(
-  map: Map<AnyNotNil, unknown> | LuaTable<AnyNotNil, unknown>,
+  map: Map<AnyNotNil, unknown> | LuaMap<AnyNotNil, unknown>,
   serializationType: SerializationType,
   traversalDescription: string,
   insideMap: boolean,
 ) {
-  let newMap: Map<AnyNotNil, unknown> | LuaTable<AnyNotNil, unknown>;
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (SAVE_DATA_MANAGER_DEBUG) {
+    log("deepCopy is copying a Map.");
+  }
+
+  let newMap: Map<AnyNotNil, unknown> | LuaMap<AnyNotNil, unknown>;
   if (serializationType === SerializationType.SERIALIZE) {
     // Since we are serializing, the new object will be a Lua table.
-    newMap = new LuaTable<AnyNotNil, unknown>();
+    newMap = new LuaMap<AnyNotNil, unknown>();
     newMap.set(SerializationBrand.MAP, "");
   } else {
     newMap = new Map();
@@ -379,16 +389,21 @@ function deepCopyMap(
 }
 
 function deepCopySet(
-  set: Set<AnyNotNil> | LuaTable<AnyNotNil, unknown>,
+  set: Set<AnyNotNil> | LuaMap<AnyNotNil, unknown>,
   serializationType: SerializationType,
   traversalDescription: string,
   insideMap: boolean,
 ) {
-  let newSet: Set<AnyNotNil> | LuaTable<AnyNotNil, string>;
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (SAVE_DATA_MANAGER_DEBUG) {
+    log("deepCopy is copying a Set.");
+  }
+
+  let newSet: Set<AnyNotNil> | LuaMap<AnyNotNil, string>;
   if (serializationType === SerializationType.SERIALIZE) {
     // For serialization purposes, we represent a `Set` as a table with keys that match the
     // keys/values in the Set and values of an empty string.
-    newSet = new LuaTable<AnyNotNil, string>();
+    newSet = new LuaMap<AnyNotNil, string>();
     newSet.set(SerializationBrand.SET, "");
   } else {
     newSet = new Set();
@@ -405,7 +420,7 @@ function deepCopySet(
     // Differentiating between the two types looks superfluous but is necessary for TSTL to produce
     // the proper set method call.
     if (isTSTLSet(newSet)) {
-      // We should never be serializing an object of type Set.
+      // We should never be serializing an object of type `Set`.
       error(
         "The deep copy function cannot convert number keys to strings for a Set.",
       );
@@ -433,10 +448,15 @@ function deepCopyTSTLClass(
   traversalDescription: string,
   insideMap: boolean,
 ) {
-  let newClass: TSTLClass | LuaTable<AnyNotNil, unknown>;
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (SAVE_DATA_MANAGER_DEBUG) {
+    log("deepCopy is copying a TSTL class.");
+  }
+
+  let newClass: TSTLClass | LuaMap<AnyNotNil, unknown>;
   if (serializationType === SerializationType.SERIALIZE) {
     // Since we are serializing, the new object will be a Lua table.
-    newClass = new LuaTable<AnyNotNil, unknown>();
+    newClass = new LuaMap<AnyNotNil, unknown>();
     // (We do not brand it with the class type because we will not have the associated class
     // constructor during deserialization, so knowing what type of class it is is pointless.)
   } else {
@@ -467,6 +487,11 @@ function deepCopyArray(
   traversalDescription: string,
   insideMap: boolean,
 ) {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (SAVE_DATA_MANAGER_DEBUG) {
+    log("deepCopy is copying an array.");
+  }
+
   const newArray: unknown[] = [];
 
   for (const value of array) {
@@ -483,14 +508,19 @@ function deepCopyArray(
 }
 
 function deepCopyNormalLuaTable(
-  luaTable: LuaTable<AnyNotNil, unknown>,
+  luaMap: LuaMap<AnyNotNil, unknown>,
   serializationType: SerializationType,
   traversalDescription: string,
   insideMap: boolean,
 ) {
-  const newTable = new LuaTable<AnyNotNil, unknown>();
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (SAVE_DATA_MANAGER_DEBUG) {
+    log("deepCopy is copying a normal Lua table.");
+  }
+
+  const newTable = new LuaMap<AnyNotNil, unknown>();
   const { entries, convertedNumberKeysToStrings } = getCopiedEntries(
-    luaTable,
+    luaMap,
     serializationType,
     traversalDescription,
     insideMap,
@@ -535,7 +565,6 @@ function getCopiedEntries(
 
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (SAVE_DATA_MANAGER_DEBUG) {
-    logTable(entries);
     entries.sort(twoDimensionalSort);
   }
 
@@ -575,8 +604,11 @@ function getCopiedEntries(
  * copy function will refuse to copy a table type that has a metatable, outside of specifically
  * supported TSTL objects.
  */
-function checkMetatable(luaTable: LuaTable, traversalDescription: string) {
-  const metatable = getmetatable(luaTable);
+function checkMetatable(
+  luaMap: LuaMap<AnyNotNil, unknown>,
+  traversalDescription: string,
+) {
+  const metatable = getmetatable(luaMap);
   if (metatable === undefined) {
     return;
   }
@@ -597,6 +629,11 @@ function deepCopyUserdata(
   serializationType: SerializationType,
   traversalDescription: string,
 ) {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (SAVE_DATA_MANAGER_DEBUG) {
+    log("deepCopy is copying userdata.");
+  }
+
   const classType = getIsaacAPIClassName(value);
   if (classType === undefined) {
     error(

package/src/functions/deepCopyTests.ts

@@ -40,7 +40,7 @@ function copiedObjectIsTable() {
     abc: "def",
   };
   const newObject = deepCopy(
-    oldObject as unknown as LuaTable,
+    oldObject as unknown as LuaMap,
     SerializationType.NONE,
     "copiedObjectIsTable",
   );
@@ -56,7 +56,7 @@ function copiedObjectHasKeyAndValueString() {
     abc: valueToLookFor,
   };
   const newTable = deepCopy(
-    oldObject as unknown as LuaTable,
+    oldObject as unknown as LuaMap,
     SerializationType.NONE,
     "copiedObjectHasKeyAndValueString",
   );
@@ -79,7 +79,7 @@ function copiedObjectHasKeyAndValueString() {
 function copiedTableHasKeyAndValueNumber() {
   const keyToLookFor = 123;
   const valueToLookFor = 456;
-  const oldTable = new LuaTable<AnyNotNil, unknown>();
+  const oldTable = new LuaMap<AnyNotNil, unknown>();
   oldTable.set(keyToLookFor, valueToLookFor);
 
   const newObject = deepCopy(
@@ -87,7 +87,7 @@ function copiedTableHasKeyAndValueNumber() {
     SerializationType.NONE,
     "copiedTableHasKeyAndValueNumber",
   );
-  const newTable = newObject as LuaTable<AnyNotNil, unknown>;
+  const newTable = newObject as LuaMap<AnyNotNil, unknown>;
 
   const value = newTable.get(keyToLookFor) as number | undefined;
   if (value === undefined) {
@@ -105,7 +105,7 @@ function copiedTableHasKeyAndValueNumber() {
 function copiedTableDoesNotCoerceTypes() {
   const keyToLookFor = 123;
   const valueToLookFor = 456;
-  const oldTable = new LuaTable<AnyNotNil, unknown>();
+  const oldTable = new LuaMap<AnyNotNil, unknown>();
   oldTable.set(keyToLookFor, valueToLookFor);
 
   const newObject = deepCopy(
@@ -113,7 +113,7 @@ function copiedTableDoesNotCoerceTypes() {
     SerializationType.NONE,
     "copiedTableDoesNotCoerceTypes",
   );
-  const newTable = newObject as LuaTable<AnyNotNil, unknown>;
+  const newTable = newObject as LuaMap<AnyNotNil, unknown>;
 
   const keyString = tostring(keyToLookFor);
   const valueString = tostring(valueToLookFor);
@@ -140,7 +140,7 @@ function copiedObjectHasNoReferencesForPrimitivesForward() {
     def: originalNumberValue,
   };
   const newTable = deepCopy(
-    oldObject as unknown as LuaTable,
+    oldObject as unknown as LuaMap,
     SerializationType.NONE,
     "copiedObjectHasNoReferencesForPrimitivesForward",
   );
@@ -165,7 +165,7 @@ function copiedObjectHasNoReferencesForPrimitivesBackward() {
     def: originalNumberValue,
   };
   const newTable = deepCopy(
-    oldObject as unknown as LuaTable,
+    oldObject as unknown as LuaMap,
     SerializationType.NONE,
     "copiedObjectHasNoReferencesForPrimitivesBackward",
   );
@@ -188,7 +188,7 @@ function copiedObjectHasNoReferencesForArray() {
     abc: [1, 2, 3],
   };
   const newTable = deepCopy(
-    oldObject as unknown as LuaTable,
+    oldObject as unknown as LuaMap,
     SerializationType.NONE,
     "copiedObjectHasNoReferencesForArray",
   );
@@ -229,7 +229,7 @@ function copiedObjectHasChildObject() {
     },
   };
   const newTable = deepCopy(
-    oldObject as unknown as LuaTable,
+    oldObject as unknown as LuaMap,
     SerializationType.NONE,
     "copiedObjectHasChildObject",
   );
@@ -268,11 +268,8 @@ function copiedMapIsMap() {
   const newObject = deepCopy(oldMap, SerializationType.NONE, "copiedMapIsMap");
   const newMap = newObject as Map<string, string>;
 
-  if (!isTable(newMap)) {
-    error(`The copied Map had a type of: ${typeof newMap}`);
-  }
   if (!isTSTLMap(newMap)) {
-    error("The copied Map was not a Map.");
+    error(`The copied Map was not a Map and has a type of: ${typeof newMap}`);
   }
 }
 
@@ -287,8 +284,13 @@ function copiedMapHasValue() {
     SerializationType.NONE,
     "copiedMapHasValue",
   );
+
   const newMap = newTable as typeof oldMap;
 
+  if (!isTSTLMap(newMap)) {
+    error(`The copied Map was not a Map and has a type of: ${typeof newMap}`);
+  }
+
   const value = newMap.get(keyToLookFor);
   if (value === undefined) {
     error(`The copied Map did not have a key of: ${keyToLookFor}`);
@@ -306,11 +308,8 @@ function copiedSetIsSet() {
   const newTable = deepCopy(oldSet, SerializationType.NONE, "copiedSetIsSet");
   const newSet = newTable as Set<string>;
 
-  if (!isTable(newSet)) {
-    error(`The copied Set had a type of: ${typeof newSet}`);
-  }
   if (!isTSTLSet(newSet)) {
-    error("The copied Set was not a Map.");
+    error(`The copied Set was not a Set and has a type of: ${typeof newSet}`);
   }
 }
 
@@ -326,6 +325,10 @@ function copiedSetHasValue() {
   );
   const newSet = newTable as Set<string>;
 
+  if (!isTSTLSet(newSet)) {
+    error(`The copied Set was not a Set and has a type of: ${typeof newSet}`);
+  }
+
   const hasValue = newSet.has(valueToLookFor);
   if (!hasValue) {
     error(`The copied Set did not have a value of: ${valueToLookFor}`);
@@ -338,7 +341,7 @@ function copiedMapHasChildMap() {
   const oldChildMap = new Map<number, number>();
   oldChildMap.set(childMapKey, childMapValue);
 
-  const keyToLookFor = "abc";
+  const keyToLookFor = "childMap";
   const oldMap = new Map<string, Map<number, number>>();
   oldMap.set(keyToLookFor, oldChildMap);
 
@@ -349,16 +352,19 @@ function copiedMapHasChildMap() {
   );
   const newMap = newTable as typeof oldMap;
 
+  if (!isTSTLMap(newMap)) {
+    error(`The copied Map was not a Map and had a type of: ${typeof newMap}`);
+  }
+
   const newChildMap = newMap.get(keyToLookFor);
   if (newChildMap === undefined) {
     error(`The copied Map did not have a child map at key: ${keyToLookFor}`);
   }
 
-  if (!isTable(newChildMap)) {
-    error(`The copied child Map had a type of: ${typeof newChildMap}`);
-  }
   if (!isTSTLMap(newChildMap)) {
-    error("The copied child Map was not a Map.");
+    error(
+      `The copied child Map was not a Map and had a type of: ${typeof newChildMap}`,
+    );
   }
 
   const value = newChildMap.get(childMapKey);
@@ -390,6 +396,12 @@ function copiedDefaultMapHasChildDefaultMap() {
   );
   const newParentMap = newTable as typeof oldParentMap;
 
+  if (!isDefaultMap(newParentMap)) {
+    error(
+      `The copied parent DefaultMap was not a DefaultMap and had a type of: ${typeof newParentMap}`,
+    );
+  }
+
   const newChildMap = newParentMap.get(parentMapKey);
   if (newChildMap === undefined) {
     error(
@@ -397,11 +409,10 @@ function copiedDefaultMapHasChildDefaultMap() {
     );
   }
 
-  if (!isTable(newChildMap)) {
-    error(`The copied child DefaultMap had a type of: ${typeof newChildMap}`);
-  }
   if (!isDefaultMap(newChildMap)) {
-    error("The copied child DefaultMap was not a DefaultMap.");
+    error(
+      `The copied child DefaultMap was not a DefaultMap and had a type of: ${typeof newChildMap}`,
+    );
   }
 
   const newChildMapValue1 = newChildMap.get(childMapKey1);
@@ -432,7 +443,13 @@ function copiedDefaultMapHasBrand() {
     oldDefaultMap,
     SerializationType.SERIALIZE,
     "copiedDefaultMapHasBrand",
-  ) as LuaTable<AnyNotNil, unknown>;
+  ) as LuaMap<AnyNotNil, unknown>;
+
+  if (!isTable(newTable)) {
+    error(
+      `The copied DefaultMap was not a table and had a type of: ${typeof newTable}`,
+    );
+  }
 
   if (!newTable.has(SerializationBrand.DEFAULT_MAP)) {
     error(

package/src/functions/entities.ts

@@ -137,11 +137,11 @@ export function getEntities(
  */
 export function getEntityFields(
   entity: Entity,
-): LuaTable<string, boolean | number | string> {
-  const entityFields = new LuaTable<string, boolean | number | string>();
+): LuaMap<string, boolean | number | string> {
+  const entityFields = new LuaMap<string, boolean | number | string>();
 
   const metatable = getmetatable(entity) as
-    | LuaTable<AnyNotNil, unknown>
+    | LuaMap<AnyNotNil, unknown>
     | undefined;
   if (metatable === undefined) {
     error("Failed to get the metatable for an entity.");
@@ -158,7 +158,7 @@ export function getEntityFields(
   }
 
   const parentTable = metatable.get("__parent") as
-    | LuaTable<AnyNotNil, unknown>
+    | LuaMap<AnyNotNil, unknown>
     | undefined;
   if (parentTable === undefined) {
     error('Failed to get the "__parent" table for an entity.');
@@ -171,11 +171,11 @@ export function getEntityFields(
 
 function setPrimitiveEntityFields(
   entity: Entity,
-  metatable: LuaTable<AnyNotNil, unknown>,
-  entityFields: LuaTable<string, boolean | number | string>,
+  metatable: LuaMap<AnyNotNil, unknown>,
+  entityFields: LuaMap<string, boolean | number | string>,
 ) {
   const propGetTable = metatable.get("__propget") as
-    | LuaTable<AnyNotNil, unknown>
+    | LuaMap<AnyNotNil, unknown>
     | undefined;
   if (propGetTable === undefined) {
     error('Failed to get the "__propget" table for an entity.');

package/src/functions/input.ts

@@ -4,10 +4,9 @@ import {
   ControllerIndex,
   Keyboard,
 } from "isaac-typescript-definitions";
-import { MAX_NUM_INPUTS } from "../constants";
+import { getEnumValues } from "./enums";
 import { copySet } from "./set";
 import { trimPrefix } from "./string";
-import { erange } from "./utils";
 
 const MODIFIER_KEYS: readonly Keyboard[] = [
   Keyboard.LEFT_SHIFT, // 340
@@ -62,9 +61,9 @@ export function getShootActions(): Set<ButtonAction> {
 
 /** Iterates over all inputs to determine if a particular button is pressed (i.e. held down). */
 export function isActionPressedOnAnyInput(buttonAction: ButtonAction): boolean {
-  const validInputs = erange(MAX_NUM_INPUTS);
-  return validInputs.some((input) =>
-    Input.IsActionPressed(buttonAction, input),
+  const controllerIndexes = getEnumValues(ControllerIndex);
+  return controllerIndexes.some((controllerIndex) =>
+    Input.IsActionPressed(buttonAction, controllerIndex),
   );
 }
 
@@ -75,9 +74,9 @@ export function isActionPressedOnAnyInput(buttonAction: ButtonAction): boolean {
 export function isActionTriggeredOnAnyInput(
   buttonAction: ButtonAction,
 ): boolean {
-  const validInputs = erange(MAX_NUM_INPUTS);
-  return validInputs.some((input) =>
-    Input.IsActionTriggered(buttonAction, input),
+  const controllerIndexes = getEnumValues(ControllerIndex);
+  return controllerIndexes.some((controllerIndex) =>
+    Input.IsActionTriggered(buttonAction, controllerIndex),
   );
 }
 

package/src/functions/isaacAPIClass.ts

@@ -16,7 +16,7 @@ export function getIsaacAPIClassName(object: unknown): string | undefined {
   }
 
   const metatable = getmetatable(object) as
-    | LuaTable<AnyNotNil, unknown>
+    | LuaMap<AnyNotNil, unknown>
     | undefined;
   if (metatable === undefined) {
     return undefined;
@@ -60,8 +60,8 @@ export function isaacAPIClassEquals(
   object2: unknown,
   keys: string[],
 ): boolean {
-  const table1 = object1 as LuaTable<AnyNotNil, unknown>;
-  const table2 = object2 as LuaTable<AnyNotNil, unknown>;
+  const table1 = object1 as LuaMap<AnyNotNil, unknown>;
+  const table2 = object2 as LuaMap<AnyNotNil, unknown>;
 
   return keys.every((key) => table1.get(key) === table2.get(key));
 }