isaacscript-common 87.9.7 → 87.9.8

package/dist/functions/deepCopy.js

@@ -1,30 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deepCopy = deepCopy;
-const DefaultMap_1 = require("../classes/DefaultMap");
-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 isaacAPIClass_1 = require("./isaacAPIClass");
-const log_1 = require("./log");
-const serialization_2 = require("./serialization");
-const sort_1 = require("./sort");
-const tstlClass_1 = require("./tstlClass");
-const types_1 = require("./types");
-const utils_1 = require("./utils");
-function deepCopy(value, serializationType = SerializationType_1.SerializationType.NONE, traversalDescription = "", classConstructors = new LuaMap(), insideMap = false) {
-    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
+import { DefaultMap } from "../classes/DefaultMap";
+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 { getIsaacAPIClassName } from "./isaacAPIClass";
+import { log } from "./log";
+import { copyIsaacAPIClass, deserializeIsaacAPIClass, isCopyableIsaacAPIClass, isSerializedIsaacAPIClass, serializeIsaacAPIClass, } from "./serialization";
+import { sortTwoDimensionalArray } from "./sort";
+import { getTSTLClassName, isDefaultMap, isTSTLMap, isTSTLSet, newTSTLClass, } from "./tstlClass";
+import { asString, isNumber, isPrimitive } from "./types";
+import { assertDefined, getTraversalDescription } from "./utils";
+export function deepCopy(value, serializationType = SerializationType.NONE, traversalDescription = "", classConstructors = new LuaMap(), insideMap = false) {
+    if (SAVE_DATA_MANAGER_DEBUG) {
         let logString = `deepCopy is operating on: ${traversalDescription}`;
-        if (serializationType === SerializationType_1.SerializationType.SERIALIZE) {
+        if (serializationType === SerializationType.SERIALIZE) {
             logString += " (serializing)";
         }
-        else if (serializationType === SerializationType_1.SerializationType.DESERIALIZE) {
+        else if (serializationType === SerializationType.DESERIALIZE) {
             logString += " (deserializing)";
         }
         logString += `: ${value}`;
-        (0, log_1.log)(logString);
+        log(logString);
     }
     const valueType = type(value);
     switch (valueType) {
@@ -38,10 +35,10 @@ function deepCopy(value, serializationType = SerializationType_1.SerializationTy
         // Second, handle values that cannot be serialized.
         case "function":
         case "thread": {
-            if (serializationType === SerializationType_1.SerializationType.SERIALIZE) {
+            if (serializationType === SerializationType.SERIALIZE) {
                 error(`The deep copy function does not support serialization of "${traversalDescription}", since it is type: ${valueType}`);
             }
-            if (serializationType === SerializationType_1.SerializationType.DESERIALIZE) {
+            if (serializationType === SerializationType.DESERIALIZE) {
                 error(`The deep copy function does not support deserialization of "${traversalDescription}", since it is type: ${valueType}`);
             }
             // We cannot copy this, so simply return the reference.
@@ -72,8 +69,8 @@ function checkMetatable(luaMap, traversalDescription) {
     error(`The deepCopy function detected that ${tableDescription} has a metatable. Copying tables with metatables is not supported, unless they are explicitly handled by the save data manager. (e.g. TypeScriptToLua Maps, TypeScriptToLua Sets, etc.)`);
 }
 function deepCopyArray(array, serializationType, traversalDescription, classConstructors, insideMap) {
-    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-        (0, log_1.log)("deepCopy is copying an array.");
+    if (SAVE_DATA_MANAGER_DEBUG) {
+        log("deepCopy is copying an array.");
     }
     const newArray = [];
     for (const value of array) {
@@ -83,17 +80,17 @@ function deepCopyArray(array, serializationType, traversalDescription, classCons
     return newArray;
 }
 function deepCopyDefaultMap(defaultMap, serializationType, traversalDescription, classConstructors, insideMap) {
-    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-        (0, log_1.log)("deepCopy is copying a DefaultMap.");
+    if (SAVE_DATA_MANAGER_DEBUG) {
+        log("deepCopy is copying a DefaultMap.");
     }
-    const constructorArg = (0, tstlClass_1.isDefaultMap)(defaultMap)
+    const constructorArg = isDefaultMap(defaultMap)
         ? defaultMap.getConstructorArg()
         : undefined; // The undefined case is handled explicitly in the "getNewDefaultMap" function.
     // First, handle the special case of serializing a DefaultMap instantiated with a factory
     // function. If this is the case, then we cannot serialize it (because there is no way to
     // serialize a function).
-    if (serializationType === SerializationType_1.SerializationType.SERIALIZE
-        && !(0, types_1.isPrimitive)(constructorArg)) {
+    if (serializationType === SerializationType.SERIALIZE
+        && !isPrimitive(constructorArg)) {
         if (insideMap) {
             // The case of a DefaultMap within another map is complicated. Unlike a DefaultMap attached to
             // a "normal" object, the `merge` function will have no reference to the factory function that
@@ -115,18 +112,18 @@ function deepCopyDefaultMap(defaultMap, serializationType, traversalDescription,
     if (convertedNumberKeysToStrings) {
         // Differentiating between the two types looks superfluous but is necessary for TSTL to produce
         // the proper set method call.
-        if ((0, tstlClass_1.isDefaultMap)(newDefaultMap)) {
-            newDefaultMap.set(SerializationBrand_1.SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
+        if (isDefaultMap(newDefaultMap)) {
+            newDefaultMap.set(SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
             // eslint-disable-next-line unicorn/no-duplicate-if-branches
         }
         else {
-            newDefaultMap.set(SerializationBrand_1.SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
+            newDefaultMap.set(SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
         }
     }
     for (const [key, value] of entries) {
         // Differentiating between the two types looks superfluous but is necessary for TSTL to produce
         // the proper set method call.
-        if ((0, tstlClass_1.isDefaultMap)(newDefaultMap)) {
+        if (isDefaultMap(newDefaultMap)) {
             newDefaultMap.set(key, value);
             // eslint-disable-next-line unicorn/no-duplicate-if-branches
         }
@@ -137,14 +134,14 @@ function deepCopyDefaultMap(defaultMap, serializationType, traversalDescription,
     return newDefaultMap;
 }
 function deepCopyMap(map, serializationType, traversalDescription, classConstructors, insideMap) {
-    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-        (0, log_1.log)("deepCopy is copying a Map.");
+    if (SAVE_DATA_MANAGER_DEBUG) {
+        log("deepCopy is copying a Map.");
     }
     let newMap;
-    if (serializationType === SerializationType_1.SerializationType.SERIALIZE) {
+    if (serializationType === SerializationType.SERIALIZE) {
         // Since we are serializing, the new object will be a Lua table.
         newMap = new LuaMap();
-        newMap.set(SerializationBrand_1.SerializationBrand.MAP, "");
+        newMap.set(SerializationBrand.MAP, "");
     }
     else {
         newMap = new Map();
@@ -154,18 +151,18 @@ function deepCopyMap(map, serializationType, traversalDescription, classConstruc
     if (convertedNumberKeysToStrings) {
         // Differentiating between the two types looks superfluous but is necessary for TSTL to produce
         // the proper set method call.
-        if ((0, tstlClass_1.isTSTLMap)(newMap)) {
-            newMap.set(SerializationBrand_1.SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
+        if (isTSTLMap(newMap)) {
+            newMap.set(SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
             // eslint-disable-next-line unicorn/no-duplicate-if-branches
         }
         else {
-            newMap.set(SerializationBrand_1.SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
+            newMap.set(SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
         }
     }
     for (const [key, value] of entries) {
         // Differentiating between the two types looks superfluous but is necessary for TSTL to produce
         // the proper set method call.
-        if ((0, tstlClass_1.isTSTLMap)(newMap)) {
+        if (isTSTLMap(newMap)) {
             newMap.set(key, value);
             // eslint-disable-next-line unicorn/no-duplicate-if-branches
         }
@@ -176,13 +173,13 @@ function deepCopyMap(map, serializationType, traversalDescription, classConstruc
     return newMap;
 }
 function deepCopyNormalLuaTable(luaMap, serializationType, traversalDescription, classConstructors, insideMap) {
-    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-        (0, log_1.log)("deepCopy is copying a normal Lua table.");
+    if (SAVE_DATA_MANAGER_DEBUG) {
+        log("deepCopy is copying a normal Lua table.");
     }
     const newTable = new LuaMap();
     const { entries, convertedNumberKeysToStrings } = getCopiedEntries(luaMap, serializationType, traversalDescription, classConstructors, insideMap);
     if (convertedNumberKeysToStrings) {
-        newTable.set(SerializationBrand_1.SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
+        newTable.set(SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
     }
     for (const [key, value] of entries) {
         newTable.set(key, value);
@@ -190,15 +187,15 @@ function deepCopyNormalLuaTable(luaMap, serializationType, traversalDescription,
     return newTable;
 }
 function deepCopySet(set, serializationType, traversalDescription, classConstructors, insideMap) {
-    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-        (0, log_1.log)("deepCopy is copying a Set.");
+    if (SAVE_DATA_MANAGER_DEBUG) {
+        log("deepCopy is copying a Set.");
     }
     let newSet;
-    if (serializationType === SerializationType_1.SerializationType.SERIALIZE) {
+    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 LuaMap();
-        newSet.set(SerializationBrand_1.SerializationBrand.SET, "");
+        newSet.set(SerializationBrand.SET, "");
     }
     else {
         newSet = new Set();
@@ -207,18 +204,18 @@ function deepCopySet(set, serializationType, traversalDescription, classConstruc
     if (convertedNumberKeysToStrings) {
         // Differentiating between the two types looks superfluous but is necessary for TSTL to produce
         // the proper set method call.
-        if ((0, tstlClass_1.isTSTLSet)(newSet)) {
+        if (isTSTLSet(newSet)) {
             // We should never be serializing an object of type `Set`.
             error("The deep copy function cannot convert number keys to strings for a Set.");
         }
         else {
-            newSet.set(SerializationBrand_1.SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
+            newSet.set(SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
         }
     }
     for (const [key] of entries) {
         // Differentiating between the two types looks superfluous but is necessary for TSTL to produce
         // the proper set method call.
-        if ((0, tstlClass_1.isTSTLSet)(newSet)) {
+        if (isTSTLSet(newSet)) {
             newSet.add(key);
         }
         else {
@@ -229,62 +226,62 @@ function deepCopySet(set, serializationType, traversalDescription, classConstruc
 }
 function deepCopyTable(luaMap, serializationType, traversalDescription, classConstructors, insideMap) {
     // First, handle the cases of TSTL classes or serialized TSTL classes.
-    if ((0, tstlClass_1.isDefaultMap)(luaMap) || luaMap.has(SerializationBrand_1.SerializationBrand.DEFAULT_MAP)) {
+    if (isDefaultMap(luaMap) || luaMap.has(SerializationBrand.DEFAULT_MAP)) {
         return deepCopyDefaultMap(luaMap, serializationType, traversalDescription, classConstructors, insideMap);
     }
-    if ((0, tstlClass_1.isTSTLMap)(luaMap) || luaMap.has(SerializationBrand_1.SerializationBrand.MAP)) {
+    if (isTSTLMap(luaMap) || luaMap.has(SerializationBrand.MAP)) {
         return deepCopyMap(luaMap, serializationType, traversalDescription, classConstructors, insideMap);
     }
-    if ((0, tstlClass_1.isTSTLSet)(luaMap) || luaMap.has(SerializationBrand_1.SerializationBrand.SET)) {
+    if (isTSTLSet(luaMap) || luaMap.has(SerializationBrand.SET)) {
         return deepCopySet(luaMap, serializationType, traversalDescription, classConstructors, insideMap);
     }
-    const className = (0, tstlClass_1.getTSTLClassName)(luaMap);
+    const className = getTSTLClassName(luaMap);
     if (className === "WeakMap" || className === "WeakSet") {
         error(`The deep copy function does not support copying the "${className}" class for: ${traversalDescription}`);
     }
-    if (className !== undefined || luaMap.has(SerializationBrand_1.SerializationBrand.TSTL_CLASS)) {
+    if (className !== undefined || luaMap.has(SerializationBrand.TSTL_CLASS)) {
         return deepCopyTSTLClass(luaMap, serializationType, traversalDescription, classConstructors, insideMap);
     }
     // This is not a TSTL Map/Set/class. If it has a metatable, abort.
     checkMetatable(luaMap, traversalDescription);
     // Handle the special case of serialized Isaac API classes.
-    if ((0, serialization_2.isSerializedIsaacAPIClass)(luaMap)
-        && serializationType === SerializationType_1.SerializationType.DESERIALIZE) {
-        return (0, serialization_2.deserializeIsaacAPIClass)(luaMap);
+    if (isSerializedIsaacAPIClass(luaMap)
+        && serializationType === SerializationType.DESERIALIZE) {
+        return deserializeIsaacAPIClass(luaMap);
     }
     // Handle the special case of an array.
-    if ((0, array_1.isArray)(luaMap)) {
+    if (isArray(luaMap)) {
         return deepCopyArray(luaMap, serializationType, traversalDescription, classConstructors, insideMap);
     }
     // Base case: copy a normal Lua table
     return deepCopyNormalLuaTable(luaMap, serializationType, traversalDescription, classConstructors, insideMap);
 }
 function deepCopyTSTLClass(tstlClass, serializationType, traversalDescription, classConstructors, insideMap) {
-    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-        (0, log_1.log)("deepCopy is copying a TSTL class.");
+    if (SAVE_DATA_MANAGER_DEBUG) {
+        log("deepCopy is copying a TSTL class.");
     }
     let newClass;
     switch (serializationType) {
-        case SerializationType_1.SerializationType.NONE: {
+        case SerializationType.NONE: {
             // We can use the class constructor from the old class.
-            newClass = (0, tstlClass_1.newTSTLClass)(tstlClass);
+            newClass = newTSTLClass(tstlClass);
             break;
         }
-        case SerializationType_1.SerializationType.SERIALIZE: {
+        case SerializationType.SERIALIZE: {
             newClass = new LuaMap();
             // We brand it with the name of the class so that we can run the corresponding constructor
             // during deserialization.
-            const tstlClassName = (0, tstlClass_1.getTSTLClassName)(tstlClass);
+            const tstlClassName = getTSTLClassName(tstlClass);
             if (tstlClassName !== undefined) {
-                newClass.set(SerializationBrand_1.SerializationBrand.TSTL_CLASS, tstlClassName);
+                newClass.set(SerializationBrand.TSTL_CLASS, tstlClassName);
             }
             break;
         }
-        case SerializationType_1.SerializationType.DESERIALIZE: {
-            const tstlClassName = tstlClass.get(SerializationBrand_1.SerializationBrand.TSTL_CLASS);
-            (0, utils_1.assertDefined)(tstlClassName, "Failed to deserialize a TSTL class since the brand did not contain the class name.");
+        case SerializationType.DESERIALIZE: {
+            const tstlClassName = tstlClass.get(SerializationBrand.TSTL_CLASS);
+            assertDefined(tstlClassName, "Failed to deserialize a TSTL class since the brand did not contain the class name.");
             const classConstructor = classConstructors.get(tstlClassName);
-            (0, utils_1.assertDefined)(classConstructor, `Failed to deserialize a TSTL class since there was no constructor registered for a class name of "${tstlClassName}". If this mod is using the save data manager, it must register the class constructor with the "saveDataManagerRegisterClass" method.`);
+            assertDefined(classConstructor, `Failed to deserialize a TSTL class since there was no constructor registered for a class name of "${tstlClassName}". If this mod is using the save data manager, it must register the class constructor with the "saveDataManagerRegisterClass" method.`);
             // eslint-disable-next-line new-cap
             newClass = new classConstructor();
             break;
@@ -292,7 +289,7 @@ function deepCopyTSTLClass(tstlClass, serializationType, traversalDescription, c
     }
     const { entries, convertedNumberKeysToStrings } = getCopiedEntries(tstlClass, serializationType, traversalDescription, classConstructors, insideMap);
     if (convertedNumberKeysToStrings) {
-        newClass.set(SerializationBrand_1.SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
+        newClass.set(SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
     }
     for (const [key, value] of entries) {
         newClass.set(key, value);
@@ -301,18 +298,18 @@ function deepCopyTSTLClass(tstlClass, serializationType, traversalDescription, c
 }
 /** Isaac API classes are of type "userdata". End-user code cannot create userdata. */
 function deepCopyUserdata(value, serializationType, traversalDescription) {
-    if (!(0, serialization_2.isCopyableIsaacAPIClass)(value)) {
-        const className = (0, isaacAPIClass_1.getIsaacAPIClassName)(value) ?? "Unknown";
+    if (!isCopyableIsaacAPIClass(value)) {
+        const className = getIsaacAPIClassName(value) ?? "Unknown";
         error(`The deep copy function does not support serializing "${traversalDescription}", since it is an Isaac API class of type: ${className}`);
     }
     switch (serializationType) {
-        case SerializationType_1.SerializationType.NONE: {
-            return (0, serialization_2.copyIsaacAPIClass)(value);
+        case SerializationType.NONE: {
+            return copyIsaacAPIClass(value);
         }
-        case SerializationType_1.SerializationType.SERIALIZE: {
-            return (0, serialization_2.serializeIsaacAPIClass)(value);
+        case SerializationType.SERIALIZE: {
+            return serializeIsaacAPIClass(value);
         }
-        case SerializationType_1.SerializationType.DESERIALIZE: {
+        case SerializationType.DESERIALIZE: {
             return error(`The deep copy function can not deserialize "${traversalDescription}", since it is userdata.`);
         }
     }
@@ -327,7 +324,7 @@ function getCopiedEntries(object, serializationType, traversalDescription, class
     // First, shallow copy the entries. We cannot use "pairs" to iterate over a `Map` or `Set`. We
     // cannot use "[...pairs(object)]", as it results in a run-time error.
     const entries = [];
-    if ((0, tstlClass_1.isTSTLMap)(object) || (0, tstlClass_1.isTSTLSet)(object) || (0, tstlClass_1.isDefaultMap)(object)) {
+    if (isTSTLMap(object) || isTSTLSet(object) || isDefaultMap(object)) {
         for (const [key, value] of object.entries()) {
             entries.push([key, value]);
         }
@@ -337,24 +334,24 @@ function getCopiedEntries(object, serializationType, traversalDescription, class
             entries.push([key, value]);
         }
     }
-    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-        entries.sort(sort_1.sortTwoDimensionalArray);
+    if (SAVE_DATA_MANAGER_DEBUG) {
+        entries.sort(sortTwoDimensionalArray);
     }
     // 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 = serializationType === SerializationType_1.SerializationType.DESERIALIZE
-        && entries.some(([key]) => key === (0, types_1.asString)(SerializationBrand_1.SerializationBrand.OBJECT_WITH_NUMBER_KEYS));
-    const hasNumberKeys = entries.some(([key]) => (0, types_1.isNumber)(key));
-    const convertNumberKeysToStrings = serializationType === SerializationType_1.SerializationType.SERIALIZE && hasNumberKeys;
+    const convertStringKeysToNumbers = serializationType === SerializationType.DESERIALIZE
+        && entries.some(([key]) => key === asString(SerializationBrand.OBJECT_WITH_NUMBER_KEYS));
+    const hasNumberKeys = entries.some(([key]) => isNumber(key));
+    const convertNumberKeysToStrings = serializationType === SerializationType.SERIALIZE && hasNumberKeys;
     // Second, deep copy the entries.
     const copiedEntries = [];
     for (const [key, value] of entries) {
         // When deserializing, we do not need to copy the serialization brands that are used to denote
         // the object type.
-        if ((0, serialization_1.isSerializationBrand)(key)) {
+        if (isSerializationBrand(key)) {
             continue;
         }
-        traversalDescription = (0, utils_1.getTraversalDescription)(key, traversalDescription);
+        traversalDescription = getTraversalDescription(key, traversalDescription);
         const newValue = deepCopy(value, serializationType, traversalDescription, classConstructors, insideMap);
         let keyToUse = key;
         if (convertStringKeysToNumbers) {
@@ -379,26 +376,26 @@ function getCopiedEntries(object, serializationType, traversalDescription, class
  */
 function getNewDefaultMap(defaultMap, serializationType, traversalDescription, constructorArg) {
     switch (serializationType) {
-        case SerializationType_1.SerializationType.NONE: {
+        case SerializationType.NONE: {
             // eslint-disable-next-line isaacscript/no-invalid-default-map
-            return new DefaultMap_1.DefaultMap(constructorArg);
+            return new DefaultMap(constructorArg);
         }
-        case SerializationType_1.SerializationType.SERIALIZE: {
+        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 LuaMap();
-            newDefaultMap.set(SerializationBrand_1.SerializationBrand.DEFAULT_MAP, "");
-            newDefaultMap.set(SerializationBrand_1.SerializationBrand.DEFAULT_MAP_VALUE, constructorArg);
+            newDefaultMap.set(SerializationBrand.DEFAULT_MAP, "");
+            newDefaultMap.set(SerializationBrand.DEFAULT_MAP_VALUE, constructorArg);
             return newDefaultMap;
         }
-        case SerializationType_1.SerializationType.DESERIALIZE: {
-            if ((0, tstlClass_1.isDefaultMap)(defaultMap)) {
+        case SerializationType.DESERIALIZE: {
+            if (isDefaultMap(defaultMap)) {
                 error(`Failed to deserialize a default map of "${traversalDescription}", since it was not a Lua table.`);
             }
-            const defaultMapValue = defaultMap.get(SerializationBrand_1.SerializationBrand.DEFAULT_MAP_VALUE);
-            (0, utils_1.assertDefined)(defaultMapValue, `Failed to deserialize a default map of "${traversalDescription}", since there was no serialization brand of: ${SerializationBrand_1.SerializationBrand.DEFAULT_MAP_VALUE}`);
+            const defaultMapValue = defaultMap.get(SerializationBrand.DEFAULT_MAP_VALUE);
+            assertDefined(defaultMapValue, `Failed to deserialize a default map of "${traversalDescription}", since there was no serialization brand of: ${SerializationBrand.DEFAULT_MAP_VALUE}`);
             // eslint-disable-next-line isaacscript/no-invalid-default-map
-            return new DefaultMap_1.DefaultMap(defaultMapValue);
+            return new DefaultMap(defaultMapValue);
         }
     }
 }