isaacscript-common 87.9.7 → 87.9.8

package/dist/functions/map.js

@@ -1,23 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.copyMap = copyMap;
-exports.defaultMapGetHash = defaultMapGetHash;
-exports.defaultMapSetHash = defaultMapSetHash;
-exports.getReversedMap = getReversedMap;
-exports.mapSetHash = mapSetHash;
-exports.objectToMap = objectToMap;
-exports.objectToReadonlyMap = objectToReadonlyMap;
-exports.sumMap = sumMap;
-const array_1 = require("./array");
+import { sumArray } from "./array";
 /** Helper function to copy a map. (You can also use a Map constructor to accomplish this task.) */
-function copyMap(oldMap) {
+export function copyMap(oldMap) {
     return new Map(oldMap);
 }
 /**
  * Helper function to get the value from a `DefaultMap` that corresponds to an entity, assuming that
  * the map uses `PtrHash` as an index.
  */
-function defaultMapGetHash(map, entity, ...extraArgs) {
+export function defaultMapGetHash(map, entity, ...extraArgs) {
     const ptrHash = GetPtrHash(entity);
     return map.getAndSetDefault(ptrHash, ...extraArgs);
 }
@@ -28,7 +18,7 @@ function defaultMapGetHash(map, entity, ...extraArgs) {
  * Since `Map` and `DefaultMap` set values in the same way, this function is simply an alias for the
  * `mapSetHash` helper function.
  */
-function defaultMapSetHash(
+export function defaultMapSetHash(
 // eslint-disable-next-line complete/prefer-readonly-parameter-types
 map, entity, value) {
     mapSetHash(map, entity, value);
@@ -54,7 +44,7 @@ map, entity, value) {
  * ]);
  * ```
  */
-function getReversedMap(map) {
+export function getReversedMap(map) {
     const reverseMap = new Map();
     for (const [key, value] of map) {
         reverseMap.set(value, key);
@@ -65,7 +55,7 @@ function getReversedMap(map) {
  * Helper function to set a value for a `DefaultMap` that corresponds to an entity, assuming that
  * the map uses `PtrHash` as an index.
  */
-function mapSetHash(
+export function mapSetHash(
 // eslint-disable-next-line complete/prefer-readonly-parameter-types
 map, entity, value) {
     const hash = GetPtrHash(entity);
@@ -84,7 +74,7 @@ map, entity, value) {
  *
  * Also see the `objectToReadonlyMap` function.
  */
-function objectToMap(object) {
+export function objectToMap(object) {
     const map = new Map();
     for (const [key, value] of Object.entries(object)) {
         map.set(key, value);
@@ -104,11 +94,11 @@ function objectToMap(object) {
  *
  * Also see the `objectToMap` function.
  */
-function objectToReadonlyMap(object) {
+export function objectToReadonlyMap(object) {
     return objectToMap(object);
 }
 /** Helper function to sum every value in a map together. */
-function sumMap(map) {
+export function sumMap(map) {
     const values = [...map.values()];
-    return (0, array_1.sumArray)(values);
+    return sumArray(values);
 }

package/dist/functions/math.js

@@ -1,30 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clamp = clamp;
-exports.getAngleDifference = getAngleDifference;
-exports.getCircleDiscretizedPoints = getCircleDiscretizedPoints;
-exports.inRectangle = inRectangle;
-exports.isCircleIntersectingRectangle = isCircleIntersectingRectangle;
-exports.isEven = isEven;
-exports.isOdd = isOdd;
-exports.lerp = lerp;
-exports.lerpAngleDegrees = lerpAngleDegrees;
-exports.round = round;
-exports.sign = sign;
-exports.splitNumber = splitNumber;
-exports.tanh = tanh;
-const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
-const direction_1 = require("./direction");
+import { Direction } from "isaac-typescript-definitions";
+import { directionToVector } from "./direction";
 /**
  * Helper function to normalize a number, ensuring that it is within a certain range.
  *
  * - If `num` is less than `min`, then it will be clamped to `min`.
  * - If `num` is greater than `max`, then it will be clamped to `max`.
  */
-function clamp(num, min, max) {
+export function clamp(num, min, max) {
     return Math.max(min, Math.min(num, max));
 }
-function getAngleDifference(angle1, angle2) {
+export function getAngleDifference(angle1, angle2) {
     const subtractedAngle = angle1 - angle2;
     return ((subtractedAngle + 180) % 360) - 180;
 }
@@ -40,8 +25,8 @@ function getAngleDifference(angle1, angle2) {
  * @param initialDirection By default, the first point on the circle will be on the top center, but
  *                         this can be optionally changed by specifying this argument.
  */
-function getCircleDiscretizedPoints(centerPos, radius, numPoints, xMultiplier = 1, yMultiplier = 1, initialDirection = isaac_typescript_definitions_1.Direction.UP) {
-    const vector = (0, direction_1.directionToVector)(initialDirection);
+export function getCircleDiscretizedPoints(centerPos, radius, numPoints, xMultiplier = 1, yMultiplier = 1, initialDirection = Direction.UP) {
+    const vector = directionToVector(initialDirection);
     const initialPosition = vector.mul(radius);
     const positions = [];
     for (let i = 0; i < numPoints; i++) {
@@ -59,7 +44,7 @@ function getCircleDiscretizedPoints(centerPos, radius, numPoints, xMultiplier =
  * This is an inclusive check, meaning that it will return true if the position is on the border of
  * the rectangle.
  */
-function inRectangle(position, topLeft, bottomRight) {
+export function inRectangle(position, topLeft, bottomRight) {
     return (position.X >= topLeft.X
         && position.X <= bottomRight.X
         && position.Y >= topLeft.Y
@@ -68,25 +53,25 @@ function inRectangle(position, topLeft, bottomRight) {
 /**
  * From: https://www.geeksforgeeks.org/check-if-any-point-overlaps-the-given-circle-and-rectangle/
  */
-function isCircleIntersectingRectangle(circleCenter, circleRadius, rectangleTopLeft, rectangleBottomRight) {
+export function isCircleIntersectingRectangle(circleCenter, circleRadius, rectangleTopLeft, rectangleBottomRight) {
     const nearestX = Math.max(rectangleTopLeft.X, Math.min(circleCenter.X, rectangleBottomRight.X));
     const nearestY = Math.max(rectangleTopLeft.Y, Math.min(circleCenter.Y, rectangleBottomRight.Y));
     const nearestPointToCircleOnRectangle = Vector(nearestX, nearestY);
     const distanceToCenterOfCircle = nearestPointToCircleOnRectangle.Distance(circleCenter);
     return distanceToCenterOfCircle <= circleRadius;
 }
-function isEven(num) {
+export function isEven(num) {
     // This is benchmarked to be faster than using the modulus operator by 3%.
     return (num & 1) === 0;
 }
-function isOdd(num) {
+export function isOdd(num) {
     // This is benchmarked to be faster than using the modulus operator by 3%.
     return (num & 1) === 1;
 }
-function lerp(a, b, pos) {
+export function lerp(a, b, pos) {
     return a + (b - a) * pos;
 }
-function lerpAngleDegrees(aStart, aEnd, percent) {
+export function lerpAngleDegrees(aStart, aEnd, percent) {
     return aStart + getAngleDifference(aStart, aEnd) * percent;
 }
 /**
@@ -97,13 +82,13 @@ function lerpAngleDegrees(aStart, aEnd, percent) {
  * @param num The number to round.
  * @param numDecimalPlaces Optional. Default is 0.
  */
-function round(num, numDecimalPlaces = 0) {
+export function round(num, numDecimalPlaces = 0) {
     const roundedString = string.format(`%.${numDecimalPlaces}f`, num);
     const roundedNum = tonumber(roundedString);
     return roundedNum ?? 0;
 }
 /** @returns 1 if n is positive, -1 if n is negative, or 0 if n is 0. */
-function sign(n) {
+export function sign(n) {
     if (n > 0) {
         return 1;
     }
@@ -128,7 +113,7 @@ function sign(n) {
  * @param startAtZero Whether to start at 0. Defaults to false. If true, the chunks will start at 0
  *                    instead of 1.
  */
-function splitNumber(num, size, startAtZero = false) {
+export function splitNumber(num, size, startAtZero = false) {
     if (num <= 0) {
         error(`The number to split needs to be a positive number and is instead: ${num}`);
     }
@@ -144,6 +129,6 @@ function splitNumber(num, size, startAtZero = false) {
     }
     return chunks;
 }
-function tanh(x) {
+export function tanh(x) {
     return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x));
 }

package/dist/functions/merge.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.merge = merge;
-const constants_1 = require("../classes/features/other/saveDataManager/constants");
-const SerializationBrand_1 = require("../enums/private/SerializationBrand");
-const SerializationType_1 = require("../enums/SerializationType");
-const serialization_1 = require("../serialization");
-const array_1 = require("./array");
-const deepCopy_1 = require("./deepCopy");
-const log_1 = require("./log");
-const serialization_2 = require("./serialization");
-const table_1 = require("./table");
-const tstlClass_1 = require("./tstlClass");
-const types_1 = require("./types");
-const utils_1 = require("./utils");
+import { SAVE_DATA_MANAGER_DEBUG } from "../classes/features/other/saveDataManager/constants";
+import { SerializationBrand } from "../enums/private/SerializationBrand";
+import { SerializationType } from "../enums/SerializationType";
+import { isSerializationBrand } from "../serialization";
+import { isArray } from "./array";
+import { deepCopy } from "./deepCopy";
+import { log } from "./log";
+import { deserializeIsaacAPIClass, isSerializedIsaacAPIClass, } from "./serialization";
+import { clearTable, iterateTableInOrder } from "./table";
+import { isDefaultMap, isTSTLMap, isTSTLSet } from "./tstlClass";
+import { isTable } from "./types";
+import { getTraversalDescription } from "./utils";
 /**
  * `merge` takes the values from a new table and recursively merges them into an old object (while
  * performing appropriate deserialization).
@@ -49,24 +46,24 @@ const utils_1 = require("./utils");
  *                          object, it will use this map to instantiate a new class. Default is an
  *                          empty Lua table.
  */
-function merge(oldObject, newTable, traversalDescription, classConstructors = new LuaMap()) {
-    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-        (0, log_1.log)(`merge is traversing: ${traversalDescription}`);
+export function merge(oldObject, newTable, traversalDescription, classConstructors = new LuaMap()) {
+    if (SAVE_DATA_MANAGER_DEBUG) {
+        log(`merge is traversing: ${traversalDescription}`);
     }
-    if (!(0, types_1.isTable)(oldObject)) {
+    if (!isTable(oldObject)) {
         error("The first argument given to the merge function is not a table.");
     }
-    if (!(0, types_1.isTable)(newTable)) {
+    if (!isTable(newTable)) {
         error("The second argument given to the merge function is not a table.");
     }
     // First, handle the special case of an array with a shallow copy.
-    if ((0, array_1.isArray)(oldObject) && (0, array_1.isArray)(newTable)) {
+    if (isArray(oldObject) && isArray(newTable)) {
         mergeSerializedArray(oldObject, newTable, traversalDescription, classConstructors);
         return;
     }
     // Depending on whether we are working on a Lua table or a TypeScriptToLua object, we need to
     // iterate in a specific way.
-    if ((0, tstlClass_1.isTSTLMap)(oldObject) || (0, tstlClass_1.isTSTLSet)(oldObject) || (0, tstlClass_1.isDefaultMap)(oldObject)) {
+    if (isTSTLMap(oldObject) || isTSTLSet(oldObject) || isDefaultMap(oldObject)) {
         mergeSerializedTSTLObject(oldObject, newTable, traversalDescription, classConstructors);
     }
     else {
@@ -74,69 +71,69 @@ function merge(oldObject, newTable, traversalDescription, classConstructors = ne
     }
 }
 function mergeSerializedArray(oldArray, newArray, traversalDescription, classConstructors) {
-    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-        (0, log_1.log)(`merge encountered an array: ${traversalDescription}`);
+    if (SAVE_DATA_MANAGER_DEBUG) {
+        log(`merge encountered an array: ${traversalDescription}`);
     }
     // Assume that we should blow away all array values with whatever is present in the incoming
     // array.
-    (0, table_1.clearTable)(oldArray);
-    (0, table_1.iterateTableInOrder)(newArray, (key, value) => {
-        const deserializedValue = (0, deepCopy_1.deepCopy)(value, SerializationType_1.SerializationType.DESERIALIZE, traversalDescription, classConstructors);
+    clearTable(oldArray);
+    iterateTableInOrder(newArray, (key, value) => {
+        const deserializedValue = deepCopy(value, SerializationType.DESERIALIZE, traversalDescription, classConstructors);
         oldArray.set(key, deserializedValue);
-    }, constants_1.SAVE_DATA_MANAGER_DEBUG);
+    }, SAVE_DATA_MANAGER_DEBUG);
 }
 function mergeSerializedTable(oldTable, newTable, traversalDescription, classConstructors) {
-    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-        (0, log_1.log)(`merge encountered a Lua table: ${traversalDescription}`);
+    if (SAVE_DATA_MANAGER_DEBUG) {
+        log(`merge encountered a Lua table: ${traversalDescription}`);
     }
-    (0, table_1.iterateTableInOrder)(newTable, (key, value) => {
-        if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
+    iterateTableInOrder(newTable, (key, value) => {
+        if (SAVE_DATA_MANAGER_DEBUG) {
             const valueToPrint = value === "" ? "(empty string)" : String(value);
-            (0, log_1.log)(`merge is merging: ${traversalDescription} --> ${valueToPrint}`);
+            log(`merge is merging: ${traversalDescription} --> ${valueToPrint}`);
         }
-        if ((0, serialization_1.isSerializationBrand)(key)) {
+        if (isSerializationBrand(key)) {
             return;
         }
         // Handle the special case of serialized Isaac API classes.
-        if ((0, serialization_2.isSerializedIsaacAPIClass)(value)) {
-            if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-                (0, log_1.log)("merge found a serialized Isaac API class.");
+        if (isSerializedIsaacAPIClass(value)) {
+            if (SAVE_DATA_MANAGER_DEBUG) {
+                log("merge found a serialized Isaac API class.");
             }
-            const deserializedObject = (0, serialization_2.deserializeIsaacAPIClass)(value);
+            const deserializedObject = deserializeIsaacAPIClass(value);
             oldTable.set(key, deserializedObject);
             return;
         }
-        if ((0, types_1.isTable)(value)) {
+        if (isTable(value)) {
             let oldValue = oldTable.get(key);
-            if (!(0, types_1.isTable)(oldValue)) {
+            if (!isTable(oldValue)) {
                 // The child table does not exist on the old table. However, we still need to copy over
                 // the new table, because we need to handle data types like `Foo | null`. Thus, set up a
                 // blank sub-table on the old table, and continue to recursively merge.
                 oldValue = new LuaMap();
                 oldTable.set(key, oldValue);
             }
-            traversalDescription = (0, utils_1.getTraversalDescription)(key, traversalDescription);
+            traversalDescription = getTraversalDescription(key, traversalDescription);
             merge(oldValue, value, traversalDescription, classConstructors);
         }
         else {
             // Base case: copy the value
             oldTable.set(key, value);
         }
-    }, constants_1.SAVE_DATA_MANAGER_DEBUG);
+    }, SAVE_DATA_MANAGER_DEBUG);
 }
 function mergeSerializedTSTLObject(
 // eslint-disable-next-line complete/prefer-readonly-parameter-types
 oldObject, newTable, traversalDescription, classConstructors) {
-    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-        (0, log_1.log)(`merge encountered a TSTL object: ${traversalDescription}`);
+    if (SAVE_DATA_MANAGER_DEBUG) {
+        log(`merge encountered a TSTL object: ${traversalDescription}`);
     }
     // We blow away the old object and recursively copy over all of the incoming values.
     oldObject.clear();
     // During serialization, we brand some Lua tables with a special identifier to signify that it has
     // keys that should be deserialized to numbers.
-    const convertStringKeysToNumbers = newTable.has(SerializationBrand_1.SerializationBrand.OBJECT_WITH_NUMBER_KEYS);
-    (0, table_1.iterateTableInOrder)(newTable, (key, value) => {
-        if ((0, serialization_1.isSerializationBrand)(key)) {
+    const convertStringKeysToNumbers = newTable.has(SerializationBrand.OBJECT_WITH_NUMBER_KEYS);
+    iterateTableInOrder(newTable, (key, value) => {
+        if (isSerializationBrand(key)) {
             return;
         }
         let keyToUse = key;
@@ -147,12 +144,12 @@ oldObject, newTable, traversalDescription, classConstructors) {
             }
             keyToUse = numberKey;
         }
-        if ((0, tstlClass_1.isTSTLMap)(oldObject) || (0, tstlClass_1.isDefaultMap)(oldObject)) {
-            const deserializedValue = (0, deepCopy_1.deepCopy)(value, SerializationType_1.SerializationType.DESERIALIZE, traversalDescription, classConstructors);
+        if (isTSTLMap(oldObject) || isDefaultMap(oldObject)) {
+            const deserializedValue = deepCopy(value, SerializationType.DESERIALIZE, traversalDescription, classConstructors);
             oldObject.set(keyToUse, deserializedValue);
         }
-        else if ((0, tstlClass_1.isTSTLSet)(oldObject)) {
+        else if (isTSTLSet(oldObject)) {
             oldObject.add(keyToUse);
         }
-    }, constants_1.SAVE_DATA_MANAGER_DEBUG);
+    }, SAVE_DATA_MANAGER_DEBUG);
 }

package/dist/functions/mergeTests.js

@@ -1,20 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runMergeTests = runMergeTests;
-const DefaultMap_1 = require("../classes/DefaultMap");
-const SerializationType_1 = require("../enums/SerializationType");
-const deepCopy_1 = require("./deepCopy");
-const log_1 = require("./log");
-const merge_1 = require("./merge");
-const rng_1 = require("./rng");
-const serialization_1 = require("./serialization");
-const vector_1 = require("./vector");
+import { DefaultMap } from "../classes/DefaultMap";
+import { SerializationType } from "../enums/SerializationType";
+import { deepCopy } from "./deepCopy";
+import { logAndPrint } from "./log";
+import { merge } from "./merge";
+import { isRNG, newRNG } from "./rng";
+import { isSerializedIsaacAPIClass } from "./serialization";
+import { isVector, serializeVector } from "./vector";
 /**
  * Run the suite of tests that prove that the "merge" function works properly.
  *
  * This function is only useful if you are troubleshooting the save data manager.
  */
-function runMergeTests() {
+export function runMergeTests() {
     oldTableHasUpdatedValue();
     newTableHasSameValue();
     oldTableHasUpdatedValueFromNull();
@@ -27,7 +24,7 @@ function runMergeTests() {
     oldTableHasRNG();
     oldTableHasRNGSerialized();
     const successText = "All merge tests passed!";
-    (0, log_1.logAndPrint)(successText);
+    logAndPrint(successText);
 }
 function newTableHasSameValue() {
     const key = "foo";
@@ -35,7 +32,7 @@ function newTableHasSameValue() {
     const newValue = "baz";
     const oldTable = { foo: oldValue };
     const newTable = { foo: newValue };
-    (0, merge_1.merge)(oldTable, newTable, "newTableHasSameValue");
+    merge(oldTable, newTable, "newTableHasSameValue");
     const newTableValue = newTable.get(key);
     if (newTableValue !== newValue) {
         error(`The new table does not have a value of: ${newValue}`);
@@ -47,7 +44,7 @@ function oldTableHasFilledChildTable() {
     const oldTable = { foo: null };
     const foo = { bar: newValue };
     const newTable = { foo };
-    (0, merge_1.merge)(oldTable, newTable, "oldTableHasFilledChildTable");
+    merge(oldTable, newTable, "oldTableHasFilledChildTable");
     const oldTableValue = oldTable.get(key);
     if (oldTableValue === undefined) {
         error(`The old table's key of "${key}" was not filled.`);
@@ -59,20 +56,20 @@ function oldTableHasFilledChildTable() {
 function oldTableHasFilledDefaultMap() {
     const fakeV = {
         run: {
-            myDefaultMap: new DefaultMap_1.DefaultMap("default"),
+            myDefaultMap: new DefaultMap("default"),
         },
     };
     const saveData = {
         run: {
-            myDefaultMap: new DefaultMap_1.DefaultMap("default", [
+            myDefaultMap: new DefaultMap("default", [
                 ["foo1", "bar1"],
                 ["foo2", "bar2"],
                 ["foo3", "bar3"],
             ]),
         },
     };
-    const serializedSaveData = (0, deepCopy_1.deepCopy)(saveData, SerializationType_1.SerializationType.SERIALIZE);
-    (0, merge_1.merge)(fakeV, serializedSaveData, "oldTableHasFilledDefaultMap");
+    const serializedSaveData = deepCopy(saveData, SerializationType.SERIALIZE);
+    merge(fakeV, serializedSaveData, "oldTableHasFilledDefaultMap");
     const expectedSize = 3;
     if (fakeV.run.myDefaultMap.size !== expectedSize) {
         error(`The size of the merged default map was equal to ${fakeV.run.myDefaultMap.size}, but it should be equal to: ${expectedSize}`);
@@ -117,8 +114,8 @@ function oldTableHasFilledMap() {
             ]),
         },
     };
-    const serializedSaveData = (0, deepCopy_1.deepCopy)(saveData, SerializationType_1.SerializationType.SERIALIZE);
-    (0, merge_1.merge)(fakeV, serializedSaveData, "oldTableHasFilledMap");
+    const serializedSaveData = deepCopy(saveData, SerializationType.SERIALIZE);
+    merge(fakeV, serializedSaveData, "oldTableHasFilledMap");
     const expectedSize = 3;
     if (fakeV.run.myMap.size !== expectedSize) {
         error(`The size of the merged map was equal to ${fakeV.run.myMap.size}, but it should be equal to: ${expectedSize}`);
@@ -151,16 +148,16 @@ function oldTableHasFilledMap() {
 function oldTableHasRNG() {
     const key = "foo";
     const seed = 50;
-    const newValue = (0, rng_1.newRNG)(seed);
+    const newValue = newRNG(seed);
     const oldTable = { foo: null };
     const foo = { bar: newValue };
     const newTable = { foo };
-    (0, merge_1.merge)(oldTable, newTable, "oldTableHasRNG");
+    merge(oldTable, newTable, "oldTableHasRNG");
     const oldTableValue = oldTable.get(key);
     if (oldTableValue === undefined) {
         error(`The old table's key of "${key}" was not filled.`);
     }
-    if (!(0, rng_1.isRNG)(oldTableValue.bar)) {
+    if (!isRNG(oldTableValue.bar)) {
         error("The old table's value is not an RNG object.");
     }
     const newSeed = oldTableValue.bar.GetSeed();
@@ -171,17 +168,17 @@ function oldTableHasRNG() {
 function oldTableHasRNGSerialized() {
     const key = "foo";
     const seed = 50;
-    const newValue = (0, rng_1.newRNG)(seed);
+    const newValue = newRNG(seed);
     const oldTable = { foo: null };
     const foo = { bar: newValue };
     const newTable = { foo };
-    const newTableSerialized = (0, deepCopy_1.deepCopy)(newTable, SerializationType_1.SerializationType.SERIALIZE, "oldTableHasRNGSerialized");
-    (0, merge_1.merge)(oldTable, newTableSerialized, "oldTableHasRNGSerialized");
+    const newTableSerialized = deepCopy(newTable, SerializationType.SERIALIZE, "oldTableHasRNGSerialized");
+    merge(oldTable, newTableSerialized, "oldTableHasRNGSerialized");
     const oldTableValue = oldTable.get(key);
     if (oldTableValue === undefined) {
         error(`The old table's key of "${key}" was not filled.`);
     }
-    if (!(0, rng_1.isRNG)(oldTableValue.bar)) {
+    if (!isRNG(oldTableValue.bar)) {
         error("The old table's value is not an RNG object (during the serialized test).");
     }
     const newSeed = oldTableValue.bar.GetSeed();
@@ -193,8 +190,8 @@ function oldTableHasSerializedIsaacAPIClass() {
     const x = 50;
     const y = 60;
     const vector = Vector(x, y);
-    const vectorSerialized = (0, vector_1.serializeVector)(vector);
-    if (!(0, serialization_1.isSerializedIsaacAPIClass)(vectorSerialized)) {
+    const vectorSerialized = serializeVector(vector);
+    if (!isSerializedIsaacAPIClass(vectorSerialized)) {
         error('The "isSerializedIsaacAPIClass" function says that a serialized vector is not serialized.');
     }
 }
@@ -204,7 +201,7 @@ function oldTableHasUpdatedValue() {
     const newValue = "baz";
     const oldTable = { foo: oldValue };
     const newTable = { foo: newValue };
-    (0, merge_1.merge)(oldTable, newTable, "oldTableHasUpdatedValue");
+    merge(oldTable, newTable, "oldTableHasUpdatedValue");
     const oldTableValue = oldTable.get(key);
     if (oldTableValue !== newValue) {
         error(`The old table does not have a value of: ${newValue}`);
@@ -215,7 +212,7 @@ function oldTableHasUpdatedValueFromNull() {
     const newValue = "baz";
     const oldTable = { foo: null };
     const newTable = { foo: newValue };
-    (0, merge_1.merge)(oldTable, newTable, "oldTableHasUpdatedValueFromNull");
+    merge(oldTable, newTable, "oldTableHasUpdatedValueFromNull");
     const oldTableValue = oldTable.get(key);
     if (oldTableValue !== newValue) {
         error(`The old table does not have a value of: ${newValue}`);
@@ -229,7 +226,7 @@ function oldTableHasVector() {
     const oldTable = { foo: null };
     const foo = { bar: newValue };
     const newTable = { foo };
-    (0, merge_1.merge)(oldTable, newTable, "oldTableHasVector");
+    merge(oldTable, newTable, "oldTableHasVector");
     const oldTableValue = oldTable.get(key);
     if (oldTableValue === undefined) {
         error(`The old table's key of "${key}" was not filled.`);
@@ -240,7 +237,7 @@ function oldTableHasVector() {
     if (oldTableValue.bar.Y !== y) {
         error(`The old table's value for "y" does not match: ${y}`);
     }
-    if (!(0, vector_1.isVector)(oldTableValue.bar)) {
+    if (!isVector(oldTableValue.bar)) {
         error("The old table's value is not a Vector object.");
     }
 }
@@ -252,8 +249,8 @@ function oldTableHasVectorSerialized() {
     const oldTable = { foo: null };
     const foo = { bar: newValue };
     const newTable = { foo };
-    const newTableSerialized = (0, deepCopy_1.deepCopy)(newTable, SerializationType_1.SerializationType.SERIALIZE, "oldTableHasVectorSerialized");
-    (0, merge_1.merge)(oldTable, newTableSerialized, "oldTableHasVectorSerialized");
+    const newTableSerialized = deepCopy(newTable, SerializationType.SERIALIZE, "oldTableHasVectorSerialized");
+    merge(oldTable, newTableSerialized, "oldTableHasVectorSerialized");
     const oldTableValue = oldTable.get(key);
     if (oldTableValue === undefined) {
         error(`The old table's key of "${key}" was not filled.`);
@@ -264,7 +261,7 @@ function oldTableHasVectorSerialized() {
     if (oldTableValue.bar.Y !== y) {
         error(`The old table's value for "y" does not match: ${y}`);
     }
-    if (!(0, vector_1.isVector)(oldTableValue.bar)) {
+    if (!isVector(oldTableValue.bar)) {
         error("The old table's value is not a Vector object (during the serialized test).");
     }
 }