manyfest 1.0.42 → 1.0.44

package/dist/manyfest.js

@@ -175,6 +175,12 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
       //
       // TODO: Should template literals be processed?  If so what state do they have access to?  That should happen here if so.
       // TODO: Make a simple class include library with these
+      /**
+       * @param {string} pCharacter - The character to remove from the start and end of the string
+       * @param {string} pString - The string to clean
+       *
+       * @return {string} The cleaned string
+       */
       const cleanWrapCharacters = (pCharacter, pString) => {
         if (pString.startsWith(pCharacter) && pString.endsWith(pCharacter)) {
           return pString.substring(1, pString.length - 1);
@@ -206,15 +212,27 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
       * @class ManyfestHashTranslation
       */
       class ManyfestHashTranslation {
+        /**
+         * @param {function} [pInfoLog] - (optional) A logging function for info messages
+         * @param {function} [pErrorLog] - (optional) A logging function for error messages
+         */
         constructor(pInfoLog, pErrorLog) {
           // Wire in logging
           this.logInfo = typeof pInfoLog === 'function' ? pInfoLog : libSimpleLog;
           this.logError = typeof pErrorLog === 'function' ? pErrorLog : libSimpleLog;
           this.translationTable = {};
         }
+
+        /**
+         * @return {number} The number of translations in the table
+         */
         translationCount() {
           return Object.keys(this.translationTable).length;
         }
+
+        /**
+         * @param {object} pTranslation - An object containing source:destination hash pairs to add to the translation table
+         */
         addTranslation(pTranslation) {
           // This adds a translation in the form of:
           // { "SourceHash": "DestinationHash", "SecondSourceHash":"SecondDestinationHash" }
@@ -231,15 +249,23 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
             }
           });
         }
+
+        /**
+         * @param {string} pTranslationHash - The source hash to remove from the translation table
+         */
         removeTranslationHash(pTranslationHash) {
-          if (pTranslationHash in this.translationTable) {
-            delete this.translationTable[pTranslationHash];
-          }
+          delete this.translationTable[pTranslationHash];
         }
 
