web-speech-cognitive-services 8.0.0-main.478b2e9 → 8.0.0-main.5903868

package/dist/web-speech-cognitive-services.mjs

@@ -1,69 +1,3 @@
-// src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfill.js
-import { Event, EventTarget, getEventAttributeValue, setEventAttributeValue } from "event-target-shim";
-
-// src/Util/arrayToMap.js
-function arrayToMap_default(array, extras) {
-  const map = {
-    ...[].reduce.call(
-      array,
-      (map2, value, index) => {
-        map2[index] = value;
-        return map2;
-      },
-      {}
-    ),
-    ...extras,
-    length: array.length,
-    [Symbol.iterator]: () => [].slice.call(map)[Symbol.iterator]()
-  };
-  return map;
-}
-
-// src/SpeechServices/SpeechSDK.js
-import {
-  AudioConfig,
-  OutputFormat,
-  ResultReason,
-  SpeechConfig,
-  SpeechRecognizer
-} from "microsoft-cognitiveservices-speech-sdk/distrib/lib/microsoft.cognitiveservices.speech.sdk";
-var SpeechSDK_default = {
-  AudioConfig,
-  OutputFormat,
-  ResultReason,
-  SpeechConfig,
-  SpeechRecognizer
-};
-
-// src/SpeechServices/SpeechToText/cognitiveServiceEventResultToWebSpeechRecognitionResultList.js
-var {
-  ResultReason: { RecognizingSpeech, RecognizedSpeech }
-} = SpeechSDK_default;
-function cognitiveServiceEventResultToWebSpeechRecognitionResultList_default(result, { maxAlternatives = Infinity, textNormalization = "display" } = {}) {
-  if (result.reason === RecognizingSpeech || result.reason === RecognizedSpeech && !result.json.NBest) {
-    const resultList = [
-      {
-        confidence: 0.5,
-        transcript: result.text
-      }
-    ];
-    if (result.reason === RecognizedSpeech) {
-      resultList.isFinal = true;
-    }
-    return resultList;
-  } else if (result.reason === RecognizedSpeech) {
-    const resultList = arrayToMap_default(
-      (result.json.NBest || []).slice(0, maxAlternatives).map(({ Confidence: confidence, Display: display, ITN: itn, Lexical: lexical, MaskedITN: maskedITN }) => ({
-        confidence,
-        transcript: textNormalization === "itn" ? itn : textNormalization === "lexical" ? lexical : textNormalization === "maskeditn" ? maskedITN : display
-      })),
-      { isFinal: true }
-    );
-    return resultList;
-  }
-  return [];
-}
-
 // ../../node_modules/p-defer/index.js
 function pDefer() {
   const deferred = {};
@@ -182,6 +116,127 @@ function patchOptions({
   };
 }
 
+// src/SpeechServices/SpeechSDK.js
+import {
+  AudioConfig,
+  OutputFormat,
+  ResultReason,
+  SpeechConfig,
+  SpeechRecognizer
+} from "microsoft-cognitiveservices-speech-sdk/distrib/lib/microsoft.cognitiveservices.speech.sdk";
+var SpeechSDK_default = {
+  AudioConfig,
+  OutputFormat,
+  ResultReason,
+  SpeechConfig,
+  SpeechRecognizer
+};
+
+// src/SpeechServices/SpeechToText/SpeechRecognitionAlternative.ts
+var SpeechRecognitionAlternative = class {
+  constructor({ confidence, transcript }) {
+    this.#confidence = confidence;
+    this.#transcript = transcript;
+  }
+  #confidence;
+  #transcript;
+  get confidence() {
+    return this.#confidence;
+  }
+  get transcript() {
+    return this.#transcript;
+  }
+};
+
+// src/SpeechServices/SpeechToText/FakeArray.ts
+var FakeArray = class {
+  constructor(array) {
+    if (!array) {
+      throw new Error("array must be set.");
+    }
+    this.#array = array;
+    for (const key in array) {
+      Object.defineProperty(this, key, {
+        enumerable: true,
+        get() {
+          return array[key];
+        }
+      });
+    }
+  }
+  #array;
+  [Symbol.iterator]() {
+    return this.#array[Symbol.iterator]();
+  }
+  get length() {
+    return this.#array.length;
+  }
+};
+
+// src/SpeechServices/SpeechToText/SpeechRecognitionResult.ts
+var SpeechRecognitionResult = class extends FakeArray {
+  constructor(init) {
+    super(init.results);
+    this.#isFinal = init.isFinal;
+  }
+  #isFinal;
+  get isFinal() {
+    return this.#isFinal;
+  }
+};
+
+// src/SpeechServices/SpeechToText/cognitiveServiceEventResultToWebSpeechRecognitionResult.ts
+var {
+  ResultReason: { RecognizingSpeech, RecognizedSpeech }
+} = SpeechSDK_default;
+function cognitiveServiceEventResultToWebSpeechRecognitionResult_default(result, init) {
+  const { maxAlternatives = Infinity, textNormalization = "display" } = init || {};
+  const json = typeof result.json === "string" ? JSON.parse(result.json) : result.json;
+  if (result.reason === RecognizingSpeech || result.reason === RecognizedSpeech && !json.NBest) {
+    return new SpeechRecognitionResult({
+      isFinal: result.reason === RecognizedSpeech,
+      results: [
+        new SpeechRecognitionAlternative({
+          confidence: 0.5,
+          transcript: result.text
+        })
+      ]
+    });
+  } else if (result.reason === RecognizedSpeech) {
+    return new SpeechRecognitionResult({
+      isFinal: true,
+      results: (json.NBest || []).slice(0, maxAlternatives).map(
+        ({ Confidence: confidence, Display: display, ITN: itn, Lexical: lexical, MaskedITN: maskedITN }) => new SpeechRecognitionAlternative({
+          confidence,
+          transcript: textNormalization === "itn" ? itn : textNormalization === "lexical" ? lexical : textNormalization === "maskeditn" ? maskedITN : display
+        })
+      )
+    });
+  }
+  return new SpeechRecognitionResult({ isFinal: false, results: [] });
+}
+
+// src/SpeechServices/SpeechToText/EventListenerMap.ts
+var EventListenerMap = class {
+  constructor(eventTarget) {
+    this.#eventTarget = eventTarget;
+    this.#propertyMap = {};
+  }
+  #eventTarget;
+  #propertyMap;
+  getProperty(name) {
+    return this.#propertyMap[name];
+  }
+  setProperty(name, value) {
+    const existing = this.#propertyMap[name];
+    existing && this.#eventTarget.removeEventListener(name, existing);
+    if (value) {
+      this.#eventTarget.addEventListener(name, value);
+    }
+    this.#propertyMap[name] = value;
+  }
+};
+
 // src/SpeechServices/SpeechToText/SpeechGrammarList.js
 var SpeechGrammarList_default = class {
   constructor() {
@@ -204,6 +259,53 @@ var SpeechGrammarList_default = class {
   }
 };
 
+// src/SpeechServices/SpeechToText/SpeechRecognitionErrorEvent.ts
+var SpeechRecognitionErrorEvent = class extends Event {
+  constructor(type, { error, message }) {
+    super(type);
+    this.#error = error;
+    this.#message = message;
+  }
+  #error;
+  #message;
+  get error() {
+    return this.#error;
+  }
+  get message() {
+    return this.#message;
+  }
+};
+
+// src/SpeechServices/SpeechToText/SpeechRecognitionResultList.ts
+var SpeechRecognitionResultList = class extends FakeArray {
+  constructor(result) {
+    super(result);
+  }
+};
+
+// src/SpeechServices/SpeechToText/SpeechRecognitionEvent.ts
+var SpeechRecognitionEvent = class extends Event {
+  constructor(type, { data, resultIndex, results } = {}) {
+    super(type);
+    this.#data = data;
+    this.#resultIndex = resultIndex;
+    this.#results = results || new SpeechRecognitionResultList([]);
+  }
+  #data;
+  // TODO: "resultIndex" should be set.
+  #resultIndex;
+  #results;
+  get data() {
+    return this.#data;
+  }
+  get resultIndex() {
+    return this.#resultIndex;
+  }
+  get results() {
+    return this.#results;
+  }
+};
+
 // src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfill.js
 var { AudioConfig: AudioConfig2, OutputFormat: OutputFormat2, ResultReason: ResultReason2, SpeechConfig: SpeechConfig2, SpeechRecognizer: SpeechRecognizer2 } = SpeechSDK_default;
 function serializeRecognitionResult({ duration, errorDetails, json, offset, properties, reason, resultId, text }) {
@@ -225,16 +327,6 @@ function averageAmplitude(arrayBuffer) {
 function cognitiveServicesAsyncToPromise(fn) {
   return (...args) => new Promise((resolve, reject) => fn(...args, resolve, reject));
 }
-var SpeechRecognitionEvent = class extends Event {
-  constructor(type, { data, emma, interpretation, resultIndex, results } = {}) {
-    super(type);
-    this.data = data;
-    this.emma = emma;
-    this.interpretation = interpretation;
-    this.resultIndex = resultIndex;
-    this.results = results;
-  }
-};
 function prepareAudioConfig(audioConfig) {
   const originalAttach = audioConfig.attach;
   const boundOriginalAttach = audioConfig.attach.bind(audioConfig);
@@ -283,7 +375,10 @@ function createSpeechRecognitionPonyfillFromRecognizer({
       this._lang = typeof window !== "undefined" ? window.document.documentElement.getAttribute("lang") || window.navigator.language : "en-US";
       this._grammars = new SpeechGrammarList_default();
       this._maxAlternatives = 1;
+      this.#eventListenerMap = new EventListenerMap(this);
     }
+    /** @type { import('./SpeechRecognitionEventListenerMap').SpeechRecognitionEventListenerMap } */
+    #eventListenerMap;
     emitCognitiveServices(type, event) {
       this.dispatchEvent(
         new SpeechRecognitionEvent("cognitiveservices", {
@@ -328,75 +423,88 @@ function createSpeechRecognitionPonyfillFromRecognizer({
     set lang(value) {
       this._lang = value;
     }
+    /** @type { ((event: SpeechRecognitionEvent<'audioend'>) => void) | undefined } */
     get onaudioend() {
-      return getEventAttributeValue(this, "audioend");
+      return this.#eventListenerMap.getProperty("audioend");
     }
     set onaudioend(value) {
-      setEventAttributeValue(this, "audioend", value);
+      this.#eventListenerMap.setProperty("audioend", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'audiostart'>) => void) | undefined } */
     get onaudiostart() {
-      return getEventAttributeValue(this, "audiostart");
+      return this.#eventListenerMap.getProperty("audiostart");
     }
     set onaudiostart(value) {
-      setEventAttributeValue(this, "audiostart", value);
+      this.#eventListenerMap.setProperty("audiostart", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'cognitiveservices'>) => void) | undefined } */
     get oncognitiveservices() {
-      return getEventAttributeValue(this, "cognitiveservices");
+      return this.#eventListenerMap.getProperty("cognitiveservices");
     }
     set oncognitiveservices(value) {
-      setEventAttributeValue(this, "cognitiveservices", value);
+      this.#eventListenerMap.setProperty("cognitiveservices", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'end'>) => void) | undefined } */
     get onend() {
-      return getEventAttributeValue(this, "end");
+      return this.#eventListenerMap.getProperty("end");
     }
     set onend(value) {
-      setEventAttributeValue(this, "end", value);
+      this.#eventListenerMap.setProperty("end", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'error'>) => void) | undefined } */
     get onerror() {
-      return getEventAttributeValue(this, "error");
+      return this.#eventListenerMap.getProperty("error");
     }
     set onerror(value) {
-      setEventAttributeValue(this, "error", value);
+      this.#eventListenerMap.setProperty("error", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'result'>) => void) | undefined } */
     get onresult() {
-      return getEventAttributeValue(this, "result");
+      return this.#eventListenerMap.getProperty("result");
     }
     set onresult(value) {
-      setEventAttributeValue(this, "result", value);
+      this.#eventListenerMap.setProperty("result", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'soundend'>) => void) | undefined } */
     get onsoundend() {
-      return getEventAttributeValue(this, "soundend");
+      return this.#eventListenerMap.getProperty("soundend");
     }
     set onsoundend(value) {
-      setEventAttributeValue(this, "soundend", value);
+      this.#eventListenerMap.setProperty("soundend", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'soundstart'>) => void) | undefined } */
     get onsoundstart() {
-      return getEventAttributeValue(this, "soundstart");
+      return this.#eventListenerMap.getProperty("soundstart");
     }
     set onsoundstart(value) {
-      setEventAttributeValue(this, "soundstart", value);
+      this.#eventListenerMap.setProperty("soundstart", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'speechend'>) => void) | undefined } */
     get onspeechend() {
-      return getEventAttributeValue(this, "speechend");
+      return this.#eventListenerMap.getProperty("speechend");
     }
     set onspeechend(value) {
-      setEventAttributeValue(this, "speechend", value);
+      this.#eventListenerMap.setProperty("speechend", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'speechstart'>) => void) | undefined } */
     get onspeechstart() {
-      return getEventAttributeValue(this, "speechstart");
+      return this.#eventListenerMap.getProperty("speechstart");
     }
     set onspeechstart(value) {
-      setEventAttributeValue(this, "speechstart", value);
+      this.#eventListenerMap.setProperty("speechstart", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'start'>) => void) | undefined } */
     get onstart() {
-      return getEventAttributeValue(this, "start");
+      return this.#eventListenerMap.getProperty("start");
     }
     set onstart(value) {
-      setEventAttributeValue(this, "start", value);
+      this.#eventListenerMap.setProperty("start", value);
     }
     start() {
       this._startOnce().catch((err) => {
-        this.dispatchEvent(new ErrorEvent("error", { error: err, message: err && (err.stack || err.message) }));
+        this.dispatchEvent(
+          new SpeechRecognitionErrorEvent("error", { error: err, message: err && (err.stack || err.message) })
+        );
       });
     }
     async _startOnce() {
@@ -486,10 +594,7 @@ function createSpeechRecognitionPonyfillFromRecognizer({
           Object.keys(event).forEach((name) => this.emitCognitiveServices(name, event[name]));
           const errorMessage = canceled && canceled.errorDetails;
           if (/Permission\sdenied/u.test(errorMessage || "")) {
-            finalEvent = {
-              error: "not-allowed",
-              type: "error"
-            };
+            finalEvent = new SpeechRecognitionErrorEvent("error", { error: "not-allowed" });
             break;
           }
           if (!loop) {
@@ -501,23 +606,14 @@ function createSpeechRecognitionPonyfillFromRecognizer({
                 this.dispatchEvent(new SpeechRecognitionEvent("audiostart"));
                 this.dispatchEvent(new SpeechRecognitionEvent("audioend"));
               }
-              finalEvent = {
-                error: "network",
-                type: "error"
-              };
+              finalEvent = new SpeechRecognitionErrorEvent("error", { error: "network" });
             } else {
-              finalEvent = {
-                error: "unknown",
-                type: "error"
-              };
+              finalEvent = new SpeechRecognitionErrorEvent("error", { error: "unknown" });
             }
             break;
           } else if (abort || stop) {
             if (abort) {
-              finalEvent = {
-                error: "aborted",
-                type: "error"
-              };
+              finalEvent = new SpeechRecognitionErrorEvent("error", { error: "aborted" });
               stopping = "abort";
             } else {
               pause();
@@ -540,10 +636,11 @@ function createSpeechRecognitionPonyfillFromRecognizer({
             break;
           } else if (stopping !== "abort") {
             if (recognized && recognized.result && recognized.result.reason === ResultReason2.NoMatch) {
-              finalEvent = {
-                error: "no-speech",
-                type: "error"
-              };
+              if (!this.continuous || stopping === "stop") {
+                finalEvent = new SpeechRecognitionEvent("result", { results: finalizedResults });
+                recognizer.stopContinuousRecognitionAsync && await cognitiveServicesAsyncToPromise(recognizer.stopContinuousRecognitionAsync.bind(recognizer))();
+                break;
+              }
             } else if (recognized || recognizing) {
               if (!audioStarted) {
                 this.dispatchEvent(new SpeechRecognitionEvent("audiostart"));
@@ -558,7 +655,7 @@ function createSpeechRecognitionPonyfillFromRecognizer({
                 speechStarted = true;
               }
               if (recognized) {
-                const result = cognitiveServiceEventResultToWebSpeechRecognitionResultList_default(recognized.result, {
+                const result = cognitiveServiceEventResultToWebSpeechRecognitionResult_default(recognized.result, {
                   maxAlternatives: this.maxAlternatives,
                   textNormalization
                 });
@@ -567,35 +664,34 @@ function createSpeechRecognitionPonyfillFromRecognizer({
                   finalizedResults = [...finalizedResults, result];
                   this.continuous && this.dispatchEvent(
                     new SpeechRecognitionEvent("result", {
-                      results: finalizedResults
+                      results: new SpeechRecognitionResultList(finalizedResults)
                     })
                   );
                 }
                 if (this.continuous && recognizable) {
-                  finalEvent = null;
+                  finalEvent = void 0;
                 } else {
-                  finalEvent = {
-                    results: finalizedResults,
-                    type: "result"
-                  };
+                  finalEvent = new SpeechRecognitionEvent("result", {
+                    results: new SpeechRecognitionResultList(finalizedResults)
+                  });
                 }
-                if (!this.continuous && recognizer.stopContinuousRecognitionAsync) {
+                if ((!this.continuous || stopping === "stop") && recognizer.stopContinuousRecognitionAsync) {
                   await cognitiveServicesAsyncToPromise(recognizer.stopContinuousRecognitionAsync.bind(recognizer))();
                 }
                 if (looseEvents && finalEvent && recognizable) {
-                  this.dispatchEvent(new SpeechRecognitionEvent(finalEvent.type, finalEvent));
-                  finalEvent = null;
+                  this.dispatchEvent(finalEvent);
+                  finalEvent = void 0;
                 }
               } else if (recognizing) {
                 this.interimResults && this.dispatchEvent(
                   new SpeechRecognitionEvent("result", {
-                    results: [
+                    results: new SpeechRecognitionResultList([
                       ...finalizedResults,
-                      cognitiveServiceEventResultToWebSpeechRecognitionResultList_default(recognizing.result, {
+                      cognitiveServiceEventResultToWebSpeechRecognitionResult_default(recognizing.result, {
                         maxAlternatives: this.maxAlternatives,
                         textNormalization
                       })
-                    ]
+                    ])
                   })
                 );
               }
@@ -613,16 +709,9 @@ function createSpeechRecognitionPonyfillFromRecognizer({
         }
         if (finalEvent) {
           if (finalEvent.type === "result" && !finalEvent.results.length) {
-            finalEvent = {
-              error: "no-speech",
-              type: "error"
-            };
-          }
-          if (finalEvent.type === "error") {
-            this.dispatchEvent(new ErrorEvent("error", finalEvent));
-          } else {
-            this.dispatchEvent(new SpeechRecognitionEvent(finalEvent.type, finalEvent));
+            finalEvent = new SpeechRecognitionErrorEvent("error", { error: "no-speech" });
           }
+          this.dispatchEvent(finalEvent);
         }
         this.dispatchEvent(new SpeechRecognitionEvent("end"));
         detachAudioConfigEvent();
@@ -694,8 +783,8 @@ var createSpeechRecognitionPonyfill_default = (options) => {
 var SpeechToText_default = createSpeechRecognitionPonyfill_default;
 
 // src/SpeechServices/TextToSpeech/createSpeechSynthesisPonyfill.js
-import { EventTarget as EventTarget3, getEventAttributeValue as getEventAttributeValue3, setEventAttributeValue as setEventAttributeValue3 } from "event-target-shim";
-import onErrorResumeNext from "on-error-resume-next";
+import { EventTarget as EventTarget3, getEventAttributeValue as getEventAttributeValue2, setEventAttributeValue as setEventAttributeValue2 } from "event-target-shim";
+import { onErrorResumeNext } from "on-error-resume-next/async";
 
 // src/SpeechServices/TextToSpeech/AudioContextQueue.js
 import memoize from "memoize-one";
@@ -769,80 +858,6 @@ var AudioContextQueue_default = class {
   }
 };
 
-// src/SpeechServices/TextToSpeech/SpeechSynthesisVoice.js
-var SpeechSynthesisVoice_default = class {
-  constructor({ gender, lang, voiceURI }) {
-    this._default = false;
-    this._gender = gender;
-    this._lang = lang;
-    this._localService = false;
-    this._name = voiceURI;
-    this._voiceURI = voiceURI;
-  }
-  get default() {
-    return this._default;
-  }
-  get gender() {
-    return this._gender;
-  }
-  get lang() {
-    return this._lang;
-  }
-  get localService() {
-    return this._localService;
-  }
-  get name() {
-    return this._name;
-  }
-  get voiceURI() {
-    return this._voiceURI;
-  }
-};
-
-// src/SpeechServices/TextToSpeech/fetchCustomVoices.js
-async function fetchCustomVoices({ customVoiceHostname, deploymentId, region, subscriptionKey }) {
-  const hostname = customVoiceHostname || `${region}.customvoice.api.speech.microsoft.com`;
-  const res = await fetch(
-    `https://${encodeURI(hostname)}/api/texttospeech/v2.0/endpoints/${encodeURIComponent(deploymentId)}`,
-    {
-      headers: {
-        accept: "application/json",
-        "ocp-apim-subscription-key": subscriptionKey
-      }
-    }
-  );
-  if (!res.ok) {
-    throw new Error("Failed to fetch custom voices");
-  }
-  return res.json();
-}
-async function fetchCustomVoices_default({ customVoiceHostname, deploymentId, region, subscriptionKey }) {
-  const { models } = await fetchCustomVoices({ customVoiceHostname, deploymentId, region, subscriptionKey });
-  return models.map(
-    ({ properties: { Gender: gender }, locale: lang, name: voiceURI }) => new SpeechSynthesisVoice_default({ gender, lang, voiceURI })
-  ).sort(({ name: x }, { name: y }) => x > y ? 1 : x < y ? -1 : 0);
-}
-
-// src/SpeechServices/TextToSpeech/fetchVoices.js
-async function fetchVoices({ authorizationToken, region, speechSynthesisHostname, subscriptionKey }) {
-  const hostname = speechSynthesisHostname || `${encodeURI(region)}.tts.speech.microsoft.com`;
-  const res = await fetch(`https://${hostname}/cognitiveservices/voices/list`, {
-    headers: {
-      "content-type": "application/json",
-      ...authorizationToken ? {
-        authorization: `Bearer ${authorizationToken}`
-      } : {
-        "Ocp-Apim-Subscription-Key": subscriptionKey
-      }
-    }
-  });
-  if (!res.ok) {
-    throw new Error("Failed to fetch voices");
-  }
-  const voices = await res.json();
-  return voices.map(({ Gender: gender, Locale: lang, Name: voiceURI }) => new SpeechSynthesisVoice_default({ gender, lang, voiceURI })).sort(({ name: x }, { name: y }) => x > y ? 1 : x < y ? -1 : 0);
-}
-
 // src/SpeechServices/TextToSpeech/SpeechSynthesisEvent.js
 import { Event as Event2 } from "event-target-shim";
 var SpeechSynthesisEvent = class extends Event2 {
@@ -852,8 +867,8 @@ var SpeechSynthesisEvent = class extends Event2 {
 };
 
 // src/SpeechServices/TextToSpeech/SpeechSynthesisUtterance.js
-import { EventTarget as EventTarget2, getEventAttributeValue as getEventAttributeValue2, setEventAttributeValue as setEventAttributeValue2 } from "event-target-shim";
-import EventAsPromise from "event-as-promise";
+import { EventAsPromise } from "event-as-promise";
+import { EventTarget as EventTarget2, getEventAttributeValue, setEventAttributeValue } from "event-target-shim";
 
 // src/SpeechServices/TextToSpeech/fetchSpeechData.js
 import { decode } from "base64-arraybuffer";
@@ -992,46 +1007,46 @@ var SpeechSynthesisUtterance = class extends EventTarget2 {
     this._lang = value;
   }
   get onboundary() {
-    return getEventAttributeValue2(this, "boundary");
+    return getEventAttributeValue(this, "boundary");
   }
   set onboundary(value) {
-    setEventAttributeValue2(this, "boundary", value);
+    setEventAttributeValue(this, "boundary", value);
   }
   get onend() {
-    return getEventAttributeValue2(this, "end");
+    return getEventAttributeValue(this, "end");
   }
   set onend(value) {
-    setEventAttributeValue2(this, "end", value);
+    setEventAttributeValue(this, "end", value);
   }
   get onerror() {
-    return getEventAttributeValue2(this, "error");
+    return getEventAttributeValue(this, "error");
   }
   set onerror(value) {
-    setEventAttributeValue2(this, "error", value);
+    setEventAttributeValue(this, "error", value);
   }
   get onmark() {
-    return getEventAttributeValue2(this, "mark");
+    return getEventAttributeValue(this, "mark");
   }
   set onmark(value) {
-    setEventAttributeValue2(this, "mark", value);
+    setEventAttributeValue(this, "mark", value);
   }
   get onpause() {
-    return getEventAttributeValue2(this, "pause");
+    return getEventAttributeValue(this, "pause");
   }
   set onpause(value) {
-    setEventAttributeValue2(this, "pause", value);
+    setEventAttributeValue(this, "pause", value);
   }
   get onresume() {
-    return getEventAttributeValue2(this, "resume");
+    return getEventAttributeValue(this, "resume");
   }
   set onresume(value) {
-    setEventAttributeValue2(this, "resume", value);
+    setEventAttributeValue(this, "resume", value);
   }
   get onstart() {
-    return getEventAttributeValue2(this, "start");
+    return getEventAttributeValue(this, "start");
   }
   set onstart(value) {
-    setEventAttributeValue2(this, "start", value);
+    setEventAttributeValue(this, "start", value);
   }
   get pitch() {
     return this._pitch;
@@ -1090,6 +1105,80 @@ var SpeechSynthesisUtterance = class extends EventTarget2 {
 };
 var SpeechSynthesisUtterance_default = SpeechSynthesisUtterance;
 
+// src/SpeechServices/TextToSpeech/SpeechSynthesisVoice.js
+var SpeechSynthesisVoice_default = class {
+  constructor({ gender, lang, voiceURI }) {
+    this._default = false;
+    this._gender = gender;
+    this._lang = lang;
+    this._localService = false;
+    this._name = voiceURI;
+    this._voiceURI = voiceURI;
+  }
+  get default() {
+    return this._default;
+  }
+  get gender() {
+    return this._gender;
+  }
+  get lang() {
+    return this._lang;
+  }
+  get localService() {
+    return this._localService;
+  }
+  get name() {
+    return this._name;
+  }
+  get voiceURI() {
+    return this._voiceURI;
+  }
+};
+
+// src/SpeechServices/TextToSpeech/fetchCustomVoices.js
+async function fetchCustomVoices({ customVoiceHostname, deploymentId, region, subscriptionKey }) {
+  const hostname = customVoiceHostname || `${region}.customvoice.api.speech.microsoft.com`;
+  const res = await fetch(
+    `https://${encodeURI(hostname)}/api/texttospeech/v2.0/endpoints/${encodeURIComponent(deploymentId)}`,
+    {
+      headers: {
+        accept: "application/json",
+        "ocp-apim-subscription-key": subscriptionKey
+      }
+    }
+  );
+  if (!res.ok) {
+    throw new Error("Failed to fetch custom voices");
+  }
+  return res.json();
+}
+async function fetchCustomVoices_default({ customVoiceHostname, deploymentId, region, subscriptionKey }) {
+  const { models } = await fetchCustomVoices({ customVoiceHostname, deploymentId, region, subscriptionKey });
+  return models.map(
+    ({ properties: { Gender: gender }, locale: lang, name: voiceURI }) => new SpeechSynthesisVoice_default({ gender, lang, voiceURI })
+  ).sort(({ name: x }, { name: y }) => x > y ? 1 : x < y ? -1 : 0);
+}
+
+// src/SpeechServices/TextToSpeech/fetchVoices.js
+async function fetchVoices({ authorizationToken, region, speechSynthesisHostname, subscriptionKey }) {
+  const hostname = speechSynthesisHostname || `${encodeURI(region)}.tts.speech.microsoft.com`;
+  const res = await fetch(`https://${hostname}/cognitiveservices/voices/list`, {
+    headers: {
+      "content-type": "application/json",
+      ...authorizationToken ? {
+        authorization: `Bearer ${authorizationToken}`
+      } : {
+        "Ocp-Apim-Subscription-Key": subscriptionKey
+      }
+    }
+  });
+  if (!res.ok) {
+    throw new Error("Failed to fetch voices");
+  }
+  const voices = await res.json();
+  return voices.map(({ Gender: gender, Locale: lang, Name: voiceURI }) => new SpeechSynthesisVoice_default({ gender, lang, voiceURI })).sort(({ name: x }, { name: y }) => x > y ? 1 : x < y ? -1 : 0);
+}
+
 // src/SpeechServices/TextToSpeech/createSpeechSynthesisPonyfill.js
 var DEFAULT_OUTPUT_FORMAT2 = "audio-24khz-160kbitrate-mono-mp3";
 var EMPTY_ARRAY = [];
@@ -1122,10 +1211,10 @@ var createSpeechSynthesisPonyfill_default = (options) => {
       return EMPTY_ARRAY;
     }
     get onvoiceschanged() {
-      return getEventAttributeValue3(this, "voiceschanged");
+      return getEventAttributeValue2(this, "voiceschanged");
     }
     set onvoiceschanged(value) {
-      setEventAttributeValue3(this, "voiceschanged", value);
+      setEventAttributeValue2(this, "voiceschanged", value);
     }
     pause() {
       this.queue.pause();
@@ -1220,7 +1309,7 @@ function createSpeechServicesPonyfill(options = {}, ...args) {
 }
 var meta = document.createElement("meta");
 meta.setAttribute("name", "web-speech-cognitive-services");
-meta.setAttribute("content", `version=${"8.0.0-main.478b2e9"}`);
+meta.setAttribute("content", `version=${"8.0.0-main.5903868"}`);
 document.head.appendChild(meta);
 export {
   SpeechToText_default as createSpeechRecognitionPonyfill,