# Source: businessRules/rules/stringParsing/wordStringParsing.js

    /**
     * @file wordStringParsing.js
     * @module wordStringParsing
     * @description Contains all system defined business rules for parsing words and lists.
     * @requires module:ruleParsing
     * @requires module:configurator
     * @requires module:loggers
     * @requires {@link https://www.npmjs.com/package/@haystacks/constants|@haystacks/constants}
     * @requires {@link https://mathjs.org/index.html|math}
     * @requires {@link https://www.npmjs.com/package/path|path}
     * @author Seth Hollingsead
     * @date 2022/04/25
     * @copyright Copyright © 2022-… by Seth Hollingsead. All rights reserved
     */

    // Internal imports
    import ruleParsing from '../ruleParsing.js';
    import configurator from '../../../executrix/configurator.js';
    import loggers from '../../../executrix/loggers.js';
    // External imports
    import hayConst from '@haystacks/constants';
    import * as math from 'mathjs';
    import path from 'path';

    const {abt, bas, biz, cfg, msg, sys, wrd} = hayConst;
    const baseFileName = path.basename(import.meta.url, path.extname(import.meta.url));
    // framework.businessRules.rules.stringParsing.wordStringParsing.
    const namespacePrefix = wrd.cframework + bas.cDot + sys.cbusinessRules + bas.cDot + wrd.crules + bas.cDot + wrd.cstring + wrd.cParsing + bas.cDot + baseFileName + bas.cDot;

    /**
     * @function isStringCamelCase
     * @description Determines if an input string is a camel case string or not.
     * @param {string} inputData The string that should be checked for the camel case qualifications.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {boolean} True or False to indicate if the string is camel case or not.
     * @author Seth Hollingsead
     * @date 2022/01/23
     * @NOTE Even if we have an all upper case acronym at the end fo the camel case string,
     * the string itself is still considered camel case.
     * Valid Examples:
     * myParsedXML
     * fireflyWonder1996
     * wonderWomand1984
     * covidMedicalCase
     * aBc
     */
    async function isStringCamelCase(inputData, inputMetaData) {
      let functionName = isStringCamelCase.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + inputData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
      let returnData = false;
      if (inputData) {
        let foundFirstCapitalLetter = false;
        // First make sure the string meets the basic qualifications of a camel case string.
        // 1. Does not contain underscore or dash word separators.
        // 2. Contains at least 1 lower case letter or more.
        // 3. Contains at least 1 upper case letter or more.
        // 4. Has a lower case or upper case first letter of the first word.
        let doesContainUpperCaseCharacter = await ruleParsing.processRulesInternal([inputData, ''], [biz.cdoesStringContainUpperCaseCharacter]);
        let doesContainLowerCaseCharacter = await ruleParsing.processRulesInternal([inputData, ''], [biz.cdoesStringContainLowerCaseCharacter]);
        let isFirstCharUpperCase = await ruleParsing.processRulesInternal([inputData, ''], [biz.cisFirstCharacterUpperCase]);
        let isFirstCharLowerCase = await ruleParsing.processRulesInternal([inputData, ''], [biz.cisFirstCharacterLowerCase]);
        if (!inputData.match(/[\s_-]/g) && doesContainUpperCaseCharacter &&
        doesContainLowerCaseCharacter && (isFirstCharUpperCase || isFirstCharLowerCase)) {
          for (let i = 1; i < inputData.length; i++) {
            // Now check or the final qualification:
            // 3. Ensure that upper case letters are separated by lower case letters
            // (numbers also allowed, but there should be at least some lower case letters)
            // NOTE: This for-loop is how we iterate over the characters of the string.

            // First we need to ok for the first upper case letter.
            if (foundFirstCapitalLetter === false) {
              if (abt.cUpperCaseEnglishAlphabet.includes(inputData.charAt(i))) {
                // Found an upper case letter, ensure the next letter is lower case.
                foundFirstCapitalLetter = true;
              }
            } else if (foundFirstCapitalLetter === true) {
              if (abt.cLowerCaseEnglishAlphabet.includes(inputData.charAt(i))) {
                returnData = true;
                break; // Sufficient evidence to prove this is a camel case string.
              }
            }
          } // End-for (let i = 1; i < inputData.length; i++)
        } // End-if (!inputData.match(/[\s_-]/g) && doesStringContainUpperCaseCharacter(inputData, '') &&...)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function mapWordToCamelCaseWord
     * @description Takes a string key and an indexed string value and maps the word to an upper case first letter word.
     * @param {string} inputData The string key/value that should be converted to a camel case word.
     * @param {string} inputMetaData The string index for the map to the value that should be used.
     * @return {string} A string where the word has been converted into a camel case word.
     * @author Seth Hollingsead
     * @date 2022/01/23
     */
    async function mapWordToCamelCaseWord(inputData, inputMetaData) {
      let functionName = mapWordToCamelCaseWord.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + inputData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
      let returnData = false;
      if (inputData) {
        returnData = inputData.replace(/^./, character => character.toUpperCase());
      }
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function simplifyAndConsolidateString
     * @description Takes a string, and returns a version of it converted to lower case,
     * with all digits and symbols and whitespace removed.
     * @param {string} inputData The string that should be simplified and consolidated.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {string} A string that has been simplified and consolidated by converting to lower case, removing all digits, symbols and white space.
     * @author Seth Hollingsead
     * @date 2022/01/23
     * @NOTE I think this function is not completely working as expected, probably something to do with that regular expression.
     * Input was: 11UpberDriver321CodeClearance0x#0000FF-akaBlue
     * Output was: upberdrivercodeclearanceffakablue
     */
    async function simplifyAndConsolidateString(inputData, inputMetaData) {
      let functionName = simplifyAndConsolidateString.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + inputData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
      let returnData = '';
      if (inputData) {
        // returnData = inputData.toLowerCase().replace(/[\W]/g, '');
        returnData = await ruleParsing.processRulesInternal([inputData.toLowerCase().trim(), [/[^\w\s]/g, '']], [biz.cutilitiesReplaceCharacterWithCharacter]);
        returnData = await ruleParsing.processRulesInternal([returnData, [/[\0-9]/g, '']], [biz.cutilitiesReplaceCharacterWithCharacter]);
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function compareSimplifiedAndConsolidatedStrings
     * @description Compares two strings by their simplified versions (see simplifyAndConsolidateString()).
     * @param {string} inputData The first string to be compared.
     * @param {string} inputMetaData The second string to be compared.
     * @return {boolean} A True or False value to indicate if the strings are virtually identical or not.
     * @author Seth Hollingsead
     * @date 2022/01/23
     */
    async function compareSimplifiedAndConsolidatedStrings(inputData, inputMetaData) {
      let functionName = compareSimplifiedAndConsolidatedStrings.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + inputData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
      let returnData = false;
      if (inputData && inputMetaData) {
        returnData = await simplifyAndConsolidateString(inputData, '') === await simplifyAndConsolidateString(inputMetaData, '');
      }
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function countCamelCaseWords
     * @description Takes a string in camelCase and returns the number of words that it contains based on camel case rules.
     * @param {string} inputData String to count words from.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {integer} The number of camel case words found in the string.
     * @author Seth Hollingsead
     * @date 2022/01/23
     * @NOTE Might not work so well with numbers as part of the string, they are not treated as capital letters.
     * We might need to do some refactoring of this function if
     * mixed numbers and camel case strings ever becomes a requirement as input to this function.
     * @NOTE Based on the implementation for the business rule/function arrayParsing.convertCamelCaseStringToArray.
     */
    async function countCamelCaseWords(inputData, inputMetaData) {
      let functionName = countCamelCaseWords.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + inputData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
      let returnData = 0;
      if (inputData) {
        let caps = [];
        for (let i = 0; i < inputData.length; i++) {
          await loggers.consoleLog(namespacePrefix + functionName, msg.ccharacterIs + inputData.charAt(i));
          if (abt.cUpperCaseEnglishAlphabet.includes(inputData.charAt(i))) {
            // Upper case letter found.
            await loggers.consoleLog(namespacePrefix + functionName, msg.cupperCaseLetterFound);
            caps.push(i);
          }
        } // End-for (let i = 1; i < inputData.length; i++)
        returnData = caps.length;
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function doesStringContainAcronym
     * @description Scans a string and determines if there are 2 or more immediately adjacent upper-case characters in the string.
     * Example: nodeJS where JS is an acronym for JavaScript.
     * @param {string} inputData The string that should be scanned to determine if it contains an acronym or not.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {boolean} True or False to indicate if the input string contains an acronym.
     * @author Seth Hollingsead
     * @date 2022/01/23
     */
    async function doesStringContainAcronym(inputData, inputMetaData) {
      let functionName = doesStringContainAcronym.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + inputData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
      let returnData = false;
      let lastCharacterWasUpperCase = false;
      if (inputData) {
        for (let i = 1; i < inputData.length; i++) {
          // if the last character was upper case and the current character is upper case,
          // then we have found an acronym and we can exit the loop.
          if (lastCharacterWasUpperCase === true && abt.cUpperCaseEnglishAlphabet.includes(inputData.charAt(i))) {
            returnData = true;
            break;
          }
          if (abt.cUpperCaseEnglishAlphabet.includes(inputData.charAt(i))) {
            lastCharacterWasUpperCase = true;
          } else {
            lastCharacterWasUpperCase = false;
          }
        } // End-for (let i = 1; i < inputData.length; i++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function determineWordDelimiter
     * @description Determines what delimiter should e used to break a string up into words if possible.
     * @param {string} inputData The string that should be examined to determine what delimiter should be used to break it up into words.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {string} The delimiter that should be used, or if camelCase then the function will return the string "CamelCase".
     * @author Seth Hollingsead
     * @date 2022/01/23
     */
    async function determineWordDelimiter(inputData, inputMetaData) {
      let functionName = determineWordDelimiter.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + inputData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
      let returnData = '';
      if (inputData) {
        let camelCaseWordCount = await countCamelCaseWords(inputData, '');
        await loggers.consoleLog(namespacePrefix + functionName, msg.ccamelCaseWordCountIs + camelCaseWordCount);
        let containsAcronym = await doesStringContainAcronym(inputData, '');
        await loggers.consoleLog(namespacePrefix + functionName, msg.ccontainsAcronymIs + containsAcronym);
        let spacesCount = await countDelimiterInString(inputData, bas.cSpace);
        await loggers.consoleLog(namespacePrefix + functionName, msg.cspacesCountIs + spacesCount);
        let periodCount = await countDelimiterInString(inputData, bas.cDot);
        await loggers.consoleLog(namespacePrefix + functionName, msg.cperiodCountIs + periodCount);
        let dashCount = await countDelimiterInString(inputData, bas.cDash);
        await loggers.consoleLog(namespacePrefix + functionName, msg.cdashCountIs + dashCount);
        let comaCount = await countDelimiterInString(inputData, bas.cComa);
        await loggers.consoleLog(namespacePrefix + functionName, msg.ccomaCountIs + comaCount);
        let underscoreCount = await countDelimiterInString(inputData, bas.cUnderscore);
        await loggers.consoleLog(namespacePrefix + functionName, msg.cunderscoreCountIs + underscoreCount);
        let plusCount = await countDelimiterInString(inputData, bas.cPlus);
        await loggers.consoleLog(namespacePrefix + functionName, msg.cplusCountIs + plusCount);
        let percentCount = await countDelimiterInString(inputData, bas.cPercent);
        await loggers.consoleLog(namespacePrefix + functionName, msg.cpercentCountIs + percentCount);
        if (
        camelCaseWordCount > 0 &&
        containsAcronym === false &&
        spacesCount === 0 &&
        periodCount === 0 &&
        dashCount === 0 &&
        comaCount === 0 &&
        underscoreCount === 0 &&
        plusCount === 0 &&
        percentCount === 0) {
          returnData = sys.cCamelCase;
          // We haven't hit the case eyt where we need to differentiate between all these extra cases, and there are several of them.
          // We could have multiple acronyms in a word, or in multiple words that are camelCase.
          // Each of these could be really complex special cases.
          // If we get to that point we will handle those cases on a case by case basis to improve the algorithm.
        } else if (spacesCount > 0 && periodCount === 0 && dashCount === 0 && comaCount === 0 && underscoreCount === 0 && plusCount === 0 && percentCount === 0) {
          returnData = bas.cSpace;
        } else if (spacesCount === 0 && periodCount > 0 && dashCount === 0 && comaCount === 0 && underscoreCount === 0 && plusCount === 0 && percentCount === 0) {
          returnData = bas.cDot;
        } else if (spacesCount === 0 && periodCount === 0 && dashCount > 0 && comaCount === 0 && underscoreCount === 0 && plusCount === 0 && percentCount === 0) {
          returnData = bas.cDash;
        } else if (spacesCount === 0 && periodCount === 0 && dashCount === 0 && comaCount > 0 && underscoreCount === 0 && plusCount === 0 && percentCount === 0) {
          returnData = bas.cComa;
        } else if (spacesCount === 0 && periodCount === 0 && dashCount === 0 && comaCount === 0 && underscoreCount > 0 && plusCount === 0 && percentCount === 0) {
          returnData = bas.cUnderscore;
        } else if (spacesCount === 0 && periodCount === 0 && dashCount === 0 && comaCount === 0 && underscoreCount === 0 && plusCount > 0 && percentCount === 0) {
          returnData = bas.cPlus;
        } else if (spacesCount === 0 && periodCount === 0 && dashCount === 0 && comaCount === 0 && underscoreCount === 0 && plusCount === 0 && percentCount > 0) {
          returnData = bas.cPercent;
        } else {
          if (spacesCount > periodCount && spacesCount > dashCount && spacesCount > comaCount && spacesCount > underscoreCount && spacesCount > plusCount && spacesCount > percentCount) {
            returnData = bas.cSpace;
          } else if (periodCount > spacesCount && periodCount > dashCount && periodCount > comaCount && periodCount > underscoreCount && periodCount > plusCount && periodCount > percentCount) {
            returnData = bas.cDot;
          } else if (dashCount > spacesCount && dashCount > periodCount && dashCount > comaCount && dashCount > underscoreCount && dashCount > plusCount && dashCount > percentCount) {
            returnData = bas.cDash;
          } else if (comaCount > spacesCount && comaCount > periodCount && comaCount > dashCount && comaCount > underscoreCount && comaCount > plusCount && comaCount > percentCount) {
            returnData = bas.cComa;
          } else if (underscoreCount > spacesCount && underscoreCount > periodCount && underscoreCount > dashCount && underscoreCount > comaCount && underscoreCount > plusCount && underscoreCount > percentCount) {
            returnData = bas.cUnderscore;
          } else if (plusCount > spacesCount && plusCount > periodCount && plusCount > dashCount && plusCount > comaCount && plusCount > underscoreCount && plusCount > percentCount) {
            returnData = bas.cPlus;
          } else if (percentCount > spacesCount && percentCount > periodCount && percentCount > dashCount && percentCount > comaCount && percentCount > underscoreCount && percentCount > plusCount) {
            returnData = bas.cPercent;
          } else {
            // We don't need to be showing this warning unless we are debugging.
            // WARNING: Mixed string. Cannot determine what delimiter should be used to break up the string into words.
            await loggers.consoleLog(namespacePrefix + functionName, msg.cDetermineWordDelimiterMessage1 + msg.cDetermineWordDelimiterMessage2 +
              msg.cDetermineWordDelimiterMessage3 + msg.cDetermineWordDelimiterMessage4);
          }
        }
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function countDelimiterInString
     * @description Takes a string and returns the number of specified delimiters it contains.
     * @param {string} inputData String to count delimiters from.
     * @param {string} inputMetaData The delimiter that should be used when counting from the input string.
     * @return {integer} The number of delimiters found in the string.
     * @author Seth Hollingsead
     * @date 2022/01/23
     * @NOTE: https://stackoverflow.com/questions/35849174/count-spaces-in-a-string
     */
    async function countDelimiterInString(inputData, inputMetaData) {
      let functionName = countDelimiterInString.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + inputData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
      let returnData = 0;
      if (inputData && inputMetaData) {
        returnData = (inputData.split(inputMetaData).length - 1);
      }
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function getWordCountInString
     * @description Gets the number of words in a string, it expects words to be
     * delimited by either camel-case, spaces, period, dash, underscore, plus or percent symbols.
     * @param {string} inputData The string that words should be counted from.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {integer} The number of words that were found in the string.
     * @author Seth Hollingsead
     * @date 2022/01/23
     */
    async function getWordCountInString(inputData, inputMetaData) {
      let functionName = getWordCountInString.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + inputData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
      let returnData = 0;
      if (inputData) {
        let wordDelimiter = await determineWordDelimiter(inputData, inputMetaData);
        if (wordDelimiter === sys.cCamelCase) {
          returnData = await countCamelCaseWords(inputData, '');
        } else if (wordDelimiter !== '') {
          returnData = inputData.split(wordDelimiter).length;
        } else {
          // We don't need to be showing this warning unless we are debugging.
          // WARNING: Mixed string. Cannot determine how words are delimited in the string. Unable to count words.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cGetWordCountInStringMessage1 + msg.cGetWordCountInStringMessage2 + msg.cGetWordCountInStringMessage3);
        }
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function isStringList
     * @description Determines if the input string is a list or not.
     * @param {string} inputData The string that should be checked if it is a list or not.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {boolean} True or False to indicate if the input string is a list or not a list.
     * Using the list of system defined primary, secondary or tertiary command delimiters.
     * @author Seth Hollingsead
     * @date 2022/01/23
     */
    async function isStringList(inputData, inputMetaData) {
      let functionName = isStringList.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      console.log(msg.cinputDataIs + inputData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + inputData);
      console.log(msg.cinputMetaDataIs + inputMetaData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
      let returnData = false;
      if (inputData) {
        let primaryCommandDelimiter = await configurator.getConfigurationSetting(wrd.csystem, cfg.cprimaryCommandDelimiter);
        let secondaryCommandDelimiter = await configurator.getConfigurationSetting(wrd.csystem, cfg.csecondaryCommandDelimiter);
        let tertiaryCommandDelimiter = await configurator.getConfigurationSetting(wrd.csystem, cfg.ctertiaryCommandDelimiter);
        if (inputData.includes(primaryCommandDelimiter) === true ||
        inputData.includes(secondaryCommandDelimiter) === true ||
        inputData.includes(tertiaryCommandDelimiter) === true) {
          returnData = true;
        }
      } // End-if (inputData)
      console.log(msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function aggregateNumericalDifferenceBetweenTwoStrings
     * @description Determines the delta difference between the two input strings and returns it as a number.
     * @param {string} inputData String 1 to compare.
     * @param {string} inputMetaData String 2 to compare.
     * @return {integer} The delta difference between the two strings, expressed as a number.
     * @author Seth Hollingsead
     * @date 2022/01/23
     */
    async function aggregateNumericalDifferenceBetweenTwoStrings(inputData, inputMetaData) {
      let functionName = aggregateNumericalDifferenceBetweenTwoStrings.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + inputData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
      let returnData = -1;
      if (inputData && inputMetaData) {
        // Convert the input strings to lower case and clean them up for parsing.
        let string1 = inputData.toLowerCase().replace(/\W/g, '');
        let string2 = inputMetaData.toLowerCase().replace(/\W/g, '');
        await loggers.consoleLog(namespacePrefix + functionName, msg.cstring1Is + string1);
        await loggers.consoleLog(namespacePrefix + functionName, msg.cstring2Is + string2);

        // Build some arrays of variations on string 2, we will use these for doing the comparisons.
        let variation0 = Array(string2.length + 1).fill(0).map((v, i) => i);
        let variation1 = Array(string2.length + 1).fill(0);
        await loggers.consoleLog(namespacePrefix + functionName, msg.cvariation0ValueIs + variation0);
        await loggers.consoleLog(namespacePrefix + functionName, msg.cvariation1ValueIs + variation1);

        for (let i = 0; i < string1.length; i++) {
          await loggers.consoleLog(namespacePrefix + functionName, msg.ciValueIs + i);
          variation1[0] = i + 1;
          await loggers.consoleLog(namespacePrefix + functionName, msg.cvariation0ValueIs + variation0);
          for (let j = 0; j < string2.length; j++) {
            await loggers.consoleLog(namespacePrefix + functionName, msg.cjValueIs + j);
            let deletionCost = variation0[j + 1] + 1;
            let insertionCost = variation1[j] + 1;
            let substitutionCost;
            if (string1[i] === string2[j]) {
              substitutionCost = variation0[j];
            } else {
              substitutionCost = variation0[j] + 1;
            }
            await loggers.consoleLog(namespacePrefix + functionName, msg.cdeletionCostIs + deletionCost);
            await loggers.consoleLog(namespacePrefix + functionName, msg.cinsertionCostIs + insertionCost);
            await loggers.consoleLog(namespacePrefix + functionName, msg.csubstitutionCostIs + substitutionCost);
            variation1[j + 1] = math.min(deletionCost, insertionCost, substitutionCost);
            await loggers.consoleLog(namespacePrefix + functionName, msg.cvariation1ValueIs + variation1);
          } // End-for (let j = 0; j < string2.length; j++)
          let temp = variation1;
          variation1 = variation0;
          variation0 = temp;
        } // End-for (let i = 0; i < string1.length; i++)
        returnData = variation0[string2.length];
      } // End-if (inputData && inputMetaData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    export default {
      isStringCamelCase,
      mapWordToCamelCaseWord,
      simplifyAndConsolidateString,
      compareSimplifiedAndConsolidatedStrings,
      countCamelCaseWords,
      doesStringContainAcronym,
      determineWordDelimiter,
      countDelimiterInString,
      getWordCountInString,
      isStringList,
      aggregateNumericalDifferenceBetweenTwoStrings
    };