@nualang/nualang-ui-components 0.1.1399 → 0.2.0

package/dist/hooks/useExerciseState.js

@@ -1,2039 +0,0 @@
-import { useState, useEffect } from "react";
-import { useNavigate } from "react-router";
-import distance from "jaro-winkler";
-import { shuffle, removeAllSymbols, removeAllSymbolsFillInBlanks, formatMarkdownNewlines, localeCompare, localeCompareCase, removeExtraWhiteSpaces } from "../utils/index";
-import { botErrorMessage } from "../utils/constants";
-import { convertNumberToText, getLearnLangCode } from "../utils/languageHelpers";
-import BotNualaImage from "../img/bot_nuala.svg";
-export default function useExerciseState({
-  t,
-  open,
-  handleClose,
-  exerciseName,
-  gameId,
-  phrases,
-  topicInfo = {},
-  initialVoiceSpeed,
-  remainingQuestions = [],
-  existingAnswerAttempts = [],
-  existingMessages = [],
-  existingVars,
-  exerciseStartTime,
-  handleComplete,
-  roleplayCreatedAtId,
-  handleSaveProgress,
-  handleDeleteProgress,
-  handleDeleteRoleplayProgress,
-  handleDeleteBotProgress,
-  openSnackbar,
-  courseId,
-  sectionId,
-  topicId,
-  finalTranscript,
-  interimTranscript,
-  resetTranscript,
-  stopListening,
-  handleSpeak,
-  handleStopSpeaking,
-  learnLang,
-  hiddenWordBankExercises = [],
-  hiddenImageExercises = [],
-  roleplay,
-  selectedActor,
-  bot,
-  userAttributes,
-  handleMessageBot,
-  clearAttemptAudio,
-  transcriptConfidence,
-  transcriptWords,
-  correctSound,
-  incorrectSound,
-  indicateEndStream,
-  disableShuffle,
-  textInputRef,
-  toggleMuteSound,
-  uploadAudioAttempt,
-  audioBlob,
-  attemptAudioURL,
-  clearQueue,
-  stopAudio,
-  languageInformation,
-  isLiveGame = false,
-  isCreator,
-  isKeyboardHiddenTranslation,
-  isReadWriteModeStudent = false,
-  classroomId,
-  phraseListId,
-  i18nLanguage,
-  isDynamicResponsesEnabled,
-  aiChatbotConversationHistory,
-  isWrite
-}) {
-  const navigate = useNavigate();
-  const [questions, setQuestions] = useState([]);
-  const [currentPhrase, setCurrentPhrase] = useState("");
-  const [currentTranslations, setCurrentTranslations] = useState("");
-  const [wordOptions, setWordOptions] = useState([]);
-  const [wordLibrary, setWordLibrary] = useState([]);
-  const [translationText, setTranslationText] = useState("");
-  const [translationWords, setTranslationWords] = useState([]);
-  const [isConfidenceOpen, setIsConfidenceOpen] = useState(false);
-  const handleCloseConfidence = () => setIsConfidenceOpen(false);
-  const handleOpenConfidence = () => setIsConfidenceOpen(true);
-  const [listeningText, setListeningText] = useState("");
-  const [listeningWords, setListeningWords] = useState([]);
-  const [useWordBank, setUseWordBank] = useState(isKeyboardHiddenTranslation ?? false);
-  const [isWordBankHidden, setIsWordBankHidden] = useState(false);
-  const [roleplayText, setRoleplayText] = useState("");
-  const [roleplayMessages, setRoleplayMessages] = useState(existingMessages || []);
-  const [isActorOne, setIsActorOne] = useState(selectedActor && selectedActor === 1 ? true : false);
-  const [disableSkip, setDisableSkip] = useState(false);
-  const [roleplayHasStarted, setRoleplayHasStarted] = useState(existingMessages && existingMessages.length ? true : false);
-  const [sentenceLibrary, setSentenceLibrary] = useState([]);
-  const [isMyTurn, setIsMyTurn] = useState(false);
-  const [showOptions, setShowOptions] = useState(false);
-  const [answerOptions, setAnswerOptions] = useState([]);
-  const [botText, setBotText] = useState("");
-  const [botMessages, setBotMessages] = useState(existingMessages || []);
-  const [botVars, setBotVars] = useState(existingVars || null);
-  const [muteSound, setMuteSound] = useState(false);
-  const [isSpeaking, setIsSpeaking] = useState(false);
-  const [isSpeakingTextContainer, setIsSpeakingTextContainer] = useState(null);
-  const [pollyResult, setPollyResult] = useState(null);
-  const [answerAttempt, setAnswerAttempt] = useState(null);
-  const [isCorrectResultOpen, setIsCorrectResultOpen] = useState(false);
-  const [isPartiallyCorrectResultOpen, setIsPartiallyCorrectResultOpen] = useState(false);
-  const [isIncorrectResultOpen, setIsIncorrectResultOpen] = useState(false);
-  const [answerAttempts, setAnswerAttempts] = useState(existingAnswerAttempts || []);
-  const [startTime, setStartTime] = useState(exerciseStartTime || Date.now());
-  const [isCloseModalOpen, setIsCloseModalOpen] = useState(false);
-  const [isInProgressModalOpen, setIsInProgressModalOpen] = useState(false);
-  const [isCompletionModalOpen, setIsCompletionModalOpen] = useState(false);
-  const [isTourFinished, setIsTourFinished] = useState(false);
-  const [voiceSpeed, setVoiceSpeed] = useState(initialVoiceSpeed || "");
-  const [isVoiceSpeedMenuOpen, setIsVoiceSpeedMenuOpen] = useState(null);
-  const [isReportProblemOpen, setIsReportProblemOpen] = useState(false);
-  const [transcript, setTranscript] = useState("");
-  const [checked, setChecked] = useState(false);
-  const [inAnswerOptions, setInAnswerOptions] = useState(false);
-  const [isSkipResultOpen, setIsSkipResultOpen] = useState(false);
-  const [checkAnswer, setCheckAnswer] = useState(false);
-  const [isWordBankAttemptChanged, setIsWordBankAttemptChanged] = useState(false);
-  const [isKeyboardHidden, setIsKeyboardHidden] = useState(false);
-  const [isAssignmentExercise, setIsAssignmentExercise] = useState(false);
-  const [isFirstMessage, setIsFirstMessage] = useState(true);
-  const [conversationHistory, setConversationHistory] = useState([]);
-  const [readWriteText, setReadWriteText] = useState("");
-  useEffect(() => {
-    if (isLiveGame && existingMessages && existingMessages.length > 0) {
-      setRoleplayMessages(existingMessages);
-    }
-  }, [existingMessages]);
-  const openCloseModal = () => {
-    setIsCloseModalOpen(true);
-    if (stopAudio) {
-      stopAudio();
-    }
-    if (clearQueue) {
-      clearQueue();
-    }
-  };
-  const closeCloseModal = () => {
-    setIsCloseModalOpen(false);
-  };
-  const openInProgressModal = () => {
-    setIsInProgressModalOpen(true);
-    if (stopAudio) {
-      stopAudio();
-    }
-    if (clearQueue) {
-      clearQueue();
-    }
-  };
-  const closeInProgressModal = () => {
-    setIsInProgressModalOpen(false);
-  };
-  const openCompletionModal = () => {
-    setIsCompletionModalOpen(true);
-    if (stopAudio) {
-      stopAudio();
-    }
-    if (clearQueue) {
-      clearQueue();
-    }
-  };
-  const closeCompletionModal = () => {
-    setIsCompletionModalOpen(false);
-  };
-  const [actorHasBeenSelected, setActorHasBeenSelected] = useState(selectedActor ? true : false);
-  const [playAllEnabled, setPlayAllEnabled] = useState(false);
-  const [finishedRoleplay, setFinishedRoleplay] = useState(false);
-  const [roleplayInProgress, setRoleplayInProgress] = useState(false);
-  const numberBlankOptions = 3;
-  const handleOpenVoiceSpeedMenu = event => {
-    setIsVoiceSpeedMenuOpen(event.currentTarget);
-  };
-  const handleCloseVoiceSpeedMenu = () => {
-    setIsVoiceSpeedMenuOpen(null);
-  };
-  const handleChangeVoiceSpeed = speed => {
-    setVoiceSpeed(speed);
-    handleCloseVoiceSpeedMenu();
-  };
-  const handleOpenReportProblem = () => {
-    setIsReportProblemOpen(true);
-  };
-  const handleCloseReportProblem = () => {
-    setIsReportProblemOpen(false);
-  };
-  useEffect(() => {
-    if (phrases && phrases.length) {
-      if (remainingQuestions && remainingQuestions.length) {
-        setQuestions(remainingQuestions);
-        openInProgressModal();
-      } else {
-        setStartTime(Date.now());
-        const qs = phrases.slice();
-        if (!disableShuffle) {
-          shuffle(qs);
-        }
-        setQuestions(qs);
-      }
-      if (["translation", "listening"].includes(exerciseName)) {
-        const wordSet = new Set();
-        for (const p of phrases) {
-          if (exerciseName === "translation") {
-            for (const t of p.translations) {
-              if (t) {
-                for (const w of t.trim().split(" ")) {
-                  if (w && w !== "") {
-                    wordSet.add(w);
-                  }
-                }
-              }
-            }
-          } else if (exerciseName === "listening") {
-            for (const p of phrases) {
-              for (const w of p.phrase.trim().split(" ")) {
-                if (w && w !== "") {
-                  wordSet.add(w);
-                }
-              }
-            }
-          }
-        }
-        setWordLibrary([...wordSet]);
-      }
-    }
-  }, [phrases]);
-  useEffect(() => {
-    if (open && ["roleplay", "bot"].includes(exerciseName) && existingMessages && existingMessages.length) {
-      openInProgressModal();
-      if (exerciseName === "roleplay") {
-        setRoleplayHasStarted(true);
-      }
-    }
-  }, [open, exerciseName]);
-  useEffect(() => {
-    if (open && exerciseStartTime && exerciseStartTime !== startTime) {
-      setStartTime(exerciseStartTime);
-    }
-  }, [open, exerciseStartTime]);
-  useEffect(() => {
-    if (["translation"].includes(exerciseName)) {
-      setIsKeyboardHidden(isKeyboardHiddenTranslation);
-    }
-  }, [exerciseName, isKeyboardHiddenTranslation]);
-  useEffect(() => {
-    if (["translation", "listening"].includes(exerciseName) && !hiddenWordBankExercises) {
-      setIsWordBankHidden(false);
-    } else {
-      setIsWordBankHidden(hiddenWordBankExercises.includes(exerciseName));
-    }
-  }, [exerciseName, hiddenWordBankExercises]);
-  useEffect(() => {
-    if (["translation", "listening", "pronunciation", "meaning", "meaning-listen-and-speak", "meaning-read-and-write"].includes(exerciseName)) {
-      const qs = questions;
-      if (qs && qs.length > 0) {
-        setCurrentPhrase(qs[0]);
-        setCurrentTranslations(qs[0].translations);
-      }
-    }
-  }, [exerciseName, questions]);
-  useEffect(() => {
-    if (open && currentPhrase && currentPhrase.phrase !== "" && !isCompletionModalOpen && learnLang && learnLang !== "irish" && isTourFinished && exerciseName !== "meaning" && exerciseName !== "meaning-listen-and-speak" && exerciseName !== "meaning-read-and-write") {
-      const {
-        voice,
-        voiceLanguageCode,
-        voicePitch
-      } = topicInfo;
-      speak(currentPhrase.phrase, voice, false, "#currentPhrase", voiceLanguageCode, false, voicePitch);
-    }
-  }, [currentPhrase, open, isTourFinished]);
-  useEffect(() => {
-    if (["translation"].includes(exerciseName)) {
-      if (currentTranslations && currentTranslations.length > 0) {
-        const currentTranslationArray = currentTranslations[0].split(" ");
-        const normalizeWord = word => word.replace(/[.,!¡¿?;:]/g, "").toLowerCase();
-        const normalizedToOriginalMap = new Map();
-        currentTranslationArray.forEach(word => {
-          const normalized = normalizeWord(word);
-          normalizedToOriginalMap.set(normalized, word);
-        });
-        const wordLibraryCopy = wordLibrary.filter((word, i, arr) => {
-          const prevWord = i > 0 ? arr[i - 1] : null;
-          const nextWord = i < arr.length - 1 ? arr[i + 1] : null;
-          const prevPair = prevWord ? `${prevWord}-${word}` : null;
-          const nextPair = nextWord ? `${word}-${nextWord}` : null;
-          if (prevPair && arr.includes(prevPair) || nextPair && arr.includes(nextPair)) {
-            return false;
-          }
-          const normalized = normalizeWord(word);
-          if (!normalizedToOriginalMap.has(normalized)) {
-            normalizedToOriginalMap.set(normalized, word);
-            return true;
-          }
-          return false;
-        });
-
-        // Shuffle the word library copy
-        shuffle(wordLibraryCopy);
-
-        // Create a set for unique words
-        const wordSet = new Set(normalizedToOriginalMap.keys());
-
-        // Take up to five additional words as options
-        const additionalOptions = Array.from(wordSet).slice(currentTranslationArray.length, currentTranslationArray.length + 5);
-
-        // Create the word options array using the original formatting for display
-        const wordOptions = [...currentTranslationArray, ...additionalOptions.map(normalized => normalizedToOriginalMap.get(normalized))].map((text, id) => ({
-          text,
-          id
-        }));
-        shuffle(wordOptions);
-        setWordOptions(wordOptions);
-      }
-    }
-  }, [exerciseName, currentPhrase, currentTranslations]);
-  useEffect(() => {
-    if (["listening"].includes(exerciseName)) {
-      if (wordLibrary && wordLibrary.length > 0) {
-        const currentPhraseArray = currentPhrase.phrase.split(" ");
-        const normalizeWord = word => word.replace(/[.,!¡¿?;:]/g, "").toLowerCase();
-        const normalizedToOriginalMap = new Map();
-        currentPhraseArray.forEach(word => {
-          const normalized = normalizeWord(word);
-          normalizedToOriginalMap.set(normalized, word);
-        });
-        const wordLibraryCopy = wordLibrary.filter((word, i, arr) => {
-          const prevWord = i > 0 ? arr[i - 1] : null;
-          const nextWord = i < arr.length - 1 ? arr[i + 1] : null;
-          const prevPair = prevWord ? `${prevWord}-${word}` : null;
-          const nextPair = nextWord ? `${word}-${nextWord}` : null;
-          if (prevPair && arr.includes(prevPair) || nextPair && arr.includes(nextPair)) {
-            return false;
-          }
-          const normalized = normalizeWord(word);
-          if (!normalizedToOriginalMap.has(normalized)) {
-            normalizedToOriginalMap.set(normalized, word);
-            return true;
-          }
-          return false;
-        });
-
-        // Shuffle the word library copy
-        shuffle(wordLibraryCopy);
-
-        // Create a set of normalized words to ensure uniqueness
-        const wordSet = new Set(normalizedToOriginalMap.keys());
-
-        // Take up to five additional words as options
-        const additionalOptions = Array.from(wordSet).slice(currentPhraseArray.length, currentPhraseArray.length + 5);
-
-        // Create the word options array using the original formatting for display
-        const wordOptions = [...currentPhraseArray, ...additionalOptions.map(normalized => normalizedToOriginalMap.get(normalized))].map((text, id) => ({
-          text,
-          id
-        }));
-        shuffle(wordOptions);
-        setWordOptions(wordOptions);
-      }
-    }
-  }, [exerciseName, currentPhrase]);
-
-  // Uncomment to renable auto mark translations as correct
-  // useEffect(() => {
-  //   if (open && ['translation'].includes(exerciseName)) {
-  //     if (
-  //       translationText &&
-  //       currentPhrase &&
-  //       currentPhrase.phrase &&
-  //       currentTranslations
-  //     ) {
-  //       if (checkIsTranslationCorrect(translationText, currentTranslations)) {
-  //         handleContinue();
-  //       }
-  //     }
-  //   }
-  // }, [open, exerciseName, translationText, currentPhrase, currentTranslations]);
-
-  // useEffect(() => {
-  //   if (open && ["translation"].includes(exerciseName)) {
-  //     if (translationWords && translationWords.length > 0) {
-  //       const translationValue = translationWords.map((w) => w.text).join(" ");
-  //       if (checkIsTranslationCorrect(translationValue, currentTranslations)) {
-  //         handleContinue(false);
-  //       }
-  //     }
-  //   }
-  // }, [
-  //   open,
-  //   exerciseName,
-  //   currentTranslations,
-  //   translationWords,
-  //   translationWords.length,
-  // ]);
-
-  // Uncomment to renable auto mark listening text as correct
-  // useEffect(() => {
-  //   if (open && ['listening'].includes(exerciseName)) {
-  //     if (listeningText && currentPhrase && currentPhrase.phrase) {
-  //       if (checkIsListeningCorrect(listeningText, currentPhrase)) {
-  //         handleContinue();
-  //       }
-  //     }
-  //   }
-  // }, [open, exerciseName, listeningText, currentPhrase]);
-
-  // Uncomment to renable auto mark listening words as correct
-  // useEffect(() => {
-  //   if (open && ["listening"].includes(exerciseName)) {
-  //     if (listeningWords && listeningWords.length > 0 && !isLiveGame) {
-  //       const phraseValue = listeningWords.map((w) => w.text).join(" ");
-  //       if (checkIsListeningCorrect(phraseValue, currentPhrase)) {
-  //         handleContinue(false);
-  //       }
-  //     }
-  //   }
-  // }, [
-  //   open,
-  //   exerciseName,
-  //   listeningWords,
-  //   listeningWords.length,
-  //   currentPhrase,
-  // ]);
-
-  useEffect(() => {
-    if (open && ["pronunciation", "meaning-listen-and-speak"].includes(exerciseName) && finalTranscript && currentPhrase && currentPhrase.phrase) {
-      setTimeout(() => {
-        handleOpenConfidence();
-      }, 500);
-      if (checkIsPronunciationCorrect(finalTranscript, currentPhrase)) {
-        handleContinue(false, currentPhrase);
-      }
-    }
-  }, [open, exerciseName, finalTranscript, currentPhrase]);
-  useEffect(() => {
-    if (open && ["pronunciation", "meaning-listen-and-speak"].includes(exerciseName) && interimTranscript && currentPhrase && currentPhrase.phrase) {
-      // Check if final + interim transcript is the correct answer,
-      if (checkIsPronunciationCorrect(`${finalTranscript || ""} ${interimTranscript || ""}`, currentPhrase)) {
-        // End recogniton if the answer is correct (Indicate end stream to get final results)
-        indicateEndStream();
-      }
-    }
-  }, [open, exerciseName, interimTranscript, currentPhrase]);
-  useEffect(() => {
-    if (open && ["roleplay"].includes(exerciseName) && finalTranscript && roleplay && roleplay.script) {
-      const script = roleplay.script;
-      const currentScriptLine = script[roleplayMessages.length];
-      setTimeout(() => {
-        handleOpenConfidence();
-      }, 500);
-      if (checkIsRoleplayMessageCorrect(finalTranscript, currentScriptLine.text)) {
-        checkRoleplayPronunciation(finalTranscript, currentScriptLine.text);
-      }
-    }
-  }, [open, exerciseName, finalTranscript, currentPhrase]);
-  useEffect(() => {
-    if (open && ["roleplay"].includes(exerciseName) && interimTranscript && roleplay && roleplay.script) {
-      const script = roleplay.script;
-      const currentScriptLine = script[roleplayMessages.length];
-      // Check if final + interim transcript is the correct answer,
-      if (checkIsRoleplayMessageCorrect(`${finalTranscript || ""} ${interimTranscript || ""}`, currentScriptLine.text)) {
-        // End recogniton if the answer is correct (Indicate end stream to get final results)
-        indicateEndStream();
-      }
-    }
-  }, [open, exerciseName, interimTranscript]);
-  useEffect(() => {
-    if (open && ["bot"].includes(exerciseName) && finalTranscript) {
-      setTimeout(() => {
-        handleOpenConfidence();
-        if (textInputRef && textInputRef.current) {
-          textInputRef.current.focus();
-        }
-      }, 500);
-    }
-  }, [open, exerciseName, finalTranscript]);
-  useEffect(() => {
-    if (open && ["pronunciation"].includes(exerciseName) && isConfidenceOpen) {
-      setTimeout(() => {
-        handleCloseConfidence();
-      }, 3000);
-    }
-  }, [open, exerciseName, isConfidenceOpen]);
-  useEffect(() => {
-    if (["roleplay"].includes(exerciseName) && isConfidenceOpen) {
-      setTimeout(() => {
-        handleCloseConfidence();
-      }, 3000);
-    }
-  }, [exerciseName, isConfidenceOpen]);
-  useEffect(() => {
-    if (open && roleplayHasStarted && roleplay && roleplay.script) {
-      const sentences = roleplay.script.filter(s => s.text && s.actor === (isActorOne ? 1 : 2)).map(s => s.text);
-      setSentenceLibrary(sentences);
-    }
-  }, [open, roleplayHasStarted]);
-  useEffect(() => {
-    if (open && roleplayHasStarted && roleplay && roleplay.script && (gameId?.startsWith("act-it-out") || gameId === "original")) {
-      if (roleplayMessages.length <= roleplay.script.length) {
-        const {
-          script = []
-        } = roleplay;
-        const nextScriptline = script[roleplayMessages.length - 1];
-        if (nextScriptline && nextScriptline?.question) {
-          // question time
-          const correctAnswers = nextScriptline.answers.reduce((accumulator, currentValue, currentIndex) => {
-            const attempts = answerAttempts.filter(attempt => {
-              return attempt.type === "question" && attempt.question === nextScriptline.question && attempt.attempt === currentValue.text && currentValue.correct;
-            });
-            if (attempts.length) {
-              accumulator.push(currentIndex);
-            }
-            return accumulator;
-          }, []);
-          if (correctAnswers.length) {
-            if (roleplayHasStarted) {
-              if (roleplayMessages.length === script.length) {
-                roleplayHasEnded(2000);
-              } else {
-                handleNext();
-              }
-            }
-          }
-        } else {
-          if (roleplayMessages.length === script.length && !isSpeaking) {
-            roleplayHasEnded(2000);
-          } else {
-            if (!isSpeaking) {
-              if (muteSound) {
-                // if sound is muted delay the next message to simulate speech
-                setTimeout(() => {
-                  handleNext();
-                }, 3000);
-              } else if (!inAnswerOptions) {
-                handleNext();
-              }
-            }
-          }
-        }
-      }
-    }
-  }, [open, roleplayHasStarted, roleplayMessages, isSpeaking]);
-
-  // Causes issue with bot inside course
-  // useEffect(() => {
-  //   if (open && exerciseName === 'bot' && Array.isArray(existingMessages)) {
-  //     setBotMessages(existingMessages);
-  //   }
-  //   if (open && exerciseName === 'bot' && existingVars) {
-  //     setBotVars(existingVars);
-  //   }
-  //   if (open && exerciseName === 'roleplay' && Array.isArray(existingMessages)) {
-  //     setRoleplayMessages(existingMessages);
-  //   }
-  // }, [open, existingMessages])
-
-  useEffect(() => {
-    if (open && roleplayText && roleplay && roleplay.script && roleplay.script && roleplayMessages && gameId === "original") {
-      const script = roleplay.script;
-      const scriptLine = script[roleplayMessages.length] ? script[roleplayMessages.length].text : "";
-      const formattedScriptLine = removeAllSymbols(scriptLine).trim().toString();
-      const formattedText = removeAllSymbols(roleplayText).trim().toString();
-      if (checkIsRoleplayMessageCorrect(formattedText, formattedScriptLine)) {
-        handleMakeAttempt();
-      }
-    }
-  }, [open, roleplayText, roleplay]);
-  useEffect(() => {
-    if (open && exerciseName === "bot" && botMessages && botMessages.length) {
-      handleSaveBotExerciseProgress(botMessages, botVars);
-    }
-  }, [open, exerciseName, botMessages]);
-  const stopExerciseAudio = () => {
-    if (clearQueue) {
-      clearQueue();
-    }
-    if (stopAudio) {
-      stopAudio();
-    }
-  };
-  const handleInputChange = event => {
-    const target = event.target;
-    const value = target.type === "checkbox" ? target.checked : target.value;
-    const name = event.target.name;
-    if (name === "translationText") {
-      setTranslationText(value);
-    }
-    if (name === "listeningText") {
-      setListeningText(value);
-    }
-    if (name === "isActorOne") {
-      setIsActorOne(value);
-      if (roleplayHasStarted && !gameId.startsWith("act-it-out")) {
-        handleRestartExercise();
-      }
-    }
-    if (name === "roleplayText") {
-      setRoleplayText(value);
-    }
-    if (name === "botText") {
-      setBotText(value);
-    }
-    if (name === "readWriteText") {
-      setReadWriteText(value);
-    }
-  };
-  const clearPreviousAttempt = () => {
-    setTranslationText("");
-    setTranslationWords([]);
-    setListeningText("");
-    setListeningWords([]);
-    setReadWriteText("");
-    if (!isKeyboardHidden) {
-      setUseWordBank(false);
-    }
-  };
-  const handleUseWordBank = () => {
-    setUseWordBank(true);
-    setIsWordBankHidden(false);
-  };
-  const finishedSpeaking = () => {
-    setIsSpeaking(false);
-    setIsSpeakingTextContainer(null);
-  };
-  const disableStudentLiveStorySpeak = gameId === "story" && isLiveGame && !isCreator;
-  const speak = async (text, voice = null, overrideMute = false, textContainer, languageCode, isHoverText = false, pitch, callback) => {
-    try {
-      if ((!muteSound || overrideMute) && !disableStudentLiveStorySpeak) {
-        setIsSpeaking(true);
-        setIsSpeakingTextContainer(textContainer);
-        const result = await handleSpeak({
-          text,
-          learnLanguage: learnLang,
-          voiceName: voice,
-          mute: null,
-          callback: () => {
-            finishedSpeaking();
-            if (callback) {
-              callback();
-            }
-          },
-          textContainer,
-          languageCode,
-          voiceSpeed,
-          isHoverText,
-          pitch
-        });
-        setPollyResult(result.audioUrl);
-      }
-    } catch (error) {
-      console.error(error);
-      finishedSpeaking();
-      if (callback) {
-        callback();
-      }
-    }
-  };
-  const stopSpeaking = async textContainer => {
-    try {
-      await handleStopSpeaking(textContainer);
-      finishedSpeaking();
-    } catch (error) {
-      console.error(error);
-    }
-  };
-  const handleContinue = async (isSkipped, answer) => {
-    if (exerciseName === "pronunciation" || exerciseName === "meaning-listen-and-speak") {
-      checkPronunciation(isSkipped, answer);
-    }
-    if (exerciseName === "translation") {
-      checkTranslation(isSkipped);
-    }
-    if (exerciseName === "listening") {
-      checkListening(isSkipped);
-    }
-    if (exerciseName === "meaning" || exerciseName === "meaning-read-and-write") {
-      checkMeaning(isSkipped, answer, isWrite);
-    }
-  };
-  const handleMute = () => {
-    setMuteSound(prevValue => !prevValue);
-    if (muteSound === false) {
-      finishedSpeaking();
-    }
-    stopExerciseAudio();
-    toggleMuteSound();
-  };
-  const handleReset = () => {
-    if (stopListening) {
-      stopListening();
-    }
-    if (resetTranscript) {
-      if (finalTranscript) {
-        setTranscript(finalTranscript);
-      } else if (interimTranscript) {
-        setTranscript(interimTranscript);
-      } else if (answerAttempt) {
-        setTranscript(answerAttempt.attempt);
-      }
-      resetTranscript();
-      setTimeout(() => {
-        // Check if transcript has been reset
-        if (interimTranscript || finalTranscript) {
-          resetTranscript();
-        }
-      }, 800);
-    }
-    clearPreviousAttempt();
-  };
-  const startRoleplay = () => {
-    handleNext();
-    setRoleplayHasStarted(true);
-    // setDisableSkip(true);
-    setStartTime(Date.now());
-  };
-  const checkIsMyTurn = () => {
-    const script = roleplay.script;
-    const currentScriptLine = script[roleplayMessages.length];
-    return currentScriptLine && (currentScriptLine.actor === 1 && isActorOne || currentScriptLine.actor === 2 && !isActorOne);
-  };
-  const handleNext = updatedAnswerAttempts => {
-    const script = roleplay.script;
-    const currentScriptLine = script[roleplayMessages.length];
-    if (gameId === "story") {
-      if (currentScriptLine) {
-        if (currentScriptLine?.question) {
-          setRoleplayMessages(prevState => [...prevState, currentScriptLine]);
-        } else {
-          addRoleplayMessage(currentScriptLine.text, currentScriptLine.actor === 2);
-        }
-      }
-      return;
-    }
-    if (gameId === "fill-in-the-blanks") {
-      if (currentScriptLine && currentScriptLine.text) {
-        addRoleplayMessage(currentScriptLine.text, currentScriptLine.actor === 2);
-        if (currentScriptLine.text.trim().split(" ").length <= 2 && currentScriptLine.text === script[script.length - 1].text) {
-          //no blanks in chat and last chat
-          roleplayHasEnded(2000, updatedAnswerAttempts);
-        }
-      }
-      return;
-    }
-    if (!checkIsMyTurn()) {
-      setIsMyTurn(false);
-      if (currentScriptLine?.question) {
-        setRoleplayMessages(prevState => [...prevState, currentScriptLine]);
-      } else {
-        addRoleplayMessage(currentScriptLine.text, currentScriptLine.actor === 2);
-      }
-    } else {
-      setDisableSkip(false);
-      setIsMyTurn(true);
-      let sentences;
-      if (sentenceLibrary && sentenceLibrary.length) {
-        sentences = sentenceLibrary;
-      } else {
-        sentences = roleplay.script.filter(s => s.text && s.actor === (isActorOne ? 1 : 2)).map(s => s.text);
-      }
-      shuffle(sentences);
-      const sentenceSet = new Set([currentScriptLine.text, ...sentences]);
-      const ansOptions = [...sentenceSet].slice(0, 4);
-      shuffle(ansOptions);
-      setAnswerOptions(ansOptions);
-    }
-  };
-  const getRandomFeedbackMessage = feedbackArray => {
-    const feedback = feedbackArray[Math.floor(Math.random() * feedbackArray.length)];
-    return feedback;
-  };
-  const handleMakeAttempt = (attemptText, attemptMethod) => {
-    const attempt = attemptText || roleplayText;
-    const script = roleplay.script;
-    const currentScriptLine = script[roleplayMessages.length];
-    if (currentScriptLine) {
-      const formattedText = removeAllSymbols(attempt).trim().toString();
-      const formattedScriptLine = removeAllSymbols(currentScriptLine.text).trim().toString();
-      const strDistance = stringDistance(formattedText, formattedScriptLine);
-      const method = attemptMethod || (`${finalTranscript || ""} ${interimTranscript || ""}`.trim() === attempt.trim() ? "voice" : "text");
-      handleReset();
-      let answerMessage, color;
-      if (strDistance === 1) {
-        answerMessage = "answer_message_100";
-        color = "success";
-      } else if (strDistance > 0.95) {
-        answerMessage = "answer_message_95";
-        color = "info";
-      } else if (strDistance >= 0.9) {
-        answerMessage = "answer_message_90";
-        color = "info";
-      } else {
-        answerMessage = getRandomFeedbackMessage(languageInformation.incorrectAnswerMessage) || "answer_message_wrong";
-        color = "error";
-      }
-      openSnackbar(answerMessage, color);
-      const isCorrect = checkIsRoleplayMessageCorrect(formattedText, formattedScriptLine);
-      setAnswerAttempts(prevAttempts => [...prevAttempts, {
-        type: "script",
-        attempt,
-        answer: currentScriptLine.text,
-        result: isCorrect ? "correct" : "incorrect",
-        method
-      }]);
-      if (isCorrect && isCorrect === true) {
-        handleRoleplayCorrect(getRandomFeedbackMessage(languageInformation.correctAnswerMessage));
-        addRoleplayMessage(currentScriptLine.text, currentScriptLine.actor === 2, true);
-        setRoleplayText("");
-        setDisableSkip(true);
-      }
-    }
-  };
-  const handleSelectAnswerOption = option => {
-    setInAnswerOptions(false);
-    handleMakeAttempt(option, "option");
-  };
-  const handleCorrectQuestionAnswer = (question, answer) => {
-    // question time over
-    let updatedAnswerAttempts = [];
-    let method = "";
-    if (gameId === "fill-in-the-blanks" || gameId === "story") {
-      method = "multiple_choice";
-      updatedAnswerAttempts = [...answerAttempts, {
-        type: "question",
-        question,
-        attempt: answer.text,
-        result: "correct",
-        answer: answer.correctAnswer,
-        method
-      }];
-    } else {
-      updatedAnswerAttempts = [...answerAttempts, {
-        type: "question",
-        question,
-        attempt: answer.text,
-        result: "correct",
-        answer: answer.correct,
-        method: null
-      }];
-    }
-    setAnswerAttempts(updatedAnswerAttempts);
-    handleSaveRoleplayExerciseProgress(roleplayMessages, updatedAnswerAttempts);
-    const {
-      script = []
-    } = roleplay;
-    if (roleplayHasStarted) {
-      if (roleplayMessages.length === script.length) {
-        roleplayHasEnded(2000, updatedAnswerAttempts);
-      } else {
-        handleNext(updatedAnswerAttempts);
-      }
-    }
-  };
-  const handleIncorrectQuestionAnswer = (question, answer) => {
-    let method = "";
-    let updatedAnswerAttempts = [];
-    if (gameId === "fill-in-the-blanks" || gameId === "story") {
-      method = "multiple_choice";
-      updatedAnswerAttempts = [...answerAttempts, {
-        type: "question",
-        question,
-        attempt: answer.text,
-        result: "incorrect",
-        answer: answer.correctAnswer,
-        method
-      }];
-    } else {
-      updatedAnswerAttempts = [...answerAttempts, {
-        type: "question",
-        question,
-        attempt: answer.text,
-        result: "incorrect",
-        answer: answer.correct,
-        method: null
-      }];
-    }
-    setAnswerAttempts(updatedAnswerAttempts);
-    handleSaveRoleplayExerciseProgress(roleplayMessages, updatedAnswerAttempts);
-  };
-  const stringDistance = (string1, string2) => {
-    return distance(string1, string2, {
-      caseSensitive: false
-    });
-  };
-  const handleSkip = () => {
-    setDisableSkip(true);
-    const script = roleplay.script;
-    const currentScriptLine = script[roleplayMessages.length];
-    setAnswerAttempts(prevAttempts => [...prevAttempts, {
-      type: "script",
-      attempt: roleplayText,
-      answer: currentScriptLine.text,
-      result: "skipped"
-    }]);
-    addRoleplayMessage(currentScriptLine.text, currentScriptLine.actor === 2);
-    handleReset();
-    setRoleplayText("");
-  };
-  const roleplayHasEnded = (timeout, newAnswerAttempts) => {
-    setTimeout(() => {
-      handleCompleteExercise(null, newAnswerAttempts);
-    }, timeout || 0);
-  };
-  const handleRestart = () => {
-    handleReset();
-    if (phrases && phrases.length) {
-      const qs = phrases.slice();
-      if (!disableShuffle) {
-        shuffle(qs);
-      }
-      setQuestions(qs);
-    }
-    if (exerciseName === "roleplay") {
-      if (gameId.startsWith("act-it-out")) {
-        setRoleplayHasStarted(false); // need to select actor first
-      } else if (!roleplayHasStarted) {
-        setRoleplayHasStarted(true);
-      }
-    }
-    setAnswerAttempts([]);
-    setStartTime(Date.now());
-    setRoleplayText("");
-    setRoleplayMessages([]);
-    setBotVars(null);
-    setBotText("");
-    setBotMessages([]);
-    setConversationHistory([]);
-    setIsFirstMessage(true);
-    deleteProgress();
-    setChecked(false);
-    setActorHasBeenSelected(false);
-    setInAnswerOptions(false);
-  };
-  const handlePlayAgain = () => {
-    closeCompletionModal();
-    closeInProgressModal();
-    handleReset();
-    if (phrases && phrases.length) {
-      const qs = phrases.slice();
-      shuffle(qs);
-      setQuestions(qs);
-    }
-    setRoleplayHasStarted(false);
-    setActorHasBeenSelected(false);
-    setAnswerAttempts([]);
-    setStartTime(Date.now());
-    setRoleplayText("");
-    setRoleplayMessages([]);
-    setBotVars(null);
-    setBotText("");
-    setBotMessages([]);
-    setConversationHistory([]);
-    setIsFirstMessage(true);
-    deleteProgress();
-    if (exerciseName === "roleplay" && !gameId.startsWith("act-it-out")) {
-      // if act-it-out need to select actor
-      startRoleplay();
-    }
-    setActorHasBeenSelected(false);
-    setInAnswerOptions(false);
-  };
-  const deleteProgress = () => {
-    if (courseId && sectionId && topicId) {
-      handleDeleteProgress(courseId, sectionId, topicId, `${exerciseName}${gameId && gameId !== "original" ? `-${gameId}` : ""}`);
-    } else if (exerciseName === "roleplay") {
-      handleDeleteRoleplayProgress(roleplay.roleplayId, `${exerciseName}${gameId && gameId !== "original" ? `-${gameId}` : ""}`);
-    } else if (exerciseName === "bot") {
-      handleDeleteBotProgress(bot.botId, exerciseName);
-    }
-  };
-  const handleRestartExercise = () => {
-    closeCompletionModal();
-    closeInProgressModal();
-    handleRestart();
-    stopExerciseAudio();
-  };
-  const getActorName = isA1 => {
-    return isA1 ? roleplay.actor1 && roleplay.actor1.name ? roleplay.actor1.name : t("actor", {
-      number: "1"
-    }) : roleplay.actor2 && roleplay.actor2.name ? roleplay.actor2.name : t("actor", {
-      number: "2"
-    });
-  };
-  const checkPronunciation = (isSkipped, answer) => {
-    let correctWordConfidenceScoreTotal = 0;
-    let correctWordCounter = 0;
-    let nearCorrectWordCounter = 0;
-    const isCorrect = checkIsPronunciationCorrect(finalTranscript, answer);
-    const answerArray = removeExtraWhiteSpaces(answer.phrase).split(" ");
-    (finalTranscript || interimTranscript).split(" ").forEach((word, i) => {
-      const isWordCorrect = answerArray[i] && checkIsPronunciationCorrect(word.trim(), {
-        phrase: answerArray[i].trim(),
-        alternativeVersions: currentPhrase.alternativeVersions ? currentPhrase.alternativeVersions.map(altAns => {
-          return altAns ? altAns.split(" ")[i] : "";
-        }) : []
-      });
-      if (isWordCorrect) {
-        correctWordCounter += 1;
-        const wordIndex = (transcriptWords || []).findIndex(w => w.word === word.trim());
-        if (wordIndex > -1 && transcriptWords[wordIndex].confidence) {
-          correctWordConfidenceScoreTotal += transcriptWords[wordIndex].confidence;
-        } else {
-          correctWordConfidenceScoreTotal += transcriptConfidence;
-        }
-      }
-      if (!isWordCorrect && (answerArray[i - 1] && checkIsPronunciationCorrect(word.trim(), {
-        phrase: answerArray[i - 1].trim(),
-        alternativeVersions: currentPhrase.alternativeVersions ? currentPhrase.alternativeVersions.map(altAns => {
-          return altAns ? removeExtraWhiteSpaces(altAns).split(" ")[i - 1] : "";
-        }) : []
-      }) || answerArray[i + 1] && checkIsPronunciationCorrect(word.trim(), {
-        phrase: answerArray[i + 1].trim(),
-        alternativeVersions: currentPhrase.alternativeVersions ? currentPhrase.alternativeVersions.map(altAns => {
-          return altAns ? removeExtraWhiteSpaces(altAns).split(" ")[i + 1] : "";
-        }) : []
-      }))) {
-        nearCorrectWordCounter += 1;
-      }
-    });
-    const transcriptCompleteness = correctWordCounter / answerArray.length;
-
-    // A confidence score the awards 0 to an incorrect word
-    const transcriptCorrectWordConfidence = correctWordConfidenceScoreTotal / answerArray.length;
-    const pronunciationScore = (transcriptCorrectWordConfidence + transcriptCompleteness) / 2;
-    const answerAttempt = {
-      attempt: finalTranscript ? finalTranscript : interimTranscript,
-      answer: answer.phrase,
-      alternativeAnswers: currentPhrase.alternativeVersions ? currentPhrase.alternativeVersions : [],
-      result: isSkipped ? "skipped" : isCorrect ? "correct" : correctWordCounter >= 1 ? "partially_correct" : nearCorrectWordCounter >= 1 ? "partially_correct" : "incorrect",
-      transcriptConfidence,
-      transcriptCorrectWordConfidence,
-      transcriptCompleteness,
-      transcriptWords,
-      pronunciationScore
-    };
-    if (isSkipped === true) {
-      handleExerciseSkip(answerAttempt);
-    }
-    if (isCorrect && isCorrect === true) {
-      handleCorrect(answerAttempt);
-    } else if (correctWordCounter >= 1) {
-      handlePartiallyCorrect(answerAttempt);
-    } else {
-      handleIncorrect(answerAttempt);
-    }
-  };
-  const checkIsPronunciationCorrect = (finalTranscript, answer) => {
-    const words = finalTranscript.split(" ");
-    const isSingleWord = words.length === 1;
-    let stringMatch = localeCompare(removeAllSymbols(finalTranscript).trim(), removeAllSymbols(answer.phrase).trim());
-    if (stringMatch === 0) {
-      return true;
-    } else if (answer && answer.alternativeVersions && answer.alternativeVersions.length > 0) {
-      for (let index = 0; index < answer.alternativeVersions.length; index++) {
-        const alternativeVersion = answer.alternativeVersions[index];
-        stringMatch = localeCompare(removeAllSymbols(finalTranscript), removeAllSymbols(alternativeVersion));
-        if (stringMatch === 0) {
-          return true;
-        }
-      }
-    } // If answer contains words && finaltranscript contains digits
-    else if (isSingleWord && /^\d+$/.test(finalTranscript)) {
-      const numberToText = convertNumberToText(finalTranscript, learnLang);
-      stringMatch = localeCompare(removeAllSymbols(numberToText), removeAllSymbols(answer.phrase));
-      if (stringMatch === 0) {
-        return true;
-      }
-    } else if (!isSingleWord) {
-      let newStringArray = words;
-      words.map((word, index) => {
-        if (/^\d+$/.test(word)) {
-          const numberToText = convertNumberToText(word, learnLang);
-          newStringArray[index] = numberToText;
-        }
-      });
-      stringMatch = localeCompare(removeAllSymbols(newStringArray.join(" ")), removeAllSymbols(answer.phrase));
-      if (stringMatch === 0) {
-        return true;
-      }
-    }
-    return false;
-  };
-  const checkTranslation = isSkipped => {
-    let translations;
-    if (questions && questions.length > 0) {
-      translations = questions[0].translations || [];
-    } else {
-      return;
-    }
-    const translationAttempt = useWordBank || isKeyboardHidden ? translationWords.map(w => w.text).join(" ") : translationText.trim();
-    const isCorrect = checkIsTranslationCorrect(translationAttempt, translations);
-    const answerAttempt = {
-      attempt: translationAttempt,
-      answer: translations,
-      result: isSkipped ? "skipped" : isCorrect ? "correct" : "incorrect",
-      method: useWordBank ? "word_bank" : "text"
-    };
-    if (isSkipped === true) {
-      handleExerciseSkip(answerAttempt);
-    }
-    if (isCorrect && isCorrect === true) {
-      handleCorrect(answerAttempt);
-    } else {
-      useWordBank ? handleIncorrectWordBank(answerAttempt) : handleIncorrect(answerAttempt);
-    }
-  };
-  const checkIsTranslationCorrect = (translationAttempt, translations) => {
-    let translationMatch;
-    for (const item of translations) {
-      translationMatch = removeAllSymbols(item).localeCompare(removeAllSymbols(translationAttempt), undefined, {
-        sensitivity: "base"
-      });
-      if (translationMatch === 0) {
-        return true;
-      }
-    }
-  };
-  const checkIsMeaningCorrect = (meaningAttempt, phrase, alternativeVersions = []) => {
-    let meaningMatch = removeAllSymbols(phrase).localeCompare(removeAllSymbols(meaningAttempt), undefined, {
-      sensitivity: "base"
-    });
-    if (meaningMatch === 0) {
-      return true;
-    }
-    if (alternativeVersions && alternativeVersions.length > 0) {
-      for (let index = 0; index < alternativeVersions.length; index++) {
-        const alternativeVersion = alternativeVersions[index];
-        meaningMatch = removeAllSymbols(alternativeVersion).localeCompare(removeAllSymbols(meaningAttempt), undefined, {
-          sensitivity: "base"
-        });
-        if (meaningMatch === 0) {
-          return true;
-        }
-      }
-    }
-  };
-  const phraseWordList = currentPhrase && currentPhrase.phrase ? removeExtraWhiteSpaces(currentPhrase.phrase).split(" ") : [];
-  const checkListening = isSkipped => {
-    let correctWordCounter = 0;
-    const phraseAttempt = useWordBank ? listeningWords.map(w => w.text).join(" ") : listeningText.trim();
-    const isCorrect = checkIsListeningCorrect(phraseAttempt, currentPhrase);
-    const isCaseCorrect = checkIsCaseCorrect(phraseAttempt, currentPhrase);
-    (phraseAttempt || "").split(" ").forEach((word, i) => {
-      const correctWord = phraseWordList[i]?.trim() || "";
-      const isWordCorrect = checkIsListeningCorrect(word.trim(), {
-        phrase: correctWord
-      });
-      if (isWordCorrect === true) {
-        correctWordCounter += 1;
-        if (!checkIsCaseCorrect(word.trim(), {
-          phrase: correctWord
-        })) {
-          checkIsLetterCorrect(word, correctWord);
-        }
-      }
-    });
-    const result = isSkipped ? "skipped" : isCorrect && isCaseCorrect ? "correct" : correctWordCounter >= 1 && !isCaseCorrect ? "partially_correct" : "incorrect";
-    const answerAttempt = {
-      attempt: phraseAttempt,
-      answer: currentPhrase.phrase,
-      result,
-      method: useWordBank ? "word_bank" : "text"
-    };
-    if (isSkipped === true) {
-      handleExerciseSkip(answerAttempt);
-    }
-    if (isCorrect && isCaseCorrect) {
-      handleCorrect(answerAttempt);
-    } else if (correctWordCounter >= 1 && !isCaseCorrect) {
-      handlePartiallyCorrect(answerAttempt);
-    } else {
-      useWordBank ? handleIncorrectWordBank(answerAttempt) : handleIncorrect(answerAttempt);
-    }
-  };
-  const checkIsLetterCorrect = (attemptWord, correctWord) => {
-    const letterComparison = [];
-    if (attemptWord.toLowerCase() !== correctWord.toLowerCase()) {
-      return correctWord.split("").map(letter => ({
-        letter,
-        isCorrect: false
-      }));
-    }
-    const maxLength = Math.max(attemptWord.length, correctWord.length);
-    for (let i = 0; i < maxLength; i++) {
-      letterComparison.push({
-        letter: correctWord[i] || "",
-        isCorrect: attemptWord[i] === correctWord[i]
-      });
-    }
-    return letterComparison;
-  };
-  const checkIsCaseCorrect = (listeningText, currentPhrase) => {
-    const words = listeningText.split(" ");
-    const isSingleWord = words.length === 1;
-    if (listeningText && listeningText) {
-      let phraseMatch = localeCompareCase(removeAllSymbols(listeningText), removeAllSymbols(currentPhrase.phrase));
-      if (phraseMatch === 0) {
-        return true;
-      } else if (currentPhrase && currentPhrase.alternativeVersions && currentPhrase.alternativeVersions.length > 0) {
-        for (let index = 0; index < currentPhrase.alternativeVersions.length; index += 1) {
-          const alternativeVersion = currentPhrase.alternativeVersions[index];
-          phraseMatch = localeCompareCase(removeAllSymbols(listeningText), removeAllSymbols(alternativeVersion));
-          if (phraseMatch === 0) {
-            return true;
-          }
-        }
-      } else if (isSingleWord && /^\d+$/.test(listeningText)) {
-        const numberToText = convertNumberToText(listeningText, learnLang);
-        phraseMatch = localeCompareCase(removeAllSymbols(numberToText), removeAllSymbols(currentPhrase.phrase));
-        if (phraseMatch === 0) {
-          return true;
-        }
-      } else if (!isSingleWord) {
-        let newStringArray = words;
-        words.map((word, index) => {
-          if (/^\d+$/.test(word)) {
-            const numberToText = convertNumberToText(word, learnLang);
-            newStringArray[index] = numberToText;
-          }
-        });
-        phraseMatch = localeCompareCase(removeAllSymbols(newStringArray.join(" ")), removeAllSymbols(currentPhrase.phrase));
-        if (phraseMatch === 0) {
-          return true;
-        }
-      }
-      return false;
-    }
-  };
-  const checkIsListeningCorrect = (listeningText, currentPhrase) => {
-    const words = listeningText.split(" ");
-    const isSingleWord = words.length === 1;
-    if (listeningText && listeningText) {
-      let phraseMatch = localeCompare(removeAllSymbols(listeningText), removeAllSymbols(currentPhrase.phrase));
-      if (phraseMatch === 0) {
-        return true;
-      } else if (currentPhrase && currentPhrase.alternativeVersions && currentPhrase.alternativeVersions.length > 0) {
-        for (let index = 0; index < currentPhrase.alternativeVersions.length; index += 1) {
-          const alternativeVersion = currentPhrase.alternativeVersions[index];
-          phraseMatch = localeCompare(removeAllSymbols(listeningText), removeAllSymbols(alternativeVersion));
-          if (phraseMatch === 0) {
-            return true;
-          }
-        }
-      } else if (isSingleWord && /^\d+$/.test(listeningText)) {
-        const numberToText = convertNumberToText(listeningText, learnLang);
-        phraseMatch = localeCompare(removeAllSymbols(numberToText), removeAllSymbols(currentPhrase.phrase));
-        if (phraseMatch === 0) {
-          return true;
-        }
-      } else if (!isSingleWord) {
-        let newStringArray = words;
-        words.map((word, index) => {
-          if (/^\d+$/.test(word)) {
-            const numberToText = convertNumberToText(word, learnLang);
-            newStringArray[index] = numberToText;
-          }
-        });
-        phraseMatch = localeCompare(removeAllSymbols(newStringArray.join(" ")), removeAllSymbols(currentPhrase.phrase));
-        if (phraseMatch === 0) {
-          return true;
-        }
-      }
-      return false;
-    }
-  };
-  const checkMeaning = (isSkipped, selectedOption, isWrite = false) => {
-    const question = questions[0];
-    if (!question) return;
-    let isCorrect;
-    let answerAttemptData;
-    if (isWrite) {
-      const meaningAttempt = readWriteText.trim();
-      isCorrect = checkIsMeaningCorrect(meaningAttempt, question.phrase, question.alternativeVersions);
-      answerAttemptData = {
-        attempt: meaningAttempt,
-        answer: question.phrase,
-        result: isSkipped ? "skipped" : isCorrect ? "correct" : "incorrect",
-        method: "text"
-      };
-    } else {
-      isCorrect = selectedOption?.isCorrect;
-      answerAttemptData = {
-        attempt: isSkipped ? "" : selectedOption?.text ?? "",
-        answer: question.phrase,
-        result: isSkipped ? "skipped" : isCorrect ? "correct" : "incorrect"
-      };
-    }
-    if (isSkipped) {
-      handleExerciseSkip(answerAttemptData);
-    } else if (isCorrect) {
-      handleCorrect(answerAttemptData);
-    } else {
-      handleIncorrect(answerAttemptData);
-    }
-  };
-  const handleRoleplayCorrect = message => {
-    setShowOptions(false);
-    openSnackbar(message || "correct", "success");
-  };
-  const handleCorrect = answerAttempt => {
-    !muteSound && correctSound.play();
-    if (exerciseName === "meaning-listen-and-speak") {
-      const {
-        voice,
-        voiceLanguageCode,
-        voicePitch
-      } = topicInfo;
-      speak(currentPhrase.phrase, voice, false, "#currentPhrase", voiceLanguageCode, false, voicePitch);
-    }
-    setAnswerAttempt(answerAttempt);
-    setIsCorrectResultOpen(true);
-    handleReset();
-  };
-  const handlePartiallyCorrect = answerAttempt => {
-    !muteSound && correctSound.play();
-    if (exerciseName === "meaning-listen-and-speak") {
-      const {
-        voice,
-        voiceLanguageCode,
-        voicePitch
-      } = topicInfo;
-      speak(currentPhrase.phrase, voice, false, "#currentPhrase", voiceLanguageCode, false, voicePitch);
-    }
-    setAnswerAttempt(answerAttempt);
-    setIsPartiallyCorrectResultOpen(true);
-    handleReset();
-  };
-  const handleIncorrect = answerAttempt => {
-    !muteSound && incorrectSound.play();
-    if (exerciseName === "meaning-listen-and-speak") {
-      const {
-        voice,
-        voiceLanguageCode,
-        voicePitch
-      } = topicInfo;
-      speak(currentPhrase.phrase, voice, false, "#currentPhrase", voiceLanguageCode, false, voicePitch);
-    }
-    setIsIncorrectResultOpen(true);
-    setAnswerAttempt(answerAttempt);
-    handleReset();
-  };
-  const handleExerciseSkip = answerAttempt => {
-    !muteSound && incorrectSound.play();
-    setIsSkipResultOpen(true);
-    setAnswerAttempt(answerAttempt);
-    handleReset();
-  };
-  const formatAnswerAttempt = async answerAttempt => {
-    if (checked && audioBlob) {
-      // upload blob, function returns url
-      const voiceAttemptURL = await uploadAudioAttempt(audioBlob);
-      answerAttempt.voiceAttempt = voiceAttemptURL;
-    }
-    return answerAttempt;
-  };
-  const handleIncorrectWordBank = async answerAttempt => {
-    !muteSound && incorrectSound.play();
-    setCheckAnswer(true);
-    setAnswerAttempt(answerAttempt);
-    const formattedAnswerAttempt = await formatAnswerAttempt(answerAttempt);
-    const newAnswerAttempts = [...answerAttempts, formattedAnswerAttempt];
-    setAnswerAttempts(newAnswerAttempts);
-    setIsWordBankAttemptChanged(false);
-  };
-  const formatBotMessages = async botMessages => {
-    const updatedConversationHistory = conversationHistory.slice(1);
-    const responses = await Promise.all(botMessages.map(async m => {
-      let conversationHistoryMessage = updatedConversationHistory.find(historyMsg => historyMsg.content?.trim() === m.text?.trim());
-      const updatedMessage = {
-        ...m,
-        studentInappropriate: m?.studentInappropriate === true || conversationHistoryMessage?.studentInappropriate === true ? true : false
-      };
-      if (updatedMessage.audioBlob) delete updatedMessage.audioBlob;
-      if (updatedMessage.audioURL) delete updatedMessage.audioURL;
-      if (updatedMessage.checked) delete updatedMessage.checked;
-      if (m.checked && m.audioBlob) {
-        const voiceAttemptURL = await uploadAudioAttempt(m.audioBlob);
-        return {
-          ...updatedMessage,
-          voiceAttempt: voiceAttemptURL
-        };
-      }
-      return updatedMessage;
-    }));
-    return responses;
-  };
-  const handleNextQuestion = async () => {
-    const {
-      result,
-      attempt
-    } = answerAttempt;
-    if (["translation", "listening", "pronunciation", "meaning", "meaning-listen-and-speak", "meaning-read-and-write"].includes(exerciseName)) {
-      if (result === "correct" || exerciseName === "pronunciation" && attempt !== "" || exerciseName === "listening" && result === "partially_correct" || exerciseName === "meaning-listen-and-speak" && result === "partially_correct") {
-        const newQs = questions.filter((_, i) => i !== 0);
-        const formattedAnswerAttempt = await formatAnswerAttempt(answerAttempt);
-        const newAnswerAttempts = [...answerAttempts, formattedAnswerAttempt];
-        setAnswerAttempts(newAnswerAttempts);
-        setQuestions(newQs);
-        handleSaveExerciseProgress(newQs, newAnswerAttempts);
-        if (!newQs.length > 0) {
-          handleCompleteExercise(newQs, newAnswerAttempts);
-        }
-      } else {
-        const newQs = [...questions, {
-          ...questions[0],
-          questionAttempted: true
-        }].filter((_, i) => i !== 0).slice();
-        const formattedAnswerAttempt = await formatAnswerAttempt(answerAttempt);
-        const newAnswerAttempts = [...answerAttempts, formattedAnswerAttempt];
-        setAnswerAttempts(newAnswerAttempts);
-        setQuestions(newQs);
-        handleSaveExerciseProgress(newQs, newAnswerAttempts);
-        if (result === "incorrect" && newQs.length === 1) {
-          handleCompleteExercise(newQs, newAnswerAttempts);
-        }
-      }
-    } else if (["roleplay"].includes(exerciseName)) {
-      const formattedAnswerAttempt = await formatAnswerAttempt(answerAttempt);
-      const newAnswerAttempts = [...answerAttempts, formattedAnswerAttempt];
-      setAnswerAttempts(newAnswerAttempts);
-      const script = roleplay.script;
-      const currentScriptLine = script[roleplayMessages.length];
-      addRoleplayMessage(currentScriptLine.text, currentScriptLine.actor === 2, true);
-      setRoleplayText("");
-      setDisableSkip(true);
-    }
-    if (clearAttemptAudio) {
-      clearAttemptAudio();
-    }
-    setAnswerAttempt(null);
-    setIsCorrectResultOpen(false);
-    setIsPartiallyCorrectResultOpen(false);
-    setIsSkipResultOpen(false);
-    setIsIncorrectResultOpen(false);
-    setTranscript("");
-  };
-  const addRoleplayMessage = (text, isMyMessage, playAudio) => {
-    if (!text) {
-      return;
-    }
-    text = removeExtraWhiteSpaces(text);
-    const voice = !isMyMessage ? roleplay.actor1 && roleplay.actor1.voice ? roleplay.actor1.voice : null : roleplay.actor2 && roleplay.actor2.voice ? roleplay.actor2.voice : null;
-    const voiceLanguageCode = !isMyMessage ? roleplay.actor1 && roleplay.actor1.voiceLanguageCode ? roleplay.actor1.voiceLanguageCode : null : roleplay.actor2 && roleplay.actor2.voiceLanguageCode ? roleplay.actor2.voiceLanguageCode : null;
-    const voicePitch = !isMyMessage ? roleplay.actor1 && roleplay.actor1.voicePitch ? roleplay.actor1.voicePitch : null : roleplay.actor2 && roleplay.actor2.voicePitch ? roleplay.actor2.voicePitch : null;
-    const message = {
-      isMyMessage: isMyMessage,
-      name: !isMyMessage ? roleplay.actor1 && roleplay.actor1.name ? roleplay.actor1.name : t("actor", {
-        number: "1"
-      }) : roleplay.actor2 && roleplay.actor2.name ? roleplay.actor2.name : t("actor", {
-        number: "2"
-      }),
-      userImage: !isMyMessage ? roleplay.actor1 && roleplay.actor1.picture ? roleplay.actor1.picture : null : roleplay.actor2 && roleplay.actor2.picture ? roleplay.actor2.picture : null,
-      voice: voice,
-      voicePitch: voicePitch,
-      text: formatMarkdownNewlines(text),
-      datetime: new Date()
-    };
-    if (gameId === "fill-in-the-blanks") {
-      let rand;
-      let finished = false;
-      let count = 0;
-      const chatArray = message.text.trim().split(/\s+/);
-      const blankArray = [];
-      if (chatArray.length > 2) {
-        // no other words in chat if blanks were taken out
-        while (!finished) {
-          rand = Math.floor(Math.random() * chatArray.length); // choose where to create blanks
-          if (!blankArray.includes(rand) && removeAllSymbolsFillInBlanks(chatArray[rand]) !== "") {
-            blankArray.push(rand);
-            count += 1;
-            if (count >= 2) {
-              finished = true;
-              break;
-            }
-          }
-        }
-        count = 0;
-        finished = false;
-        const blank1 = removeAllSymbolsFillInBlanks(chatArray[blankArray[0]]);
-        const blank2 = removeAllSymbolsFillInBlanks(chatArray[blankArray[1]]);
-        message.correctAnswer = message.text;
-        message.blanks = [blank1, blank2]; // two blanks for now
-        message.blankIndexes = blankArray;
-        message.text = replaceBlankWords(chatArray, message.blanks, blankArray);
-        const listOfWords = compileWords(roleplay.script, roleplayMessages.length);
-        let optionArray = [blank1, blank2];
-        while (!finished) {
-          rand = Math.floor(Math.random() * listOfWords.length);
-          const optionWord = removeAllSymbolsFillInBlanks(listOfWords[rand]);
-          if (!checkWordExists(optionArray, optionWord) && optionWord !== "") {
-            optionArray.push(optionWord);
-            count += 1;
-            if (count >= numberBlankOptions) {
-              finished = true;
-              break;
-            }
-          }
-        }
-        message.answers = optionArray.sort(() => 0.5 - Math.random()); // randomize order of array
-      }
-    }
-    if (playAudio !== false && learnLang !== "irish" && !isReadWriteModeStudent) {
-      speak(message.text, voice, false, `#message${roleplayMessages.length}`, voiceLanguageCode, false, voicePitch);
-    }
-    const updatedRoleplayMessages = [...roleplayMessages, message];
-    setRoleplayMessages(updatedRoleplayMessages);
-    handleSaveRoleplayExerciseProgress(updatedRoleplayMessages, answerAttempts);
-  };
-  const addBotMessage = (text, isMyMessage, playAudio, method = null, isErrorMsg = false, finalTranscript) => {
-    if (!text) {
-      return;
-    }
-    const voice = bot.voice ? bot.voice : null;
-    const voiceLanguageCode = bot.voiceLanguageCode ? bot.voiceLanguageCode : null;
-    const voicePitch = bot.voicePitch ? bot.voicePitch : null;
-    let message = {
-      isMyMessage,
-      userImage: isErrorMsg ? BotNualaImage : isMyMessage ? userAttributes && userAttributes.picture ? userAttributes.picture : null : bot && bot.botAvatar ? bot.botAvatar : null,
-      name: isErrorMsg ? "Bot" : isMyMessage ? userAttributes && userAttributes.preferred_username ? userAttributes.preferred_username : "Me" : bot && bot.name ? bot.name : "Bot",
-      voice,
-      voicePitch,
-      text,
-      datetime: new Date(),
-      method,
-      isEdited: finalTranscript && text.trim() !== finalTranscript.trim() && method === "text",
-      audioBlob: audioBlob && isMyMessage ? audioBlob : null,
-      audioURL: attemptAudioURL && isMyMessage ? attemptAudioURL : null,
-      checked: attemptAudioURL && isMyMessage && checked ? checked : null,
-      transcriptConfidence: attemptAudioURL && isMyMessage ? transcriptConfidence : null
-    };
-    if (text.includes(botErrorMessage)) {
-      message.text = t("play_bot_error");
-    }
-    if (playAudio !== false && learnLang !== "irish" && !isReadWriteModeStudent && !text.includes(botErrorMessage)) {
-      speak(text, voice, false, `#message${botMessages.length + 1}`, voiceLanguageCode, false, voicePitch);
-    }
-    setBotMessages(prevState => [...prevState, message]);
-  };
-  const getInitialStudentGreeting = learnLang => {
-    const langCode = getLearnLangCode(learnLang);
-    return langCode ? t("hello", {
-      lng: langCode
-    }).toLowerCase() : "hello";
-  };
-  const resetConversationHistory = () => {
-    setConversationHistory([]);
-    setIsFirstMessage(true);
-  };
-  const handleSubmitBotMessage = async () => {
-    try {
-      if (botText && botText.trim() !== "") {
-        const method = `${finalTranscript || ""} ${interimTranscript || ""}`.trim() === botText.trim() ? "voice" : "text";
-        addBotMessage(botText, true, false, method, false, finalTranscript);
-        resetTranscript();
-        const loadingMessage = {
-          isMyMessage: false,
-          userImage: bot && bot.botAvatar ? bot.botAvatar : null,
-          name: bot && bot.name ? bot.name : "Bot",
-          text: "Loading ...",
-          isLoading: true
-        };
-        setBotMessages(prevMessages => [...prevMessages, loadingMessage]);
-        const intialStudentGreeting = getInitialStudentGreeting(learnLang);
-        const body = {
-          message: botText,
-          vars: botVars,
-          isFirstMessage: Array.isArray(aiChatbotConversationHistory) && aiChatbotConversationHistory.length !== 0 ? false : isFirstMessage,
-          i18nLanguage,
-          isDynamicResponsesEnabled: isDynamicResponsesEnabled === "enable" ? true : false,
-          conversationHistory,
-          botProgess: aiChatbotConversationHistory,
-          botTemplate: bot.selectedTemplate ? bot.selectedTemplate : "",
-          intialStudentGreeting,
-          botIntroMessage: bot.introMessage ? bot.introMessage : ""
-        };
-        const response = await handleMessageBot(bot.botId, body);
-        if (response.errorMessage) {
-          openSnackbar(t("problem_getting_reply"), "error");
-          setBotMessages(prevMessages => prevMessages.filter(message => message.isLoading !== true));
-          addBotMessage(t("ai_chatbot_error_response"), false, false);
-        } else if (typeof response === "string" && response.startsWith("Syntax error:")) {
-          openSnackbar(response, "error");
-        }
-        if (response && response.reply) {
-          setBotText("");
-          setBotVars(response.vars);
-          setConversationHistory(response.conversationHistory);
-          handleReset();
-          if (clearAttemptAudio) {
-            clearAttemptAudio();
-          }
-          setBotMessages(prevMessages => prevMessages.filter(message => message.isLoading !== true));
-          addBotMessage(response.reply, false, true);
-          setIsFirstMessage(false);
-        }
-      }
-    } catch (error) {
-      console.error(error);
-      openSnackbar(t("problem_getting_reply"), "error");
-      setBotMessages(prevMessages => prevMessages.filter(message => message.isLoading !== true));
-    }
-  };
-  const viewReport = () => {
-    handleClose();
-    if (exerciseName === "bot") {
-      if (classroomId && courseId && sectionId && topicId) {
-        navigate(`/classrooms/${classroomId}/${courseId}/${sectionId}/${topicId}/activity/${exerciseName}?botId=${bot.botId}`);
-      } else if (courseId && sectionId && topicId) {
-        navigate(`/courses/${courseId}/${sectionId}/${topicId}/activity/${exerciseName}?botId=${bot.botId}`);
-      } else if (bot.botId) {
-        navigate(`/bots/${bot.botId}/activity`);
-      }
-    } else if (exerciseName === "roleplay") {
-      if (classroomId && courseId && sectionId && topicId) {
-        navigate(`/classrooms/${classroomId}/${courseId}/${sectionId}/${topicId}/activity/${exerciseName}?roleplayId=${roleplay.roleplayId}`);
-      } else if (courseId && sectionId && topicId) {
-        navigate(`/courses/${courseId}/${sectionId}/${topicId}/activity/${exerciseName}?roleplayId=${roleplay.roleplayId}`);
-      } else if (roleplay.roleplayId) {
-        navigate(`/roleplays/${roleplay.roleplayId}/activity/${roleplay.createdBy}/${roleplayCreatedAtId}`);
-      }
-    } else {
-      if (classroomId) {
-        navigate(`/classrooms/${classroomId}/${courseId}/${sectionId}/${topicId}/activity/${exerciseName}`);
-      } else {
-        navigate(`/courses/${courseId}/${sectionId}/${topicId}/activity/${exerciseName}`);
-      }
-    }
-  };
-  const handleCloseClicked = () => {
-    if (answerAttempts.length === 0 && botMessages.length === 0 && !roleplayHasStarted) {
-      isAssignmentExercise ? navigate(`/classrooms/${classroomId}#Assignments`) : handleClose();
-    } else {
-      openCloseModal();
-    }
-  };
-  const handleCloseExercise = () => {
-    closeCompletionModal();
-    closeInProgressModal();
-    closeCloseModal();
-    handleClose();
-    stopExerciseAudio();
-  };
-  const handleCompleteExercise = async (unansweredPhrases, newAnswerAttempts) => {
-    setIsCompletionModalOpen(true);
-    openCompletionModal();
-    closeInProgressModal();
-    closeCloseModal();
-    openSnackbar("exercise_complete", "success");
-    stopExerciseAudio();
-    const exerciseCompletion = {
-      exercise: `${exerciseName}${gameId && gameId !== "original" ? `-${gameId}` : ""}`,
-      exerciseStartTime: startTime,
-      courseId,
-      sectionId,
-      topicId
-    };
-    if (exerciseName === "bot") {
-      const {
-        botId,
-        picture,
-        botName,
-        description
-      } = bot;
-      exerciseCompletion.botId = botId;
-      exerciseCompletion.vars = botVars;
-      exerciseCompletion.picture = picture;
-      exerciseCompletion.botName = botName;
-      exerciseCompletion.description = description;
-      const formattedBotMessages = await formatBotMessages(botMessages);
-      exerciseCompletion.messages = formattedBotMessages;
-    } else if (exerciseName === "roleplay") {
-      const {
-        picture,
-        roleplayName,
-        description,
-        roleplayId
-      } = roleplay;
-      exerciseCompletion.gameId = gameId;
-      exerciseCompletion.selectedActor = isActorOne ? 1 : 2;
-      exerciseCompletion.actor1 = roleplay.actor1;
-      exerciseCompletion.actor2 = roleplay.actor2;
-      exerciseCompletion.answerAttempts = newAnswerAttempts && Array.isArray(newAnswerAttempts) ? newAnswerAttempts : answerAttempts;
-      exerciseCompletion.picture = picture;
-      exerciseCompletion.roleplayId = roleplayId;
-      exerciseCompletion.roleplayName = roleplayName;
-      exerciseCompletion.description = description;
-      exerciseCompletion.unansweredQuestions = [];
-      setRoleplayHasStarted(false);
-      setRoleplayMessages([]);
-    } else {
-      const {
-        topicName,
-        description
-      } = topicInfo;
-      exerciseCompletion.topicName = topicName;
-      exerciseCompletion.description = description;
-      exerciseCompletion.answerAttempts = newAnswerAttempts && Array.isArray(newAnswerAttempts) ? newAnswerAttempts : answerAttempts;
-      exerciseCompletion.unansweredPhrases = unansweredPhrases && Array.isArray(unansweredPhrases) ? unansweredPhrases : questions;
-      exerciseCompletion.remainingQuestions = remainingQuestions;
-      if (phraseListId) exerciseCompletion.phraseListId = phraseListId;
-      setQuestions(phrases.slice());
-    }
-    handleComplete(exerciseCompletion);
-    deleteProgress();
-  };
-  const handleSaveExerciseProgress = (remainingQuestions = [], answerAttempts = [], closeExercise = false) => {
-    const progressData = {
-      exercise: exerciseName,
-      remainingQuestions,
-      answerAttempts,
-      exerciseStartTime: startTime,
-      courseId,
-      sectionId,
-      topicId,
-      ...(phraseListId ? {
-        phraseListId
-      } : {})
-    };
-    handleSaveProgress(progressData);
-    if (closeExercise) {
-      handleCloseExercise();
-    }
-  };
-  const handleSaveRoleplayExerciseProgress = (existingMessages = [], answerAttempts = [], closeExercise = false) => {
-    handleSaveProgress({
-      exercise: `${exerciseName}${gameId && gameId !== "original" ? `-${gameId}` : ""}`,
-      roleplayId: roleplay.roleplayId,
-      gameId: gameId,
-      existingMessages,
-      answerAttempts,
-      exerciseStartTime: startTime,
-      selectedActor: isActorOne ? 1 : 2,
-      actor1: roleplay.actor1,
-      actor2: roleplay.actor2,
-      courseId,
-      sectionId,
-      topicId
-    });
-    if (closeExercise) {
-      handleCloseExercise();
-    }
-  };
-  const handleSaveBotExerciseProgress = async (existingMessages = [], existingVars = null, closeExercise = false) => {
-    const filteredMessages = existingMessages.filter(message => !message.isLoading);
-    const formattedBotMessages = await formatBotMessages(filteredMessages);
-    handleSaveProgress({
-      exercise: exerciseName,
-      botId: bot.botId,
-      existingMessages: formattedBotMessages,
-      existingVars,
-      exerciseStartTime: startTime,
-      courseId,
-      sectionId,
-      topicId
-    });
-    if (closeExercise) {
-      handleCloseExercise();
-    }
-  };
-  const handlePronunciationTourFinished = () => {
-    setIsTourFinished(true);
-  };
-  const handleListeningTourFinished = () => {
-    setIsTourFinished(true);
-  };
-  const handleTranslationTourFinished = () => {
-    setIsTourFinished(true);
-  };
-  const handleTryAgain = async () => {
-    const formattedAnswerAttempt = await formatAnswerAttempt(answerAttempt);
-    const newAnswerAttempts = [...answerAttempts, formattedAnswerAttempt];
-    setAnswerAttempts(newAnswerAttempts);
-    if (exerciseName === "roleplay") {
-      handleSaveRoleplayExerciseProgress(roleplayMessages, newAnswerAttempts);
-    } else {
-      handleSaveExerciseProgress(questions, newAnswerAttempts);
-    }
-    if (clearAttemptAudio) {
-      clearAttemptAudio();
-    }
-    setAnswerAttempt(null);
-    setIsCorrectResultOpen(false);
-    setIsPartiallyCorrectResultOpen(false);
-    setIsIncorrectResultOpen(false);
-    setIsSkipResultOpen(false);
-    handleCloseConfidence();
-  };
-  const compileWords = (chats, index) => {
-    let returnArray = [];
-    for (let i = 0; i < chats.length; i += 1) {
-      if (!chats[i]?.question && i !== index) {
-        // don't want to choose words from current chat
-        const stringArray = chats[i].text.split(" ");
-        returnArray = returnArray.concat(stringArray);
-      }
-    }
-    return returnArray;
-  };
-  const replaceBlankWords = (chat, words, blankArray) => {
-    const chatCopy = chat;
-    chatCopy[blankArray[0]] = chatCopy[blankArray[0]].replace(removeAllSymbolsFillInBlanks(chatCopy[blankArray[0]]), "_____");
-    chatCopy[blankArray[1]] = chatCopy[blankArray[1]].replace(removeAllSymbolsFillInBlanks(chatCopy[blankArray[1]]), "_____");
-    let fillBlank = [...chatCopy].join(" ");
-    return fillBlank;
-  };
-  // Commented out to fix lint warning - no-unused-vars
-  // const addQuestionsToChats = (chats, blankChats) => {
-  //   const newChatArray = [];
-  //   const chatArray = [...chats];
-  //   let blankChatCounter = 0;
-  //   for (let i = 0; i < chatArray.length; i += 1) {
-  //     if (!chatArray[i].question) {
-  //       if (blankChats[blankChatCounter].question) {
-  //         chatArray[i].text = blankChats[blankChatCounter].text;
-  //         newChatArray.push(chatArray[i]);
-  //         newChatArray.push(blankChats[blankChatCounter]);
-  //       } else {
-  //         newChatArray.push(chatArray[i]);
-  //       }
-  //       blankChatCounter += 1;
-  //     }
-  //   }
-  //   return newChatArray;
-  // }
-
-  const checkWordExists = (wordArray, word) => {
-    for (let i = 0; i < wordArray.length; i++) {
-      if (wordArray[i].toLowerCase() === word.toLowerCase()) {
-        return true;
-      }
-    }
-    return false;
-  };
-  const checkIsRoleplayMessageCorrect = (finalTranscript, answer) => {
-    const words = finalTranscript.split(" ");
-    const isSingleWord = words.length === 1;
-    let stringMatch = localeCompare(removeAllSymbols(finalTranscript).trim(), removeAllSymbols(answer).trim());
-    if (stringMatch === 0) {
-      return true;
-    } // If answer contains words && finaltranscript contains digits
-    else if (isSingleWord && /^\d+$/.test(finalTranscript)) {
-      const numberToText = convertNumberToText(finalTranscript, learnLang);
-      stringMatch = localeCompare(removeAllSymbols(numberToText), removeAllSymbols(answer));
-      if (stringMatch === 0) {
-        return true;
-      }
-    } else if (!isSingleWord) {
-      let newStringArray = words;
-      words.map((word, index) => {
-        if (/^\d+$/.test(word)) {
-          const numberToText = convertNumberToText(word, learnLang);
-          newStringArray[index] = numberToText;
-        }
-        stringMatch = localeCompare(removeAllSymbols(newStringArray.join(" ")), removeAllSymbols(currentPhrase.phrase));
-        if (stringMatch === 0) {
-          return true;
-        }
-      });
-    }
-    return false;
-  };
-  const checkRoleplayPronunciation = (finalTranscript, answer) => {
-    let correctWordConfidenceScoreTotal = 0;
-    let correctWordCounter = 0;
-    const isCorrect = checkIsRoleplayMessageCorrect(finalTranscript, answer);
-    const answerArray = removeExtraWhiteSpaces(answer).split(" ");
-    (finalTranscript || interimTranscript).split(" ").forEach((word, i) => {
-      const isWordCorrect = answerArray[i] && checkIsRoleplayMessageCorrect(word.trim(), answerArray[i].trim());
-      if (isWordCorrect) {
-        correctWordCounter += 1;
-        const wordIndex = (transcriptWords || []).findIndex(w => w.word === word.trim());
-        if (wordIndex > -1 && transcriptWords[wordIndex].confidence) {
-          correctWordConfidenceScoreTotal += transcriptWords[wordIndex].confidence;
-        } else {
-          correctWordConfidenceScoreTotal += transcriptConfidence;
-        }
-      }
-    });
-    const transcriptCompleteness = correctWordCounter / answerArray.length;
-
-    // A confidence score the awards 0 to an incorrect word
-    const transcriptCorrectWordConfidence = correctWordConfidenceScoreTotal / answerArray.length;
-    const pronunciationScore = (transcriptCorrectWordConfidence + transcriptCompleteness) / 2;
-    const answerAttempt = {
-      attempt: finalTranscript ? finalTranscript : interimTranscript,
-      answer: answer,
-      result: isCorrect ? "correct" : correctWordCounter >= 1 ? "partially_correct" : "incorrect",
-      transcriptConfidence,
-      transcriptCorrectWordConfidence,
-      transcriptCompleteness,
-      transcriptWords,
-      pronunciationScore
-    };
-    if (isCorrect && isCorrect === true) {
-      handleCorrect(answerAttempt);
-    } else if (correctWordCounter >= 1) {
-      handlePartiallyCorrect(answerAttempt);
-    } else {
-      handleIncorrect(answerAttempt);
-    }
-  };
-  return {
-    questions,
-    currentPhrase,
-    currentTranslations,
-    wordOptions,
-    wordLibrary,
-    translationText,
-    translationWords,
-    listeningText,
-    listeningWords,
-    useWordBank,
-    isWordBankHidden,
-    roleplayText,
-    roleplayMessages,
-    sentenceLibrary,
-    roleplayHasStarted,
-    botMessages,
-    botText,
-    botVars,
-    handleMute,
-    muteSound,
-    isSpeaking,
-    setIsSpeaking,
-    isSpeakingTextContainer,
-    isConfidenceOpen,
-    answerAttempt,
-    isCorrectResultOpen,
-    isIncorrectResultOpen,
-    isSkipResultOpen,
-    answerAttempts,
-    pollyResult,
-    startTime,
-    isCloseModalOpen,
-    isInProgressModalOpen,
-    isCompletionModalOpen,
-    voiceSpeed,
-    isVoiceSpeedMenuOpen,
-    isPartiallyCorrectResultOpen,
-    transcript,
-    setTranscript,
-    setIsPartiallyCorrectResultOpen,
-    handleOpenVoiceSpeedMenu,
-    handleCloseVoiceSpeedMenu,
-    handleChangeVoiceSpeed,
-    isReportProblemOpen,
-    handleCloseReportProblem,
-    handleOpenReportProblem,
-    openCloseModal,
-    closeCloseModal,
-    openInProgressModal,
-    closeInProgressModal,
-    openCompletionModal,
-    closeCompletionModal,
-    handleCloseConfidence,
-    handleOpenConfidence,
-    handleInputChange,
-    setTranslationWords,
-    setListeningWords,
-    setUseWordBank,
-    handleUseWordBank,
-    checkIsPronunciationCorrect,
-    checkIsTranslationCorrect,
-    checkIsListeningCorrect,
-    checkIsLetterCorrect,
-    checkIsRoleplayMessageCorrect,
-    setRoleplayText,
-    getActorName,
-    handleSkip,
-    handleNextQuestion,
-    playAllEnabled,
-    setPlayAllEnabled,
-    roleplayInProgress,
-    setRoleplayInProgress,
-    finishedRoleplay,
-    setFinishedRoleplay,
-    setIsCloseModalOpen,
-    setIsInProgressModalOpen,
-    setIsCompletionModalOpen,
-    disableSkip,
-    handleSelectAnswerOption,
-    startRoleplay,
-    isActorOne,
-    isMyTurn,
-    showOptions,
-    setShowOptions,
-    answerOptions,
-    handleMakeAttempt,
-    handleCorrectQuestionAnswer,
-    handleIncorrectQuestionAnswer,
-    setBotText,
-    addBotMessage,
-    handleSubmitBotMessage,
-    handleContinue,
-    speak,
-    stopSpeaking,
-    handleRestart,
-    handlePlayAgain,
-    handleReset,
-    handleRestartExercise,
-    viewReport,
-    roleplayCreatedAtId,
-    handleSaveExerciseProgress,
-    handleSaveRoleplayExerciseProgress,
-    handleSaveBotExerciseProgress,
-    handleCompleteExercise,
-    handleCloseExercise,
-    selectedActor,
-    handleCloseClicked,
-    isTourFinished,
-    handlePronunciationTourFinished,
-    handleListeningTourFinished,
-    handleTranslationTourFinished,
-    handleTryAgain,
-    setIsCorrectResultOpen,
-    setIsIncorrectResultOpen,
-    setIsSkipResultOpen,
-    handleIncorrect,
-    checkRoleplayPronunciation,
-    handleNext,
-    checked,
-    setChecked,
-    setBotMessages,
-    setInAnswerOptions,
-    setBotVars,
-    actorHasBeenSelected,
-    setActorHasBeenSelected,
-    checkAnswer,
-    setCheckAnswer,
-    isWordBankAttemptChanged,
-    setIsWordBankAttemptChanged,
-    isKeyboardHidden,
-    setWordOptions,
-    setIsAssignmentExercise,
-    resetConversationHistory,
-    setAnswerAttempt,
-    readWriteText
-  };
-}