-        // This removes translations.
-        // If passed a string, just removes the single one.
-        // If passed an object, it does all the source keys.
+        /**
+         * This removes translations.
+         * If passed a string, just removes the single one.
+         * If passed an object, it does all the source keys.
+         *
+         * @param {string|object} pTranslation - Either a source hash string to remove, or an object containing source:destination hash pairs to remove
+         *
+         * @return {boolean} True if the removal was successful, false otherwise
+         */
         removeTranslation(pTranslation) {
           if (typeof pTranslation == 'string') {
             this.removeTranslationHash(pTranslation);
@@ -258,6 +284,12 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
         clearTranslations() {
           this.translationTable = {};
         }
+
+        /**
+         * @param {string} pTranslation - The source hash to translate
+         *
+         * @return {string} The translated hash, or the original if no translation exists
+         */
         translate(pTranslation) {
           if (pTranslation in this.translationTable) {
             return this.translationTable[pTranslation];
@@ -293,6 +325,7 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
       const libSimpleLog = require('./Manyfest-LogToConsole.js');
       // This is for resolving functions mid-address
       const libGetObjectValue = require('./Manyfest-ObjectAddress-GetValue.js');
+      const fCleanWrapCharacters = require('./Manyfest-CleanWrapCharacters.js');
 
       // TODO: Just until this is a fable service.
       let _MockFable = {
@@ -318,19 +351,32 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
       * @class ManyfestObjectAddressResolverCheckAddressExists
       */
       class ManyfestObjectAddressResolverCheckAddressExists {
+        /**
+         * @param {function} [pInfoLog] - (optional) Function to use for info logging
+         * @param {function} [pErrorLog] - (optional) Function to use for error logging
+         */
         constructor(pInfoLog, pErrorLog) {
           // Wire in logging
           this.logInfo = typeof pInfoLog == 'function' ? pInfoLog : libSimpleLog;
           this.logError = typeof pErrorLog == 'function' ? pErrorLog : libSimpleLog;
           this.getObjectValueClass = new libGetObjectValue(this.logInfo, this.logError);
+          this.cleanWrapCharacters = fCleanWrapCharacters;
         }
 
-        // Check if an address exists.
-        //
-        // This is necessary because the getValueAtAddress function is ambiguous on
-        // whether the element/property is actually there or not (it returns
-        // undefined whether the property exists or not).  This function checks for
-        // existance and returns true or false dependent.
+        /**
+         * Check if an address exists.
+         *
+         * This is necessary because the getValueAtAddress function is ambiguous on
+         * whether the element/property is actually there or not (it returns
+         * undefined whether the property exists or not).  This function checks for
+         * existance and returns true or false dependent.
+         *
+         * @param {object} pObject - The object to check within
+         * @param {string} pAddress - The address to check for
+         * @param {object} [pRootObject] - (optional) The root object for function resolution context
+         *
+         * @return {boolean} - True if the address exists, false if it does not
+         */
         checkAddressExists(pObject, pAddress, pRootObject) {
           // TODO: Should these throw an error?
           // Make sure pObject is an object
@@ -463,7 +509,7 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
               let tmpFunctionAddress = tmpSubObjectName.substring(0, tmpFunctionStartIndex).trim();
               //tmpParentAddress = `${tmpParentAddress}${(tmpParentAddress.length > 0) ? '.' : ''}${tmpSubObjectName}`;
 
-              if (!typeof pObject[tmpFunctionAddress] == 'function') {
+              if (typeof pObject[tmpFunctionAddress] !== 'function') {
                 // The address suggests it is a function, but it is not.
                 return false;
               }
@@ -478,12 +524,12 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
                     return this.checkAddressExists(pObject[tmpFunctionAddress].apply(pObject), tmpNewAddress, tmpRootObject);
                   } catch (pError) {
                     // The function call failed, so the address doesn't exist
-                    libSimpleLog.log("Error calling function ".concat(tmpFunctionAddress, " (address [").concat(pAddress, "]): ").concat(pError.message));
+                    libSimpleLog("Error calling function ".concat(tmpFunctionAddress, " (address [").concat(pAddress, "]): ").concat(pError.message));
                     return false;
                   }
                 } else {
                   // The function doesn't exist, so the address doesn't exist
-                  libSimpleLog.log("Function ".concat(tmpFunctionAddress, " does not exist (address [").concat(pAddress, "])"));
+                  libSimpleLog("Function ".concat(tmpFunctionAddress, " does not exist (address [").concat(pAddress, "])"));
                   return false;
                 }
               } else {
@@ -503,12 +549,12 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
                     return this.checkAddressExists(pObject[tmpFunctionAddress].apply(pObject, tmpArgumentValues), tmpNewAddress, tmpRootObject);
                   } catch (pError) {
                     // The function call failed, so the address doesn't exist
-                    libSimpleLog.log("Error calling function ".concat(tmpFunctionAddress, " (address [").concat(pAddress, "]): ").concat(pError.message));
+                    libSimpleLog("Error calling function ".concat(tmpFunctionAddress, " (address [").concat(pAddress, "]): ").concat(pError.message));
                     return false;
                   }
                 } else {
                   // The function doesn't exist, so the address doesn't exist
-                  libSimpleLog.log("Function ".concat(tmpFunctionAddress, " does not exist (address [").concat(pAddress, "])"));
+                  libSimpleLog("Function ".concat(tmpFunctionAddress, " does not exist (address [").concat(pAddress, "])"));
                   return false;
                 }
               }
@@ -583,9 +629,9 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
           }
         }
       }
