web-speech-cognitive-services 8.0.0-main.5903868 → 8.0.0-main.6cbf0fb

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

@@ -792,7 +792,7 @@
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.AudioStreamNodeErrorEvent = exports.AudioStreamNodeDetachedEvent = exports.AudioStreamNodeAttachedEvent = exports.AudioStreamNodeAttachingEvent = exports.AudioStreamNodeEvent = exports.AudioSourceErrorEvent = exports.AudioSourceOffEvent = exports.AudioSourceReadyEvent = exports.AudioSourceInitializingEvent = exports.AudioSourceEvent = void 0;
       var PlatformEvent_js_1 = require_PlatformEvent();
-      var AudioSourceEvent = class extends PlatformEvent_js_1.PlatformEvent {
+      var AudioSourceEvent2 = class extends PlatformEvent_js_1.PlatformEvent {
         constructor(eventName, audioSourceId, eventType = PlatformEvent_js_1.EventType.Info) {
           super(eventName, eventType);
           this.privAudioSourceId = audioSourceId;
@@ -801,26 +801,26 @@
           return this.privAudioSourceId;
         }
       };
-      exports.AudioSourceEvent = AudioSourceEvent;
-      var AudioSourceInitializingEvent = class extends AudioSourceEvent {
+      exports.AudioSourceEvent = AudioSourceEvent2;
+      var AudioSourceInitializingEvent = class extends AudioSourceEvent2 {
         constructor(audioSourceId) {
           super("AudioSourceInitializingEvent", audioSourceId);
         }
       };
       exports.AudioSourceInitializingEvent = AudioSourceInitializingEvent;
-      var AudioSourceReadyEvent = class extends AudioSourceEvent {
+      var AudioSourceReadyEvent = class extends AudioSourceEvent2 {
         constructor(audioSourceId) {
           super("AudioSourceReadyEvent", audioSourceId);
         }
       };
       exports.AudioSourceReadyEvent = AudioSourceReadyEvent;
-      var AudioSourceOffEvent = class extends AudioSourceEvent {
+      var AudioSourceOffEvent = class extends AudioSourceEvent2 {
         constructor(audioSourceId) {
           super("AudioSourceOffEvent", audioSourceId);
         }
       };
       exports.AudioSourceOffEvent = AudioSourceOffEvent;
-      var AudioSourceErrorEvent = class extends AudioSourceEvent {
+      var AudioSourceErrorEvent = class extends AudioSourceEvent2 {
         constructor(audioSourceId, error) {
           super("AudioSourceErrorEvent", audioSourceId, PlatformEvent_js_1.EventType.Error);
           this.privError = error;
@@ -830,7 +830,7 @@
         }
       };
       exports.AudioSourceErrorEvent = AudioSourceErrorEvent;
-      var AudioStreamNodeEvent = class extends AudioSourceEvent {
+      var AudioStreamNodeEvent = class extends AudioSourceEvent2 {
         constructor(eventName, audioSourceId, audioNodeId) {
           super(eventName, audioSourceId);
           this.privAudioNodeId = audioNodeId;
@@ -6920,7 +6920,7 @@
       var Exports_js_2 = require_Exports();
       var Contracts_js_1 = require_Contracts();
       var Exports_js_3 = require_Exports3();
-      var SpeechRecognizer3 = class _SpeechRecognizer extends Exports_js_3.Recognizer {
+      var SpeechRecognizer4 = class _SpeechRecognizer extends Exports_js_3.Recognizer {
         /**
          * SpeechRecognizer constructor.
          * @constructor
@@ -7123,7 +7123,7 @@
           return new Exports_js_1.SpeechServiceRecognizer(authentication, connectionFactory, configImpl, recognizerConfig, this);
         }
       };
-      exports.SpeechRecognizer = SpeechRecognizer3;
+      exports.SpeechRecognizer = SpeechRecognizer4;
     }
   });
 
@@ -23432,41 +23432,6 @@
     }
   });
 
-  // ../../node_modules/p-defer/index.js
-  function pDefer() {
-    const deferred = {};
-    deferred.promise = new Promise((resolve, reject) => {
-      deferred.resolve = resolve;
-      deferred.reject = reject;
-    });
-    return deferred;
-  }
-
-  // src/Util/createPromiseQueue.js
-  function createPromiseQueue_default() {
-    let shiftDeferred;
-    const queue = [];
-    const push = (value) => {
-      if (shiftDeferred) {
-        const { resolve } = shiftDeferred;
-        shiftDeferred = null;
-        resolve(value);
-      } else {
-        queue.push(value);
-      }
-    };
-    const shift = () => {
-      if (queue.length) {
-        return Promise.resolve(queue.shift());
-      }
-      return (shiftDeferred || (shiftDeferred = pDefer())).promise;
-    };
-    return {
-      push,
-      shift
-    };
-  }
-
   // src/SpeechServices/resolveFunctionOrReturnValue.ts
   function isFunction(value) {
     return typeof value === "function";
@@ -23475,17 +23440,21 @@
     return isFunction(fnOrValue) ? fnOrValue() : fnOrValue;
   }
 
-  // src/SpeechServices/patchOptions.js
+  // src/SpeechServices/patchOptions.ts
   var shouldWarnOnSubscriptionKey = true;
-  function patchOptions({
-    authorizationToken,
-    credentials,
-    looseEvent,
-    looseEvents,
-    region = "westus",
-    subscriptionKey,
-    ...otherOptions
-  } = {}) {
+  function patchOptions(init) {
+    const {
+      audioConfig,
+      authorizationToken,
+      enableTelemetry,
+      looseEvent,
+      referenceGrammars,
+      region = "westus",
+      speechRecognitionEndpointId,
+      subscriptionKey,
+      textNormalization
+    } = init;
+    let { credentials, looseEvents } = init;
     if (typeof looseEvent !== "undefined") {
       console.warn('web-speech-cognitive-services: The option "looseEvent" should be named as "looseEvents".');
       looseEvents = looseEvent;
@@ -23497,11 +23466,12 @@
         console.warn(
           "web-speech-cognitive-services: We are deprecating authorizationToken, region, and subscriptionKey. Please use credentials instead. The deprecated option will be removed on or after 2020-11-14."
         );
-        credentials = async () => authorizationToken ? { authorizationToken: await resolveFunctionOrReturnValue(authorizationToken), region } : { region, subscriptionKey: await resolveFunctionOrReturnValue(subscriptionKey) };
+        credentials = async () => typeof init.authorizationToken !== "undefined" ? { authorizationToken: await resolveFunctionOrReturnValue(init.authorizationToken), region } : { region, subscriptionKey: await resolveFunctionOrReturnValue(init.subscriptionKey) };
       }
     }
-    return {
-      ...otherOptions,
+    return Object.freeze({
+      audioConfig,
+      enableTelemetry,
       fetchCredentials: async () => {
         const {
           authorizationToken: authorizationToken2,
@@ -23536,21 +23506,23 @@
           );
           shouldWarnOnSubscriptionKey = false;
         }
-        const resolvedCredentials = authorizationToken2 ? { authorizationToken: authorizationToken2 } : { subscriptionKey: subscriptionKey2 };
-        if (region2) {
-          resolvedCredentials.region = region2;
-        } else {
-          resolvedCredentials.customVoiceHostname = customVoiceHostname;
-          resolvedCredentials.speechRecognitionHostname = speechRecognitionHostname;
-          resolvedCredentials.speechSynthesisHostname = speechSynthesisHostname;
-        }
-        return resolvedCredentials;
+        return {
+          ...typeof authorizationToken2 !== "undefined" ? { authorizationToken: authorizationToken2 } : { subscriptionKey: subscriptionKey2 },
+          ...typeof region2 !== "undefined" ? { region: region2 } : {
+            customVoiceHostname,
+            speechRecognitionHostname,
+            speechSynthesisHostname
+          }
+        };
       },
-      looseEvents
-    };
+      looseEvents: !!looseEvents,
+      referenceGrammars: referenceGrammars && Object.freeze([...referenceGrammars]),
+      speechRecognitionEndpointId,
+      textNormalization
+    });
   }
 
-  // src/SpeechServices/SpeechSDK.js
+  // src/SpeechServices/SpeechSDK.ts
   var import_microsoft_cognitiveservices_speech = __toESM(require_microsoft_cognitiveservices_speech_sdk());
   var SpeechSDK_default = {
     AudioConfig: import_microsoft_cognitiveservices_speech.AudioConfig,
@@ -23560,6 +23532,41 @@
     SpeechRecognizer: import_microsoft_cognitiveservices_speech.SpeechRecognizer
   };
 
+  // ../../node_modules/p-defer/index.js
+  function pDefer() {
+    const deferred = {};
+    deferred.promise = new Promise((resolve, reject) => {
+      deferred.resolve = resolve;
+      deferred.reject = reject;
+    });
+    return deferred;
+  }
+
+  // src/Util/createPromiseQueue.js
+  function createPromiseQueue_default() {
+    let shiftDeferred;
+    const queue = [];
+    const push = (value) => {
+      if (shiftDeferred) {
+        const { resolve } = shiftDeferred;
+        shiftDeferred = null;
+        resolve(value);
+      } else {
+        queue.push(value);
+      }
+    };
+    const shift = () => {
+      if (queue.length) {
+        return Promise.resolve(queue.shift());
+      }
+      return (shiftDeferred || (shiftDeferred = pDefer())).promise;
+    };
+    return {
+      push,
+      shift
+    };
+  }
+
   // src/SpeechServices/SpeechToText/SpeechRecognitionAlternative.ts
   var SpeechRecognitionAlternative = class {
     constructor({ confidence, transcript }) {
@@ -23576,7 +23583,7 @@
     }
   };
 
-  // src/SpeechServices/SpeechToText/FakeArray.ts
+  // src/SpeechServices/SpeechToText/private/FakeArray.ts
   var FakeArray = class {
     constructor(array) {
       if (!array) {
@@ -23644,7 +23651,15 @@
     return new SpeechRecognitionResult({ isFinal: false, results: [] });
   }
 
-  // src/SpeechServices/SpeechToText/EventListenerMap.ts
+  // src/SpeechServices/SpeechToText/cognitiveServicesAsyncToPromise.ts
+  function cognitiveServicesAsyncToPromise(fn, context = void 0) {
+    return (...args) => (
+      // eslint-disable-next-line prefer-spread
+      new Promise((resolve, reject) => fn.apply(context, [...args, resolve, reject]))
+    );
+  }
+
+  // src/SpeechServices/SpeechToText/private/EventListenerMap.ts
   var EventListenerMap = class {
     constructor(eventTarget) {
       this.#eventTarget = eventTarget;
@@ -23665,22 +23680,90 @@
     }
   };
 
-  // src/SpeechServices/SpeechToText/SpeechGrammarList.js
-  var SpeechGrammarList_default = class {
+  // src/SpeechServices/SpeechToText/private/prepareAudioConfig.ts
+  var import_AudioSourceEvents = __toESM(require_AudioSourceEvents());
+
+  // src/SpeechServices/SpeechToText/private/averageAmplitude.ts
+  function averageAmplitude(arrayBuffer) {
+    const array = Array.from(new Int16Array(arrayBuffer));
+    return array.reduce((averageAmplitude2, amplitude) => averageAmplitude2 + Math.abs(amplitude), 0) / array.length;
+  }
+
+  // src/SpeechServices/SpeechToText/private/prepareAudioConfig.ts
+  function prepareAudioConfig(audioConfig) {
+    const audioConfigImpl = audioConfig;
+    const originalAttach = audioConfigImpl.attach;
+    const boundOriginalAttach = audioConfigImpl.attach.bind(audioConfigImpl);
+    let firstChunk = false;
+    let muted = false;
+    audioConfigImpl.attach = async () => {
+      const reader = await boundOriginalAttach("");
+      return {
+        ...reader,
+        read: async () => {
+          const chunk = await reader.read();
+          if (!firstChunk && averageAmplitude(chunk.buffer) > 150) {
+            audioConfigImpl.events.onEvent(new import_AudioSourceEvents.AudioSourceEvent("FirstAudibleChunk", ""));
+            firstChunk = true;
+          }
+          if (muted) {
+            return { buffer: new ArrayBuffer(0), isEnd: true, timeReceived: Date.now() };
+          }
+          return chunk;
+        }
+      };
+    };
+    return {
+      audioConfig,
+      pause: () => {
+        muted = true;
+      },
+      unprepare: () => {
+        audioConfigImpl.attach = originalAttach;
+      }
+    };
+  }
+
+  // src/SpeechServices/SpeechToText/private/serializeRecognitionResult.ts
+  function serializeRecognitionResult({
+    duration,
+    errorDetails,
+    json,
+    offset,
+    properties,
+    reason,
+    resultId,
+    text
+  }) {
+    return Object.freeze({
+      duration,
+      errorDetails,
+      json: json && JSON.parse(json),
+      offset,
+      properties,
+      reason,
+      resultId,
+      text
+    });
+  }
+
+  // src/SpeechServices/SpeechToText/SpeechGrammarList.ts
+  var SpeechGrammarList = class {
     constructor() {
-      this._phrases = [];
+      this.#phrases = [];
     }
     addFromString() {
       throw new Error("JSGF is not supported");
     }
+    #phrases;
     get phrases() {
-      return this._phrases;
+      return this.#phrases;
     }
     set phrases(value) {
       if (Array.isArray(value)) {
-        this._phrases = value;
+        this.#phrases = Object.freeze([...value]);
       } else if (typeof value === "string") {
-        this._phrases = [value];
+        this.#phrases = Object.freeze([value]);
       } else {
         throw new Error(`The provided value is not an array or of type 'string'`);
       }
@@ -23702,6 +23785,9 @@
     get message() {
       return this.#message;
     }
+    get type() {
+      return "error";
+    }
   };
 
   // src/SpeechServices/SpeechToText/SpeechRecognitionResultList.ts
@@ -23732,61 +23818,13 @@
     get results() {
       return this.#results;
     }
+    get type() {
+      return super.type;
+    }
   };
 
-  // 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 }) {
-    return {
-      duration,
-      errorDetails,
-      json: JSON.parse(json),
-      offset,
-      properties,
-      reason,
-      resultId,
-      text
-    };
-  }
-  function averageAmplitude(arrayBuffer) {
-    const array = new Int16Array(arrayBuffer);
-    return [].reduce.call(array, (averageAmplitude2, amplitude) => averageAmplitude2 + Math.abs(amplitude), 0) / array.length;
-  }
-  function cognitiveServicesAsyncToPromise(fn) {
-    return (...args) => new Promise((resolve, reject) => fn(...args, resolve, reject));
-  }
-  function prepareAudioConfig(audioConfig) {
-    const originalAttach = audioConfig.attach;
-    const boundOriginalAttach = audioConfig.attach.bind(audioConfig);
-    let firstChunk;
-    let muted;
-    audioConfig.attach = async () => {
-      const reader = await boundOriginalAttach();
-      return {
-        ...reader,
-        read: async () => {
-          const chunk = await reader.read();
-          if (!firstChunk && averageAmplitude(chunk.buffer) > 150) {
-            audioConfig.events.onEvent({ name: "FirstAudibleChunk" });
-            firstChunk = true;
-          }
-          if (muted) {
-            return { buffer: new ArrayBuffer(0), isEnd: true, timeReceived: Date.now() };
-          }
-          return chunk;
-        }
-      };
-    };
-    return {
-      audioConfig,
-      pause: () => {
-        muted = true;
-      },
-      unprepare: () => {
-        audioConfig.attach = originalAttach;
-      }
-    };
-  }
+  // src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfillFromRecognizer.ts
+  var { ResultReason: ResultReason2, SpeechRecognizer: SpeechRecognizer2 } = SpeechSDK_default;
   function createSpeechRecognitionPonyfillFromRecognizer({
     createRecognizer,
     enableTelemetry,
@@ -23796,17 +23834,13 @@
   }) {
     SpeechRecognizer2.enableTelemetry(enableTelemetry !== false);
     class SpeechRecognition extends EventTarget {
-      constructor() {
-        super();
-        this._continuous = false;
-        this._interimResults = false;
-        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;
+      #continuous = false;
+      #eventListenerMap = new EventListenerMap(this);
+      #grammars = new SpeechGrammarList();
+      #interimResults = false;
+      #lang = typeof window !== "undefined" ? window.document.documentElement.getAttribute("lang") || window.navigator.language : "en-US";
+      // eslint-disable-next-line no-magic-numbers
+      #maxAlternatives = 1;
       emitCognitiveServices(type, event) {
         this.dispatchEvent(
           new SpeechRecognitionEvent("cognitiveservices", {
@@ -23818,40 +23852,39 @@
         );
       }
       get continuous() {
-        return this._continuous;
+        return this.#continuous;
       }
       set continuous(value) {
-        this._continuous = value;
+        this.#continuous = value;
       }
       get grammars() {
-        return this._grammars;
+        return this.#grammars;
       }
       set grammars(value) {
-        if (value instanceof SpeechGrammarList_default) {
-          this._grammars = value;
+        if (value instanceof SpeechGrammarList) {
+          this.#grammars = value;
         } else {
           throw new Error(`The provided value is not of type 'SpeechGrammarList'`);
         }
       }
       get interimResults() {
-        return this._interimResults;
+        return this.#interimResults;
       }
       set interimResults(value) {
-        this._interimResults = value;
+        this.#interimResults = value;
       }
       get maxAlternatives() {
-        return this._maxAlternatives;
+        return this.#maxAlternatives;
       }
       set maxAlternatives(value) {
-        this._maxAlternatives = value;
+        this.#maxAlternatives = value;
       }
       get lang() {
-        return this._lang;
+        return this.#lang;
       }
       set lang(value) {
-        this._lang = value;
+        this.#lang = value;
       }
-      /** @type { ((event: SpeechRecognitionEvent<'audioend'>) => void) | undefined } */
       get onaudioend() {
         return this.#eventListenerMap.getProperty("audioend");
       }
@@ -23879,7 +23912,7 @@
       set onend(value) {
         this.#eventListenerMap.setProperty("end", value);
       }
-      /** @type { ((event: SpeechRecognitionEvent<'error'>) => void) | undefined } */
+      /** @type { ((event: SpeechRecognitionErrorEvent) => void) | undefined } */
       get onerror() {
         return this.#eventListenerMap.getProperty("error");
       }
@@ -23928,6 +23961,8 @@
       set onstart(value) {
         this.#eventListenerMap.setProperty("start", value);
       }
+      abort;
+      stop;
       start() {
         this._startOnce().catch((err) => {
           this.dispatchEvent(
@@ -23937,22 +23972,24 @@
       }
       async _startOnce() {
         const recognizer = await createRecognizer(this.lang);
-        const { pause, unprepare } = prepareAudioConfig(recognizer.audioConfig);
+        const { pause, unprepare } = prepareAudioConfig(recognizer["audioConfig"]);
         try {
           const queue = createPromiseQueue_default();
           let soundStarted;
           let speechStarted;
           let stopping;
-          const { detach: detachAudioConfigEvent } = recognizer.audioConfig.events.attach((event) => {
-            const { name } = event;
-            if (name === "AudioSourceReadyEvent") {
-              queue.push({ audioSourceReady: {} });
-            } else if (name === "AudioSourceOffEvent") {
-              queue.push({ audioSourceOff: {} });
-            } else if (name === "FirstAudibleChunk") {
-              queue.push({ firstAudibleChunk: {} });
+          const { detach: detachAudioConfigEvent } = recognizer["audioConfig"].events.attach(
+            (event) => {
+              const { name } = event;
+              if (name === "AudioSourceReadyEvent") {
+                queue.push({ audioSourceReady: {} });
+              } else if (name === "AudioSourceOffEvent") {
+                queue.push({ audioSourceOff: {} });
+              } else if (name === "FirstAudibleChunk") {
+                queue.push({ firstAudibleChunk: {} });
+              }
             }
-          });
+          );
           recognizer.canceled = (_, { errorDetails, offset, reason, sessionId }) => {
             queue.push({
               canceled: {
@@ -23994,18 +24031,18 @@
             queue.push({ speechEndDetected: { sessionId } });
           };
           const { phrases } = this.grammars;
-          const { dynamicGrammar } = recognizer.privReco;
-          referenceGrammars && referenceGrammars.length && dynamicGrammar.addReferenceGrammar(referenceGrammars);
-          phrases && phrases.length && dynamicGrammar.addPhrase(phrases);
-          await cognitiveServicesAsyncToPromise(recognizer.startContinuousRecognitionAsync.bind(recognizer))();
-          if (recognizer.stopContinuousRecognitionAsync) {
+          const { dynamicGrammar } = recognizer["privReco"];
+          referenceGrammars && referenceGrammars.length && dynamicGrammar.addReferenceGrammar([...referenceGrammars]);
+          phrases && phrases.length && dynamicGrammar.addPhrase([...phrases]);
+          await cognitiveServicesAsyncToPromise(recognizer.startContinuousRecognitionAsync, recognizer)();
+          if (typeof recognizer.stopContinuousRecognitionAsync === "function") {
             this.abort = () => queue.push({ abort: {} });
             this.stop = () => queue.push({ stop: {} });
           } else {
             this.abort = this.stop = void 0;
           }
           let audioStarted;
-          let finalEvent;
+          let finalEvent = void 0;
           let finalizedResults = [];
           for (let loop = 0; !stopping || audioStarted; loop++) {
             const event = await queue.shift();
@@ -24048,7 +24085,7 @@
                 stopping = "stop";
               }
               if (abort && recognizer.stopContinuousRecognitionAsync) {
-                await cognitiveServicesAsyncToPromise(recognizer.stopContinuousRecognitionAsync.bind(recognizer))();
+                await cognitiveServicesAsyncToPromise(recognizer.stopContinuousRecognitionAsync, recognizer)();
               }
             } else if (audioSourceReady) {
               this.dispatchEvent(new SpeechRecognitionEvent("audiostart"));
@@ -24065,8 +24102,13 @@
             } else if (stopping !== "abort") {
               if (recognized && recognized.result && recognized.result.reason === ResultReason2.NoMatch) {
                 if (!this.continuous || stopping === "stop") {
-                  finalEvent = new SpeechRecognitionEvent("result", { results: finalizedResults });
-                  recognizer.stopContinuousRecognitionAsync && await cognitiveServicesAsyncToPromise(recognizer.stopContinuousRecognitionAsync.bind(recognizer))();
+                  finalEvent = new SpeechRecognitionEvent("result", {
+                    results: new SpeechRecognitionResultList(finalizedResults)
+                  });
+                  recognizer.stopContinuousRecognitionAsync && await cognitiveServicesAsyncToPromise(
+                    recognizer.stopContinuousRecognitionAsync,
+                    recognizer
+                  )();
                   break;
                 }
               } else if (recognized || recognizing) {
@@ -24087,7 +24129,7 @@
                     maxAlternatives: this.maxAlternatives,
                     textNormalization
                   });
-                  const recognizable = !!result[0].transcript;
+                  const recognizable = !!result[0]?.transcript;
                   if (recognizable) {
                     finalizedResults = [...finalizedResults, result];
                     this.continuous && this.dispatchEvent(
@@ -24104,7 +24146,7 @@
                     });
                   }
                   if ((!this.continuous || stopping === "stop") && recognizer.stopContinuousRecognitionAsync) {
-                    await cognitiveServicesAsyncToPromise(recognizer.stopContinuousRecognitionAsync.bind(recognizer))();
+                    await cognitiveServicesAsyncToPromise(recognizer.stopContinuousRecognitionAsync, recognizer)();
                   }
                   if (looseEvents && finalEvent && recognizable) {
                     this.dispatchEvent(finalEvent);
@@ -24148,17 +24190,20 @@
           throw err;
         } finally {
           unprepare();
-          recognizer.dispose();
+          recognizer["dispose"](false);
         }
       }
     }
     return {
-      SpeechGrammarList: SpeechGrammarList_default,
+      SpeechGrammarList,
       SpeechRecognition,
       SpeechRecognitionEvent
     };
   }
-  var createSpeechRecognitionPonyfill_default = (options) => {
+
+  // src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfill.ts
+  var { AudioConfig: AudioConfig2, OutputFormat: OutputFormat2, SpeechConfig: SpeechConfig2, SpeechRecognizer: SpeechRecognizer3 } = SpeechSDK_default;
+  function createSpeechRecognitionPonyfill(options) {
     const {
       audioConfig = AudioConfig2.fromDefaultMicrophoneInput(),
       // We set telemetry to true to honor the default telemetry settings of Speech SDK
@@ -24171,44 +24216,40 @@
       textNormalization = "display"
     } = patchOptions(options);
     if (!audioConfig && (!window.navigator.mediaDevices || !window.navigator.mediaDevices.getUserMedia)) {
-      console.warn(
-        "web-speech-cognitive-services: This browser does not support WebRTC and it will not work with Cognitive Services Speech Services."
+      throw new Error(
+        "web-speech-cognitive-services: This browser does not support Media Capture and Streams API and it will not work with Cognitive Services Speech Services."
       );
-      return {};
     }
     const createRecognizer = async (lang) => {
-      const { authorizationToken, region, speechRecognitionHostname, subscriptionKey } = await fetchCredentials();
+      const credentials = await fetchCredentials();
       let speechConfig;
-      if (speechRecognitionHostname) {
-        const host = { hostname: speechRecognitionHostname, port: 443, protocol: "wss:" };
-        if (authorizationToken) {
+      if (typeof credentials.speechRecognitionHostname !== "undefined") {
+        const host = new URL("wss://hostname:443");
+        host.hostname = credentials.speechRecognitionHostname;
+        if (credentials.authorizationToken) {
           speechConfig = SpeechConfig2.fromHost(host);
-          speechConfig.authorizationToken = authorizationToken;
+          speechConfig.authorizationToken = credentials.authorizationToken;
         } else {
-          speechConfig = SpeechConfig2.fromHost(host, subscriptionKey);
+          speechConfig = SpeechConfig2.fromHost(host, credentials.subscriptionKey);
         }
       } else {
-        speechConfig = authorizationToken ? SpeechConfig2.fromAuthorizationToken(authorizationToken, region) : SpeechConfig2.fromSubscription(subscriptionKey, region);
+        speechConfig = typeof credentials.authorizationToken !== "undefined" ? SpeechConfig2.fromAuthorizationToken(credentials.authorizationToken, credentials.region) : SpeechConfig2.fromSubscription(credentials.subscriptionKey, credentials.region);
       }
       if (speechRecognitionEndpointId) {
         speechConfig.endpointId = speechRecognitionEndpointId;
       }
       speechConfig.outputFormat = OutputFormat2.Detailed;
       speechConfig.speechRecognitionLanguage = lang || "en-US";
-      return new SpeechRecognizer2(speechConfig, audioConfig);
+      return new SpeechRecognizer3(speechConfig, audioConfig);
     };
     return createSpeechRecognitionPonyfillFromRecognizer({
-      audioConfig,
       createRecognizer,
       enableTelemetry,
       looseEvents,
       referenceGrammars,
       textNormalization
     });
-  };
-
-  // src/SpeechServices/SpeechToText.js
-  var SpeechToText_default = createSpeechRecognitionPonyfill_default;
+  }
 
   // ../../node_modules/event-target-shim/index.mjs
   function assertType(condition, message, ...args) {
@@ -25675,16 +25716,16 @@
   // src/SpeechServices/TextToSpeech.js
   var TextToSpeech_default = createSpeechSynthesisPonyfill_default;
 
-  // src/SpeechServices.js
-  function createSpeechServicesPonyfill(options = {}, ...args) {
+  // src/SpeechServices.ts
+  function createSpeechServicesPonyfill(options = {}) {
     return {
-      ...SpeechToText_default(options, ...args),
-      ...TextToSpeech_default(options, ...args)
+      ...createSpeechRecognitionPonyfill(options),
+      ...TextToSpeech_default(options)
     };
   }
   var meta = document.createElement("meta");
   meta.setAttribute("name", "web-speech-cognitive-services");
-  meta.setAttribute("content", `version=${"8.0.0-main.5903868"}`);
+  meta.setAttribute("content", `version=${"8.0.0-main.6cbf0fb"}`);
   document.head.appendChild(meta);
 
   // src/index.umd.js