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

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

@@ -30,49 +30,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.js
 var src_exports = {};
 __export(src_exports, {
-  createSpeechRecognitionPonyfill: () => SpeechToText_default,
+  createSpeechRecognitionPonyfill: () => createSpeechRecognitionPonyfill,
   createSpeechRecognitionPonyfillFromRecognizer: () => createSpeechRecognitionPonyfillFromRecognizer,
   createSpeechServicesPonyfill: () => createSpeechServicesPonyfill,
   createSpeechSynthesisPonyfill: () => TextToSpeech_default,
-  fetchAuthorizationToken: () => fetchAuthorizationToken_default
+  fetchAuthorizationToken: () => fetchAuthorizationToken
 });
 module.exports = __toCommonJS(src_exports);
 
-// ../../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";
@@ -81,17 +46,21 @@ function resolveFunctionOrReturnValue(fnOrValue) {
   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;
@@ -103,11 +72,12 @@ function patchOptions({
       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,
@@ -142,21 +112,23 @@ function patchOptions({
         );
         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 = require("microsoft-cognitiveservices-speech-sdk/distrib/lib/microsoft.cognitiveservices.speech.sdk");
 var SpeechSDK_default = {
   AudioConfig: import_microsoft_cognitiveservices_speech.AudioConfig,
@@ -166,6 +138,41 @@ var SpeechSDK_default = {
   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 }) {
@@ -182,7 +189,7 @@ var SpeechRecognitionAlternative = class {
   }
 };
 
-// src/SpeechServices/SpeechToText/FakeArray.ts
+// src/SpeechServices/SpeechToText/private/FakeArray.ts
 var FakeArray = class {
   constructor(array) {
     if (!array) {
@@ -250,7 +257,15 @@ function cognitiveServiceEventResultToWebSpeechRecognitionResult_default(result,
   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;
@@ -271,22 +286,90 @@ var EventListenerMap = class {
   }
 };
 
-// src/SpeechServices/SpeechToText/SpeechGrammarList.js
-var SpeechGrammarList_default = class {
+// src/SpeechServices/SpeechToText/private/prepareAudioConfig.ts
+var import_AudioSourceEvents = require("microsoft-cognitiveservices-speech-sdk/distrib/lib/src/common/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'`);
     }
@@ -308,6 +391,9 @@ var SpeechRecognitionErrorEvent = class extends Event {
   get message() {
     return this.#message;
   }
+  get type() {
+    return "error";
+  }
 };
 
 // src/SpeechServices/SpeechToText/SpeechRecognitionResultList.ts
@@ -338,61 +424,13 @@ var SpeechRecognitionEvent = class extends Event {
   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,
@@ -402,17 +440,13 @@ function createSpeechRecognitionPonyfillFromRecognizer({
 }) {
   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", {
@@ -424,40 +458,39 @@ function createSpeechRecognitionPonyfillFromRecognizer({
       );
     }
     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");
     }
@@ -485,7 +518,7 @@ function createSpeechRecognitionPonyfillFromRecognizer({
     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");
     }
@@ -534,6 +567,8 @@ function createSpeechRecognitionPonyfillFromRecognizer({
     set onstart(value) {
       this.#eventListenerMap.setProperty("start", value);
     }
+    abort;
+    stop;
     start() {
       this._startOnce().catch((err) => {
         this.dispatchEvent(
@@ -543,22 +578,24 @@ function createSpeechRecognitionPonyfillFromRecognizer({
     }
     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: {
@@ -600,18 +637,18 @@ function createSpeechRecognitionPonyfillFromRecognizer({
           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();
@@ -654,7 +691,7 @@ function createSpeechRecognitionPonyfillFromRecognizer({
               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"));
@@ -671,8 +708,13 @@ function createSpeechRecognitionPonyfillFromRecognizer({
           } 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) {
@@ -693,7 +735,7 @@ function createSpeechRecognitionPonyfillFromRecognizer({
                   maxAlternatives: this.maxAlternatives,
                   textNormalization
                 });
-                const recognizable = !!result[0].transcript;
+                const recognizable = !!result[0]?.transcript;
                 if (recognizable) {
                   finalizedResults = [...finalizedResults, result];
                   this.continuous && this.dispatchEvent(
@@ -710,7 +752,7 @@ function createSpeechRecognitionPonyfillFromRecognizer({
                   });
                 }
                 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);
@@ -754,17 +796,20 @@ function createSpeechRecognitionPonyfillFromRecognizer({
         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
@@ -777,44 +822,40 @@ var createSpeechRecognitionPonyfill_default = (options) => {
     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;
+}
 
 // src/SpeechServices/TextToSpeech/createSpeechSynthesisPonyfill.js
 var import_event_target_shim3 = require("event-target-shim");
@@ -1319,9 +1360,12 @@ var createSpeechSynthesisPonyfill_default = (options) => {
 // src/SpeechServices/TextToSpeech.js
 var TextToSpeech_default = createSpeechSynthesisPonyfill_default;
 
-// src/SpeechServices/fetchAuthorizationToken.js
+// src/SpeechServices/fetchAuthorizationToken.ts
 var TOKEN_URL_TEMPLATE = "https://{region}.api.cognitive.microsoft.com/sts/v1.0/issueToken";
-async function fetchAuthorizationToken_default({ region, subscriptionKey }) {
+async function fetchAuthorizationToken({
+  region,
+  subscriptionKey
+}) {
   const res = await fetch(TOKEN_URL_TEMPLATE.replace(/\{region\}/u, region), {
     headers: {
       "Ocp-Apim-Subscription-Key": subscriptionKey
@@ -1334,16 +1378,16 @@ async function fetchAuthorizationToken_default({ region, subscriptionKey }) {
   return res.text();
 }
 
-// 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);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {