isaacscript-common 87.5.1 → 87.6.0

package/src/lib/jsonLua.js

@@ -30,11 +30,11 @@ function lua_load(a, b) {
       "Lua parser not available, perhaps you're not using the lua+parser.js version of the library?",
     );
   eval(
-    "fn = function " +
-      (b || "load") +
-      "() {\nreturn (function () {\n" +
-      lua_parser.parse(a) +
-      "\n})()[0];\n};",
+    "fn = function "
+      + (b || "load")
+      + "() {\nreturn (function () {\n"
+      + lua_parser.parse(a)
+      + "\n})()[0];\n};",
   );
 }
 function slice(a, b) {
@@ -181,8 +181,8 @@ function lua_eq(a, b) {
 }
 function lua_lt(a, b) {
   if (
-    ("number" == typeof a && "number" == typeof b) ||
-    ("string" == typeof a && "string" == typeof b)
+    ("number" == typeof a && "number" == typeof b)
+    || ("string" == typeof a && "string" == typeof b)
   )
     return a < b;
   var c = a.metatable && a.metatable.str.__lt;
@@ -192,16 +192,16 @@ function lua_lt(a, b) {
 }
 function lua_lte(a, b) {
   if (
-    ("number" == typeof a && "number" == typeof b) ||
-    ("string" == typeof a && "string" == typeof b)
+    ("number" == typeof a && "number" == typeof b)
+    || ("string" == typeof a && "string" == typeof b)
   )
     return a <= b;
   var c = a.metatable && a.metatable.str.__le;
   if (c && c == (b.metatable && b.metatable.str.__le))
     return lua_true(lua_rawcall(c, [a, b])[0]);
   if (
-    (c = a.metatable && a.metatable.str.__lt) &&
-    c == (b.metatable && b.metatable.str.__lt)
+    (c = a.metatable && a.metatable.str.__lt)
+    && c == (b.metatable && b.metatable.str.__lt)
   )
     return lua_not(lua_rawcall(c, [b, a])[0]);
   throw Error("Unable to compare " + a + " and " + b);
@@ -221,8 +221,8 @@ function lua_add(a, b) {
   if (isNaN(c) || isNaN(d)) {
     if (
       (c =
-        (a.metatable && a.metatable.str.__add) ||
-        (b.metatable && b.metatable.str.__add))
+        (a.metatable && a.metatable.str.__add)
+        || (b.metatable && b.metatable.str.__add))
     )
       return lua_rawcall(c, [a, b])[0];
     throw Error("Adding <" + a + "> and <" + b + "> not supported");
@@ -235,8 +235,8 @@ function lua_subtract(a, b) {
   if (isNaN(c) || isNaN(d)) {
     if (
       (c =
-        (a.metatable && a.metatable.str.__sub) ||
-        (b.metatable && b.metatable.str.__sub))
+        (a.metatable && a.metatable.str.__sub)
+        || (b.metatable && b.metatable.str.__sub))
     )
       return lua_rawcall(c, [a, b])[0];
     throw Error("Subtracting <" + a + "> and <" + b + "> not supported");
@@ -249,8 +249,8 @@ function lua_divide(a, b) {
   if (isNaN(c) || isNaN(d)) {
     if (
       (c =
-        (a.metatable && a.metatable.str.__div) ||
-        (b.metatable && b.metatable.str.__div))
+        (a.metatable && a.metatable.str.__div)
+        || (b.metatable && b.metatable.str.__div))
     )
       return lua_rawcall(c, [a, b])[0];
     throw Error("Dividing <" + a + "> and <" + b + "> not supported");
@@ -263,8 +263,8 @@ function lua_multiply(a, b) {
   if (isNaN(c) || isNaN(d)) {
     if (
       (c =
-        (a.metatable && a.metatable.str.__mul) ||
-        (b.metatable && b.metatable.str.__mul))
+        (a.metatable && a.metatable.str.__mul)
+        || (b.metatable && b.metatable.str.__mul))
     )
       return lua_rawcall(c, [a, b])[0];
     throw Error("Multiplying <" + a + "> and <" + b + "> not supported");
@@ -277,8 +277,8 @@ function lua_power(a, b) {
   if (isNaN(c) || isNaN(d)) {
     if (
       (c =
-        (a.metatable && a.metatable.str.__pow) ||
-        (b.metatable && b.metatable.str.__pow))
+        (a.metatable && a.metatable.str.__pow)
+        || (b.metatable && b.metatable.str.__pow))
     )
       return lua_rawcall(c, [a, b])[0];
     throw Error("<" + a + "> to the power of <" + b + "> not supported");
@@ -291,8 +291,8 @@ function lua_mod(a, b) {
   if (isNaN(c) || isNaN(d)) {
     if (
       (c =
-        (a.metatable && a.metatable.str.__mod) ||
-        (b.metatable && b.metatable.str.__mod))
+        (a.metatable && a.metatable.str.__mod)
+        || (b.metatable && b.metatable.str.__mod))
     )
       return lua_rawcall(c, [a, b])[0];
     throw Error("Modulo <" + a + "> and <" + b + "> not supported");
@@ -393,13 +393,13 @@ function lua_concat(a, b) {
   if ("number" == typeof a && "number" == typeof b)
     throw Error("number concat not supported yet");
   if (
-    ("string" == typeof a || "number" == typeof a) &&
-    ("string" == typeof b || "number" == typeof b)
+    ("string" == typeof a || "number" == typeof a)
+    && ("string" == typeof b || "number" == typeof b)
   )
     return a + b;
   var c =
-    (a.metatable && a.metatable.str.__concat) ||
-    (b.metatable && b.metatable.str.__concat);
+    (a.metatable && a.metatable.str.__concat)
+    || (b.metatable && b.metatable.str.__concat);
   if (c) return lua_rawcall(c, [a, b])[0];
   throw Error("Unable to concat " + a + " and " + b);
 }
@@ -1075,8 +1075,8 @@ var lua_script = (function () {
       }
       lua_tableset(_stack, _val, true);
       if (
-        !lua_eq(lua_call(G.str["rawget"], [_val, 1])[0], null) ||
-        lua_eq(lua_call(G.str["next"], [_val])[0], null)
+        !lua_eq(lua_call(G.str["rawget"], [_val, 1])[0], null)
+        || lua_eq(lua_call(G.str["next"], [_val])[0], null)
       ) {
         var _n_8 = 0;
         tmp = lua_call(G.str["pairs"], [_val]);
@@ -1214,9 +1214,9 @@ var lua_script = (function () {
     var _encode_number_1 = function (_val) {
       var tmp;
       if (
-        !lua_eq(_val, _val) ||
-        lua_lte(_val, lua_unm(lua_tableget(G.str["math"], "huge"))) ||
-        lua_lte(lua_tableget(G.str["math"], "huge"), _val)
+        !lua_eq(_val, _val)
+        || lua_lte(_val, lua_unm(lua_tableget(G.str["math"], "huge")))
+        || lua_lte(lua_tableget(G.str["math"], "huge"), _val)
       ) {
         lua_call(G.str["error"], [
           lua_concat(

package/src/shouldFire.ts

@@ -68,9 +68,8 @@ export function shouldFireBomb(
   const [callbackBombVariant, callbackSubType] = optionalArgs;
 
   return (
-    (callbackBombVariant === undefined ||
-      callbackBombVariant === bomb.Variant) &&
-    (callbackSubType === undefined || callbackSubType === bomb.SubType)
+    (callbackBombVariant === undefined || callbackBombVariant === bomb.Variant)
+    && (callbackSubType === undefined || callbackSubType === bomb.SubType)
   );
 }
 
@@ -92,8 +91,8 @@ export function shouldFireCollectibleType(
   const [callbackCollectibleType] = optionalArgs;
 
   return (
-    callbackCollectibleType === undefined ||
-    callbackCollectibleType === collectibleType
+    callbackCollectibleType === undefined
+    || callbackCollectibleType === collectibleType
   );
 }
 
@@ -122,9 +121,9 @@ export function shouldFireEffect(
   const [callbackEffectVariant, callbackSubType] = optionalArgs;
 
   return (
-    (callbackEffectVariant === undefined ||
-      callbackEffectVariant === effect.Variant) &&
-    (callbackSubType === undefined || callbackSubType === effect.SubType)
+    (callbackEffectVariant === undefined
+      || callbackEffectVariant === effect.Variant)
+    && (callbackSubType === undefined || callbackSubType === effect.SubType)
   );
 }
 
@@ -144,9 +143,9 @@ export function shouldFireEntity(
   const [callbackEntityType, callbackVariant, callbackSubType] = optionalArgs;
 
   return (
-    (callbackEntityType === undefined || callbackEntityType === entity.Type) &&
-    (callbackVariant === undefined || callbackVariant === entity.Variant) &&
-    (callbackSubType === undefined || callbackSubType === entity.SubType)
+    (callbackEntityType === undefined || callbackEntityType === entity.Type)
+    && (callbackVariant === undefined || callbackVariant === entity.Variant)
+    && (callbackSubType === undefined || callbackSubType === entity.SubType)
   );
 }
 
@@ -162,9 +161,9 @@ export function shouldFireFamiliar(
   const [callbackFamiliarVariant, callbackSubType] = optionalArgs;
 
   return (
-    (callbackFamiliarVariant === undefined ||
-      callbackFamiliarVariant === familiar.Variant) &&
-    (callbackSubType === undefined || callbackSubType === familiar.SubType)
+    (callbackFamiliarVariant === undefined
+      || callbackFamiliarVariant === familiar.Variant)
+    && (callbackSubType === undefined || callbackSubType === familiar.SubType)
   );
 }
 
@@ -181,9 +180,9 @@ export function shouldFireGridEntity(
   const variant = gridEntity.GetVariant();
 
   return (
-    (callbackGridEntityType === undefined ||
-      callbackGridEntityType === gridEntityType) &&
-    (callbackVariant === undefined || callbackVariant === variant)
+    (callbackGridEntityType === undefined
+      || callbackGridEntityType === gridEntityType)
+    && (callbackVariant === undefined || callbackVariant === variant)
   );
 }
 
@@ -202,8 +201,8 @@ export function shouldFireGridEntityCustom(
   const [callbackGridEntityTypeCustom] = optionalArgs;
 
   return (
-    callbackGridEntityTypeCustom === undefined ||
-    callbackGridEntityTypeCustom === gridEntityTypeCustom
+    callbackGridEntityTypeCustom === undefined
+    || callbackGridEntityTypeCustom === gridEntityTypeCustom
   );
 }
 
@@ -215,10 +214,11 @@ export function shouldFireItemPickup(
   const [callbackItemType, callbackSubtype] = optionalArgs;
 
   return (
-    (callbackItemType === undefined ||
-      callbackItemType === pickingUpItem.itemType) &&
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
-    (callbackSubtype === undefined || callbackSubtype === pickingUpItem.subType)
+    (callbackItemType === undefined
+      || callbackItemType === pickingUpItem.itemType)
+    && (callbackSubtype === undefined
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+      || callbackSubtype === pickingUpItem.subType)
   );
 }
 
@@ -233,9 +233,9 @@ export function shouldFireKnife(
   const [callbackKnifeVariant, callbackSubType] = optionalArgs;
 
   return (
-    (callbackKnifeVariant === undefined ||
-      callbackKnifeVariant === knife.Variant) &&
-    (callbackSubType === undefined || callbackSubType === knife.SubType)
+    (callbackKnifeVariant === undefined
+      || callbackKnifeVariant === knife.Variant)
+    && (callbackSubType === undefined || callbackSubType === knife.SubType)
   );
 }
 
@@ -247,9 +247,9 @@ export function shouldFireLaser(
   const [callbackLaserVariant, callbackSubType] = optionalArgs;
 
   return (
-    (callbackLaserVariant === undefined ||
-      callbackLaserVariant === laser.Variant) &&
-    (callbackSubType === undefined || callbackSubType === laser.SubType)
+    (callbackLaserVariant === undefined
+      || callbackLaserVariant === laser.Variant)
+    && (callbackSubType === undefined || callbackSubType === laser.SubType)
   );
 }
 
@@ -261,8 +261,8 @@ export function shouldFireLevel(
   const [callbackStage, callbackStageType] = optionalArgs;
 
   return (
-    (callbackStage === undefined || callbackStage === stage) &&
-    (callbackStageType === undefined || callbackStageType === stageType)
+    (callbackStage === undefined || callbackStage === stage)
+    && (callbackStageType === undefined || callbackStageType === stageType)
   );
 }
 
@@ -278,9 +278,9 @@ export function shouldFireNPC(
   const [callbackEntityType, callbackVariant, callbackSubType] = optionalArgs;
 
   return (
-    (callbackEntityType === undefined || callbackEntityType === npc.Type) &&
-    (callbackVariant === undefined || callbackVariant === npc.Variant) &&
-    (callbackSubType === undefined || callbackSubType === npc.SubType)
+    (callbackEntityType === undefined || callbackEntityType === npc.Type)
+    && (callbackVariant === undefined || callbackVariant === npc.Variant)
+    && (callbackSubType === undefined || callbackSubType === npc.SubType)
   );
 }
 
@@ -303,10 +303,10 @@ export function shouldFirePickup(
   const [callbackPickupVariant, callbackPickupSubType] = optionalArgs;
 
   return (
-    (callbackPickupVariant === undefined ||
-      callbackPickupVariant === pickup.Variant) &&
-    (callbackPickupSubType === undefined ||
-      callbackPickupSubType === pickup.SubType)
+    (callbackPickupVariant === undefined
+      || callbackPickupVariant === pickup.Variant)
+    && (callbackPickupSubType === undefined
+      || callbackPickupSubType === pickup.SubType)
   );
 }
 
@@ -358,9 +358,9 @@ export function shouldFirePlayer(
   const character = player.GetPlayerType();
 
   return (
-    (callbackPlayerVariant === undefined ||
-      callbackPlayerVariant === player.Variant) &&
-    (callbackCharacter === undefined || callbackCharacter === character)
+    (callbackPlayerVariant === undefined
+      || callbackPlayerVariant === player.Variant)
+    && (callbackCharacter === undefined || callbackCharacter === character)
   );
 }
 
@@ -374,8 +374,8 @@ export function shouldFirePoop(
   const poopGridEntityVariant = poop.GetVariant();
 
   return (
-    callbackPoopGridEntityVariant === undefined ||
-    callbackPoopGridEntityVariant === poopGridEntityVariant
+    callbackPoopGridEntityVariant === undefined
+    || callbackPoopGridEntityVariant === poopGridEntityVariant
   );
 }
 
@@ -389,8 +389,8 @@ export function shouldFirePressurePlate(
   const pressurePlateVariant = pressurePlate.GetVariant();
 
   return (
-    callbackPressurePlateVariant === undefined ||
-    callbackPressurePlateVariant === pressurePlateVariant
+    callbackPressurePlateVariant === undefined
+    || callbackPressurePlateVariant === pressurePlateVariant
   );
 }
 
@@ -405,9 +405,9 @@ export function shouldFireProjectile(
   const [callbackProjectileVariant, callbackSubType] = optionalArgs;
 
   return (
-    (callbackProjectileVariant === undefined ||
-      callbackProjectileVariant === projectile.Variant) &&
-    (callbackSubType === undefined || callbackSubType === projectile.SubType)
+    (callbackProjectileVariant === undefined
+      || callbackProjectileVariant === projectile.Variant)
+    && (callbackSubType === undefined || callbackSubType === projectile.SubType)
   );
 }
 
@@ -422,9 +422,8 @@ export function shouldFireRock(
   const variant = rock.GetVariant();
 
   return (
-    (callbackGridEntity === undefined ||
-      callbackGridEntity === gridEntityType) &&
-    (callbackVariant === undefined || callbackVariant === variant)
+    (callbackGridEntity === undefined || callbackGridEntity === gridEntityType)
+    && (callbackVariant === undefined || callbackVariant === variant)
   );
 }
 
@@ -450,9 +449,8 @@ export function shouldFireSlot(
   const [callbackSlotVariant, callbackSubType] = optionalArgs;
 
   return (
-    (callbackSlotVariant === undefined ||
-      callbackSlotVariant === slot.Variant) &&
-    (callbackSubType === undefined || callbackSubType === slot.SubType)
+    (callbackSlotVariant === undefined || callbackSlotVariant === slot.Variant)
+    && (callbackSubType === undefined || callbackSubType === slot.SubType)
   );
 }
 
@@ -491,9 +489,8 @@ export function shouldFireTear(
   const [callbackTearVariant, callbackSubType] = optionalArgs;
 
   return (
-    (callbackTearVariant === undefined ||
-      callbackTearVariant === tear.Variant) &&
-    (callbackSubType === undefined || callbackSubType === tear.SubType)
+    (callbackTearVariant === undefined || callbackTearVariant === tear.Variant)
+    && (callbackSubType === undefined || callbackSubType === tear.SubType)
   );
 }
 

package/src/types/Increment.ts

@@ -3,8 +3,8 @@
  *
  * From: https://stackoverflow.com/questions/54243431/typescript-increment-number-type
  */
-export type Increment<N extends number> = [...Arr<N>, unknown]["length"] &
-  number;
+export type Increment<N extends number> = [...Arr<N>, unknown]["length"]
+  & number;
 
 type Arr<N extends number, T extends unknown[] = []> = T["length"] extends N
   ? T

package/src/types/PickingUpItem.ts

@@ -50,6 +50,7 @@ export function newPickingUpItem(): PickingUpItem {
   };
 }
 
+/** Helper function to reset a `PickupUpItem` object to all 0 values. */
 export function resetPickingUpItem(pickingUpItem: PickingUpItem): void {
   pickingUpItem.itemType = DEFAULT_ITEM_TYPE;
   pickingUpItem.subType = DEFAULT_SUB_TYPE;
@@ -61,21 +62,27 @@ const COLLECTIBLE_ITEM_TYPES = new ReadonlySet<ItemType>([
   ItemType.FAMILIAR, // 4
 ]);
 
-/** Helper function to narrow the type of `PickingUpItem`. */
+/** Helper function to narrow the type of `PickingUpItem` to `ItemType.NULL` (0). */
 export function isPickingUpItemNull(
   pickingUpItem: PickingUpItem,
 ): pickingUpItem is PickingUpItemTrinket {
   return pickingUpItem.itemType === ItemType.NULL;
 }
 
-/** Helper function to narrow the type of `PickingUpItem`. */
+/**
+ * Helper function to narrow the type of `PickingUpItem` to one of the following:
+ *
+ * - `ItemType.PASSIVE` (1)
+ * - `ItemType.ACTIVE` (3)
+ * - `ItemType.FAMILIAR` (4)
+ */
 export function isPickingUpItemCollectible(
   pickingUpItem: PickingUpItem,
 ): pickingUpItem is PickingUpItemCollectible {
   return COLLECTIBLE_ITEM_TYPES.has(pickingUpItem.itemType);
 }
 
-/** Helper function to narrow the type of `PickingUpItem`. */
+/** Helper function to narrow the type of `PickingUpItem` to `ItemType.TRINKET` (2). */
 export function isPickingUpItemTrinket(
   pickingUpItem: PickingUpItem,
 ): pickingUpItem is PickingUpItemTrinket {