isaacscript-common 6.15.0 → 6.16.2

package/src/functions/serialization.ts

@@ -1,16 +1,17 @@
 import { CopyableIsaacAPIClassType } from "../enums/private/CopyableIsaacAPIClassType";
-import { SerializationType } from "../enums/SerializationType";
 import { ISAAC_API_CLASS_TYPE_TO_BRAND } from "../objects/isaacAPIClassTypeToBrand";
-import { ISAAC_API_CLASS_TYPE_TO_COPY_FUNCTION } from "../objects/isaacAPIClassTypeToCopyFunction";
-import { SERIALIZED_ISAAC_API_CLASS_TYPE_TO_IDENTITY_FUNCTION } from "../objects/serializedIsaacAPIClassTypeToIdentityFunction";
-import { SerializedIsaacAPIClass } from "../types/private/SerializedIsaacAPIClass";
+import { ISAAC_API_CLASS_TYPE_TO_FUNCTIONS } from "../objects/isaacAPIClassTypeToFunctions";
+import { SerializedIsaacAPIClass } from "../types/SerializedIsaacAPIClass";
 import { getIsaacAPIClassName } from "./isaacAPIClass";
 import { isTable, isUserdata } from "./types";
 
-export function copyIsaacAPIClass(
-  isaacAPIClass: unknown,
-  serializationType: SerializationType,
-): unknown {
+/**
+ * Helper function to generically copy an Isaac API class without knowing what specific type of
+ * class it is. (This is used by the save data manager.)
+ *
+ * For the list of supported classes, see the `CopyableIsaacAPIClassType` enum.
+ */
+export function copyIsaacAPIClass(isaacAPIClass: unknown): unknown {
   if (!isUserdata(isaacAPIClass)) {
     error(
       `Failed to copy an Isaac API class since the provided object was of type: ${typeof isaacAPIClass}`,
@@ -26,26 +27,27 @@ export function copyIsaacAPIClass(
 
   const copyableIsaacAPIClassType =
     isaacAPIClassType as CopyableIsaacAPIClassType;
-  const copyFunction =
-    ISAAC_API_CLASS_TYPE_TO_COPY_FUNCTION[copyableIsaacAPIClassType];
+  const functions =
+    ISAAC_API_CLASS_TYPE_TO_FUNCTIONS[copyableIsaacAPIClassType];
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  if (copyFunction === undefined) {
+  if (functions === undefined) {
     error(
-      `Failed to copy Isaac API class "${copyableIsaacAPIClassType}" since there is not a defined copy function for this class type.`,
+      `Failed to copy an Isaac API class since the associated functions were not found for Isaac API class type: ${copyableIsaacAPIClassType}`,
     );
   }
 
-  return copyFunction(isaacAPIClass, serializationType);
+  return functions.copy(isaacAPIClass);
 }
 
 /**
- * Deserialization is a special case, so we make a dedicated function for this.
+ * Helper function to generically deserialize an Isaac API class without knowing what specific type
+ * of class it is. (This is used by the save data manager when reading data from the "save#.dat"
+ * file.)
  *
- * There is no need for a corresponding "serializeIsaacAPIClass" function because the
- * "copyIsaacAPIClass" function can handle all serialization types.
+ * For the list of supported classes, see the `CopyableIsaacAPIClassType` enum.
  */
 export function deserializeIsaacAPIClass(
-  serializedIsaacAPIClass: SerializedIsaacAPIClass,
+  serializedIsaacAPIClass: unknown,
 ): unknown {
   if (!isTable(serializedIsaacAPIClass)) {
     error(
@@ -58,17 +60,28 @@ export function deserializeIsaacAPIClass(
   );
   if (copyableIsaacAPIClassType === undefined) {
     error(
-      "Failed to deserialize an API class since a valid class type brand was not found.",
+      "Failed to deserialize an Isaac API class since a valid class type brand was not found.",
+    );
+  }
+
+  const functions =
+    ISAAC_API_CLASS_TYPE_TO_FUNCTIONS[copyableIsaacAPIClassType];
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (functions === undefined) {
+    error(
+      `Failed to deserialize an Isaac API class since the associated functions were not found for class type: ${copyableIsaacAPIClassType}`,
     );
   }
 
-  const copyFunction =
-    ISAAC_API_CLASS_TYPE_TO_COPY_FUNCTION[copyableIsaacAPIClassType];
-  return copyFunction(serializedIsaacAPIClass, SerializationType.DESERIALIZE);
+  return functions.deserialize(serializedIsaacAPIClass);
 }
 
+/**
+ * In order to find out what type of serialized Isaac API class this is, we search through the
+ * serialized table for brands.
+ */
 function getSerializedTableType(
-  serializedIsaacAPIClass: SerializedIsaacAPIClass,
+  serializedIsaacAPIClass: LuaMap<AnyNotNil, unknown>,
 ): CopyableIsaacAPIClassType | undefined {
   for (const [copyableIsaacAPIClassType, serializationBrand] of Object.entries(
     ISAAC_API_CLASS_TYPE_TO_BRAND,
@@ -81,11 +94,54 @@ function getSerializedTableType(
   return undefined;
 }
 
+/**
+ * Helper function to generically check if a given Lua table is a serialized Isaac API class. (This
+ * is used by the save data manager when reading data from the "save#.dat" file.)
+ *
+ * For the list of supported classes, see the `CopyableIsaacAPIClassType` enum.
+ */
 export function isSerializedIsaacAPIClass(
   object: unknown,
 ): object is SerializedIsaacAPIClass {
-  const identityFunctions = Object.values(
-    SERIALIZED_ISAAC_API_CLASS_TYPE_TO_IDENTITY_FUNCTION,
+  const allFunctions = Object.values(ISAAC_API_CLASS_TYPE_TO_FUNCTIONS);
+  const isSerializedFunctions = allFunctions.map(
+    (functions) => functions.isSerialized,
+  );
+  return isSerializedFunctions.some((identityFunction) =>
+    identityFunction(object),
   );
-  return identityFunctions.some((identityFunction) => identityFunction(object));
+}
+
+/**
+ * Helper function to generically serialize an Isaac API class without knowing what specific type of
+ * class it is. (This is used by the save data manager when writing data to the "save#.dat" file.)
+ *
+ * For the list of supported classes, see the `CopyableIsaacAPIClassType` enum.
+ */
+export function serializeIsaacAPIClass(isaacAPIClass: unknown): unknown {
+  if (!isUserdata(isaacAPIClass)) {
+    error(
+      `Failed to serialize an Isaac API class since the provided object was of type: ${typeof isaacAPIClass}`,
+    );
+  }
+
+  const isaacAPIClassType = getIsaacAPIClassName(isaacAPIClass);
+  if (isaacAPIClassType === undefined) {
+    error(
+      "Failed to serialize an Isaac API class since it does not have a class type.",
+    );
+  }
+
+  const copyableIsaacAPIClassType =
+    isaacAPIClassType as CopyableIsaacAPIClassType;
+  const functions =
+    ISAAC_API_CLASS_TYPE_TO_FUNCTIONS[copyableIsaacAPIClassType];
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (functions === undefined) {
+    error(
+      `Failed to serialize an Isaac API class since the associated functions were not found for class type: ${copyableIsaacAPIClassType}`,
+    );
+  }
+
+  return functions.serialize(isaacAPIClass);
 }

package/src/functions/table.ts

@@ -57,8 +57,8 @@ export function getBooleansFromTable(
 }
 
 /**
- * Helper function to safely get number values from a Lua table. Will throw an error if the specific
- * value does not exist on the table or if it cannot be converted to a number.
+ * Helper function to safely get number values from specific keys on a Lua table. Will throw an
+ * error if the specific value does not exist on the table or if it cannot be converted to a number.
  *
  * This function is variadic, meaning that you can specify N arguments to get N values.
  */

package/src/functions/tstlClass.ts

@@ -1,6 +1,6 @@
 import { DefaultMap } from "../classes/DefaultMap";
 import { TSTLClassMetatable } from "../interfaces/private/TSTLClassMetatable";
-import { TSTLClass } from "../types/private/TSTLClass";
+import { TSTLClass } from "../types/TSTLClass";
 import { isString, isTable } from "./types";
 
 const VANILLA_TSTL_CLASSES = new Set(["Map", "Set", "WeakMap", "WeakSet"]);

package/src/functions/vector.ts

@@ -1,6 +1,5 @@
 import { Direction } from "isaac-typescript-definitions";
 import { SerializationBrand } from "../enums/private/SerializationBrand";
-import { SerializationType } from "../enums/SerializationType";
 import { angleToDirection } from "./direction";
 import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
 import { getRandomFloat } from "./random";
@@ -8,88 +7,53 @@ import { getRandomSeed, isRNG, newRNG } from "./rng";
 import { copyValuesToTable, getNumbersFromTable, tableHasKeys } from "./table";
 import { isTable } from "./types";
 
-type SerializedVector = LuaMap<string, unknown> & {
+export type SerializedVector = LuaMap<string, unknown> & {
   readonly __serializedVectorBrand: symbol;
 };
 
-interface CopyVectorReturn {
-  [SerializationType.NONE]: Vector;
-  [SerializationType.SERIALIZE]: SerializedVector;
-  [SerializationType.DESERIALIZE]: Vector;
-}
-
 const KEYS = ["X", "Y"];
 const OBJECT_NAME = "Vector";
 
+/** Helper function to copy a `Vector` Isaac API class. */
+export function copyVector(vector: Vector): Vector {
+  if (!isVector(vector)) {
+    error(
+      `Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+    );
+  }
+
+  return Vector(vector.X, vector.Y);
+}
+
 /**
- * Helper function to copy a `Vector` object.
- *
- * @param vector The vector to copy. In the case of deserialization, this will actually be a Lua
- *               table instead of an instantiated Vector class.
- * @param serializationType Default is `SerializationType.NONE`.
+ * Helper function to convert a `SerializedVector` object to a normal `RNG` object. (This is used by
+ * the save data manager when reading data from the "save#.dat" file.)
  */
-export function copyVector<
-  V extends Vector | SerializedVector,
-  S extends SerializationType,
->(vector: V, serializationType: S): CopyVectorReturn[S];
-export function copyVector<V extends Vector | SerializedVector>(
-  vector: V,
-): CopyVectorReturn[SerializationType.NONE];
-export function copyVector(
-  vector: Vector | SerializedVector,
-  serializationType = SerializationType.NONE,
-): CopyVectorReturn[keyof CopyVectorReturn] {
-  switch (serializationType) {
-    case SerializationType.NONE: {
-      if (!isVector(vector)) {
-        error(
-          `Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
-        );
-      }
-
-      return Vector(vector.X, vector.Y);
-    }
-
-    case SerializationType.SERIALIZE: {
-      if (!isVector(vector)) {
-        error(
-          `Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
-        );
-      }
-
-      const vectorTable = new LuaMap<string, unknown>();
-      copyValuesToTable(vector, KEYS, vectorTable);
-      vectorTable.set(SerializationBrand.VECTOR, "");
-      return vectorTable as SerializedVector;
-    }
-
-    case SerializationType.DESERIALIZE: {
-      if (!isTable(vector)) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`,
-        );
-      }
-
-      const [x, y] = getNumbersFromTable(
-        vector as LuaMap<string, unknown>,
-        OBJECT_NAME,
-        ...KEYS,
-      );
-
-      if (x === undefined) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: x`,
-        );
-      }
-      if (y === undefined) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: y`,
-        );
-      }
-
-      return Vector(x, y);
-    }
+export function deserializeVector(vector: SerializedVector): Vector {
+  if (!isTable(vector)) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`,
+    );
+  }
+
+  const [x, y] = getNumbersFromTable(
+    vector as LuaMap<string, unknown>,
+    OBJECT_NAME,
+    ...KEYS,
+  );
+
+  if (x === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: X`,
+    );
   }
+  if (y === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: Y`,
+    );
+  }
+
+  return Vector(x, y);
 }
 
 /**
@@ -132,6 +96,23 @@ export function isVector(object: unknown): object is Vector {
   return isIsaacAPIClassOfType(object, OBJECT_NAME);
 }
 
+/**
+ * Helper function to convert a `Vector` object to a `SerializedVector` object. (This is used by the
+ * save data manager when writing data from the "save#.dat" file.)
+ */
+export function serializeVector(vector: Vector): SerializedVector {
+  if (!isVector(vector)) {
+    error(
+      `Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+    );
+  }
+
+  const vectorTable = new LuaMap<string, unknown>();
+  copyValuesToTable(vector, KEYS, vectorTable);
+  vectorTable.set(SerializationBrand.VECTOR, "");
+  return vectorTable as SerializedVector;
+}
+
 export function vectorEquals(vector1: Vector, vector2: Vector): boolean {
   return isaacAPIClassEquals(vector1, vector2, KEYS);
 }

package/src/index.ts

@@ -142,6 +142,7 @@ export * from "./functions/players";
 export * from "./functions/pocketItems";
 export * from "./functions/positionVelocity";
 export * from "./functions/pressurePlate";
+export * from "./functions/projectiles";
 export * from "./functions/random";
 export * from "./functions/revive";
 export * from "./functions/rng";

package/src/initCustomCallbacks.ts

@@ -20,6 +20,7 @@ import { postFlipCallbacksInit } from "./callbacks/postFlip";
 import { postGreedModeWaveInit } from "./callbacks/postGreedModeWave";
 import { postGridEntityCallbacksInit } from "./callbacks/postGridEntity";
 import { postGridEntityCollisionInit } from "./callbacks/postGridEntityCollision";
+import { postGridEntityCustomCollisionInit } from "./callbacks/postGridEntityCustomCollision";
 import { postGridEntityCustomRenderInit } from "./callbacks/postGridEntityCustomRender";
 import { postGridEntityCustomUpdateInit } from "./callbacks/postGridEntityCustomUpdate";
 import { postGridEntityRenderInit } from "./callbacks/postGridEntityRender";
@@ -91,6 +92,7 @@ export function initCustomCallbacks(mod: ModUpgraded): void {
   postGreedModeWaveInit(mod);
   postGridEntityCallbacksInit(mod);
   postGridEntityCollisionInit(mod);
+  postGridEntityCustomCollisionInit(mod);
   postGridEntityCustomRenderInit(mod);
   postGridEntityCustomUpdateInit(mod);
   postGridEntityRenderInit(mod);

package/src/interfaces/AddCallbackParameterCustom.ts

@@ -23,6 +23,8 @@ import { PostGameStartedReorderedRegisterParameters } from "../callbacks/subscri
 import { PostGreedModeWaveRegisterParameters } from "../callbacks/subscriptions/postGreedModeWave";
 import { PostGridEntityBrokenRegisterParameters } from "../callbacks/subscriptions/postGridEntityBroken";
 import { PostGridEntityCollisionRegisterParameters } from "../callbacks/subscriptions/postGridEntityCollision";
+import { PostGridEntityCustomBrokenRegisterParameters } from "../callbacks/subscriptions/postGridEntityCustomBroken";
+import { PostGridEntityCustomCollisionRegisterParameters } from "../callbacks/subscriptions/postGridEntityCustomCollision";
 import { PostGridEntityCustomRenderRegisterParameters } from "../callbacks/subscriptions/postGridEntityCustomRender";
 import { PostGridEntityCustomUpdateRegisterParameters } from "../callbacks/subscriptions/postGridEntityCustomUpdate";
 import { PostGridEntityInitRegisterParameters } from "../callbacks/subscriptions/postGridEntityInit";
@@ -111,6 +113,8 @@ export interface AddCallbackParameterCustom {
   [ModCallbackCustom.POST_GREED_MODE_WAVE]: PostGreedModeWaveRegisterParameters;
   [ModCallbackCustom.POST_GRID_ENTITY_BROKEN]: PostGridEntityBrokenRegisterParameters;
   [ModCallbackCustom.POST_GRID_ENTITY_COLLISION]: PostGridEntityCollisionRegisterParameters;
+  [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_BROKEN]: PostGridEntityCustomBrokenRegisterParameters;
+  [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_COLLISION]: PostGridEntityCustomCollisionRegisterParameters;
   [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_RENDER]: PostGridEntityCustomRenderRegisterParameters;
   [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_UPDATE]: PostGridEntityCustomUpdateRegisterParameters;
   [ModCallbackCustom.POST_GRID_ENTITY_INIT]: PostGridEntityInitRegisterParameters;

package/src/objects/callbackRegisterFunctions.ts

@@ -23,6 +23,8 @@ import { postGameStartedReorderedRegister } from "../callbacks/subscriptions/pos
 import { postGreedModeWaveRegister } from "../callbacks/subscriptions/postGreedModeWave";
 import { postGridEntityBrokenRegister } from "../callbacks/subscriptions/postGridEntityBroken";
 import { postGridEntityCollisionRegister } from "../callbacks/subscriptions/postGridEntityCollision";
+import { postGridEntityCustomBrokenRegister } from "../callbacks/subscriptions/postGridEntityCustomBroken";
+import { postGridEntityCustomCollisionRegister } from "../callbacks/subscriptions/postGridEntityCustomCollision";
 import { postGridEntityCustomRenderRegister } from "../callbacks/subscriptions/postGridEntityCustomRender";
 import { postGridEntityCustomUpdateRegister } from "../callbacks/subscriptions/postGridEntityCustomUpdate";
 import { postGridEntityInitRegister } from "../callbacks/subscriptions/postGridEntityInit";
@@ -120,6 +122,10 @@ export const CALLBACK_REGISTER_FUNCTIONS: {
   [ModCallbackCustom.POST_GRID_ENTITY_BROKEN]: postGridEntityBrokenRegister,
   [ModCallbackCustom.POST_GRID_ENTITY_COLLISION]:
     postGridEntityCollisionRegister,
+  [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_BROKEN]:
+    postGridEntityCustomBrokenRegister,
+  [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_COLLISION]:
+    postGridEntityCustomCollisionRegister,
   [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_RENDER]:
     postGridEntityCustomRenderRegister,
   [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_UPDATE]:

package/src/objects/isaacAPIClassTypeToFunctions.ts

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { CopyableIsaacAPIClassType } from "../enums/private/CopyableIsaacAPIClassType";
+import {
+  copyColor,
+  deserializeColor,
+  isSerializedColor,
+  serializeColor,
+} from "../functions/color";
+import {
+  copyKColor,
+  deserializeKColor,
+  isSerializedKColor,
+  serializeKColor,
+} from "../functions/kColor";
+import {
+  copyRNG,
+  deserializeRNG,
+  isSerializedRNG,
+  serializeRNG,
+} from "../functions/rng";
+import {
+  copyVector,
+  deserializeVector,
+  isSerializedVector,
+  serializeVector,
+} from "../functions/vector";
+
+interface IsaacAPIClassTypeFunctions {
+  isSerialized: (object: unknown) => object is unknown;
+  copy: (object: any) => any;
+  serialize: (object: any) => any;
+  deserialize: (object: any) => any;
+}
+
+export const ISAAC_API_CLASS_TYPE_TO_FUNCTIONS: {
+  readonly [key in CopyableIsaacAPIClassType]: IsaacAPIClassTypeFunctions;
+} = {
+  [CopyableIsaacAPIClassType.COLOR]: {
+    isSerialized: isSerializedColor,
+    copy: copyColor,
+    serialize: serializeColor,
+    deserialize: deserializeColor,
+  },
+  [CopyableIsaacAPIClassType.K_COLOR]: {
+    isSerialized: isSerializedKColor,
+    copy: copyKColor,
+    serialize: serializeKColor,
+    deserialize: deserializeKColor,
+  },
+  [CopyableIsaacAPIClassType.RNG]: {
+    isSerialized: isSerializedRNG,
+    copy: copyRNG,
+    serialize: serializeRNG,
+    deserialize: deserializeRNG,
+  },
+  [CopyableIsaacAPIClassType.VECTOR]: {
+    isSerialized: isSerializedVector,
+    copy: copyVector,
+    serialize: serializeVector,
+    deserialize: deserializeVector,
+  },
+} as const;

package/dist/objects/isaacAPIClassTypeToCopyFunction.d.ts

@@ -1,6 +0,0 @@
-import { CopyableIsaacAPIClassType } from "../enums/private/CopyableIsaacAPIClassType";
-import { SerializationType } from "../enums/SerializationType";
-export declare const ISAAC_API_CLASS_TYPE_TO_COPY_FUNCTION: {
-    readonly [key in CopyableIsaacAPIClassType]: (object: unknown, serializationType: SerializationType) => boolean;
-};
-//# sourceMappingURL=isaacAPIClassTypeToCopyFunction.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"isaacAPIClassTypeToCopyFunction.d.ts","sourceRoot":"","sources":["../../src/objects/isaacAPIClassTypeToCopyFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AACvF,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAM/D,eAAO,MAAM,qCAAqC,EAAE;IAClD,QAAQ,EAAE,GAAG,IAAI,yBAAyB,GAAG,CAC3C,MAAM,EAAE,OAAO,EACf,iBAAiB,EAAE,iBAAiB,KACjC,OAAO;CAMJ,CAAC"}

package/dist/objects/isaacAPIClassTypeToCopyFunction.lua

@@ -1,13 +0,0 @@
-local ____exports = {}
-local ____CopyableIsaacAPIClassType = require("enums.private.CopyableIsaacAPIClassType")
-local CopyableIsaacAPIClassType = ____CopyableIsaacAPIClassType.CopyableIsaacAPIClassType
-local ____color = require("functions.color")
-local copyColor = ____color.copyColor
-local ____kColor = require("functions.kColor")
-local copyKColor = ____kColor.copyKColor
-local ____rng = require("functions.rng")
-local copyRNG = ____rng.copyRNG
-local ____vector = require("functions.vector")
-local copyVector = ____vector.copyVector
-____exports.ISAAC_API_CLASS_TYPE_TO_COPY_FUNCTION = {[CopyableIsaacAPIClassType.COLOR] = copyColor, [CopyableIsaacAPIClassType.K_COLOR] = copyKColor, [CopyableIsaacAPIClassType.RNG] = copyRNG, [CopyableIsaacAPIClassType.VECTOR] = copyVector}
-return ____exports

package/dist/objects/serializedIsaacAPIClassTypeToIdentityFunction.d.ts

@@ -1,5 +0,0 @@
-import { CopyableIsaacAPIClassType } from "../enums/private/CopyableIsaacAPIClassType";
-export declare const SERIALIZED_ISAAC_API_CLASS_TYPE_TO_IDENTITY_FUNCTION: {
-    readonly [key in CopyableIsaacAPIClassType]: (object: unknown) => boolean;
-};
-//# sourceMappingURL=serializedIsaacAPIClassTypeToIdentityFunction.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"serializedIsaacAPIClassTypeToIdentityFunction.d.ts","sourceRoot":"","sources":["../../src/objects/serializedIsaacAPIClassTypeToIdentityFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AAMvF,eAAO,MAAM,oDAAoD,EAAE;IACjE,QAAQ,EAAE,GAAG,IAAI,yBAAyB,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO;CAMjE,CAAC"}

package/dist/objects/serializedIsaacAPIClassTypeToIdentityFunction.lua

@@ -1,13 +0,0 @@
-local ____exports = {}
-local ____CopyableIsaacAPIClassType = require("enums.private.CopyableIsaacAPIClassType")
-local CopyableIsaacAPIClassType = ____CopyableIsaacAPIClassType.CopyableIsaacAPIClassType
-local ____color = require("functions.color")
-local isSerializedColor = ____color.isSerializedColor
-local ____kColor = require("functions.kColor")
-local isSerializedKColor = ____kColor.isSerializedKColor
-local ____rng = require("functions.rng")
-local isSerializedRNG = ____rng.isSerializedRNG
-local ____vector = require("functions.vector")
-local isSerializedVector = ____vector.isSerializedVector
-____exports.SERIALIZED_ISAAC_API_CLASS_TYPE_TO_IDENTITY_FUNCTION = {[CopyableIsaacAPIClassType.COLOR] = isSerializedColor, [CopyableIsaacAPIClassType.K_COLOR] = isSerializedKColor, [CopyableIsaacAPIClassType.RNG] = isSerializedRNG, [CopyableIsaacAPIClassType.VECTOR] = isSerializedVector}
-return ____exports

package/dist/types/private/IsaacAPIClass.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IsaacAPIClass.d.ts","sourceRoot":"","sources":["../../../src/types/private/IsaacAPIClass.ts"],"names":[],"mappings":";AAAA,oBAAY,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACpD,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;CACvC,CAAC"}

package/dist/types/private/SerializedIsaacAPIClass.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SerializedIsaacAPIClass.d.ts","sourceRoot":"","sources":["../../../src/types/private/SerializedIsaacAPIClass.ts"],"names":[],"mappings":";AAAA,oBAAY,uBAAuB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAC9D,QAAQ,CAAC,8BAA8B,EAAE,MAAM,CAAC;CACjD,CAAC"}

package/dist/types/private/TSTLClass.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TSTLClass.d.ts","sourceRoot":"","sources":["../../../src/types/private/TSTLClass.ts"],"names":[],"mappings":";AAAA,oBAAY,SAAS,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG;IACnD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC,CAAC"}

package/src/objects/isaacAPIClassTypeToCopyFunction.ts

@@ -1,18 +0,0 @@
-import { CopyableIsaacAPIClassType } from "../enums/private/CopyableIsaacAPIClassType";
-import { SerializationType } from "../enums/SerializationType";
-import { copyColor } from "../functions/color";
-import { copyKColor } from "../functions/kColor";
-import { copyRNG } from "../functions/rng";
-import { copyVector } from "../functions/vector";
-
-export const ISAAC_API_CLASS_TYPE_TO_COPY_FUNCTION: {
-  readonly [key in CopyableIsaacAPIClassType]: (
-    object: unknown,
-    serializationType: SerializationType,
-  ) => boolean;
-} = {
-  [CopyableIsaacAPIClassType.COLOR]: copyColor,
-  [CopyableIsaacAPIClassType.K_COLOR]: copyKColor,
-  [CopyableIsaacAPIClassType.RNG]: copyRNG,
-  [CopyableIsaacAPIClassType.VECTOR]: copyVector,
-} as const;

package/src/objects/serializedIsaacAPIClassTypeToIdentityFunction.ts

@@ -1,14 +0,0 @@
-import { CopyableIsaacAPIClassType } from "../enums/private/CopyableIsaacAPIClassType";
-import { isSerializedColor } from "../functions/color";
-import { isSerializedKColor } from "../functions/kColor";
-import { isSerializedRNG } from "../functions/rng";
-import { isSerializedVector } from "../functions/vector";
-
-export const SERIALIZED_ISAAC_API_CLASS_TYPE_TO_IDENTITY_FUNCTION: {
-  readonly [key in CopyableIsaacAPIClassType]: (object: unknown) => boolean;
-} = {
-  [CopyableIsaacAPIClassType.COLOR]: isSerializedColor,
-  [CopyableIsaacAPIClassType.K_COLOR]: isSerializedKColor,
-  [CopyableIsaacAPIClassType.RNG]: isSerializedRNG,
-  [CopyableIsaacAPIClassType.VECTOR]: isSerializedVector,
-} as const;