# Source: businessRules/rules/stringGeneration.js

    /**
     * @file stringGeneration.js
     * @module stringGeneration
     * @description Contains all business rules for randomly generating strings of all kinds.
     * @requires module:ruleParsing
     * @requires module:loggers
     * @requires {@link https://www.npmjs.com/package/@haystacks/constants|@haystacks/constants}
     * @requires {@link https://www.npmjs.com/package/path|path}
     * @author Seth Hollingsead
     * @date 2022/01/25
     * @copyright Copyright © 2022-… by Seth Hollingsead. All rights reserved
     */

    // Internal imports
    import ruleParsing from './ruleParsing.js';
    import loggers from '../../executrix/loggers.js';
    // External imports
    import hayConst from '@haystacks/constants';
    import path from 'path';

    const {bas, biz, gen, msg, num, sys, wrd} = hayConst;
    const baseFileName = path.basename(import.meta.url, path.extname(import.meta.url));
    // framework.businessRules.rules.stringGeneration.
    const namespacePrefix = wrd.cframework + bas.cDot + sys.cbusinessRules + bas.cDot + wrd.crules + bas.cDot + baseFileName + bas.cDot;

    /**
     * @function generateRandomMixedCaseTextByLength
     * @description Parse the input string, and determine how many mixed case
     * english alphabetic characters should be generated,
     * generate them and string them together.
     * @param {string} inputData The string that contains a number or how many
     * randomly generated mixed case alphabetic characters should be generated.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {string} A string of randomly generated mixed case letters where the
     * length of the string is defined by the input parameter.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomMixedCaseTextByLength(inputData, inputMetaData) {
      let functionName = generateRandomMixedCaseTextByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal([inputData, inputMetaData], [biz.crandomlyGenerateMixedCaseAlphabeticCharacter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomUpperCaseTextByLength
     * @description Parse the input string, and determine how many upper case
     * english alphabetic characters should be generated, generate them and string them together.
     * @param {string} inputData The string that contains a number for how many randomly
     * generated upper case english alphabetic characters should be generated.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {string} A string of randomly generated upper case letters where the
     * length of the string is defined by the input parameter.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomUpperCaseTextByLength(inputData, inputMetaData) {
      let functionName = generateRandomUpperCaseTextByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal([inputData, inputMetaData], [biz.crandomlyGenerateUpperCaseLetter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomLowerCaseTextByLength
     * @description Parse the input string, and determine how many lower case
     * english alphabetic characters should be generated, generate them and string them together.
     * @param {string} inputData The string that contains a number for how many randomly
     * generated lower case english alphabetic characters that should be generated.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {string} A string of randomly generated lower case letters where the
     * length of the string is defined by the input parameter.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomLowerCaseTextByLength(inputData, inputMetaData) {
      let functionName = generateRandomLowerCaseTextByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal([inputData, inputMetaData], [biz.crandomlyGenerateLowerCaseLetter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomMixedCaseTextWithSpecialCharactersByLength
     * @description Generate teh specified number of random mixed case letters and/or
     * special characters and string them together.
     * @param {string} inputData The number of randomly generated mixed case letters and/or
     * special characters to generate the output string.
     * @param {string} inputMetaData The ist of special characters that should be used during the generation process.
     * @return {string} A string of randomly generated mixed case letters and
     * special characters where the length of the string is defined by the input parameter.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomMixedCaseTextWithSpecialCharactersByLength(inputData, inputMetaData) {
      let functionName = generateRandomMixedCaseTextWithSpecialCharactersByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal([inputMetaData, ''], [biz.crandomlyGenerateMixedCaseLetterOrSpecialCharacter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomUpperCaseTextWithSpecialCharactersByLength
     * @description Generate the specified number of random upper cae letters and/or special characters and string them together.
     * @param {string} inputData The number of randomly generated upper case english letters and/or special characters to generate.
     * @param {string} inputMetaData The list of special characters that should be used during the generate process.
     * @return {string} A string of randomly generated upper case english letters and
     * special characters where the length of the string is defined by the input parameter.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomUpperCaseTextWithSpecialCharactersByLength(inputData, inputMetaData) {
      let functionName = generateRandomUpperCaseTextWithSpecialCharactersByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal([inputMetaData, ''], [biz.crandomlyGenerateUpperCaseLetterOrSpecialCharacter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomLowerCaseTextWithSpecialCharactersByLength
     * @description Generate the specified number of random lower case english letters and/or
     * special characters and string them together.
     * @param {string} inputData The number of randomly generated lower case letters and/or
     * special characters to generate.
     * @param {string} inputMetaData The list of special characters that should be
     * used during the generation process.
     * @return {string} A string of randomly generated lower case english letters and
     * special characters where the length of the string is defined by the input parameter.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomLowerCaseTextWithSpecialCharactersByLength(inputData, inputMetaData) {
      let functionName = generateRandomLowerCaseTextWithSpecialCharactersByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal([inputMetaData, ''], [biz.crandomlyGenerateLowerCaseLetterOrSpecialCharacter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomMixedCaseAlphaNumericCodeByLength
     * @description Generate the specified number of random mixed case english letters and/or
     * numeric characters and string them together.
     * @param {string} inputData The number of randomly generated mixed case letters and/or
     * numbers that should be generated.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {string} A string of randomly generated mixed case english letters and
     * numbers where the length of the string is defined by the input parameter.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomMixedCaseAlphaNumericCodeByLength(inputData, inputMetaData) {
      let functionName = generateRandomMixedCaseAlphaNumericCodeByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal(['', ''], [biz.crandomlyGenerateMixedCaseAlphaNumericCharacter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomUpperCaseAlphaNumericCodeByLength
     * @description Generate the specified number of random upper case english letters and/or
     * numeric characters and string them together.
     * @param {string} inputData The string that contains a number for how many randomly
     * generated upper case english letters and/or numbers that should be generated.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {string} A string of randomly generated upper case english letters and numbers
     * where the length of the string is defined by the input parameter.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomUpperCaseAlphaNumericCodeByLength(inputData, inputMetaData) {
      let functionName = generateRandomUpperCaseAlphaNumericCodeByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal(['', ''], [biz.crandomlyGenerateUpperCaseAlphaNumericCharacter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomLowerCaseAlphaNumericCodeByLength
     * @description Generate the specified number of random lower case english letters and/or
     * numeric characters and string them together.
     * @param {string} inputData The number of randomly generated lower case letters and/or
     * numbers that should be generated.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {string} A string of randomly generated lower case english letters and
     * numbers where the length of the string is defined by the input parameter.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomLowerCaseAlphaNumericCodeByLength(inputData, inputMetaData) {
      let functionName = generateRandomLowerCaseAlphaNumericCodeByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal(['', ''], [biz.crandomlyGenerateLowerCaseAlphaNumericCharacter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomNumericCodeByLength
     * @description Generate the specified number of random numeric characters and string them together.
     * @param {string} inputData The number of randomly generated numeric characters that should be generated.
     * @param {string} inputMetaData Not used for this business rule.
     * @return {string} A string of randomly generated numeric characters where the
     * length of the string is defined by the input parameter.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomNumericCodeByLength(inputData, inputMetaData) {
      let functionName = generateRandomNumericCodeByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal(['', ''], [biz.crandomlyGenerateNumericCharacter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength
     * @description Generate a random selection of mixed case english letters,
     * numeric characters and special characters from a list of allowable special characters,
     * should be generated; generate them and string them together to the specified length.
     * @param {string} inputData The number of randomly generated english letters,
     * numeric characters and special characters that should  be generated.
     * @param {string} inputMetaData The list of special characters that should be used during the generation process.
     * @return {string} A string of randomly generated mixed case alpha numeric characters,
     * and special characters where the length of the string is defined by the input parameter.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(inputData, inputMetaData) {
      let functionName = generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal([inputMetaData, ''], [biz.crandomlyGenerateEitherMixedCaseLetterOrNumberOrSpecialCharacter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomUpperCaseAlphaNumericCodeWithSpecialCharactersByLength
     * @description Generate a random selection of upper case english letters,
     * numeric characters and special characters from a list of allowable special characters,
     * should be generated; generate them and string them together to the specified length.
     * @param {string} inputData The number of randomly generated upper case english letters,
     * numeric characters and special characters that should be generated.
     * @param {string} inputMetaData Teh list of special characters that should be used during the generation process.
     * @return {string} A string of randomly generated upper case alpha numeric characters,
     * and special characters where the length of the string is defined as one of the input parameters.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomUpperCaseAlphaNumericCodeWithSpecialCharactersByLength(inputData, inputMetaData) {
      let functionName = generateRandomUpperCaseAlphaNumericCodeWithSpecialCharactersByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal([inputMetaData, ''], [biz.crandomlyGenerateEitherUpperCaseLetterOrNumberOrSpecialCharacter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomLowerCaseAlphaNumericCodeWithSpecialCharactersByLength
     * @description Generate a random selection of lower case english letters,
     * numeric characters and special characters from a list of allowable special characters,
     * should be generated; generate them and string them together to the specified length.
     * @param {string} inputData The number of randomly generated lower case english letters,
     * numeric characters adn special characters that should be generated.
     * @param {string} inputMetaData The list of special characters that should be used during the generation process.
     * @return {string} A string of randomly generated lower case alpha numeric characters,
     * and special characters where the length of the string is defined as one of the input parameters.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomLowerCaseAlphaNumericCodeWithSpecialCharactersByLength(inputData, inputMetaData) {
      let functionName = generateRandomLowerCaseAlphaNumericCodeWithSpecialCharactersByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal([inputMetaData, ''], [biz.crandomlyGenerateEitherLowerCaseLetterOrNumberOrSpecialCharacter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomSpecialCharacterCodeByLength
     * @description Generate a random selection of characters from the input allowable alphabet of characters,
     * generate them and string them together to the specified length.
     * @param {string} inputData The number of randomly generated special characters that should be generated.
     * @param {string} inputMetaData The ist of special characters that should be used during the generation process.
     * @return {string} A string of randomly generated characters from the list of
     * allowable special characters that are passed in where the length of the string is defined as one of the input parameters.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomSpecialCharacterCodeByLength(inputData, inputMetaData) {
      let functionName = generateRandomSpecialCharacterCodeByLength.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      if (inputData) {
        let numberOfCharactersToGenerate = parseInt(inputData);
        for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
          returnData = returnData.concat(await ruleParsing.processRulesInternal([inputMetaData, ''], [biz.crandomlyGenerateSpecialCharacter]));
        } // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
      } // End-if (inputData)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateValidEmail
     * @description Generate a valid random email address composed of a random selection of
     * mixed case english letters, numeric characters and optionally special characters
     * from an optional list of allowable special characters, should be generated;
     * generate them and string them together to the specified length.
     * @param {string} inputData The string that contains the number of characters to generate.
     * @param {array<boolean,string,string>} inputMetaData An array map with multiple input parameters.
     * inputMetaData[0] = generateSpecialCharacters - A boolean value to indicate if
     * special characters should be included when randomly generating characters for the output string.
     * inputMetaData[1] = allowableSpecialCharacters - The list of allowable special characters as a string,
     * only used if the {@code generateSpecialCharacters} boolean value is set to {@code TRUE}.
     * inputMetaData[2] = specifiedSuffixAndDomain - The specified suffix and domain to
     * use after the "@" symbol in the email being generated, example "Yahoo.com".
     * @return {string} A string of randomly generated mixed case alpha numeric characters and optionally special characters
     * where the length of the string is also defined as one of the input parameters, formatted as an email: a@b.com".
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateValidEmail(inputData, inputMetaData) {
      let functionName = generateValidEmail.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      let allowableSpecialCharacters;
      let generateSpecialCharacters;
      let specifiedSuffixAndDomain;
      if (!!inputMetaData && inputMetaData !== 'undefined' && inputMetaData !== '') {
        if (inputMetaData.length === 3) {
          generateSpecialCharacters = await ruleParsing.processRulesInternal([inputMetaData[0], ''], [biz.cstringToBoolean]);
          allowableSpecialCharacters = inputMetaData[1];
          specifiedSuffixAndDomain = inputMetaData[2];
          // NOTE: The above function stringParsingUtilities.stringToBoolean will default to False if the input is an empty or undefined string.
          // We want to flip it back to True but ony if some special characters are passed in.
          if (generateSpecialCharacters === false && allowableSpecialCharacters !== '') {
            generateSpecialCharacters = true;
          }
          returnData = await generateValidEmailWithSpecificSuffixAndDomainName(inputData, generateSpecialCharacters,
            allowableSpecialCharacters, specifiedSuffixAndDomain);
        } else if (inputMetaData.length <= 2) {
          generateSpecialCharacters = await ruleParsing.processRulesInternal([inputMetaData[0], ''], [biz.cstringToBoolean]);
          allowableSpecialCharacters = inputMetaData[1];
          // NOTE: The above function stringParsingUtilities.stringToBoolean will default to False if the input is an empty or undefined string.
          // We want to flip it back to True but only if some special characters are passed in.
          if (generateSpecialCharacters === false && allowableSpecialCharacters !== '') {
            generateSpecialCharacters = true;
          }
          returnData = await generateRandomValidEmail(inputData, generateSpecialCharacters, allowableSpecialCharacters);
        } else {
          returnData = await generateRandomValidEmail(inputData, gen.cFalse, wrd.cEmpty);
        }
      } else { // Else-clause if (!!inputMetaData && inputMetaData !== 'undefined' && inputMetaData !== '')
        returnData = await generateRandomValidEmail(inputData, gen.cFalse, wrd.cEmpty);
      } // End-else-clause if (!!inputMetaData && inputMetaData !== 'undefined' && inputMetaData !== '')
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateInvalidEmail
     * @description Generate an invalid random email address composed of a random selection of mixed case english letters,
     * numeric characters adn optionally special characters from an optional list of allowable special characters,
     * should be generated; generate them and string them together to the specified length.
     * @param {string} inputData The string that contains the number of characters to generate.
     * @param {array<boolean,string,string>} inputMetaData An array map with multiple input parameters:
     * inputMetaData[0] = generateSpecialCharacters - A boolean value to indicate if special characters should be
     * included when randomly generating characters for the output string.
     * inputMetaData[1] = allowableSpecialCharacters - The list of allowable special characters as a string,
     * only used if the {@code generateSpecialCharacters} boolean value is set to {@code TRUE}.
     * inputMetaData[2] = specifiedSuffixAndDomain - The specified suffix and domain to use
     * after the "@" symbol in the email being generated, example "Yahoo.com".
     * @return {string}A string of randomly generated mixed case alpha numeric characters and
     * optionally special characters where the length of the string is also defined as one
     * of the input parameters, formatted as an email: "a@b.com".
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateInvalidEmail(inputData, inputMetaData) {
      let functionName = generateInvalidEmail.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = '';
      let allowableSpecialCharacters;
      let generateSpecialCharacters;
      let specifiedSuffixAndDomain;
      if (!!inputMetaData && inputMetaData !== 'undefined' && inputMetaData !== '') {
        if (inputMetaData.length === 3) {
          generateSpecialCharacters = await ruleParsing.processRulesInternal([inputMetaData[0], ''], [biz.cstringToBoolean]);
          allowableSpecialCharacters = inputMetaData[1];
          specifiedSuffixAndDomain = inputMetaData[2];
          // @NOTE The above function stringParsingUtilities.stringToBoolean will default to False if the input is an empty or undefined string.
          // We want to flip it back to True but ony if some special characters are passed in.
          if (generateSpecialCharacters === false && allowableSpecialCharacters !== '') {
            generateSpecialCharacters = true;
          }
          returnData = await generateInvalidEmailWithSpecificSuffixAndDomainName(inputData, generateSpecialCharacters,
            allowableSpecialCharacters, specifiedSuffixAndDomain);
        } else if (inputMetaData.length <= 2) {
          generateSpecialCharacters = await ruleParsing.processRulesInternal([inputMetaData[0], ''], [biz.cstringToBoolean]);
          allowableSpecialCharacters = inputMetaData[1];
          // @NOTE The above function stringParsingUtilities.stringToBoolean will default to False if the input is an empty or undefined string.
          // We want to flip it back to True but ony if some special characters are passed in.
          if (generateSpecialCharacters === false && allowableSpecialCharacters !== '') {
            generateSpecialCharacters = true;
          }
          returnData = await generateRandomInvalidEmail(inputData, generateSpecialCharacters, allowableSpecialCharacters);
        } else {
          returnData = await generateRandomInvalidEmail(inputData, [gen.cFalse, wrd.cEmpty]);
        }
      } else {
        returnData = await generateRandomInvalidEmail(inputData, [gen.cFalse, wrd.cEmpty]);
      }
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateValidEmailWithSpecificSuffixAndDomainName
     * @description Generate a valid email composed of a random selection of mixed case english letters,
     * numeric characters and optionally special characters from an optional list of allowable special characters,
     * should be generated; generate them and string them together to the specified length.
     * @param {integer} numberOfCharactersToGenerate The number of characters to generate as an integer.
     * @param {boolean} generateSpecialCharacters A boolean value to indicate if special characters should be
     * included when randomly generating characters for the output string.
     * @param {string} allowableSpecialCharacters The list of allowable special characters as a string,
     * only sued if the {@code generateSpecialCharacters} boolean value is set to {@code TRUE}.
     * @param {string} specifiedSuffixAndDomain The specified suffix and domain to use after the "@" symbol in
     * the email being generated, example: "Yahoo.com".
     * @return {string} A string of randomly generated mixed case alpha numeric characters and optionally special characters
     * where the length of the string is also defined as one of the input parameters, formatted as an email: "a@b.com".
     * @NOTE The number of characters in the {@code specifiedSuffixAndDomain} input variable must not
     * exceed the {@code numberOfCharactersToGenerate + 2} or the function/rule will return an empty string.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateValidEmailWithSpecificSuffixAndDomainName(numberOfCharactersToGenerate, generateSpecialCharacters, allowableSpecialCharacters, specifiedSuffixAndDomain) {
      let functionName = generateValidEmailWithSpecificSuffixAndDomainName.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfCharactersToGenerateIs + numberOfCharactersToGenerate);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cgenerateSpecialCharactersIs + generateSpecialCharacters);
      await loggers.consoleLog(namespacePrefix + functionName, msg.callowableSpecialCharactersIs + allowableSpecialCharacters);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cspecifiedSuffixAndDomainIs + specifiedSuffixAndDomain);
      let returnData = '';
      let prefix = '';
      if ((numberOfCharactersToGenerate >= specifiedSuffixAndDomain.length + 2) && numberOfCharactersToGenerate >= 6 &&
      specifiedSuffixAndDomain.includes(bas.cDot)) {
        // @NOTE we cannot have less then 6 characters, because an e-mail address cannot be shorter than a@b.cc which is 6 characters long.
        // We know we have to use an "@" symbol, and a "." symbol, the rest of the characters ust be generated....and the "." should have already been passed in.
        // First need to figure out how many characters of each we must generate to et the desired final length.
        //
        // So lets remove the characters that we know we are already going to be reserved, the "@" symbol.
        numberOfCharactersToGenerate = numberOfCharactersToGenerate - 1;
        numberOfCharactersToGenerate = numberOfCharactersToGenerate - specifiedSuffixAndDomain.length;
        if (generateSpecialCharacters === false) {
          prefix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfCharactersToGenerate, '');
        } else {
          prefix = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(numberOfCharactersToGenerate, allowableSpecialCharacters);
        }
        returnData = prefix + bas.cAt + specifiedSuffixAndDomain;
      } else {
        returnData = '';
      }
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomValidEmail
     * @description Generate a valid email composed of a random selection of mixed case english letters,
     * numeric characters and  optional special characters from an optional list of allowable special characters,
     * should be generated; generate them and string them together to the specified length.
     * @param {integer} numberOfCharactersToGenerate Teh number of characters to generate as an integer.
     * @param {boolean} generateSpecialCharacters A boolean value to indicate if special characters should
     * be included when randomly generating characters for the output string.
     * @param {string} allowableSpecialCharacters The list of allowable special characters as a string,
     only used if the {@code generateSpecialCharacters} boolean value is set to {@code TRUE}.
     * @return {string} A string of randomly generated  mixed case alpha numeric characters adn optionally special characters
     * where the length of the string is also defined as one of the input parameters, formatted as an email "a@b.com".
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomValidEmail(numberOfCharactersToGenerate, generateSpecialCharacters, allowableSpecialCharacters) {
      let functionName = generateRandomValidEmail.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfCharactersToGenerateIs + numberOfCharactersToGenerate);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cgenerateSpecialCharactersIs + generateSpecialCharacters);
      await loggers.consoleLog(namespacePrefix + functionName, msg.callowableSpecialCharactersIs + allowableSpecialCharacters);
      let returnData = '';
      let prefix = '';
      let suffix = '';
      let domainName = '';
      let numberOfPrefixcharacters = 0;
      let numberOfSuffixCharacters = 0;
      if (numberOfCharactersToGenerate >= 6) {
        // @NOTE We cannot have less than 6, because an e-mail address cannot be shorter than a@b.cc which is 6 characters long.
        // We know we have to use an "@" symbol, and a "." symbol, the rest of the characters must be generated.
        // first need to figure out how many characters of each we must generate to get the desired file length.
        //
        // So lets remove the characters that we know are already going to be reserved, the "@" symbol and the "." symbol.
        numberOfCharactersToGenerate = numberOfCharactersToGenerate - 2;

        // Consider that the number of characters in the domain must be either 2 or 3. (according to IpV5, IpV6 is a whole other ball of wax!!)
        // So let us first figure that out, then the rest of the available characters that we must provide can be divided up between the prefix and suffix.
        if (numberOfCharactersToGenerate === 4) { // Stick with a 2-character domain name.
          if (generateSpecialCharacters === false) {
            domainName = await generateRandomMixedCaseTextByLength(num.c2, '');
          } else {
            domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c2, allowableSpecialCharacters);
          }
        } else if (numberOfCharactersToGenerate >= 5) {
          // Randomly determine if we should generate a 2-character or 3-character domain name. We can do either one,
          // but we need to decide now so we can get it done and be fair.
          // (That is generate 2-character domains roughly equal to the times we generate a 3-character domain.)
          if (await ruleParsing.processRulesInternal(['', ''], [biz.crandomlyGenerateBooleanValue]) === true) { // Stick with a 2-character domain name.
            if (generateSpecialCharacters === false) {
              domainName = await generateRandomMixedCaseTextByLength(num.c2, '');
            } else {
              domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c2, allowableSpecialCharacters);
            }
            numberOfCharactersToGenerate = numberOfCharactersToGenerate - 2;
          } else { // Do a 3-character domain name.
            if (generateSpecialCharacters === false) {
              domainName = await generateRandomMixedCaseTextByLength(num.c3, '');
            } else {
              domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c3, allowableSpecialCharacters);
            }
            numberOfCharactersToGenerate = numberOfCharactersToGenerate - 3;
          }
        } else {
          // @NOTE We should never actually get here, because the {@code numberOfCharactersToGenerate} cannot be less than 6 and 6-2 must be >=4.
          // Just generate the minimum domain and try to proceed as best as possible as a matter of completeness of the code.
          if (generateSpecialCharacters === false) {
            domainName = await generateRandomMixedCaseTextByLength(num.c2, '');
          } else {
            domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c2, allowableSpecialCharacters);
          }
          numberOfCharactersToGenerate = numberOfCharactersToGenerate - 2;
        }

        // Remaining number of characters that we must provide to the e-mail must be divided by 2, or the prefix and suffix.
        if (numberOfCharactersToGenerate % 2 === 0) {
          // We have a number that is divisible by 2, so just divide it and that will be the number of characters we use for both the prefix and suffix.
          numberOfPrefixcharacters = numberOfCharactersToGenerate / 2;
          numberOfSuffixCharacters = numberOfPrefixcharacters;
        } else if (numberOfCharactersToGenerate % 2 === 1) {
          numberOfPrefixcharacters = numberOfCharactersToGenerate / 2;
          numberOfSuffixCharacters = numberOfPrefixcharacters - 1;
        } else { // Should also never get here, as all numbers are either divisible by 2 or not with a remainder of 1.
          // Just do something to see if we can survive, again as a matter of completeness of code logic.
          numberOfPrefixcharacters = numberOfCharactersToGenerate / 2;
          numberOfSuffixCharacters = numberOfPrefixcharacters;
        }

        if (generateSpecialCharacters === false) {
          prefix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfPrefixcharacters, '');
          suffix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfSuffixCharacters, '');
        } else {
          prefix = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(numberOfPrefixcharacters, allowableSpecialCharacters);
          suffix = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(numberOfSuffixCharacters, allowableSpecialCharacters);
        }
        returnData = prefix + bas.cAt + suffix + bas.cDot + domainName;
      } else {
        returnData = '';
      }
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateInvalidEmailWithSpecificSuffixAndDomainName
     * @description Generate an invalid email composed of a random selection of mixed case english letters,
     * numeric characters and optional special characters from an optional list of allowable special characters,
     * should be generated; generate them and string them together to the specified length.
     * @param {integer} numberOfCharactersToGenerate The number of characters to generate as an integer.
     * @param {boolean} generateSpecialCharacters A boolean value to indicate if special characters should be
     * included when randomly generating characters fro the output string.
     * @param {string} allowableSpecialCharacters The list of allowable special characters as a string,
     * only used if the {@code generateSpecialCharacters} boolean value is set to {@code TRUE}.
     * @param {string} specifiedSuffixAndDomain The specified suffix and domain to use
     * after the "@" symbol n the email being generated, example: "Yahoo.com".
     * @return {string} A string of randomly generated mixed case alpha numeric characters and optionally
     * special characters where the length of the string is also defined as one of the input parameters, formatted as an email "a@b.com".
     * @NOTE The number of characters in the {@code specifiedSuffixAndDomain} input variable must not
     * exceed the {@code numberOfCharactersToGenerate + 2} or the function/rule will return an empty string.
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateInvalidEmailWithSpecificSuffixAndDomainName(numberOfCharactersToGenerate, generateSpecialCharacters, allowableSpecialCharacters, specifiedSuffixAndDomain) {
      let functionName = generateInvalidEmailWithSpecificSuffixAndDomainName.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfCharactersToGenerateIs + numberOfCharactersToGenerate);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cgenerateSpecialCharactersIs + generateSpecialCharacters);
      await loggers.consoleLog(namespacePrefix + functionName, msg.callowableSpecialCharactersIs + allowableSpecialCharacters);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cspecifiedSuffixAndDomainIs + specifiedSuffixAndDomain);
      let returnData = '';
      let prefix = '';
      let numberOfPrefixCharacters = 0;
      let failureMode = -1;
      // NOTE: Cannot have a "." as part of a variable name in a {set}.
      failureMode = await ruleParsing.processRulesInternal([num.c1, [num.c3, gen.cTrue, gen.cTrue]], [biz.crandomlyGenerateNumberInRange]);
      // failureMode is:
      await loggers.consoleLog(namespacePrefix + functionName, msg.cfailureModeIs + failureMode);
      // ************************************************************
      // Failure Mode Legend:
      // ************************************************************
      // intFailureMode =
      // 1 - Without the "@" symbol
      // 2 - Without the prefix
      // 3 - Without the "@" & Prefix
      // NOTE: Take special note of the code below, and make sure you DO NOT add additional else statements to CYA for various special-use cases.
      // adding else statements to the end of existing if-else-if statements will break other logic causing many more problems that you might miss when testing.
      // The logic below is pretty much full-proof and will likely not need editing. If you need to handle additional special use cases,
      // I suggest you invent your own email generation function/rule.
      // Feel free to use this one as a reference as to how to do it, or just leverage the faker tool, which also has a way to generate fake emails.
      if (numberOfCharactersToGenerate >= 6) {
        // We cannot have less then 6, because an e-mail address cannot be shorter than a@b.cc which is 6 characters long.
        // We know we have to use an "@" symbol, and a "." symbol, the rest of the characters must be generated.
        // First we need to figure out how many characters of each we must generate to get the desired final length.
        switch (failureMode) {
          case 1: case num.c1:
            numberOfCharactersToGenerate = numberOfCharactersToGenerate - (specifiedSuffixAndDomain.length + 1);
            break;
          case 2: case num.c2:
            numberOfCharactersToGenerate = numberOfCharactersToGenerate - specifiedSuffixAndDomain.length;
            break;
          case 3: case num.c3:
            numberOfCharactersToGenerate = 0;
            break;
          default:
            numberOfCharactersToGenerate = 0;
            break;
        } // End-switch (failureMode)

        // This a pretty dumb and stupid way of doing it, but we only have 3 failure modes for this rule.
        // There are basically with and without the prefix, and we've refactored in all the other cases already above.
        numberOfPrefixCharacters = numberOfCharactersToGenerate;
        // numberOfCharactersToGenerate is:
        await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfCharactersToGenerateIs + numberOfCharactersToGenerate);

        if (numberOfPrefixCharacters > 0) {
          if (generateSpecialCharacters === false) {
            prefix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfPrefixCharacters.toString(), '');
          } else {
            prefix = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(numberOfPrefixCharacters.toString(), allowableSpecialCharacters);
          }
        } // End-if (numberOfPrefixCharacters > 0)

        // prefix is:
        await loggers.consoleLog(namespacePrefix + functionName, msg.cprefixIs + prefix);

        switch (failureMode) {
          case 1: case num.c1: // Without the @ symbol.
            await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbol);
            returnData = prefix + specifiedSuffixAndDomain;
            break;
          case 2: case num.c2: // Without the prefix.
            await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefix);
            returnData = bas.cAt + specifiedSuffixAndDomain;
            break;
          case 3: case num.c3: // Without the @ and prefix.
            await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolAndPrefix);
            returnData = specifiedSuffixAndDomain;
            break;
          default: // DEFAULT: Without the @ and prefix
            await loggers.consoleLog(namespacePrefix + functionName, msg.cDEFAULTWithoutTheAtSymbolAndPrefix);
            returnData = specifiedSuffixAndDomain;
            break;
        } // End-switch (failureMode)
      } // End-if (numberOfCharactersToGenerate >= 6)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomInvalidEmail
     * @description Generate an invalid email composed of a random selection of mixed case english letters,
     * numeric characters and optional special characters from an optional list of allowable special characters,
     * should be generated; generate them and string them together to the specified length.
     * @param {integer} numberOfCharactersToGenerate The number of characters to generate as an integer.
     * @param {boolean} generateSpecialCharacters A boolean value to indicate if special characters should be
     * included when randomly generating characters for the output string.
     * @param {string} allowableSpecialCharacters The ist of allowable special characters as a string,
     * only used if the {@code generateSpecialCharacters} boolean value is set to {@code TRUE}.
     * @return {string} A string of randomly generated mixed case alpha numeric characters and optionally special characters
     * where the length of the string is also defined as one of the input parameters, formatted as an email "a@b.com".
     * @author Seth Hollingsead
     * @date 2022/01/26
     */
    async function generateRandomInvalidEmail(numberOfCharactersToGenerate, generateSpecialCharacters, allowableSpecialCharacters) {
      let functionName = generateRandomInvalidEmail.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfCharactersToGenerateIs + numberOfCharactersToGenerate);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cgenerateSpecialCharactersIs + generateSpecialCharacters);
      await loggers.consoleLog(namespacePrefix + functionName, msg.callowableSpecialCharactersIs + allowableSpecialCharacters);
      let returnData = '';
      let prefix = '';
      let suffix = '';
      let domainName = '';
      let numberOfPrefixCharacters = 0;
      let numberOfSuffixCharacters = 0;
      let numberOfDomainNameCharacters = 0;
      let failureMode = -1;
      // NOTE Cannot have a "." as part of a variable name in a {set}.
      failureMode = await ruleParsing.processRulesInternal([num.c1, [num.c28 + gen.cTrue, gen.cTrue]], [biz.crandomlyGenerateNumberInRange]);
      failureMode = parseInt(failureMode);
      // failureMode is:
      await loggers.consoleLog(namespacePrefix + functionName, msg.cfailureModeIs + failureMode);
      // ************************************************************
      // Failure Mode Legend:
      // ************************************************************
      // intFailureMode =
      // 1 - Without the "@" symbol
      // 2 - Without the "." symbol
      // 3 - Without both the "@" & "." symbols
      // 4 - Without the domain name
      // 5 - Without the "@" & domain name
      // 6 - Without the "." & domain name
      // 7 - Without the "@", "." & domain name
      // 8 - Without the prefix
      // 9 - Without the suffix
      // 10- Without the "@" & Prefix
      // 11- Without the "." & Prefix
      // 12- Without the "@" & Suffix
      // 13- Without the "." & Suffix
      // 14- Without the "@", "." & Prefix
      // 15- Without the "@", "." & Suffix
      // 16- Without the "@", ".", Prefix, & Suffix
      // 17- Without the Prefix & domain name
      // 18- Without the Suffix & domain name
      // 19- Without the Prefix & Suffix
      // 20- Without the Prefix, Suffix & domain name
      // 21- Without the "@", Prefix & domain name
      // 22- Without the ".", Prefix & domain name
      // 23- Without the "@", Suffix & domain name
      // 24- Without the ".", Suffix & domain name
      // 25- Without the "@", Prefix, Suffix & domain name
      // 26- Without the ".", Prefix, Suffix & domain name
      // 27- Without the Prefix, Suffix & "@"
      // 28- Without the Prefix, Suffix & "."

      // NOTE: Take special note of the code below, and make sure you DO NOT add additional else statements to CYA for various special-use cases.
      // Adding else statements to the end of existing if-else-if statements will break other logic causing many more problems that you might miss when testing.
      // the logic below is pretty much full-proof and  will likely not need editing. If you need to handle additional special use cases,
      // I suggest you invent your own email generation function/rule.
      // Feel free to use this  one as a reference as to how to do it, or just leverage teh faker tool, which also has a way to generate fake emails.
      if (numberOfCharactersToGenerate >= 6) {
        // We cannot have less than 6, because an email address cannot be shorter than a@b.cc which is 6 characters long.
        // We know we have to use an "@" symbol, and a "." symbol, the rest fo the characters must be generated.
        // first need to figure out how many characters of each we must generate to get the desired final length.

        // So lets remove the characters that we know are already going to be reserved, the "@" symbol and the "." symbol, according to the failure mode.
        if (failureMode === 1 || failureMode === 2 || failureMode === 5 || failureMode === 6 ||
        failureMode === 10 || failureMode === 11 || failureMode == 12 || failureMode === 13 || failureMode >= 21 ) {
            numberOfCharactersToGenerate = numberOfCharactersToGenerate - 1;
        } else if (failureMode === 3 || failureMode === 7 || failureMode === 14 || failureMode === 15 || failureMode === 16) {
          numberOfCharactersToGenerate = numberOfCharactersToGenerate - 2;
        }
        // numberOfCharactersToGenerate is:
        await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfCharactersToGenerateIs + numberOfCharactersToGenerate);

        // Only work generating the domain name if we are not going to be building our invalid email on a missing domain name.
        if (failureMode === 1 || failureMode === 2 || failureMode === 3 || (failureMode >= 8 && failureMode <= 16) || failureMode === 19 || failureMode > 27) {
          // Consider that the number of characters in the domain must be either 2 or 3 (according to IpV5, I'm not going to even try touching IpV6!!)
          // So lets first figure that out, then the rest of the available characters that we must provide can be divided up between the prefix and suffix.
          if (numberOfCharactersToGenerate === 4) {
            // Stick with a 2-character domain name.
            if (generateSpecialCharacters === false) {
              domainName = await generateRandomMixedCaseTextByLength(num.c2, '');
            } else {
              if (!!allowableSpecialCharacters && allowableSpecialCharacters !== undefined) {
                domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c2, allowableSpecialCharacters);
              } else {
                domainName = await generateRandomMixedCaseTextByLength(num.c2, '');
              }
            }
            numberOfCharactersToGenerate = numberOfDomainNameCharacters - 2;
          } else if (numberOfCharactersToGenerate >= 5) {
            // Randomly determine if we should generate a 2-character or 3-character domain name. We can do either one,
            // but we need to decide now so we can get it done and be fair.
            // (That is generate 2-character domains roughly equal to the times we generate a 3-character domain.)
            if (await ruleParsing.processRulesInternal(['', ''], [biz.crandomlyGenerateBooleanValue]) === true) { // Stick with a 2-character domain name.
              if (generateSpecialCharacters === false) {
                domainName = await generateRandomMixedCaseTextByLength(num.c2, '');
              } else {
                if (!!allowableSpecialCharacters && allowableSpecialCharacters !== undefined) {
                  domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c2, allowableSpecialCharacters);
                } else {
                  domainName = await generateRandomMixedCaseTextByLength(num.c2, '');
                }
              }
              numberOfCharactersToGenerate = numberOfDomainNameCharacters - 2;
            } else { // Do a 3-character domain name.
              if (generateSpecialCharacters === false) {
                domainName = await generateRandomMixedCaseTextByLength(num.c3, '');
              } else {
                if (!!allowableSpecialCharacters && allowableSpecialCharacters !== undefined) {
                  domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c3, allowableSpecialCharacters);
                } else {
                  domainName = await generateRandomMixedCaseTextByLength(num.c3, '');
                }
              }
              numberOfCharactersToGenerate = numberOfDomainNameCharacters - 3
            }
          } // End-else-if (numberOfCharactersToGenerate >= 5)
        } // End-if (failureMode === 1 || failureMode === 2 || failureMode === 3 || (failureMode >= 8 && failureMode <= 16) || failureMode === 19 || failureMode > 27)
        // domainName is:
        await loggers.consoleLog(namespacePrefix + functionName, msg.cdomainNameIs + domainName);

        // ONLY do suffix and prefix if our failure modes do not exclude both.
        if (failureMode >= 1 && failureMode <= 7) {
          // Remaining number of characters that we must provide to the e-mail must be divided by 2, for the prefix and suffix.
          if (numberOfCharactersToGenerate % 2 === 0) {
            // We have a number that is divisible by 2, so just divide it and
            // that will be the number of characters we use for both the prefix and suffix.
            numberOfPrefixCharacters = numberOfCharactersToGenerate / 2;
            numberOfSuffixCharacters = numberOfPrefixCharacters;
          } else if (numberOfCharactersToGenerate % 2 === 1) {
            numberOfPrefixCharacters = numberOfCharactersToGenerate / 2;
            numberOfSuffixCharacters = numberOfPrefixCharacters - 1;
          }
        } else if (failureMode === 8 || failureMode === 10 || failureMode === 11 || failureMode === 14 || failureMode === 17 || failureMode === 21 || failureMode === 22) {
          // Excluding the Prefix
          numberOfSuffixCharacters = numberOfCharactersToGenerate; // Suffix get the remainder!
          numberOfPrefixCharacters = 0;
        } else if (failureMode === 9 || failureMode === 12 || failureMode === 13 || failureMode === 15 || failureMode === 18 || failureMode === 23 || failureMode === 24) {
          // Excluding the Suffix
          numberOfPrefixCharacters = numberOfCharactersToGenerate; // Prefix gets the remainder!
          numberOfSuffixCharacters = 0;
        }
        // numberOfPrefixCharacters is:
        await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfPrefixCharactersIs + numberOfPrefixCharacters);
        // numberOfSuffixCharacters is:
        await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfSuffixCharactersIs + numberOfSuffixCharacters);

        if (numberOfPrefixCharacters > 0) {
          if (generateSpecialCharacters === false) {
            prefix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfPrefixCharacters.toString(), '');
          } else {
            if (!!allowableSpecialCharacters && allowableSpecialCharacters !== undefined) {
              prefix = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(numberOfPrefixCharacters.toString(), allowableSpecialCharacters);
            } else {
              prefix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfPrefixCharacters.toString(), '');
            }
          }
        } // End-if (numberOfPrefixCharacters > 0)
        // prefix is:
        await loggers.consoleLog(namespacePrefix + functionName, msg.cprefixIs + prefix);

        if (numberOfSuffixCharacters > 0) {
          if (generateSpecialCharacters === false) {
            suffix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfSuffixCharacters.toString(), '');
          } else {
            if (!!allowableSpecialCharacters && allowableSpecialCharacters !== undefined) {
              suffix = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(numberOfSuffixCharacters.toString(), allowableSpecialCharacters);
            } else {
              suffix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfSuffixCharacters.toString(), '');
            }
          }
        } // End-if (numberOfSuffixCharacters > 0)
        // suffix is:
        await loggers.consoleLog(namespacePrefix + functionName, msg.csuffixIs + suffix);
      } // End-if (numberOfCharactersToGenerate >= 6)

      switch (failureMode) {
        case 1: // Without the @ symbol.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbol);
          returnData = prefix + suffix + bas.cDot + domainName;
          break;
        case 2: // Without the . symbol.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotSymbol);
          returnData = prefix + bas.cAt + suffix + domainName;
          break;
        case 3: // Without bot the @ and . symbols
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtAndDotSymbols);
          returnData = prefix + suffix + domainName;
          break;
        case 4: // Without the domain name.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDomainName);
          returnData = prefix + bas.cAt + suffix + bas.cDot;
          break;
        case 5: // Without the @ and domain name.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolAndDomainName);
          returnData = prefix + suffix + bas.cDot + domainName;
          break;
        case 6: // Without the . and domain name.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotAndDomainName);
          returnData = prefix + bas.cAt + suffix;
          break;
        case 7: // Without the @, . and domain name.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolDotAndDomainName);
          returnData = prefix + suffix;
          break;
        case 8: // Without the prefix.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefix);
          returnData = bas.cAt + suffix + bas.cDot + domainName;
          break;
        case 9: // Without the suffix.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheSuffix);
          returnData = prefix + bas.cAt + bas.cDot + domainName;
          break;
        case 10: // Without the @ and prefix.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolAndPrefix);
          returnData = suffix + bas.cDot + domainName;
          break;
        case 11: // Without the . and prefix.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotAndPrefix);
          returnData = bas.cAt + suffix + domainName;
          break;
        case 12: // Without the @ and suffix.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolAndSuffix);
          returnData = prefix + bas.cDot + domainName;
          break;
        case 13: // Without the . and suffix.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotAndSuffix);
          returnData = prefix + bas.cAt + domainName;
          break;
        case 14: // Without the @, . and prefix.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolDotAndPrefix);
          returnData = suffix + domainName;
          break;
        case 15: // Without the @, . and suffix.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolDotAndSuffix);
          returnData = prefix + domainName;
          break;
        case 16: // Without the @, ., prefix, and suffix.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolDotPrefixAndSuffix);
          returnData = domainName;
          break;
        case 17: // Without the prefix and domain name.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefixAndDomainName);
          returnData = bas.cAt + suffix + bas.cDot;
          break;
        case 18: // Without the suffix and domain name.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheSuffixAndDomainName);
          returnData = prefix + bas.cAt + bas.cDot;
          break;
        case 19: // Without the prefix and  suffix.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefixAndSuffix);
          returnData = bas.cAt + bas.cDot + domainName;
          break;
        case 20: // Without the prefix, suffix and domain name.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefixSuffixAndDomainName);
          returnData = bas.cAt + bas.cDot;
          break;
        case 21: // Without the @, prefix and  domain name.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolPrefixAndDomainName);
          returnData = suffix + bas.cDot;
          break;
        case 22: // Without the ., prefix and  domain name.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotPrefixAndDomainName);
          returnData = bas.cAt + suffix;
          break;
        case 23: // Without the @, suffix and domain name.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolSuffixAndDomainName);
          returnData = prefix + bas.cDot;
          break;
        case 24: // Without the ., suffix and domain name.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotSuffixAndDomainName);
          returnData = prefix + bas.cAt + bas.cDot;
          break;
        case 25: // Without the @, prefix, suffix and  domain name.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolPrefixSuffixAndDomainName);
          returnData = bas.cDot;
          break;
        case 26: // Without the ., prefix, suffix and  domain name.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotPrefixSuffixAndDomainName);
          returnData = bas.cAt;
          break;
        case 27: // Without the prefix, suffix and @.
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefixSuffixAndAtSymbol);
          returnData = bas.cDot + domainName;
          break;
        case 28: // Without the prefix, suffix and ..
          await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefixSuffixAndDot);
          returnData = bas.cAt + domainName;
          break;
      } // End-switch (failureMode)
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomBrightColor
     * @description Generates a random set of RGB values in the bright color spectrum range.
     * Originally I thought to generate just a bright color, but dividing the spectrum straight in half resulted in mostly drab colors.
     * So I adjusted this function to use the inputs to provide a narrow range of bright values that can be generated.
     * This makes the function nearly identical to the same function that generates random dark colors.
     * Really the only difference is the default values. So this function is refactored to call a generic random color generator business rule.
     * @param {string|integer} inputData The number in either numeric or string format that represents the minimum range that should be used to generate the random color.
     * @param {string|integer} inputMetaData The number in either numeric or string format that represents the maximum range that should be used to generate the random color.
     * @return {array<integer,integer,integer>} An array of RGB values in the bright color spectrum range.
     * @author Seth Hollingsead
     * @date 2022/01/27
     */
    async function generateRandomBrightColor(inputData, inputMetaData) {
      let functionName = generateRandomBrightColor.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = [255,255,255];
      let minimumColorRange = 127;
      let maximumColorRange = 255;
      let parsedColorRangeArray = [];
      if (inputData && inputMetaData && inputData !== '' && inputMetaData !== '') {
        // Try to parse them as numbers for the range.
        parsedColorRangeArray = await ruleParsing.processRulesInternal([inputData, inputMetaData], [biz.cparseColorRangeInputs]);
        minimumColorRange = parsedColorRangeArray[0];
        maximumColorRange = parsedColorRangeArray[1];
      } // End-if (inputData && inputMetaData && inputData !== '' && inputMetaData !== '')
      returnData = await generateRandomColor(minimumColorRange, maximumColorRange);
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomDarkColor
     * @description Generates a random set of RGB values in the dark color spectrum range.
     * Originally I thought to generate just a dark color, but dividing the spectrum straight in half resulted in mostly drab colors.
     * So I adjusted this function to use the inputs to provide a narrow range of dark values that can be generated.
     * This makes the function nearly identical to the same function that generates random bright colors.
     * Really the only difference is the default values. So this function is refactored to call a generic random color generator business rule.
     * @param {string|integer} inputData The number in either numeric or string format that represents the minimum range that should be used to generate the random color.
     * @param {string|integer} inputMetaData The number in either numeric or string format that represents the maximum range that should be used to generate the random color.
     * @return {array<integer,integer,integer>} An array of RGB values in the dark color spectrum range.
     * @author Seth Hollingsead
     * @date 2022/01/27
     */
    async function generateRandomDarkColor(inputData, inputMetaData) {
      let functionName = generateRandomDarkColor.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = [0,0,0];
      let minimumColorRange = 0;
      let maximumColorRange = 127;
      let parsedColorRangeArray = [];
      if (inputData && inputMetaData && inputData !== '' && inputMetaData !== '') {
        // Try to parse them as numbers for the range.
        parsedColorRangeArray = await ruleParsing.processRulesInternal([inputData, inputMetaData], [biz.cparseColorRangeInputs]);
        minimumColorRange = parsedColorRangeArray[0];
        maximumColorRange = parsedColorRangeArray[1];
      } // End-if (inputData && inputMetaData && inputData !== '' && inputMetaData !== '')
      returnData = await generateRandomColor(minimumColorRange, maximumColorRange);
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    /**
     * @function generateRandomColor
     * @description Generates a random set of RGB values in the given color range.
     * @param {string|integer} inputData The number in either numeric or string format that represents the minimum range that should be used to generate the random color.
     * @param {string|integer} inputMetaData The number in either numeric or string format that represents the maximum range that should be used to generate the random coor.
     * @return {array<integer,integer,integer>} An array of RGB values that will be used for a color value.
     * @author Seth Hollingsead
     * @date 2022/01/27
     */
    async function generateRandomColor(inputData, inputMetaData) {
      let functionName = generateRandomColor.name;
      await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
      let returnData = [0,0,0];
      let minimumColorRange = 0;
      let maximumColorRange = 255;
      let parsedColorRangeArray = [];
      if (inputData && inputMetaData && inputData !== '' && inputMetaData !== '') {
        // Try to parse them as numbers for the range.
        parsedColorRangeArray = await ruleParsing.processRulesInternal([inputData, inputMetaData], [biz.cparseColorRangeInputs]);
        minimumColorRange = parsedColorRangeArray[0];
        maximumColorRange = parsedColorRangeArray[1];
      } // End-if (inputData && inputMetaData && inputData !== '' && inputMetaData !== '')
      // minimumColorRange is:
      await loggers.consoleLog(namespacePrefix + functionName, msg.cminimumColorRangeIs + minimumColorRange);
      // maximumColorRange is:
      await loggers.consoleLog(namespacePrefix + functionName, msg.cmaximumColorRangeIs + maximumColorRange);
      returnData[0] = await ruleParsing.processRulesInternal([minimumColorRange.toString(), [maximumColorRange.toString(), gen.ctrue, gen.ctrue]], [biz.crandomlyGenerateNumberInRange]); // Red
      returnData[1] = await ruleParsing.processRulesInternal([minimumColorRange.toString(), [maximumColorRange.toString(), gen.ctrue, gen.ctrue]], [biz.crandomlyGenerateNumberInRange]); // Green
      returnData[2] = await ruleParsing.processRulesInternal([minimumColorRange.toString(), [maximumColorRange.toString(), gen.ctrue, gen.ctrue]], [biz.crandomlyGenerateNumberInRange]); // Blue
      await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
      await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
      return returnData;
    }

    export default {
      generateRandomMixedCaseTextByLength,
      generateRandomUpperCaseTextByLength,
      generateRandomLowerCaseTextByLength,
      generateRandomMixedCaseTextWithSpecialCharactersByLength,
      generateRandomUpperCaseTextWithSpecialCharactersByLength,
      generateRandomLowerCaseTextWithSpecialCharactersByLength,
      generateRandomMixedCaseAlphaNumericCodeByLength,
      generateRandomUpperCaseAlphaNumericCodeByLength,
      generateRandomLowerCaseAlphaNumericCodeByLength,
      generateRandomNumericCodeByLength,
      generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength,
      generateRandomUpperCaseAlphaNumericCodeWithSpecialCharactersByLength,
      generateRandomLowerCaseAlphaNumericCodeWithSpecialCharactersByLength,
      generateRandomSpecialCharacterCodeByLength,
      generateValidEmail,
      generateInvalidEmail,
      generateRandomBrightColor,
      generateRandomDarkColor,
      generateRandomColor
    };