web-speech-cognitive-services 8.0.0-main.85313be → 8.0.0-main.ccf35da

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

@@ -1,104 +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 = {};
-  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";
@@ -182,72 +81,270 @@ function patchOptions({
   };
 }
 
-// src/SpeechServices/SpeechToText/SpeechGrammarList.js
-var SpeechGrammarList_default = class {
+// 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
+};
+
+// ../../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 }) {
+    this.#confidence = confidence;
+    this.#transcript = transcript;
+  }
+  #confidence;
+  #transcript;
+  get confidence() {
+    return this.#confidence;
+  }
+  get transcript() {
+    return this.#transcript;
+  }
+};
+
+// src/SpeechServices/SpeechToText/private/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/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/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'`);
     }
   }
 };
 
-// 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));
-}
+// 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;
+  }
+  get type() {
+    return "error";
+  }
+};
+
+// 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, emma, interpretation, resultIndex, results } = {}) {
+  constructor(type, { data, resultIndex, results } = {}) {
     super(type);
-    this.data = data;
-    this.emma = emma;
-    this.interpretation = interpretation;
-    this.resultIndex = resultIndex;
-    this.results = results;
+    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;
+  }
+  get type() {
+    return super.type;
+  }
+};
+
+// src/SpeechServices/SpeechToText/private/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/private/prepareAudioConfig.ts
+import { AudioSourceEvent } from "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 originalAttach = audioConfig.attach;
-  const boundOriginalAttach = audioConfig.attach.bind(audioConfig);
-  let firstChunk;
-  let muted;
-  audioConfig.attach = async () => {
-    const reader = await boundOriginalAttach();
+  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) {
-          audioConfig.events.onEvent({ name: "FirstAudibleChunk" });
+          audioConfigImpl.events.onEvent(new AudioSourceEvent("FirstAudibleChunk", ""));
           firstChunk = true;
         }
         if (muted) {
@@ -263,10 +360,36 @@ function prepareAudioConfig(audioConfig) {
       muted = true;
     },
     unprepare: () => {
-      audioConfig.attach = originalAttach;
+      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/createSpeechRecognitionPonyfillFromRecognizer.ts
+var { ResultReason: ResultReason2, SpeechRecognizer: SpeechRecognizer2 } = SpeechSDK_default;
 function createSpeechRecognitionPonyfillFromRecognizer({
   createRecognizer,
   enableTelemetry,
@@ -276,14 +399,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;
-    }
+    #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", {
@@ -295,128 +417,144 @@ 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;
     }
     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: SpeechRecognitionErrorEvent) => 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);
     }
+    abort;
+    stop;
     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() {
       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: {
@@ -458,18 +596,18 @@ function createSpeechRecognitionPonyfillFromRecognizer({
           queue.push({ speechEndDetected: { sessionId } });
         };
         const { phrases } = this.grammars;
-        const { dynamicGrammar } = recognizer.privReco;
+        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) {
+        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();
@@ -486,10 +624,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,30 +636,21 @@ 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();
               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"));
@@ -540,10 +666,16 @@ 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: new SpeechRecognitionResultList(finalizedResults)
+                });
+                recognizer.stopContinuousRecognitionAsync && await cognitiveServicesAsyncToPromise(
+                  recognizer.stopContinuousRecognitionAsync,
+                  recognizer
+                )();
+                break;
+              }
             } else if (recognized || recognizing) {
               if (!audioStarted) {
                 this.dispatchEvent(new SpeechRecognitionEvent("audiostart"));
@@ -558,44 +690,43 @@ function createSpeechRecognitionPonyfillFromRecognizer({
                 speechStarted = true;
               }
               if (recognized) {
-                const result = cognitiveServiceEventResultToWebSpeechRecognitionResultList_default(recognized.result, {
+                const result = cognitiveServiceEventResultToWebSpeechRecognitionResult_default(recognized.result, {
                   maxAlternatives: this.maxAlternatives,
                   textNormalization
                 });
-                const recognizable = !!result[0].transcript;
+                const recognizable = !!result[0]?.transcript;
                 if (recognizable) {
                   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) {
-                  await cognitiveServicesAsyncToPromise(recognizer.stopContinuousRecognitionAsync.bind(recognizer))();
+                if ((!this.continuous || stopping === "stop") && recognizer.stopContinuousRecognitionAsync) {
+                  await cognitiveServicesAsyncToPromise(recognizer.stopContinuousRecognitionAsync, 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 +744,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();
@@ -631,17 +755,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.js
+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
@@ -678,7 +805,7 @@ var createSpeechRecognitionPonyfill_default = (options) => {
     }
     speechConfig.outputFormat = OutputFormat2.Detailed;
     speechConfig.speechRecognitionLanguage = lang || "en-US";
-    return new SpeechRecognizer2(speechConfig, audioConfig);
+    return new SpeechRecognizer3(speechConfig, audioConfig);
   };
   return createSpeechRecognitionPonyfillFromRecognizer({
     audioConfig,
@@ -688,14 +815,14 @@ var createSpeechRecognitionPonyfill_default = (options) => {
     referenceGrammars,
     textNormalization
   });
-};
+}
 
 // src/SpeechServices/SpeechToText.js
-var SpeechToText_default = createSpeechRecognitionPonyfill_default;
+var SpeechToText_default = createSpeechRecognitionPonyfill;
 
 // 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 +896,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 +905,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 +1045,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 +1143,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 +1249,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 +1347,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.85313be"}`);
+meta.setAttribute("content", `version=${"8.0.0-main.ccf35da"}`);
 document.head.appendChild(meta);
 export {
   SpeechToText_default as createSpeechRecognitionPonyfill,