-      ;
       module.exports = ManyfestObjectAddressResolverCheckAddressExists;
     }, {
+      "./Manyfest-CleanWrapCharacters.js": 3,
       "./Manyfest-LogToConsole.js": 5,
       "./Manyfest-ObjectAddress-GetValue.js": 8,
       "./Manyfest-ObjectAddress-Parser.js": 9
@@ -619,6 +665,10 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
       * @class ManyfestObjectAddressResolverDeleteValue
       */
       class ManyfestObjectAddressResolverDeleteValue {
+        /**
+         * @param {function} [pInfoLog] - (optional) A logging function for info messages
+         * @param {function} [pErrorLog] - (optional) A logging function for error messages
+         */
         constructor(pInfoLog, pErrorLog) {
           // Wire in logging
           this.logInfo = typeof pInfoLog == 'function' ? pInfoLog : libSimpleLog;
@@ -627,11 +677,25 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
         }
 
         // TODO: Dry me
+        /**
+         * @param {string} pAddress - The address being evaluated
+         * @param {object} pRecord - The record being evaluated
+         *
+         * @return {boolean} True if the record passes the filters, false if it does not
+         */
         checkRecordFilters(pAddress, pRecord) {
           return fParseConditionals(this, pAddress, pRecord);
         }
 
-        // Delete the value of an element at an address
+        /**
+         * Delete the value of an element at an address
+         *
+         * @param {object} pObject - The object to delete the value from
+         * @param {string} pAddress - The address to delete the value at
+         * @param {string} [pParentAddress] - (optional) The parent address for recursion
+         *
+         * @return {boolean|object|undefined} - True if the value was deleted, false if it could not be deleted, undefined on error
+         */
         deleteValueAtAddress(pObject, pAddress, pParentAddress) {
           // Make sure pObject (the object we are meant to be recursing) is an object (which could be an array or object)
           if (typeof pObject != 'object') return undefined;
@@ -931,17 +995,37 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
       * @class ManyfestObjectAddressResolverGetValue
       */
       class ManyfestObjectAddressResolverGetValue {
+        /**
+         * @param {function} [pInfoLog] - (optional) A logging function for info messages
+         * @param {function} [pErrorLog] - (optional) A logging function for error messages
+         */
         constructor(pInfoLog, pErrorLog) {
           // Wire in logging
           this.logInfo = typeof pInfoLog == 'function' ? pInfoLog : libSimpleLog;
           this.logError = typeof pErrorLog == 'function' ? pErrorLog : libSimpleLog;
           this.cleanWrapCharacters = fCleanWrapCharacters;
         }
+
+        /**
+         * @param {string} pAddress - The address of the record to check
+         * @param {object} pRecord - The record to check against the filters
+         *
+         * @return {boolean} - True if the record passes the filters, false otherwise
+         */
         checkRecordFilters(pAddress, pRecord) {
           return fParseConditionals(this, pAddress, pRecord);
         }
 
-        // Get the value of an element at an address
+        /**
+         * Get the value of an element at an address
+         *
+         * @param {object} pObject - The object to resolve the address against
+         * @param {string} pAddress - The address to resolve
+         * @param {string} [pParentAddress] - (optional) The parent address for back-navigation
+         * @param {object} [pRootObject] - (optional) The root object for function argument resolution
+         *
+         * @return {any} The value at the address, or undefined if not found
+         */
         getValueAtAddress(pObject, pAddress, pParentAddress, pRootObject) {
           // Make sure pObject (the object we are meant to be recursing) is an object (which could be an array or object)
           if (typeof pObject != 'object') {
@@ -1029,7 +1113,7 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
             //    2) The end bracket is after the start bracket
             && _MockFable.DataFormat.stringCountEnclosures(pAddress) > 0) {
               let tmpFunctionAddress = pAddress.substring(0, tmpFunctionStartIndex).trim();
-              if (!typeof pObject[tmpFunctionAddress] == 'function') {
+              if (typeof pObject[tmpFunctionAddress] !== 'function') {
                 // The address suggests it is a function, but it is not.
                 return false;
               }
@@ -1206,7 +1290,7 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
             && _MockFable.DataFormat.stringCountEnclosures(tmpSubObjectName) > 0) {
               let tmpFunctionAddress = tmpSubObjectName.substring(0, tmpFunctionStartIndex).trim();
               tmpParentAddress = "".concat(tmpParentAddress).concat(tmpParentAddress.length > 0 ? '.' : '').concat(tmpSubObjectName);
-              if (!typeof pObject[tmpFunctionAddress] == 'function') {
+              if (typeof pObject[tmpFunctionAddress] !== 'function') {
                 // The address suggests it is a function, but it is not.
                 return false;
               }
@@ -1415,29 +1499,32 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
       // Until we shift Manyfest to be a fable service, these three functions were pulled out of
       // fable to aid in parsing functions with nested enclosures.
 
+      const DEFAULT_START_SYMBOL_MAP = {
+        '{': 0,
+        '[': 1,
+        '(': 2
+      };
+      const DEFAULT_END_SYMBOL_MAP = {
+        '}': 0,
+        ']': 1,
+        ')': 2
+      };
       module.exports = {
         /**
          * Count the number of segments in a string, respecting enclosures
-         * 
-         * @param {string} pString 
-         * @param {string} pSeparator 
-         * @param {object} pEnclosureStartSymbolMap 
-         * @param {object} pEnclosureEndSymbolMap 
-         * @returns the count of segments in the string as a number
+         *
+         * @param {string} pString
+         * @param {string} [pSeparator]
+         * @param {Record<string, number>} [pEnclosureStartSymbolMap]
+         * @param {Record<string, number>} [pEnclosureEndSymbolMap]
+         *
+         * @return {number} - The number of segments in the string
          */
         stringCountSegments: (pString, pSeparator, pEnclosureStartSymbolMap, pEnclosureEndSymbolMap) => {
           let tmpString = typeof pString == 'string' ? pString : '';
           let tmpSeparator = typeof pSeparator == 'string' ? pSeparator : '.';
-          let tmpEnclosureStartSymbolMap = typeof pEnclosureStartSymbolMap == 'object' ? pEnclosureStart : {
-            '{': 0,
-            '[': 1,
-            '(': 2
-          };
-          let tmpEnclosureEndSymbolMap = typeof pEnclosureEndSymbolMap == 'object' ? pEnclosureEnd : {
-            '}': 0,
-            ']': 1,
-            ')': 2
-          };
+          let tmpEnclosureStartSymbolMap = typeof pEnclosureStartSymbolMap == 'object' ? pEnclosureStartSymbolMap : DEFAULT_START_SYMBOL_MAP;
+          let tmpEnclosureEndSymbolMap = typeof pEnclosureEndSymbolMap == 'object' ? pEnclosureEndSymbolMap : DEFAULT_END_SYMBOL_MAP;
           if (pString.length < 1) {
             return 0;
           }
@@ -1468,28 +1555,21 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
         },
         /**
          * Get the first segment in a string, respecting enclosures
-         * 
-         * @param {string} pString 
-         * @param {string} pSeparator 
-         * @param {object} pEnclosureStartSymbolMap 
-         * @param {object} pEnclosureEndSymbolMap 
-         * @returns the first segment in the string as a string
+         *
+         * @param {string} pString
+         * @param {string} [pSeparator]
+         * @param {Record<string, number>} [pEnclosureStartSymbolMap]
+         * @param {Record<string, number>} [pEnclosureEndSymbolMap]
+         *
+         * @return {string} - the first segment in the string as a string
          */
         stringGetFirstSegment: (pString, pSeparator, pEnclosureStartSymbolMap, pEnclosureEndSymbolMap) => {
           let tmpString = typeof pString == 'string' ? pString : '';
           let tmpSeparator = typeof pSeparator == 'string' ? pSeparator : '.';
-          let tmpEnclosureStartSymbolMap = typeof pEnclosureStartSymbolMap == 'object' ? pEnclosureStart : {
-            '{': 0,
-            '[': 1,
-            '(': 2
-          };
-          let tmpEnclosureEndSymbolMap = typeof pEnclosureEndSymbolMap == 'object' ? pEnclosureEnd : {
-            '}': 0,
-            ']': 1,
-            ')': 2
-          };
+          let tmpEnclosureStartSymbolMap = typeof pEnclosureStartSymbolMap == 'object' ? pEnclosureStartSymbolMap : DEFAULT_START_SYMBOL_MAP;
+          let tmpEnclosureEndSymbolMap = typeof pEnclosureEndSymbolMap == 'object' ? pEnclosureEndSymbolMap : DEFAULT_END_SYMBOL_MAP;
           if (pString.length < 1) {
-            return 0;
+            return '';
           }
           let tmpEnclosureStack = [];
           for (let i = 0; i < tmpString.length; i++) {
@@ -1517,26 +1597,19 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
         },
         /**
          * Get all segments in a string, respecting enclosures
-         * 
-         * @param {string} pString 
-         * @param {string} pSeparator 
-         * @param {object} pEnclosureStartSymbolMap 
-         * @param {object} pEnclosureEndSymbolMap 
-         * @returns the first segment in the string as a string
+         *
+         * @param {string} pString
+         * @param {string} [pSeparator]
+         * @param {Record<string, number>} [pEnclosureStartSymbolMap]
+         * @param {Record<string, number>} [pEnclosureEndSymbolMap]
+         *
+         * @return {Array<string>} - the segments in the string as an array of strings
          */
         stringGetSegments: (pString, pSeparator, pEnclosureStartSymbolMap, pEnclosureEndSymbolMap) => {
           let tmpString = typeof pString == 'string' ? pString : '';
           let tmpSeparator = typeof pSeparator == 'string' ? pSeparator : '.';
-          let tmpEnclosureStartSymbolMap = typeof pEnclosureStartSymbolMap == 'object' ? pEnclosureStart : {
-            '{': 0,
-            '[': 1,
-            '(': 2
-          };
-          let tmpEnclosureEndSymbolMap = typeof pEnclosureEndSymbolMap == 'object' ? pEnclosureEnd : {
-            '}': 0,
-            ']': 1,
-            ')': 2
-          };
+          let tmpEnclosureStartSymbolMap = typeof pEnclosureStartSymbolMap == 'object' ? pEnclosureStartSymbolMap : DEFAULT_START_SYMBOL_MAP;
+          let tmpEnclosureEndSymbolMap = typeof pEnclosureEndSymbolMap == 'object' ? pEnclosureEndSymbolMap : DEFAULT_END_SYMBOL_MAP;
           let tmpCurrentSegmentStart = 0;
           let tmpSegmentList = [];
           if (pString.length < 1) {
@@ -1576,8 +1649,8 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
          * If no start or end characters are specified, it will default to parentheses.  If the string is not a string, it will return 0.
          *
          * @param {string} pString
-         * @param {string} pEnclosureStart
-         * @param {string} pEnclosureEnd
+         * @param {string} [pEnclosureStart]
+         * @param {string} [pEnclosureEnd]
          * @returns the count of full in the string
          */
         stringCountEnclosures: (pString, pEnclosureStart, pEnclosureEnd) => {
@@ -1606,9 +1679,10 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
          *
          * @param {string} pString
          * @param {number} pEnclosureIndexToGet
-         * @param {string} pEnclosureStart
-         * @param {string}} pEnclosureEnd
-         * @returns {string}
+         * @param {string} [pEnclosureStart]
+         * @param {string} [pEnclosureEnd]
+         *
+         * @return {string} - The value of the enclosure at the specified index
          */
         stringGetEnclosureValueByIndex: (pString, pEnclosureIndexToGet, pEnclosureStart, pEnclosureEnd) => {
           let tmpString = typeof pString == 'string' ? pString : '';
@@ -1684,6 +1758,10 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
       * @class ManyfestObjectAddressSetValue
       */
       class ManyfestObjectAddressSetValue {
+        /**
+         * @param {function} [pInfoLog] - (optional) A logging function for info messages
+         * @param {function} [pErrorLog] - (optional) A logging function for error messages
+         */
         constructor(pInfoLog, pErrorLog) {
           // Wire in logging
           this.logInfo = typeof pInfoLog == 'function' ? pInfoLog : libSimpleLog;
@@ -1691,7 +1769,15 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
           this.cleanWrapCharacters = fCleanWrapCharacters;
         }
 
-        // Set the value of an element at an address
+        /**
+         * Set the value of an element at an address
+         *
+         * @param {object} pObject - The object to set the value in
+         * @param {string} pAddress - The address to set the value at
+         * @param {any} pValue - The value to set at the address
+         *
+         * @return {boolean} True if the value was set, false otherwise
+         */
         setValueAtAddress(pObject, pAddress, pValue) {
           // Make sure pObject is an object
           if (typeof pObject != 'object') return false;
@@ -1910,21 +1996,33 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
       * @class ManyfestObjectAddressGeneration
       */
       class ManyfestObjectAddressGeneration {
+        /**
+         * @param {function} [pInfoLog] - (optional) A logging function for info messages
+         * @param {function} [pErrorLog] - (optional) A logging function for error messages
+         */
         constructor(pInfoLog, pErrorLog) {
           // Wire in logging
           this.logInfo = typeof pInfoLog == 'function' ? pInfoLog : libSimpleLog;
           this.logError = typeof pErrorLog == 'function' ? pErrorLog : libSimpleLog;
         }
 
-        // generateAddressses
-        //
-        // This flattens an object into a set of key:value pairs for *EVERY SINGLE
-        // POSSIBLE ADDRESS* in the object.  It can get ... really insane really
-        // quickly.  This is not meant to be used directly to generate schemas, but
-        // instead as a starting point for scripts or UIs.
-        //
-        // This will return a mega set of key:value pairs with all possible schema
-        // permutations and default values (when not an object) and everything else.
+        /**
+         * generateAddressses
+         *
+         * This flattens an object into a set of key:value pairs for *EVERY SINGLE
+         * POSSIBLE ADDRESS* in the object.  It can get ... really insane really
+         * quickly.  This is not meant to be used directly to generate schemas, but
+         * instead as a starting point for scripts or UIs.
+         *
+         * This will return a mega set of key:value pairs with all possible schema
+         * permutations and default values (when not an object) and everything else.
+         *
+         * @param {any} pObject - The object to generate addresses for
+         * @param {string} [pBaseAddress] - (optional) The base address to start from
+         * @param {object} [pSchema] - (optional) The schema object to append to
+         *
+         * @return {object} The generated schema object
+         */
         generateAddressses(pObject, pBaseAddress, pSchema) {
           let tmpBaseAddress = typeof pBaseAddress == 'string' ? pBaseAddress : '';
           let tmpSchema = typeof pSchema == 'object' ? pSchema : {};
@@ -1937,7 +2035,7 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
             InSchema: false
           };
           if (tmpObjectType == 'object' && pObject == null) {
-            tmpObjectType = 'null';
+            tmpObjectType = 'undefined';
           }
           switch (tmpObjectType) {
             case 'string':
@@ -1952,7 +2050,6 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
               tmpSchema[tmpBaseAddress] = tmpSchemaObjectEntry;
               break;
             case 'undefined':
-            case 'null':
               tmpSchemaObjectEntry.DataType = 'Any';
               tmpSchemaObjectEntry.Default = pObject;
               tmpSchema[tmpBaseAddress] = tmpSchemaObjectEntry;
@@ -2137,30 +2234,41 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
       * @class ManyfestSchemaManipulation
       */
       class ManyfestSchemaManipulation {
+        /**
+         * @param {function} [pInfoLog] - (optional) A logging function for info messages
+         * @param {function} [pErrorLog] - (optional) A logging function for error messages
+         */
         constructor(pInfoLog, pErrorLog) {
           // Wire in logging
           this.logInfo = typeof pInfoLog === 'function' ? pInfoLog : libSimpleLog;
           this.logError = typeof pErrorLog === 'function' ? pErrorLog : libSimpleLog;
         }
 
-        // This translates the default address mappings to something different.
-        //
-        // For instance you can pass in manyfest schema descriptor object:
-        // 	{
-        //	  "Address.Of.a": { "Hash": "a", "Type": "Number" },
-        //	  "Address.Of.b": { "Hash": "b", "Type": "Number" }
-        //  }
-        //
-        //
-        // And then an address mapping (basically a Hash->Address map)
-        //  {
-        //    "a": "New.Address.Of.a",
-        //    "b": "New.Address.Of.b"
-        //  }
-        //
-        // NOTE: This mutates the schema object permanently, altering the base hash.
-        //       If there is a collision with an existing address, it can lead to overwrites.
-        // TODO: Discuss what should happen on collisions.
+        /**
+            * This translates the default address mappings to something different.
+            *
+            * For instance you can pass in manyfest schema descriptor object:
+            * 	{
+         *	  "Address.Of.a": { "Hash": "a", "Type": "Number" },
+         *	  "Address.Of.b": { "Hash": "b", "Type": "Number" }
+         *  }
+            *
+            *
+            * And then an address mapping (basically a Hash->Address map)
+            *  {
+            *    "a": "New.Address.Of.a",
+            *    "b": "New.Address.Of.b"
+            *  }
+            *
+            * NOTE: This mutates the schema object permanently, altering the base hash.
+            *       If there is a collision with an existing address, it can lead to overwrites.
+            * TODO: Discuss what should happen on collisions.
+         *
+         * @param {object} pManyfestSchemaDescriptors - The manyfest schema descriptors to resolve address mappings for
+         * @param {object} pAddressMapping - The address mapping object to use for remapping
+         *
+         * @return {boolean} True if successful, false if there was an error
+         */
         resolveAddressMappings(pManyfestSchemaDescriptors, pAddressMapping) {
           if (typeof pManyfestSchemaDescriptors != 'object') {
             this.logError("Attempted to resolve address mapping but the descriptor was not an object.");
@@ -2182,8 +2290,8 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
           let tmpAddressMappingSet = Object.keys(pAddressMapping);
           tmpAddressMappingSet.forEach(pInputAddress => {
             let tmpNewDescriptorAddress = pAddressMapping[pInputAddress];
-            let tmpOldDescriptorAddress = false;
-            let tmpDescriptor = false;
+            let tmpOldDescriptorAddress = null;
+            let tmpDescriptor;
 
             // See if there is a matching descriptor either by Address directly or Hash
             if (pInputAddress in pManyfestSchemaDescriptors) {
@@ -2208,12 +2316,26 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
           });
           return true;
         }
+
+        /**
+         * @param {object} pManyfestSchemaDescriptors - The manyfest schema descriptors to resolve address mappings for
+         * @param {object} pAddressMapping - The address mapping object to use for remapping
+         *
+         * @return {object} A new object containing the remapped schema descriptors
+         */
         safeResolveAddressMappings(pManyfestSchemaDescriptors, pAddressMapping) {
           // This returns the descriptors as a new object, safely remapping without mutating the original schema Descriptors
           let tmpManyfestSchemaDescriptors = JSON.parse(JSON.stringify(pManyfestSchemaDescriptors));
           this.resolveAddressMappings(tmpManyfestSchemaDescriptors, pAddressMapping);
           return tmpManyfestSchemaDescriptors;
         }
+
+        /**
+         * @param {object} pManyfestSchemaDescriptorsDestination - The destination manyfest schema descriptors
+         * @param {object} pManyfestSchemaDescriptorsSource - The source manyfest schema descriptors
+         *
+         * @return {object} A new object containing the merged schema descriptors
+         */
         mergeAddressMappings(pManyfestSchemaDescriptorsDestination, pManyfestSchemaDescriptorsSource) {
           if (typeof pManyfestSchemaDescriptorsSource != 'object' || typeof pManyfestSchemaDescriptorsDestination != 'object') {
             this.logError("Attempted to merge two schema descriptors but both were not objects.");
@@ -2279,8 +2401,14 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
             super(pFable, pManifest, pServiceHash);
           }
 
+          /** @type {import('fable')} */
+          this.fable;
           /** @type {Record<string, any>} */
           this.options;
+          /** @type {string} */
+          this.Hash;
+          /** @type {string} */
+          this.UUID;
           this.serviceType = 'Manifest';
 
           // Wire in logging
@@ -2310,9 +2438,14 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
           if (!('strict' in this.options)) {
             this.options.strict = false;
           }
+
+          /** @type {string} */
           this.scope = undefined;
+          /** @type {Array<string>} */
           this.elementAddresses = undefined;
+          /** @type {Record<string, string>} */
           this.elementHashes = undefined;
+          /** @type {Record<string, ManifestDescriptor>} */
           this.elementDescriptors = undefined;
           this.reset();
           if (typeof this.options === 'object') {
@@ -2338,7 +2471,27 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
         clone() {
           // Make a copy of the options in-place
           let tmpNewOptions = JSON.parse(JSON.stringify(this.options));
-          let tmpNewManyfest = new Manyfest(this.getManifest(), this.logInfo, this.logError, tmpNewOptions);
+          let tmpNewManyfest = new Manyfest(this.fable, tmpNewOptions, this.Hash);
+          tmpNewManyfest.logInfo = this.logInfo;
+          tmpNewManyfest.logError = this.logError;
+          //FIXME: mostly written by co-pilot
+          const {
+            Scope,
+            Descriptors,
+            HashTranslations
+          } = this.getManifest();
+          tmpNewManyfest.scope = Scope;
+          tmpNewManyfest.elementDescriptors = Descriptors;
+          tmpNewManyfest.elementAddresses = Object.keys(Descriptors);
+          // Rebuild the element hashes
+          for (let i = 0; i < tmpNewManyfest.elementAddresses.length; i++) {
+            let tmpAddress = tmpNewManyfest.elementAddresses[i];
+            let tmpDescriptor = tmpNewManyfest.elementDescriptors[tmpAddress];
+            tmpNewManyfest.elementHashes[tmpAddress] = tmpAddress;
+            if ('Hash' in tmpDescriptor) {
+              tmpNewManyfest.elementHashes[tmpDescriptor.Hash] = tmpAddress;
+            }
+          }
 
           // Import the hash translations
           tmpNewManyfest.hashTranslations.addTranslation(this.hashTranslations.translationTable);
@@ -2346,9 +2499,15 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
         }
 
         // Deserialize a Manifest from a string
+        /**
+         * @param {string} pManifestString - The manifest string to deserialize
+         *
+         * @return {Manyfest} The deserialized manifest
+         */
         deserialize(pManifestString) {
           // TODO: Add guards for bad manifest string
-          return this.loadManifest(JSON.parse(pManifestString));
+          this.loadManifest(JSON.parse(pManifestString));
+          return this;
         }
 
         // Load a manifest from an object
@@ -2387,16 +2546,25 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
           if ('HashTranslations' in tmpManifest) {
             if (typeof tmpManifest.HashTranslations === 'object') {
               for (let i = 0; i < tmpManifest.HashTranslations.length; i++) {
-                // Each translation is 
+                // Each translation is
+                //FIXME: ?????????
               }
             }
           }
         }
 
-        // Serialize the Manifest to a string
+        /**
+         * Serialize the Manifest to a string
+         *
+         * @return {string} - The serialized manifest
+         */
         serialize() {
           return JSON.stringify(this.getManifest());
         }
+
+        /**
+         * @return {{ Scope: string, Descriptors: Record<string, ManifestDescriptor>, HashTranslations: Record<string, string> }} - A copy of the manifest state.
+         */
         getManifest() {
           return {
             Scope: this.scope,