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

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

@@ -38,66 +38,6 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfill.js
-var import_event_target_shim = require("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
-var import_microsoft_cognitiveservices_speech = require("microsoft-cognitiveservices-speech-sdk/distrib/lib/microsoft.cognitiveservices.speech.sdk");
-var SpeechSDK_default = {
-  AudioConfig: import_microsoft_cognitiveservices_speech.AudioConfig,
-  OutputFormat: import_microsoft_cognitiveservices_speech.OutputFormat,
-  ResultReason: import_microsoft_cognitiveservices_speech.ResultReason,
-  SpeechConfig: import_microsoft_cognitiveservices_speech.SpeechConfig,
-  SpeechRecognizer: import_microsoft_cognitiveservices_speech.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 = {};
@@ -216,6 +156,121 @@ function patchOptions({
   };
 }
 
+// src/SpeechServices/SpeechSDK.js
+var import_microsoft_cognitiveservices_speech = require("microsoft-cognitiveservices-speech-sdk/distrib/lib/microsoft.cognitiveservices.speech.sdk");
+var SpeechSDK_default = {
+  AudioConfig: import_microsoft_cognitiveservices_speech.AudioConfig,
+  OutputFormat: import_microsoft_cognitiveservices_speech.OutputFormat,
+  ResultReason: import_microsoft_cognitiveservices_speech.ResultReason,
+  SpeechConfig: import_microsoft_cognitiveservices_speech.SpeechConfig,
+  SpeechRecognizer: import_microsoft_cognitiveservices_speech.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() {
@@ -238,6 +293,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 }) {
@@ -259,16 +361,6 @@ function averageAmplitude(arrayBuffer) {
 function cognitiveServicesAsyncToPromise(fn) {
   return (...args) => new Promise((resolve, reject) => fn(...args, resolve, reject));
 }
-var SpeechRecognitionEvent = class extends import_event_target_shim.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);
@@ -309,7 +401,7 @@ function createSpeechRecognitionPonyfillFromRecognizer({
   textNormalization
 }) {
   SpeechRecognizer2.enableTelemetry(enableTelemetry !== false);
-  class SpeechRecognition extends import_event_target_shim.EventTarget {
+  class SpeechRecognition extends EventTarget {
     constructor() {
       super();
       this._continuous = false;
@@ -317,7 +409,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", {
@@ -362,75 +457,88 @@ function createSpeechRecognitionPonyfillFromRecognizer({
     set lang(value) {
       this._lang = value;
     }
+    /** @type { ((event: SpeechRecognitionEvent<'audioend'>) => void) | undefined } */
     get onaudioend() {
-      return (0, import_event_target_shim.getEventAttributeValue)(this, "audioend");
+      return this.#eventListenerMap.getProperty("audioend");
     }
     set onaudioend(value) {
-      (0, import_event_target_shim.setEventAttributeValue)(this, "audioend", value);
+      this.#eventListenerMap.setProperty("audioend", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'audiostart'>) => void) | undefined } */
     get onaudiostart() {
-      return (0, import_event_target_shim.getEventAttributeValue)(this, "audiostart");
+      return this.#eventListenerMap.getProperty("audiostart");
     }
     set onaudiostart(value) {
-      (0, import_event_target_shim.setEventAttributeValue)(this, "audiostart", value);
+      this.#eventListenerMap.setProperty("audiostart", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'cognitiveservices'>) => void) | undefined } */
     get oncognitiveservices() {
-      return (0, import_event_target_shim.getEventAttributeValue)(this, "cognitiveservices");
+      return this.#eventListenerMap.getProperty("cognitiveservices");
     }
     set oncognitiveservices(value) {
-      (0, import_event_target_shim.setEventAttributeValue)(this, "cognitiveservices", value);
+      this.#eventListenerMap.setProperty("cognitiveservices", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'end'>) => void) | undefined } */
     get onend() {
-      return (0, import_event_target_shim.getEventAttributeValue)(this, "end");
+      return this.#eventListenerMap.getProperty("end");
     }
     set onend(value) {
-      (0, import_event_target_shim.setEventAttributeValue)(this, "end", value);
+      this.#eventListenerMap.setProperty("end", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'error'>) => void) | undefined } */
     get onerror() {
-      return (0, import_event_target_shim.getEventAttributeValue)(this, "error");
+      return this.#eventListenerMap.getProperty("error");
     }
     set onerror(value) {
-      (0, import_event_target_shim.setEventAttributeValue)(this, "error", value);
+      this.#eventListenerMap.setProperty("error", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'result'>) => void) | undefined } */
     get onresult() {
-      return (0, import_event_target_shim.getEventAttributeValue)(this, "result");
+      return this.#eventListenerMap.getProperty("result");
     }
     set onresult(value) {
-      (0, import_event_target_shim.setEventAttributeValue)(this, "result", value);
+      this.#eventListenerMap.setProperty("result", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'soundend'>) => void) | undefined } */
     get onsoundend() {
-      return (0, import_event_target_shim.getEventAttributeValue)(this, "soundend");
+      return this.#eventListenerMap.getProperty("soundend");
     }
     set onsoundend(value) {
-      (0, import_event_target_shim.setEventAttributeValue)(this, "soundend", value);
+      this.#eventListenerMap.setProperty("soundend", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'soundstart'>) => void) | undefined } */
     get onsoundstart() {
-      return (0, import_event_target_shim.getEventAttributeValue)(this, "soundstart");
+      return this.#eventListenerMap.getProperty("soundstart");
     }
     set onsoundstart(value) {
-      (0, import_event_target_shim.setEventAttributeValue)(this, "soundstart", value);
+      this.#eventListenerMap.setProperty("soundstart", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'speechend'>) => void) | undefined } */
     get onspeechend() {
-      return (0, import_event_target_shim.getEventAttributeValue)(this, "speechend");
+      return this.#eventListenerMap.getProperty("speechend");
     }
     set onspeechend(value) {
-      (0, import_event_target_shim.setEventAttributeValue)(this, "speechend", value);
+      this.#eventListenerMap.setProperty("speechend", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'speechstart'>) => void) | undefined } */
     get onspeechstart() {
-      return (0, import_event_target_shim.getEventAttributeValue)(this, "speechstart");
+      return this.#eventListenerMap.getProperty("speechstart");
     }
     set onspeechstart(value) {
-      (0, import_event_target_shim.setEventAttributeValue)(this, "speechstart", value);
+      this.#eventListenerMap.setProperty("speechstart", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'start'>) => void) | undefined } */
     get onstart() {
-      return (0, import_event_target_shim.getEventAttributeValue)(this, "start");
+      return this.#eventListenerMap.getProperty("start");
     }
     set onstart(value) {
-      (0, import_event_target_shim.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() {
@@ -520,10 +628,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) {
@@ -535,23 +640,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();
@@ -574,10 +670,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"));
@@ -592,7 +689,7 @@ function createSpeechRecognitionPonyfillFromRecognizer({
                 speechStarted = true;
               }
               if (recognized) {
-                const result = cognitiveServiceEventResultToWebSpeechRecognitionResultList_default(recognized.result, {
+                const result = cognitiveServiceEventResultToWebSpeechRecognitionResult_default(recognized.result, {
                   maxAlternatives: this.maxAlternatives,
                   textNormalization
                 });
@@ -601,35 +698,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
                       })
-                    ]
+                    ])
                   })
                 );
               }
@@ -647,16 +743,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();
@@ -728,8 +817,8 @@ var createSpeechRecognitionPonyfill_default = (options) => {
 var SpeechToText_default = createSpeechRecognitionPonyfill_default;
 
 // src/SpeechServices/TextToSpeech/createSpeechSynthesisPonyfill.js
-var import_event_target_shim4 = require("event-target-shim");
-var import_on_error_resume_next = __toESM(require("on-error-resume-next"));
+var import_event_target_shim3 = require("event-target-shim");
+var import_async = require("on-error-resume-next/async");
 
 // src/SpeechServices/TextToSpeech/AudioContextQueue.js
 var import_memoize_one = __toESM(require("memoize-one"));
@@ -803,91 +892,17 @@ 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
-var import_event_target_shim2 = require("event-target-shim");
-var SpeechSynthesisEvent = class extends import_event_target_shim2.Event {
+var import_event_target_shim = require("event-target-shim");
+var SpeechSynthesisEvent = class extends import_event_target_shim.Event {
   constructor(type) {
     super(type);
   }
 };
 
 // src/SpeechServices/TextToSpeech/SpeechSynthesisUtterance.js
-var import_event_target_shim3 = require("event-target-shim");
-var import_event_as_promise = __toESM(require("event-as-promise"));
+var import_event_as_promise = require("event-as-promise");
+var import_event_target_shim2 = require("event-target-shim");
 
 // src/SpeechServices/TextToSpeech/fetchSpeechData.js
 var import_base64_arraybuffer = require("base64-arraybuffer");
@@ -982,8 +997,8 @@ function asyncDecodeAudioData(audioContext, arrayBuffer) {
 }
 function playDecoded(audioContext, audioBuffer, source) {
   return new Promise((resolve, reject) => {
-    const audioContextClosed = new import_event_as_promise.default();
-    const sourceEnded = new import_event_as_promise.default();
+    const audioContextClosed = new import_event_as_promise.EventAsPromise();
+    const sourceEnded = new import_event_as_promise.EventAsPromise();
     const unsubscribe = subscribeEvent(
       audioContext,
       "statechange",
@@ -1002,7 +1017,7 @@ function playDecoded(audioContext, audioBuffer, source) {
     }
   });
 }
-var SpeechSynthesisUtterance = class extends import_event_target_shim3.EventTarget {
+var SpeechSynthesisUtterance = class extends import_event_target_shim2.EventTarget {
   constructor(text) {
     super();
     this._lang = null;
@@ -1026,46 +1041,46 @@ var SpeechSynthesisUtterance = class extends import_event_target_shim3.EventTarg
     this._lang = value;
   }
   get onboundary() {
-    return (0, import_event_target_shim3.getEventAttributeValue)(this, "boundary");
+    return (0, import_event_target_shim2.getEventAttributeValue)(this, "boundary");
   }
   set onboundary(value) {
-    (0, import_event_target_shim3.setEventAttributeValue)(this, "boundary", value);
+    (0, import_event_target_shim2.setEventAttributeValue)(this, "boundary", value);
   }
   get onend() {
-    return (0, import_event_target_shim3.getEventAttributeValue)(this, "end");
+    return (0, import_event_target_shim2.getEventAttributeValue)(this, "end");
   }
   set onend(value) {
-    (0, import_event_target_shim3.setEventAttributeValue)(this, "end", value);
+    (0, import_event_target_shim2.setEventAttributeValue)(this, "end", value);
   }
   get onerror() {
-    return (0, import_event_target_shim3.getEventAttributeValue)(this, "error");
+    return (0, import_event_target_shim2.getEventAttributeValue)(this, "error");
   }
   set onerror(value) {
-    (0, import_event_target_shim3.setEventAttributeValue)(this, "error", value);
+    (0, import_event_target_shim2.setEventAttributeValue)(this, "error", value);
   }
   get onmark() {
-    return (0, import_event_target_shim3.getEventAttributeValue)(this, "mark");
+    return (0, import_event_target_shim2.getEventAttributeValue)(this, "mark");
   }
   set onmark(value) {
-    (0, import_event_target_shim3.setEventAttributeValue)(this, "mark", value);
+    (0, import_event_target_shim2.setEventAttributeValue)(this, "mark", value);
   }
   get onpause() {
-    return (0, import_event_target_shim3.getEventAttributeValue)(this, "pause");
+    return (0, import_event_target_shim2.getEventAttributeValue)(this, "pause");
   }
   set onpause(value) {
-    (0, import_event_target_shim3.setEventAttributeValue)(this, "pause", value);
+    (0, import_event_target_shim2.setEventAttributeValue)(this, "pause", value);
   }
   get onresume() {
-    return (0, import_event_target_shim3.getEventAttributeValue)(this, "resume");
+    return (0, import_event_target_shim2.getEventAttributeValue)(this, "resume");
   }
   set onresume(value) {
-    (0, import_event_target_shim3.setEventAttributeValue)(this, "resume", value);
+    (0, import_event_target_shim2.setEventAttributeValue)(this, "resume", value);
   }
   get onstart() {
-    return (0, import_event_target_shim3.getEventAttributeValue)(this, "start");
+    return (0, import_event_target_shim2.getEventAttributeValue)(this, "start");
   }
   set onstart(value) {
-    (0, import_event_target_shim3.setEventAttributeValue)(this, "start", value);
+    (0, import_event_target_shim2.setEventAttributeValue)(this, "start", value);
   }
   get pitch() {
     return this._pitch;
@@ -1124,6 +1139,80 @@ var SpeechSynthesisUtterance = class extends import_event_target_shim3.EventTarg
 };
 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 = [];
@@ -1143,7 +1232,7 @@ var createSpeechSynthesisPonyfill_default = (options) => {
     );
     return {};
   }
-  class SpeechSynthesis extends import_event_target_shim4.EventTarget {
+  class SpeechSynthesis extends import_event_target_shim3.EventTarget {
     constructor() {
       super();
       this.queue = new AudioContextQueue_default({ audioContext, ponyfill });
@@ -1156,10 +1245,10 @@ var createSpeechSynthesisPonyfill_default = (options) => {
       return EMPTY_ARRAY;
     }
     get onvoiceschanged() {
-      return (0, import_event_target_shim4.getEventAttributeValue)(this, "voiceschanged");
+      return (0, import_event_target_shim3.getEventAttributeValue)(this, "voiceschanged");
     }
     set onvoiceschanged(value) {
-      (0, import_event_target_shim4.setEventAttributeValue)(this, "voiceschanged", value);
+      (0, import_event_target_shim3.setEventAttributeValue)(this, "voiceschanged", value);
     }
     pause() {
       this.queue.pause();
@@ -1200,7 +1289,7 @@ var createSpeechSynthesisPonyfill_default = (options) => {
           console.warn(
             "web-speech-cognitive-services: Listing of custom voice models are only available when using subscription key."
           );
-          await (0, import_on_error_resume_next.default)(async () => {
+          await (0, import_async.onErrorResumeNext)(async () => {
             const voices = await fetchCustomVoices_default({
               customVoiceHostname,
               deploymentId: speechSynthesisDeploymentId,
@@ -1212,7 +1301,7 @@ var createSpeechSynthesisPonyfill_default = (options) => {
           });
         }
       } else {
-        await (0, import_on_error_resume_next.default)(async () => {
+        await (0, import_async.onErrorResumeNext)(async () => {
           const voices = await fetchVoices(await fetchCredentials());
           this.getVoices = () => voices;
         });
@@ -1254,7 +1343,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);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {