@davi-ai/retorik-framework 4.0.4 → 5.0.1

package/dist/SynthesisPonyfillManager.10888d6d.js

@@ -0,0 +1,888 @@
+import {jsx as $cMDfV$jsx, jsxs as $cMDfV$jsxs} from "react/jsx-runtime";
+import $cMDfV$react, {useState as $cMDfV$useState, useRef as $cMDfV$useRef, useEffect as $cMDfV$useEffect} from "react";
+import {createSpeechSynthesisPonyfill as $cMDfV$createSpeechSynthesisPonyfill, SpeechSynthesisUtterance as $cMDfV$SpeechSynthesisUtterance} from "@davi-ai/web-speech-cognitive-services-davi";
+import {useDispatch as $cMDfV$useDispatch, useSelector as $cMDfV$useSelector} from "react-redux";
+import {SpeechMarkdown as $cMDfV$SpeechMarkdown} from "@davi-ai/speechmarkdown-davi-js";
+
+
+function $parcel$defineInteropFlag(a) {
+  Object.defineProperty(a, '__esModule', {value: true, configurable: true});
+}
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+
+      var $parcel$global = globalThis;
+    var parcelRequire = $parcel$global["parcelRequirea39d"];
+var parcelRegister = parcelRequire.register;
+parcelRegister("jv4ce", function(module, exports) {
+
+$parcel$defineInteropFlag(module.exports);
+
+$parcel$export(module.exports, "default", () => $982637234a32cc59$export$2e2bcd8739ae039);
+
+
+
+
+
+var $8ItUL = parcelRequire("8ItUL");
+
+var $d1wbP = parcelRequire("d1wbP");
+
+var $1mU9f = parcelRequire("1mU9f");
+
+var $3S6OO = parcelRequire("3S6OO");
+const $982637234a32cc59$var$SynthesisPonyfillManager = ({ isRetorikNews: isRetorikNews })=>{
+    const dispatch = (0, $cMDfV$useDispatch)();
+    const customVoice = (0, $cMDfV$useSelector)((state)=>state.speechReducer.customVoice);
+    const ponyfillCredentials = (0, $cMDfV$useSelector)((state)=>state.speechReducer.ponyfillCredentials);
+    const locale = (0, $cMDfV$useSelector)((state)=>state.localeReducer.locale);
+    const agentData = (0, $cMDfV$useSelector)((state)=>state.retorikReducer.agentData);
+    const [ponyfillCreated, setPonyfillCreated] = (0, $cMDfV$useState)(false);
+    const ponyfillRef = (0, $cMDfV$useRef)(undefined);
+    const refreshTimerRef = (0, $cMDfV$useRef)(null);
+    /**
+   * Async function to retrieve a new token and assign it to the speechConfig inside ponyfill.speechSynthesis
+   * @param {string} region
+   * @param {string} key
+   */ const refreshTokenInNineMinutes = async (region, key)=>{
+        // A token is valid during 10 minutes, let's refresh it after 9 minutes
+        refreshTimerRef.current = setTimeout(async ()=>{
+            const token = await (0, $d1wbP.fetchSpeechServicesToken)(region, key);
+            if (token && ponyfillRef.current?.speechSynthesis?.speechConfig) {
+                ponyfillRef.current.speechSynthesis.speechConfig.authorizationToken = token;
+                refreshTokenInNineMinutes(region, key);
+            }
+        }, 540000) // 9 minutes
+        ;
+    };
+    /**
+   * Fetch speech synthesis token and create the ponyfill containing all data
+   * @param {string} region
+   * @param {string} key
+   */ const fetchTokenAndCreatePonyfill = async (region, key)=>{
+        const token = await (0, $d1wbP.fetchSpeechServicesToken)(region, key);
+        if (token) {
+            ponyfillRef.current = (0, $cMDfV$createSpeechSynthesisPonyfill)({
+                credentials: {
+                    region: ponyfillCredentials?.region,
+                    authorizationToken: token
+                }
+            });
+            // Launch token refresh after ponyfill creation
+            refreshTokenInNineMinutes(region, key);
+            setPonyfillCreated(true);
+        }
+    };
+    (0, $cMDfV$useEffect)(()=>{
+        if (ponyfillCredentials?.authorizationToken && ponyfillCredentials.region) {
+            const data = {
+                credentials: ponyfillCredentials
+            };
+            ponyfillRef.current = (0, $cMDfV$createSpeechSynthesisPonyfill)(data);
+            setPonyfillCreated(true);
+        } else if (ponyfillCredentials?.subscriptionKey && ponyfillCredentials.region) fetchTokenAndCreatePonyfill(ponyfillCredentials.region, ponyfillCredentials.subscriptionKey);
+        else if (ponyfillCredentials?.speechSynthesisHostname) {
+            // To use self-hosted voice containers, we need no 'region', and 'speechSynthesisHostname' and 'speechRecognitionHostname' must both be defined
+            // As this ponyfill is for speech synthesis only, we put a mock 'speechRecognitionHostname'
+            const data = {
+                credentials: {
+                    // @ts-ignore
+                    speechSynthesisHostname: new URL(ponyfillCredentials.speechSynthesisHostname),
+                    speechRecognitionHostname: ponyfillCredentials.speechRecognitionHostname || 'mandatory_recognition_host_name',
+                    subscriptionKey: ponyfillCredentials.subscriptionKey || 'mandatory_subscription_key'
+                }
+            };
+            ponyfillRef.current = (0, $cMDfV$createSpeechSynthesisPonyfill)(data);
+            setPonyfillCreated(true);
+        }
+    }, [
+        ponyfillCredentials
+    ]);
+    const onVoicesChanged = ()=>{
+        const voices = ponyfillRef.current?.speechSynthesis.getVoices();
+        if (voices && Array.isArray(voices) && voices.length) dispatch((0, $8ItUL.storeActions).speech.setVoice((0, $1mU9f.selectVoice)(voices, locale, customVoice, agentData) || undefined));
+    };
+    (0, $cMDfV$useEffect)(()=>{
+        if (ponyfillRef.current) {
+            const voices = ponyfillRef.current.speechSynthesis.getVoices();
+            if (voices && Array.isArray(voices) && voices.length) dispatch((0, $8ItUL.storeActions).speech.setVoice((0, $1mU9f.selectVoice)(voices, locale, customVoice, agentData) || undefined));
+            else ponyfillRef.current.speechSynthesis.onvoiceschanged = onVoicesChanged;
+        }
+    }, [
+        ponyfillCreated,
+        customVoice,
+        agentData,
+        locale
+    ]);
+    (0, $cMDfV$useEffect)(()=>{
+        return ()=>{
+            refreshTimerRef.current && clearTimeout(refreshTimerRef.current);
+        };
+    }, []);
+    return ponyfillCreated && ponyfillRef.current ? /*#__PURE__*/ (0, $cMDfV$jsx)((0, $3S6OO.default), {
+        ponyfill: ponyfillRef.current,
+        isRetorikNews: isRetorikNews
+    }) : /*#__PURE__*/ (0, $cMDfV$jsx)((0, $cMDfV$react).Fragment, {});
+};
+var $982637234a32cc59$export$2e2bcd8739ae039 = $982637234a32cc59$var$SynthesisPonyfillManager;
+
+});
+parcelRegister("d1wbP", function(module, exports) {
+
+$parcel$export(module.exports, "fetchSpeechServicesToken", () => $f9d43385082cde31$export$a2ce4fdd6972d6a7);
+const $f9d43385082cde31$export$a2ce4fdd6972d6a7 = async (region, key)=>{
+    const tokenRes = await fetch(`https://${region}.api.cognitive.microsoft.com/sts/v1.0/issueToken`, {
+        method: 'POST',
+        headers: {
+            'Ocp-Apim-Subscription-Key': key
+        }
+    }).then((value)=>{
+        return value.text();
+    }).catch((error)=>{
+        console.log('Error : ', error);
+        return undefined;
+    });
+    return tokenRes;
+};
+
+});
+
+parcelRegister("1mU9f", function(module, exports) {
+
+$parcel$export(module.exports, "selectVoice", () => $e3b82aafad2d0e5e$export$4bf371fc4fa74a28);
+const $e3b82aafad2d0e5e$export$4bf371fc4fa74a28 = (voices, locale, customVoice, agentData)=>{
+    let voice = null;
+    // Check if a custom voice is defined in the props
+    if (customVoice) {
+        if (customVoice.voice) {
+            // Search voice with its full name (ex: AriaNeural, GuyNeural)
+            const neuralVoice = new RegExp(customVoice.voice, 'iu');
+            voice = voices.find(({ name: name })=>neuralVoice.test(name) || name === customVoice.voice);
+        } else if (customVoice.gender) // Search voice depending on given gender and locale
+        voice = voices.find(({ gender: gender, lang: lang })=>{
+            return gender.toLowerCase() === customVoice?.gender?.toLowerCase() && lang === locale;
+        });
+    }
+    // Get voice depending on locale and gender
+    if (!voice) voice = voices.find(({ gender: gender, lang: lang })=>{
+        return gender.toLowerCase() === (agentData?.gender?.toLowerCase() || 'female') && lang === locale;
+    });
+    // No voice found, fall back to US default voices : female => Aria / male => Guy
+    if (!voice) {
+        const genderedVoice = agentData?.gender?.toLowerCase() === 'female' ? 'AriaNeural' : 'GuyNeural';
+        const neuralVoice = new RegExp(genderedVoice, 'iu');
+        voice = voices.find(({ name: name })=>neuralVoice.test(name));
+    }
+    return voice;
+};
+
+});
+
+parcelRegister("3S6OO", function(module, exports) {
+
+$parcel$export(module.exports, "default", () => $0b8e5d756ffed1ac$export$2e2bcd8739ae039);
+
+
+
+
+var $8ItUL = parcelRequire("8ItUL");
+
+var $712C3 = parcelRequire("712C3");
+
+var $4ucVo = parcelRequire("4ucVo");
+
+var $1mU9f = parcelRequire("1mU9f");
+
+var $7UkSC = parcelRequire("7UkSC");
+
+var $b56Ud = parcelRequire("b56Ud");
+const $0b8e5d756ffed1ac$var$SynthesisManager = ({ ponyfill: ponyfill, isRetorikNews: isRetorikNews })=>{
+    const dispatch = (0, $cMDfV$useDispatch)();
+    const cancel = (0, $cMDfV$useSelector)((state)=>state.speechReducer.cancel);
+    const streamingQueue = (0, $cMDfV$useSelector)((state)=>state.speechReducer.streamingQueue);
+    const voice = (0, $cMDfV$useSelector)((state)=>state.speechReducer.voice);
+    const customVoice = (0, $cMDfV$useSelector)((state)=>state.speechReducer.customVoice);
+    const activeRecognitionState = (0, $cMDfV$useSelector)((state)=>state.speechReducer.activeRecognitionState);
+    const externalTextToSpeech = (0, $cMDfV$useSelector)((state)=>state.speechReducer.externalTextToSpeech);
+    const isMicrophoneAllowed = (0, $cMDfV$useSelector)((state)=>state.speechReducer.isMicrophoneAllowed);
+    const mode = (0, $cMDfV$useSelector)((state)=>state.speechReducer.mode);
+    const route = (0, $cMDfV$useSelector)((state)=>state.viewReducer.route);
+    const locale = (0, $cMDfV$useSelector)((state)=>state.localeReducer.locale);
+    const replacementLocales = (0, $cMDfV$useSelector)((state)=>state.localeReducer.replacementLocales);
+    const agentData = (0, $cMDfV$useSelector)((state)=>state.retorikReducer.agentData);
+    const appAvailable = (0, $cMDfV$useSelector)((state)=>state.retorikReducer.appAvailable);
+    const preventExpectedInputHint = (0, $cMDfV$useSelector)((state)=>state.retorikReducer.configuration.preventExpectedInputHint);
+    const speechSynthesisOptions = (0, $cMDfV$useSelector)((state)=>state.retorikReducer.configuration.speechSynthesisOptions);
+    const sendTrace = (0, $712C3.useTelemetry)().sendTrace;
+    const [utterance, setUtterance] = (0, $cMDfV$useState)(null);
+    const [nextUtterance, setNextUtterance] = (0, $cMDfV$useState)(null);
+    const [forceSpeechCaching, setForceSpeechCaching] = (0, $cMDfV$useState)(false);
+    const isNewsViewRef = (0, $cMDfV$useRef)(!!isRetorikNews);
+    const lastListTextPlayedRef = (0, $cMDfV$useRef)('');
+    const streamingQueueRef = (0, $cMDfV$useRef)([]);
+    const currentActivityRef = (0, $cMDfV$useRef)(null);
+    /**
+   * Check activity locale in case of voice change during the speech, to keep the language defined in activity
+   * instead of switching languages between answers that are written in the same language
+   * @param {string} activityLocale
+   * @returns {SpeechSynthesisVoice | null}
+   */ const getVoiceAfterCheckingActivityLocale = (activityLocale)=>{
+        return activityLocale === locale ? voice : (0, $1mU9f.selectVoice)(ponyfill.speechSynthesis.getVoices(), activityLocale, customVoice, agentData);
+    };
+    /**
+   * Check if the activity is a list one, to prevent text re-reading on state update
+   * @param {CreateUtteranceParams} params
+   * @returns {SpeechSynthesisUtterance}
+   */ const checkActivityAndCreateUtterance = (params)=>{
+        if (params.activity.attachmentLayout && params.activity.attachmentLayout.toLowerCase() === 'davilist') {
+            const textToSpeak = params.activity.speak || params.activity.text;
+            if (textToSpeak) {
+                if (textToSpeak === lastListTextPlayedRef.current) return (0, $7UkSC.checkSayAsWordsAndCreateUtterance)({
+                    ...params,
+                    voice: null
+                }, speechSynthesisOptions?.sayAs);
+                else lastListTextPlayedRef.current = textToSpeak;
+            }
+        }
+        return (0, $7UkSC.checkSayAsWordsAndCreateUtterance)(params, speechSynthesisOptions?.sayAs);
+    };
+    const resetData = ()=>{
+        // Set all activities currently in the queue as ended
+        streamingQueueRef.current?.forEach((activity)=>{
+            dispatch((0, $8ItUL.storeActions).activity.addEndedActivity(activity.id));
+        });
+        streamingQueueRef.current = [];
+        dispatch((0, $8ItUL.storeActions).speech.killCurrentStreaming());
+        currentActivityRef.current = null;
+        setUtterance(null);
+        setNextUtterance(null);
+        dispatch((0, $8ItUL.storeActions).speech.resetCancelCurrentUtterance());
+        dispatch((0, $8ItUL.storeActions).speech.setSpeaking(false));
+        dispatch((0, $8ItUL.storeActions).speech.setBoundaryData([]));
+    };
+    const checkReplacementLocaleAndGetUtterance = (activity, checkReplacement = true)=>{
+        const replacementLocale = checkReplacement ? replacementLocales?.[locale] || locale : locale;
+        const params = {
+            activity: activity,
+            voice: getVoiceAfterCheckingActivityLocale(replacementLocale),
+            locale: replacementLocale
+        };
+        return checkActivityAndCreateUtterance(params);
+    };
+    /**
+   * Check if the microphone can be opened automatically
+   */ const checkDictateState = ()=>{
+        if (!preventExpectedInputHint && mode === (0, $8ItUL.Mode).vocal && activeRecognitionState === (0, $8ItUL.RecognitionState).Closed) {
+            if (!isMicrophoneAllowed) dispatch((0, $8ItUL.storeActions).speech.askPermission());
+            else dispatch((0, $8ItUL.storeActions).speech.toggleMicrophone(true));
+        }
+    };
+    /**
+   * On route change, reset all data and check if we are on the news view
+   */ (0, $cMDfV$useEffect)(()=>{
+        resetData();
+        if (!isRetorikNews) isNewsViewRef.current = route === (0, $8ItUL.Routes).News || route === (0, $8ItUL.Routes).NewsInVeille;
+        // Force speech caching when using Retorik News or when using news in veille
+        setForceSpeechCaching(isRetorikNews || route === (0, $8ItUL.Routes).NewsInVeille);
+    }, [
+        route
+    ]);
+    /**
+   * On cancel call, reset all data and kill current streaming
+   */ (0, $cMDfV$useEffect)(()=>{
+        cancel && resetData();
+    }, [
+        cancel
+    ]);
+    /**
+   * Play external speech immediately but don't add it to the history
+   */ (0, $cMDfV$useEffect)(()=>{
+        if (externalTextToSpeech) {
+            const activity = {
+                speak: externalTextToSpeech,
+                locale: locale
+            };
+            currentActivityRef.current = activity;
+            setUtterance(checkReplacementLocaleAndGetUtterance(activity, false));
+        }
+    }, [
+        externalTextToSpeech
+    ]);
+    const dispatchSpeechEvent = (start)=>{
+        const speechEvent = start ? new Event('retorikSpeakStart') : new Event('retorikSpeakStop');
+        document.dispatchEvent(speechEvent);
+    };
+    /**
+   * Called when utterance's "start" event is fired
+   */ const handleUtteranceStart = ()=>{
+        sendTrace((0, $4ucVo.TraceType).utteranceStart, {
+            activityId: currentActivityRef.current?.id,
+            text: currentActivityRef.current?.speak || currentActivityRef.current?.text
+        });
+        dispatch((0, $8ItUL.storeActions).speech.setSpeaking(true));
+        if (!isNewsViewRef.current && currentActivityRef?.current) {
+            dispatch((0, $8ItUL.storeActions).speech.setCurrentOrLastPlayedActivity(currentActivityRef.current));
+            currentActivityRef.current.id && dispatch((0, $8ItUL.storeActions).directline.dispatchMarkActivity({
+                id: currentActivityRef.current.id,
+                speaking: true
+            }));
+        }
+        dispatchSpeechEvent(true);
+        // Set next utterance to prepare synthesis data in order to improve fluidity
+        if (streamingQueueRef.current.length && !streamingQueueRef.current[0].value?.streamingCount) {
+            const utt = checkReplacementLocaleAndGetUtterance(streamingQueueRef.current[0], false);
+            setNextUtterance((current)=>utt.text === current?.text ? null : utt);
+        } else setNextUtterance(null);
+    };
+    /**
+   * Called when utterance's "end" event is fired
+   */ const handleUtteranceEnd = ()=>{
+        sendTrace((0, $4ucVo.TraceType).utteranceEnd, {
+            activityId: currentActivityRef.current?.id
+        });
+        dispatch((0, $8ItUL.storeActions).speech.setSpeaking(false));
+        dispatchSpeechEvent(false);
+        if (isNewsViewRef.current) {
+            dispatch((0, $8ItUL.storeActions).utils.setRetorikNewsEnded(true));
+            currentActivityRef.current = null;
+        } else handleEnded();
+    };
+    const handleEnded = ()=>{
+        // Add played activity id to context's endedActivities
+        if (currentActivityRef.current?.id) {
+            dispatch((0, $8ItUL.storeActions).activity.addEndedActivity(currentActivityRef.current.id));
+            dispatch((0, $8ItUL.storeActions).directline.dispatchMarkActivity({
+                id: currentActivityRef.current.id,
+                speaking: false
+            }));
+        }
+        if (streamingQueueRef.current?.length) {
+            // Check if this is the message sent after streaming activities
+            if (streamingQueueRef.current[0].value?.streamingCount) {
+                dispatch((0, $8ItUL.storeActions).activity.addEndedActivity(streamingQueueRef.current[0].id));
+                // If there is another activity after this message, play it. If not, let's check if the microphone should be opened
+                if (streamingQueueRef.current?.length > 1) {
+                    const utt = checkReplacementLocaleAndGetUtterance(streamingQueueRef.current[1]);
+                    currentActivityRef.current = streamingQueueRef.current[1];
+                    setUtterance(utt);
+                    dispatch((0, $8ItUL.storeActions).speech.removeFirstFromStreamingQueue(true));
+                } else {
+                    streamingQueueRef.current[0].inputHint === 'expectingInput' && checkDictateState();
+                    currentActivityRef.current = null;
+                    setUtterance(null);
+                    setNextUtterance(null);
+                    dispatch((0, $8ItUL.storeActions).speech.removeFirstFromStreamingQueue(false));
+                }
+            } else {
+                const utt = checkReplacementLocaleAndGetUtterance(streamingQueueRef.current[0]);
+                currentActivityRef.current = streamingQueueRef.current[0];
+                setUtterance(utt);
+                dispatch((0, $8ItUL.storeActions).speech.removeFirstFromStreamingQueue(false));
+            }
+        } else {
+            currentActivityRef.current?.inputHint === 'expectingInput' && checkDictateState();
+            currentActivityRef.current = null;
+            setUtterance(null);
+            setNextUtterance(null);
+        }
+    };
+    /**
+   * Wait for app loading and voice selection to begin playing speech
+   */ (0, $cMDfV$useEffect)(()=>{
+        // Set ref from the state to use in events
+        streamingQueueRef.current = streamingQueue;
+        if (appAvailable && voice && streamingQueue.length && !currentActivityRef.current) handleEnded();
+    }, [
+        appAvailable,
+        voice,
+        streamingQueue
+    ]);
+    return /*#__PURE__*/ (0, $cMDfV$jsx)((0, $b56Ud.default), {
+        ponyfill: ponyfill,
+        appAvailable: appAvailable,
+        utterance: utterance,
+        nextUtterance: nextUtterance,
+        forceSpeechCaching: forceSpeechCaching,
+        onStart: handleUtteranceStart,
+        onError: handleUtteranceEnd,
+        onEnd: handleUtteranceEnd
+    });
+};
+var $0b8e5d756ffed1ac$export$2e2bcd8739ae039 = $0b8e5d756ffed1ac$var$SynthesisManager;
+
+});
+parcelRegister("7UkSC", function(module, exports) {
+
+$parcel$export(module.exports, "checkSayAsWordsAndCreateUtterance", () => $66dccbb634d6ce27$export$f969af62bba9a48b);
+
+var $jvc7U = parcelRequire("jvc7U");
+/**
+ * Check if there are some replacement codes for this language, to improve speech synthesis, and then create the utterance
+ * @param {CreateUtteranceParams} params - data needed to create an utterance
+ * @param {SayAs} sayAs - string that should be replaced by their ipa codes
+ * @returns {SpeechSynthesisUtterance}
+ */ const $66dccbb634d6ce27$export$f969af62bba9a48b = (params, sayAs)=>{
+    let sayAsWords = [];
+    if (sayAs) {
+        sayAs.common?.length && (sayAsWords = [
+            ...sayAs.common
+        ]);
+        sayAs.localized && sayAs.localized[params.locale]?.length && (sayAsWords = [
+            ...sayAsWords,
+            ...sayAs.localized[params.locale]
+        ]);
+    }
+    return (0, $jvc7U.default)({
+        ...params,
+        sayAsWords: sayAsWords
+    });
+};
+
+});
+parcelRegister("jvc7U", function(module, exports) {
+
+$parcel$export(module.exports, "default", () => $972cc4ac7a9f8914$export$2e2bcd8739ae039);
+
+
+const $972cc4ac7a9f8914$var$buildSSML = (activity, locale, speechMarkdownParser, sayAsWords)=>{
+    let speech = activity.speak || activity.text;
+    // Replace character not recognized in Microsoft TTS
+    speech = speech.replaceAll("\u2019", "'");
+    let textParsedAsSSML = '';
+    try {
+        if (sayAsWords?.length) {
+            const wordsUsed = [];
+            sayAsWords.forEach((tuple)=>{
+                if (!wordsUsed.includes(tuple.text.toLocaleLowerCase(locale))) {
+                    const regex = new RegExp(`\\b${tuple.text}\\b`, 'gi');
+                    speech = speech.replaceAll(regex, `(${tuple.text})[ipa:"${tuple.ipa}"]`);
+                    wordsUsed.push(tuple.text.toLocaleLowerCase(locale));
+                }
+            });
+        }
+        textParsedAsSSML = speechMarkdownParser.toSSML(speech);
+    } catch (e) {
+        console.warn('Retorik Framework > error in speechmarkdown parser : ', e);
+    }
+    return `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xmlns:emo="http://www.w3.org/2009/10/emotionml" xml:lang="${locale}">` + textParsedAsSSML + '</speak>';
+};
+const $972cc4ac7a9f8914$var$createUtterance = ({ activity: activity, voice: voice, locale: locale, sayAsWords: sayAsWords })=>{
+    // If there is no text to be read, create an empty utterance that will be put in the array of ended activities
+    if (!voice || !activity.speak && !activity.text) return new (0, $cMDfV$SpeechSynthesisUtterance)('');
+    return new (0, $cMDfV$SpeechSynthesisUtterance)($972cc4ac7a9f8914$var$buildSSML(activity, locale, new (0, $cMDfV$SpeechMarkdown)({
+        platform: 'microsoft-azure',
+        includeSpeakTag: false,
+        globalVoiceAndLang: {
+            voice: voice.name,
+            lang: voice.name.toLowerCase().includes('multilingual') ? locale : undefined
+        }
+    }), sayAsWords));
+};
+var $972cc4ac7a9f8914$export$2e2bcd8739ae039 = $972cc4ac7a9f8914$var$createUtterance;
+
+});
+
+
+parcelRegister("b56Ud", function(module, exports) {
+
+$parcel$export(module.exports, "default", () => $637384b103093c58$export$2e2bcd8739ae039);
+
+
+
+
+var $8ItUL = parcelRequire("8ItUL");
+
+var $9RfWh = parcelRequire("9RfWh");
+
+var $eAy5f = parcelRequire("eAy5f");
+
+var $6zM6Q = parcelRequire("6zM6Q");
+const $637384b103093c58$var$DBManager = new (0, $eAy5f.default)();
+const $637384b103093c58$var$tagsRemoverRegex = /<[^<>]+>/g;
+const $637384b103093c58$var$RetorikSpeech = ({ ponyfill: ponyfill, onEnd: onEnd, onError: onError, onStart: onStart, utterance: utterance, nextUtterance: nextUtterance, appAvailable: appAvailable, forceSpeechCaching: forceSpeechCaching })=>{
+    const dispatch = (0, $cMDfV$useDispatch)();
+    const locale = (0, $cMDfV$useSelector)((state)=>state.localeReducer.locale);
+    const loaderClosed = (0, $cMDfV$useSelector)((state)=>state.retorikReducer.loaderClosed);
+    const enableSpeechCaching = (0, $cMDfV$useSelector)((state)=>state.retorikReducer.configuration.enableSpeechCaching);
+    const speechRecognitionOptions = (0, $cMDfV$useSelector)((state)=>state.retorikReducer.configuration.speechRecognitionOptions);
+    const useOldRemote = (0, $cMDfV$useSelector)((state)=>state.retorikReducer.configuration.useOldRemote);
+    const voice = (0, $cMDfV$useSelector)((state)=>state.speechReducer.voice);
+    const muted = (0, $cMDfV$useSelector)((state)=>state.speechReducer.muted);
+    const activeRecognitionState = (0, $cMDfV$useSelector)((state)=>state.speechReducer.activeRecognitionState);
+    const boundaryRef = (0, $cMDfV$useRef)(null);
+    const visemeRef = (0, $cMDfV$useRef)(null);
+    const bookmarkRef = (0, $cMDfV$useRef)(null);
+    const audioRef = (0, $cMDfV$useRef)(null);
+    const speechRecognitionAudioRef = (0, $cMDfV$useRef)(null);
+    const microphoneOpenAudioRef = (0, $cMDfV$useRef)(null);
+    const microphoneCloseAudioRef = (0, $cMDfV$useRef)(null);
+    const [DBReady, setDBReady] = (0, $cMDfV$useState)(false);
+    const [playingBlob, setPlayingBlob] = (0, $cMDfV$useState)(false);
+    const nextUtteranceDataRef = (0, $cMDfV$useRef)(null);
+    const nextUtteranceTextRef = (0, $cMDfV$useRef)(null);
+    const nextUtteranceBoundariesRef = (0, $cMDfV$useRef)([]);
+    const nextUtteranceVisemesRef = (0, $cMDfV$useRef)([]);
+    const nextUtteranceBookmarksRef = (0, $cMDfV$useRef)([]);
+    const emptyTextUtteranceRef = (0, $cMDfV$useRef)(null);
+    (0, $cMDfV$useEffect)(()=>{
+        $637384b103093c58$var$DBManager.checkDB().then((result)=>setDBReady(result));
+        return ()=>{
+            stopCurrentPlaying();
+            emptyTextUtteranceRef?.current && clearTimeout(emptyTextUtteranceRef.current);
+        };
+    }, []);
+    const stopCurrentPlaying = ()=>{
+        if (appAvailable || loaderClosed) {
+            // Cancel synthesis if using synthesizer
+            if (!playingBlob) ponyfill.speechSynthesis.cancel();
+            resetNextUtteranceData();
+            if (audioRef.current && !audioRef.current?.paused) {
+                audioRef.current.pause();
+                handleEnd();
+            }
+        }
+    };
+    const attachEvents = (tempUtterance, isMainUtterance)=>{
+        tempUtterance.onerror = (event)=>{
+            isMainUtterance ? handleError(event) : nextUtteranceDataRef.current = null;
+        };
+        tempUtterance.onsynthesiscompleted = ()=>{
+            const endBoundary = {
+                word: '',
+                startTime: 0,
+                endTime: 0,
+                boundaryType: 'EndBoundary'
+            };
+            if (isMainUtterance) {
+                const tempBoundaries = boundaryRef?.current || [];
+                boundaryRef.current = [
+                    ...tempBoundaries,
+                    endBoundary
+                ];
+                dispatch((0, $8ItUL.storeActions).speech.setBoundaryData([
+                    ...tempBoundaries,
+                    endBoundary
+                ]));
+            } else nextUtteranceBoundariesRef.current = [
+                ...nextUtteranceBoundariesRef.current,
+                endBoundary
+            ];
+        };
+        tempUtterance.onboundary = (event)=>{
+            if (event.boundaryType !== 'Viseme') {
+                const newBoundary = {
+                    word: event.name,
+                    startTime: event.elapsedTime,
+                    endTime: event.elapsedTime + event.duration,
+                    boundaryType: event.boundaryType
+                };
+                if (isMainUtterance) {
+                    // Update the boundaryData state with the new data.
+                    const tempBoundaries = boundaryRef?.current || [];
+                    boundaryRef.current = [
+                        ...tempBoundaries,
+                        newBoundary
+                    ];
+                    dispatch((0, $8ItUL.storeActions).speech.setBoundaryData([
+                        ...tempBoundaries,
+                        newBoundary
+                    ]));
+                } else nextUtteranceBoundariesRef.current = [
+                    ...nextUtteranceBoundariesRef.current,
+                    newBoundary
+                ];
+            }
+        };
+        tempUtterance.onviseme = (event)=>{
+            if (isMainUtterance) {
+                // Collect visemes locally - they will be dispatched when audio starts playing
+                const tempVisemes = visemeRef?.current || [];
+                visemeRef.current = [
+                    ...tempVisemes,
+                    event
+                ];
+            } else nextUtteranceVisemesRef.current = [
+                ...nextUtteranceVisemesRef.current,
+                event
+            ];
+        };
+        tempUtterance.onmark = (event)=>{
+            console.log('Retorik Framework > onmark event', event);
+            const bookmark = {
+                name: event.name,
+                time: event.elapsedTime
+            };
+            if (isMainUtterance) {
+                // Collect bookmarks locally - they will be dispatched when audio starts playing
+                const tempBookmarks = bookmarkRef?.current || [];
+                bookmarkRef.current = [
+                    ...tempBookmarks,
+                    bookmark
+                ];
+            } else nextUtteranceBookmarksRef.current = [
+                ...nextUtteranceBookmarksRef.current,
+                bookmark
+            ];
+        };
+        return tempUtterance;
+    };
+    const processNextData = (data)=>{
+        nextUtteranceDataRef.current = data?.byteLength && nextUtteranceTextRef.current ? {
+            text: nextUtteranceTextRef.current,
+            data: {
+                speechData: data,
+                boundaries: nextUtteranceBoundariesRef.current,
+                visemes: nextUtteranceVisemesRef.current,
+                bookmarks: nextUtteranceBookmarksRef.current
+            }
+        } : null;
+        // Reset boundary / viseme data
+        resetNextUtteranceData(true);
+    };
+    const resetNextUtteranceData = (keepArrayBufferData)=>{
+        !keepArrayBufferData && (nextUtteranceDataRef.current = null);
+        nextUtteranceTextRef.current = null;
+        nextUtteranceBoundariesRef.current = [];
+        nextUtteranceVisemesRef.current = [];
+        nextUtteranceBookmarksRef.current = [];
+    };
+    (0, $cMDfV$useEffect)(()=>{
+        if (utterance) {
+            if (utterance.text) {
+                if (audioRef?.current) {
+                    if (nextUtteranceDataRef.current?.text === utterance.text && nextUtteranceDataRef.current.data) {
+                        boundaryRef.current = nextUtteranceDataRef.current.data.boundaries;
+                        dispatch((0, $8ItUL.storeActions).speech.setBoundaryData(nextUtteranceDataRef.current.data.boundaries));
+                        // Store visemes locally - they will be dispatched when audio starts playing
+                        visemeRef.current = nextUtteranceDataRef.current.data.visemes;
+                        processData(nextUtteranceDataRef.current.data.speechData, true);
+                    } else // Play utterance whether by asking for a speech synthesis, or by retrieving data from indexedDB
+                    playUtterance(attachEvents(utterance, true));
+                } else stopCurrentPlaying();
+            } else handleEmptyTextUtterance();
+        } else stopCurrentPlaying();
+    }, [
+        utterance
+    ]);
+    (0, $cMDfV$useEffect)(()=>{
+        // If there are data in nextUtteranceTextRef, this means the previous synthesis data retrieval is not finished, so we don't begin a new one
+        if (nextUtterance?.text && !nextUtteranceTextRef.current) {
+            const tempUtterance = attachEvents(nextUtterance);
+            nextUtteranceTextRef.current = nextUtterance.text;
+            ponyfill.speechSynthesis.synthesizeAndGetArrayData(tempUtterance, processNextData);
+        } else resetNextUtteranceData();
+    }, [
+        nextUtterance
+    ]);
+    const playUtterance = async (utt)=>{
+        if (DBReady && (enableSpeechCaching !== false || forceSpeechCaching) && utt) {
+            const dataFromIndexedDB = await $637384b103093c58$var$DBManager.getSpeechData(`${locale}.${voice?.name}.${utt.text.replace($637384b103093c58$var$tagsRemoverRegex, '')}`);
+            if (dataFromIndexedDB) {
+                boundaryRef.current = dataFromIndexedDB.boundaries;
+                dispatch((0, $8ItUL.storeActions).speech.setBoundaryData(dataFromIndexedDB.boundaries));
+                // Store visemes locally - they will be dispatched when audio starts playing
+                visemeRef.current = dataFromIndexedDB.visemes || [];
+                processData(dataFromIndexedDB.value, true);
+            } else ponyfill.speechSynthesis.synthesizeAndGetArrayData(utt, processData);
+        } else ponyfill.speechSynthesis.synthesizeAndGetArrayData(utt, processData);
+    };
+    const processData = (data, alreadyExistsInDB)=>{
+        if (data?.byteLength) {
+            const blob = new Blob([
+                data
+            ], {
+                type: 'audio/mp3'
+            });
+            !alreadyExistsInDB && (enableSpeechCaching !== false || forceSpeechCaching) && DBReady && boundaryRef?.current && utterance && $637384b103093c58$var$DBManager.addSpeechData({
+                id: `${locale}.${voice?.name}.${utterance.text.replace($637384b103093c58$var$tagsRemoverRegex, '')}`,
+                value: data,
+                boundaries: boundaryRef.current,
+                visemes: visemeRef.current || []
+            });
+            const url = URL.createObjectURL(blob);
+            if (audioRef?.current) {
+                setPlayingBlob(true);
+                audioRef.current.src = url;
+                audioRef.current.play().catch((e)=>console.warn(e));
+            }
+        } else handleEmptyTextUtterance();
+    };
+    const resetData = ()=>{
+        boundaryRef.current = [];
+        visemeRef.current = [];
+        dispatch((0, $8ItUL.storeActions).speech.setBoundaryData([]));
+        dispatch((0, $8ItUL.storeActions).speech.setVisemeData([]));
+        dispatch((0, $8ItUL.storeActions).speech.setBookmarkData([]));
+        setPlayingBlob(false);
+    };
+    const handleStart = ()=>{
+        if (appAvailable || loaderClosed) {
+            // Dispatch visemes now that audio is playing, ensuring lip sync timing is correct
+            if (visemeRef.current?.length) {
+                dispatch((0, $8ItUL.storeActions).speech.setVisemeData(visemeRef.current));
+                dispatch((0, $8ItUL.storeActions).speech.setBookmarkData(bookmarkRef.current || []));
+            }
+            onStart?.();
+        }
+    };
+    const handleEnd = ()=>{
+        if (appAvailable || loaderClosed) {
+            onEnd?.();
+            resetData();
+        } else dispatch((0, $8ItUL.storeActions).retorik.setLoaderClosed(true));
+    };
+    const handleError = (error)=>{
+        console.log('Retorik Framework > speech synthesis error ', error);
+        onError?.();
+        resetData();
+    };
+    const handleEmptyTextUtterance = ()=>{
+        handleStart();
+        emptyTextUtteranceRef?.current && clearTimeout(emptyTextUtteranceRef.current);
+        emptyTextUtteranceRef.current = setTimeout(()=>{
+            handleEnd();
+        }, 50);
+    };
+    /**
+   * On call :
+   *  - play 1 second muted sound to prime audio output
+   *  - MANDATORY FOR SAFARI IN VOCAL MODE
+   */ const primeRetorikSpeech = ()=>{
+        if (audioRef.current) {
+            audioRef.current.play().catch((e)=>console.warn(e));
+            speechRecognitionAudioRef?.current && speechRecognitionAudioRef.current.play().catch((e)=>console.warn(e));
+            // Send animation start event to secure animation not playing on safari if permissions are not sufficient
+            window.dispatchEvent(new Event('retorikSpiritEnginePlay'));
+        }
+    };
+    /**
+   * Play sound on speech recognition activation if it isn't disabled in configuration
+   */ (0, $cMDfV$useEffect)(()=>{
+        if (useOldRemote) {
+            if (!!speechRecognitionOptions?.enableActivationSound && activeRecognitionState === (0, $8ItUL.RecognitionState).Listening) speechRecognitionAudioRef?.current?.play().catch((e)=>console.warn(e));
+        } else if (!!speechRecognitionOptions?.enableActivationSound) switch(activeRecognitionState){
+            case (0, $8ItUL.RecognitionState).Listening:
+                microphoneOpenAudioRef?.current?.play().catch((e)=>console.warn(e));
+                break;
+            case (0, $8ItUL.RecognitionState).Closing:
+            case (0, $8ItUL.RecognitionState).ForceClosing:
+                microphoneCloseAudioRef?.current?.play().catch((e)=>console.warn(e));
+                break;
+            default:
+                break;
+        }
+    }, [
+        useOldRemote,
+        activeRecognitionState,
+        speechRecognitionOptions
+    ]);
+    return /*#__PURE__*/ (0, $cMDfV$jsxs)((0, $cMDfV$react).Fragment, {
+        children: [
+            /*#__PURE__*/ (0, $cMDfV$jsx)("audio", {
+                ref: audioRef,
+                src: (0, $9RfWh.audioFiles).onesecond,
+                muted: appAvailable || loaderClosed ? muted : true,
+                onPlay: handleStart,
+                onEnded: handleEnd
+            }),
+            /*#__PURE__*/ (0, $cMDfV$jsx)("audio", {
+                ref: speechRecognitionAudioRef,
+                src: (0, $9RfWh.audioFiles).speechrecognition,
+                preload: "auto",
+                muted: appAvailable || loaderClosed ? muted : true
+            }),
+            /*#__PURE__*/ (0, $cMDfV$jsx)("audio", {
+                ref: microphoneOpenAudioRef,
+                src: (0, $9RfWh.audioFiles).microphoneopen,
+                preload: "auto",
+                muted: appAvailable || loaderClosed ? muted : true
+            }),
+            /*#__PURE__*/ (0, $cMDfV$jsx)("audio", {
+                ref: microphoneCloseAudioRef,
+                src: (0, $9RfWh.audioFiles).microphoneclose,
+                preload: "auto",
+                muted: appAvailable || loaderClosed ? muted : true
+            }),
+            /*#__PURE__*/ (0, $cMDfV$jsx)((0, $6zM6Q.default), {
+                appAvailable: appAvailable,
+                handleValidation: primeRetorikSpeech
+            })
+        ]
+    });
+};
+var $637384b103093c58$export$2e2bcd8739ae039 = $637384b103093c58$var$RetorikSpeech;
+
+});
+parcelRegister("eAy5f", function(module, exports) {
+
+$parcel$export(module.exports, "default", () => $f8b1c4b1ab628567$export$2e2bcd8739ae039);
+class $f8b1c4b1ab628567$var$IndexedDbManager {
+    constructor(){
+        this.version = 1;
+        this.storeName = 'speechSynthesisData';
+        this.checkDB = async ()=>{
+            return new Promise((resolve)=>{
+                const request = indexedDB.open('retorik-framework-db', this.version);
+                request.onsuccess = ()=>{
+                    resolve(true);
+                };
+                request.onerror = ()=>{
+                    resolve(false);
+                };
+                request.onupgradeneeded = ()=>{
+                    const db = request.result;
+                    // If the data object store doesn't exist, create it
+                    if (!db.objectStoreNames.contains(this.storeName)) db.createObjectStore(this.storeName, {
+                        keyPath: 'id'
+                    });
+                };
+            });
+        };
+        this.addSpeechData = async (data)=>{
+            return new Promise((resolve)=>{
+                const request = indexedDB.open('retorik-framework-db', this.version);
+                request.onsuccess = ()=>{
+                    const db = request.result;
+                    const tx = db.transaction(this.storeName, 'readwrite');
+                    const store = tx.objectStore(this.storeName);
+                    // Base 64 encode
+                    data.id = window.btoa(encodeURI(data.id));
+                    store.add(data);
+                    resolve(true);
+                };
+                request.onerror = ()=>{
+                    resolve(false);
+                };
+            });
+        };
+        this.getSpeechData = async (id)=>{
+            return new Promise((resolve)=>{
+                const request = indexedDB.open('retorik-framework-db', this.version);
+                request.onsuccess = ()=>{
+                    const db = request.result;
+                    const tx = db.transaction(this.storeName, 'readonly');
+                    const store = tx.objectStore(this.storeName);
+                    // Base 64 encode
+                    const data = store.get(window.btoa(encodeURI(id)));
+                    data.onsuccess = ()=>{
+                        resolve(data.result);
+                    };
+                };
+                request.onerror = ()=>{
+                    resolve(null);
+                };
+            });
+        };
+    }
+}
+var $f8b1c4b1ab628567$export$2e2bcd8739ae039 = $f8b1c4b1ab628567$var$IndexedDbManager;
+
+});
+
+
+
+
+
+//# sourceMappingURL=SynthesisPonyfillManager.10888d6d.js.map