web-speech-cognitive-services 8.0.1-main.8743165 → 8.1.0

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

@@ -122,7 +122,7 @@
       });
       exports.default = void 0;
       var _rng = _interopRequireDefault(require_rng());
-      var _stringify = require_stringify();
+      var _stringify2 = require_stringify();
       function _interopRequireDefault(obj) {
         return obj && obj.__esModule ? obj : { default: obj };
       }
@@ -176,7 +176,7 @@
         for (let n = 0; n < 6; ++n) {
           b[i + n] = node[n];
         }
-        return buf || (0, _stringify.unsafeStringify)(b);
+        return buf || (0, _stringify2.unsafeStringify)(b);
       }
       var _default = v1;
       exports.default = _default;
@@ -195,7 +195,7 @@
       function _interopRequireDefault(obj) {
         return obj && obj.__esModule ? obj : { default: obj };
       }
-      function parse(uuid) {
+      function parse2(uuid) {
         if (!(0, _validate.default)(uuid)) {
           throw TypeError("Invalid UUID");
         }
@@ -219,7 +219,7 @@
         arr[15] = v & 255;
         return arr;
       }
-      var _default = parse;
+      var _default = parse2;
       exports.default = _default;
     }
   });
@@ -233,7 +233,7 @@
       });
       exports.URL = exports.DNS = void 0;
       exports.default = v35;
-      var _stringify = require_stringify();
+      var _stringify2 = require_stringify();
       var _parse = _interopRequireDefault(require_parse());
       function _interopRequireDefault(obj) {
         return obj && obj.__esModule ? obj : { default: obj };
@@ -275,7 +275,7 @@
             }
             return buf;
           }
-          return (0, _stringify.unsafeStringify)(bytes);
+          return (0, _stringify2.unsafeStringify)(bytes);
         }
         try {
           generateUUID.name = name;
@@ -487,7 +487,7 @@
       exports.default = void 0;
       var _native = _interopRequireDefault(require_native());
       var _rng = _interopRequireDefault(require_rng());
-      var _stringify = require_stringify();
+      var _stringify2 = require_stringify();
       function _interopRequireDefault(obj) {
         return obj && obj.__esModule ? obj : { default: obj };
       }
@@ -506,7 +506,7 @@
           }
           return buf;
         }
-        return (0, _stringify.unsafeStringify)(rnds);
+        return (0, _stringify2.unsafeStringify)(rnds);
       }
       var _default = v4;
       exports.default = _default;
@@ -674,7 +674,7 @@
       Object.defineProperty(exports, "stringify", {
         enumerable: true,
         get: function get() {
-          return _stringify.default;
+          return _stringify2.default;
         }
       });
       Object.defineProperty(exports, "v1", {
@@ -720,7 +720,7 @@
       var _nil = _interopRequireDefault(require_nil());
       var _version = _interopRequireDefault(require_version());
       var _validate = _interopRequireDefault(require_validate());
-      var _stringify = _interopRequireDefault(require_stringify());
+      var _stringify2 = _interopRequireDefault(require_stringify());
       var _parse = _interopRequireDefault(require_parse());
       function _interopRequireDefault(obj) {
         return obj && obj.__esModule ? obj : { default: obj };
@@ -1540,9 +1540,9 @@
           this.throwIfDisposed();
           return new _List(this.privList.concat(list.toArray()));
         }
-        concatArray(array) {
+        concatArray(array2) {
           this.throwIfDisposed();
-          return new _List(this.privList.concat(array));
+          return new _List(this.privList.concat(array2));
         }
         isDisposed() {
           return this.privList == null;
@@ -2673,12 +2673,12 @@
             throw new Error("the object is already disposed");
           }
         }
-        static throwIfArrayEmptyOrWhitespace(array, name) {
-          _Contracts.throwIfNullOrUndefined(array, name);
-          if (array.length === 0) {
+        static throwIfArrayEmptyOrWhitespace(array2, name) {
+          _Contracts.throwIfNullOrUndefined(array2, name);
+          if (array2.length === 0) {
             throw new Error("throwIfArrayEmptyOrWhitespace:" + name);
           }
-          for (const item of array) {
+          for (const item of array2) {
             _Contracts.throwIfNullOrWhitespace(item, name);
           }
         }
@@ -6694,78 +6694,78 @@
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.PropertyId = void 0;
-      var PropertyId;
-      (function(PropertyId2) {
-        PropertyId2[PropertyId2["SpeechServiceConnection_Key"] = 0] = "SpeechServiceConnection_Key";
-        PropertyId2[PropertyId2["SpeechServiceConnection_Endpoint"] = 1] = "SpeechServiceConnection_Endpoint";
-        PropertyId2[PropertyId2["SpeechServiceConnection_Region"] = 2] = "SpeechServiceConnection_Region";
-        PropertyId2[PropertyId2["SpeechServiceAuthorization_Token"] = 3] = "SpeechServiceAuthorization_Token";
-        PropertyId2[PropertyId2["SpeechServiceAuthorization_Type"] = 4] = "SpeechServiceAuthorization_Type";
-        PropertyId2[PropertyId2["SpeechServiceConnection_EndpointId"] = 5] = "SpeechServiceConnection_EndpointId";
-        PropertyId2[PropertyId2["SpeechServiceConnection_TranslationToLanguages"] = 6] = "SpeechServiceConnection_TranslationToLanguages";
-        PropertyId2[PropertyId2["SpeechServiceConnection_TranslationVoice"] = 7] = "SpeechServiceConnection_TranslationVoice";
-        PropertyId2[PropertyId2["SpeechServiceConnection_TranslationFeatures"] = 8] = "SpeechServiceConnection_TranslationFeatures";
-        PropertyId2[PropertyId2["SpeechServiceConnection_IntentRegion"] = 9] = "SpeechServiceConnection_IntentRegion";
-        PropertyId2[PropertyId2["SpeechServiceConnection_ProxyHostName"] = 10] = "SpeechServiceConnection_ProxyHostName";
-        PropertyId2[PropertyId2["SpeechServiceConnection_ProxyPort"] = 11] = "SpeechServiceConnection_ProxyPort";
-        PropertyId2[PropertyId2["SpeechServiceConnection_ProxyUserName"] = 12] = "SpeechServiceConnection_ProxyUserName";
-        PropertyId2[PropertyId2["SpeechServiceConnection_ProxyPassword"] = 13] = "SpeechServiceConnection_ProxyPassword";
-        PropertyId2[PropertyId2["SpeechServiceConnection_RecoMode"] = 14] = "SpeechServiceConnection_RecoMode";
-        PropertyId2[PropertyId2["SpeechServiceConnection_RecoLanguage"] = 15] = "SpeechServiceConnection_RecoLanguage";
-        PropertyId2[PropertyId2["Speech_SessionId"] = 16] = "Speech_SessionId";
-        PropertyId2[PropertyId2["SpeechServiceConnection_SynthLanguage"] = 17] = "SpeechServiceConnection_SynthLanguage";
-        PropertyId2[PropertyId2["SpeechServiceConnection_SynthVoice"] = 18] = "SpeechServiceConnection_SynthVoice";
-        PropertyId2[PropertyId2["SpeechServiceConnection_SynthOutputFormat"] = 19] = "SpeechServiceConnection_SynthOutputFormat";
-        PropertyId2[PropertyId2["SpeechServiceConnection_AutoDetectSourceLanguages"] = 20] = "SpeechServiceConnection_AutoDetectSourceLanguages";
-        PropertyId2[PropertyId2["SpeechServiceResponse_RequestDetailedResultTrueFalse"] = 21] = "SpeechServiceResponse_RequestDetailedResultTrueFalse";
-        PropertyId2[PropertyId2["SpeechServiceResponse_RequestProfanityFilterTrueFalse"] = 22] = "SpeechServiceResponse_RequestProfanityFilterTrueFalse";
-        PropertyId2[PropertyId2["SpeechServiceResponse_JsonResult"] = 23] = "SpeechServiceResponse_JsonResult";
-        PropertyId2[PropertyId2["SpeechServiceResponse_JsonErrorDetails"] = 24] = "SpeechServiceResponse_JsonErrorDetails";
-        PropertyId2[PropertyId2["CancellationDetails_Reason"] = 25] = "CancellationDetails_Reason";
-        PropertyId2[PropertyId2["CancellationDetails_ReasonText"] = 26] = "CancellationDetails_ReasonText";
-        PropertyId2[PropertyId2["CancellationDetails_ReasonDetailedText"] = 27] = "CancellationDetails_ReasonDetailedText";
-        PropertyId2[PropertyId2["LanguageUnderstandingServiceResponse_JsonResult"] = 28] = "LanguageUnderstandingServiceResponse_JsonResult";
-        PropertyId2[PropertyId2["SpeechServiceConnection_Url"] = 29] = "SpeechServiceConnection_Url";
-        PropertyId2[PropertyId2["SpeechServiceConnection_InitialSilenceTimeoutMs"] = 30] = "SpeechServiceConnection_InitialSilenceTimeoutMs";
-        PropertyId2[PropertyId2["SpeechServiceConnection_EndSilenceTimeoutMs"] = 31] = "SpeechServiceConnection_EndSilenceTimeoutMs";
-        PropertyId2[PropertyId2["Speech_SegmentationSilenceTimeoutMs"] = 32] = "Speech_SegmentationSilenceTimeoutMs";
-        PropertyId2[PropertyId2["SpeechServiceConnection_EnableAudioLogging"] = 33] = "SpeechServiceConnection_EnableAudioLogging";
-        PropertyId2[PropertyId2["SpeechServiceConnection_LanguageIdMode"] = 34] = "SpeechServiceConnection_LanguageIdMode";
-        PropertyId2[PropertyId2["SpeechServiceConnection_RecognitionEndpointVersion"] = 35] = "SpeechServiceConnection_RecognitionEndpointVersion";
-        PropertyId2[PropertyId2["SpeechServiceConnection_SpeakerIdMode"] = 36] = "SpeechServiceConnection_SpeakerIdMode";
-        PropertyId2[PropertyId2["SpeechServiceResponse_ProfanityOption"] = 37] = "SpeechServiceResponse_ProfanityOption";
-        PropertyId2[PropertyId2["SpeechServiceResponse_PostProcessingOption"] = 38] = "SpeechServiceResponse_PostProcessingOption";
-        PropertyId2[PropertyId2["SpeechServiceResponse_RequestWordLevelTimestamps"] = 39] = "SpeechServiceResponse_RequestWordLevelTimestamps";
-        PropertyId2[PropertyId2["SpeechServiceResponse_StablePartialResultThreshold"] = 40] = "SpeechServiceResponse_StablePartialResultThreshold";
-        PropertyId2[PropertyId2["SpeechServiceResponse_OutputFormatOption"] = 41] = "SpeechServiceResponse_OutputFormatOption";
-        PropertyId2[PropertyId2["SpeechServiceResponse_TranslationRequestStablePartialResult"] = 42] = "SpeechServiceResponse_TranslationRequestStablePartialResult";
-        PropertyId2[PropertyId2["SpeechServiceResponse_RequestWordBoundary"] = 43] = "SpeechServiceResponse_RequestWordBoundary";
-        PropertyId2[PropertyId2["SpeechServiceResponse_RequestPunctuationBoundary"] = 44] = "SpeechServiceResponse_RequestPunctuationBoundary";
-        PropertyId2[PropertyId2["SpeechServiceResponse_RequestSentenceBoundary"] = 45] = "SpeechServiceResponse_RequestSentenceBoundary";
-        PropertyId2[PropertyId2["Conversation_ApplicationId"] = 46] = "Conversation_ApplicationId";
-        PropertyId2[PropertyId2["Conversation_DialogType"] = 47] = "Conversation_DialogType";
-        PropertyId2[PropertyId2["Conversation_Initial_Silence_Timeout"] = 48] = "Conversation_Initial_Silence_Timeout";
-        PropertyId2[PropertyId2["Conversation_From_Id"] = 49] = "Conversation_From_Id";
-        PropertyId2[PropertyId2["Conversation_Conversation_Id"] = 50] = "Conversation_Conversation_Id";
-        PropertyId2[PropertyId2["Conversation_Custom_Voice_Deployment_Ids"] = 51] = "Conversation_Custom_Voice_Deployment_Ids";
-        PropertyId2[PropertyId2["Conversation_Speech_Activity_Template"] = 52] = "Conversation_Speech_Activity_Template";
-        PropertyId2[PropertyId2["Conversation_Request_Bot_Status_Messages"] = 53] = "Conversation_Request_Bot_Status_Messages";
-        PropertyId2[PropertyId2["Conversation_Agent_Connection_Id"] = 54] = "Conversation_Agent_Connection_Id";
-        PropertyId2[PropertyId2["SpeechServiceConnection_Host"] = 55] = "SpeechServiceConnection_Host";
-        PropertyId2[PropertyId2["ConversationTranslator_Host"] = 56] = "ConversationTranslator_Host";
-        PropertyId2[PropertyId2["ConversationTranslator_Name"] = 57] = "ConversationTranslator_Name";
-        PropertyId2[PropertyId2["ConversationTranslator_CorrelationId"] = 58] = "ConversationTranslator_CorrelationId";
-        PropertyId2[PropertyId2["ConversationTranslator_Token"] = 59] = "ConversationTranslator_Token";
-        PropertyId2[PropertyId2["PronunciationAssessment_ReferenceText"] = 60] = "PronunciationAssessment_ReferenceText";
-        PropertyId2[PropertyId2["PronunciationAssessment_GradingSystem"] = 61] = "PronunciationAssessment_GradingSystem";
-        PropertyId2[PropertyId2["PronunciationAssessment_Granularity"] = 62] = "PronunciationAssessment_Granularity";
-        PropertyId2[PropertyId2["PronunciationAssessment_EnableMiscue"] = 63] = "PronunciationAssessment_EnableMiscue";
-        PropertyId2[PropertyId2["PronunciationAssessment_Json"] = 64] = "PronunciationAssessment_Json";
-        PropertyId2[PropertyId2["PronunciationAssessment_Params"] = 65] = "PronunciationAssessment_Params";
-        PropertyId2[PropertyId2["SpeakerRecognition_Api_Version"] = 66] = "SpeakerRecognition_Api_Version";
-        PropertyId2[PropertyId2["WebWorkerLoadType"] = 67] = "WebWorkerLoadType";
-        PropertyId2[PropertyId2["TalkingAvatarService_WebRTC_SDP"] = 68] = "TalkingAvatarService_WebRTC_SDP";
-      })(PropertyId = exports.PropertyId || (exports.PropertyId = {}));
+      var PropertyId2;
+      (function(PropertyId3) {
+        PropertyId3[PropertyId3["SpeechServiceConnection_Key"] = 0] = "SpeechServiceConnection_Key";
+        PropertyId3[PropertyId3["SpeechServiceConnection_Endpoint"] = 1] = "SpeechServiceConnection_Endpoint";
+        PropertyId3[PropertyId3["SpeechServiceConnection_Region"] = 2] = "SpeechServiceConnection_Region";
+        PropertyId3[PropertyId3["SpeechServiceAuthorization_Token"] = 3] = "SpeechServiceAuthorization_Token";
+        PropertyId3[PropertyId3["SpeechServiceAuthorization_Type"] = 4] = "SpeechServiceAuthorization_Type";
+        PropertyId3[PropertyId3["SpeechServiceConnection_EndpointId"] = 5] = "SpeechServiceConnection_EndpointId";
+        PropertyId3[PropertyId3["SpeechServiceConnection_TranslationToLanguages"] = 6] = "SpeechServiceConnection_TranslationToLanguages";
+        PropertyId3[PropertyId3["SpeechServiceConnection_TranslationVoice"] = 7] = "SpeechServiceConnection_TranslationVoice";
+        PropertyId3[PropertyId3["SpeechServiceConnection_TranslationFeatures"] = 8] = "SpeechServiceConnection_TranslationFeatures";
+        PropertyId3[PropertyId3["SpeechServiceConnection_IntentRegion"] = 9] = "SpeechServiceConnection_IntentRegion";
+        PropertyId3[PropertyId3["SpeechServiceConnection_ProxyHostName"] = 10] = "SpeechServiceConnection_ProxyHostName";
+        PropertyId3[PropertyId3["SpeechServiceConnection_ProxyPort"] = 11] = "SpeechServiceConnection_ProxyPort";
+        PropertyId3[PropertyId3["SpeechServiceConnection_ProxyUserName"] = 12] = "SpeechServiceConnection_ProxyUserName";
+        PropertyId3[PropertyId3["SpeechServiceConnection_ProxyPassword"] = 13] = "SpeechServiceConnection_ProxyPassword";
+        PropertyId3[PropertyId3["SpeechServiceConnection_RecoMode"] = 14] = "SpeechServiceConnection_RecoMode";
+        PropertyId3[PropertyId3["SpeechServiceConnection_RecoLanguage"] = 15] = "SpeechServiceConnection_RecoLanguage";
+        PropertyId3[PropertyId3["Speech_SessionId"] = 16] = "Speech_SessionId";
+        PropertyId3[PropertyId3["SpeechServiceConnection_SynthLanguage"] = 17] = "SpeechServiceConnection_SynthLanguage";
+        PropertyId3[PropertyId3["SpeechServiceConnection_SynthVoice"] = 18] = "SpeechServiceConnection_SynthVoice";
+        PropertyId3[PropertyId3["SpeechServiceConnection_SynthOutputFormat"] = 19] = "SpeechServiceConnection_SynthOutputFormat";
+        PropertyId3[PropertyId3["SpeechServiceConnection_AutoDetectSourceLanguages"] = 20] = "SpeechServiceConnection_AutoDetectSourceLanguages";
+        PropertyId3[PropertyId3["SpeechServiceResponse_RequestDetailedResultTrueFalse"] = 21] = "SpeechServiceResponse_RequestDetailedResultTrueFalse";
+        PropertyId3[PropertyId3["SpeechServiceResponse_RequestProfanityFilterTrueFalse"] = 22] = "SpeechServiceResponse_RequestProfanityFilterTrueFalse";
+        PropertyId3[PropertyId3["SpeechServiceResponse_JsonResult"] = 23] = "SpeechServiceResponse_JsonResult";
+        PropertyId3[PropertyId3["SpeechServiceResponse_JsonErrorDetails"] = 24] = "SpeechServiceResponse_JsonErrorDetails";
+        PropertyId3[PropertyId3["CancellationDetails_Reason"] = 25] = "CancellationDetails_Reason";
+        PropertyId3[PropertyId3["CancellationDetails_ReasonText"] = 26] = "CancellationDetails_ReasonText";
+        PropertyId3[PropertyId3["CancellationDetails_ReasonDetailedText"] = 27] = "CancellationDetails_ReasonDetailedText";
+        PropertyId3[PropertyId3["LanguageUnderstandingServiceResponse_JsonResult"] = 28] = "LanguageUnderstandingServiceResponse_JsonResult";
+        PropertyId3[PropertyId3["SpeechServiceConnection_Url"] = 29] = "SpeechServiceConnection_Url";
+        PropertyId3[PropertyId3["SpeechServiceConnection_InitialSilenceTimeoutMs"] = 30] = "SpeechServiceConnection_InitialSilenceTimeoutMs";
+        PropertyId3[PropertyId3["SpeechServiceConnection_EndSilenceTimeoutMs"] = 31] = "SpeechServiceConnection_EndSilenceTimeoutMs";
+        PropertyId3[PropertyId3["Speech_SegmentationSilenceTimeoutMs"] = 32] = "Speech_SegmentationSilenceTimeoutMs";
+        PropertyId3[PropertyId3["SpeechServiceConnection_EnableAudioLogging"] = 33] = "SpeechServiceConnection_EnableAudioLogging";
+        PropertyId3[PropertyId3["SpeechServiceConnection_LanguageIdMode"] = 34] = "SpeechServiceConnection_LanguageIdMode";
+        PropertyId3[PropertyId3["SpeechServiceConnection_RecognitionEndpointVersion"] = 35] = "SpeechServiceConnection_RecognitionEndpointVersion";
+        PropertyId3[PropertyId3["SpeechServiceConnection_SpeakerIdMode"] = 36] = "SpeechServiceConnection_SpeakerIdMode";
+        PropertyId3[PropertyId3["SpeechServiceResponse_ProfanityOption"] = 37] = "SpeechServiceResponse_ProfanityOption";
+        PropertyId3[PropertyId3["SpeechServiceResponse_PostProcessingOption"] = 38] = "SpeechServiceResponse_PostProcessingOption";
+        PropertyId3[PropertyId3["SpeechServiceResponse_RequestWordLevelTimestamps"] = 39] = "SpeechServiceResponse_RequestWordLevelTimestamps";
+        PropertyId3[PropertyId3["SpeechServiceResponse_StablePartialResultThreshold"] = 40] = "SpeechServiceResponse_StablePartialResultThreshold";
+        PropertyId3[PropertyId3["SpeechServiceResponse_OutputFormatOption"] = 41] = "SpeechServiceResponse_OutputFormatOption";
+        PropertyId3[PropertyId3["SpeechServiceResponse_TranslationRequestStablePartialResult"] = 42] = "SpeechServiceResponse_TranslationRequestStablePartialResult";
+        PropertyId3[PropertyId3["SpeechServiceResponse_RequestWordBoundary"] = 43] = "SpeechServiceResponse_RequestWordBoundary";
+        PropertyId3[PropertyId3["SpeechServiceResponse_RequestPunctuationBoundary"] = 44] = "SpeechServiceResponse_RequestPunctuationBoundary";
+        PropertyId3[PropertyId3["SpeechServiceResponse_RequestSentenceBoundary"] = 45] = "SpeechServiceResponse_RequestSentenceBoundary";
+        PropertyId3[PropertyId3["Conversation_ApplicationId"] = 46] = "Conversation_ApplicationId";
+        PropertyId3[PropertyId3["Conversation_DialogType"] = 47] = "Conversation_DialogType";
+        PropertyId3[PropertyId3["Conversation_Initial_Silence_Timeout"] = 48] = "Conversation_Initial_Silence_Timeout";
+        PropertyId3[PropertyId3["Conversation_From_Id"] = 49] = "Conversation_From_Id";
+        PropertyId3[PropertyId3["Conversation_Conversation_Id"] = 50] = "Conversation_Conversation_Id";
+        PropertyId3[PropertyId3["Conversation_Custom_Voice_Deployment_Ids"] = 51] = "Conversation_Custom_Voice_Deployment_Ids";
+        PropertyId3[PropertyId3["Conversation_Speech_Activity_Template"] = 52] = "Conversation_Speech_Activity_Template";
+        PropertyId3[PropertyId3["Conversation_Request_Bot_Status_Messages"] = 53] = "Conversation_Request_Bot_Status_Messages";
+        PropertyId3[PropertyId3["Conversation_Agent_Connection_Id"] = 54] = "Conversation_Agent_Connection_Id";
+        PropertyId3[PropertyId3["SpeechServiceConnection_Host"] = 55] = "SpeechServiceConnection_Host";
+        PropertyId3[PropertyId3["ConversationTranslator_Host"] = 56] = "ConversationTranslator_Host";
+        PropertyId3[PropertyId3["ConversationTranslator_Name"] = 57] = "ConversationTranslator_Name";
+        PropertyId3[PropertyId3["ConversationTranslator_CorrelationId"] = 58] = "ConversationTranslator_CorrelationId";
+        PropertyId3[PropertyId3["ConversationTranslator_Token"] = 59] = "ConversationTranslator_Token";
+        PropertyId3[PropertyId3["PronunciationAssessment_ReferenceText"] = 60] = "PronunciationAssessment_ReferenceText";
+        PropertyId3[PropertyId3["PronunciationAssessment_GradingSystem"] = 61] = "PronunciationAssessment_GradingSystem";
+        PropertyId3[PropertyId3["PronunciationAssessment_Granularity"] = 62] = "PronunciationAssessment_Granularity";
+        PropertyId3[PropertyId3["PronunciationAssessment_EnableMiscue"] = 63] = "PronunciationAssessment_EnableMiscue";
+        PropertyId3[PropertyId3["PronunciationAssessment_Json"] = 64] = "PronunciationAssessment_Json";
+        PropertyId3[PropertyId3["PronunciationAssessment_Params"] = 65] = "PronunciationAssessment_Params";
+        PropertyId3[PropertyId3["SpeakerRecognition_Api_Version"] = 66] = "SpeakerRecognition_Api_Version";
+        PropertyId3[PropertyId3["WebWorkerLoadType"] = 67] = "WebWorkerLoadType";
+        PropertyId3[PropertyId3["TalkingAvatarService_WebRTC_SDP"] = 68] = "TalkingAvatarService_WebRTC_SDP";
+      })(PropertyId2 = exports.PropertyId || (exports.PropertyId = {}));
     }
   });
 
@@ -9242,10 +9242,10 @@
               throw new Error_js_1.InvalidOperationError("Only WAVE_FORMAT_PCM (8/16/32 bps) format supported at this time");
           }
         }
-        formatArrayBuffer(audioData, maxValue) {
+        formatArrayBuffer(audioData, maxValue2) {
           const float32Data = new Float32Array(audioData.length);
           for (let i = 0; i < audioData.length; i++) {
-            float32Data[i] = audioData[i] / maxValue;
+            float32Data[i] = audioData[i] / maxValue2;
           }
           return float32Data;
         }
@@ -23432,6 +23432,633 @@
     }
   });
 
+  // src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfill.ts
+  var import_microsoft_cognitiveservices_speech_sdk = __toESM(require_microsoft_cognitiveservices_speech_sdk());
+
+  // node_modules/valibot/dist/index.js
+  var EMOJI_REGEX = (
+    // eslint-disable-next-line redos-detector/no-unsafe-regex, regexp/no-dupe-disjunctions -- false positives
+    new RegExp("^(?:[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}))*)+$", "u")
+  );
+  var store;
+  function getGlobalConfig(config2) {
+    return {
+      lang: config2?.lang ?? store?.lang,
+      message: config2?.message,
+      abortEarly: config2?.abortEarly ?? store?.abortEarly,
+      abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
+    };
+  }
+  var store2;
+  function getGlobalMessage(lang) {
+    return store2?.get(lang);
+  }
+  var store3;
+  function getSchemaMessage(lang) {
+    return store3?.get(lang);
+  }
+  var store4;
+  function getSpecificMessage(reference, lang) {
+    return store4?.get(reference)?.get(lang);
+  }
+  function _stringify(input) {
+    const type = typeof input;
+    if (type === "string") {
+      return `"${input}"`;
+    }
+    if (type === "number" || type === "bigint" || type === "boolean") {
+      return `${input}`;
+    }
+    if (type === "object" || type === "function") {
+      return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+    }
+    return type;
+  }
+  function _addIssue(context, label, dataset, config2, other) {
+    const input = other && "input" in other ? other.input : dataset.value;
+    const expected = other?.expected ?? context.expects ?? null;
+    const received = other?.received ?? _stringify(input);
+    const issue = {
+      kind: context.kind,
+      type: context.type,
+      input,
+      expected,
+      received,
+      message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+      requirement: context.requirement,
+      path: other?.path,
+      issues: other?.issues,
+      lang: config2.lang,
+      abortEarly: config2.abortEarly,
+      abortPipeEarly: config2.abortPipeEarly
+    };
+    const isSchema = context.kind === "schema";
+    const message = other?.message ?? context.message ?? getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? getSchemaMessage(issue.lang) : null) ?? config2.message ?? getGlobalMessage(issue.lang);
+    if (message) {
+      issue.message = typeof message === "function" ? (
+        // @ts-expect-error
+        message(issue)
+      ) : message;
+    }
+    if (isSchema) {
+      dataset.typed = false;
+    }
+    if (dataset.issues) {
+      dataset.issues.push(issue);
+    } else {
+      dataset.issues = [issue];
+    }
+  }
+  function _joinExpects(values, separator) {
+    const list = [...new Set(values)];
+    if (list.length > 1) {
+      return `(${list.join(` ${separator} `)})`;
+    }
+    return list[0] ?? "never";
+  }
+  var ValiError = class extends Error {
+    /**
+     * The error issues.
+     */
+    issues;
+    /**
+     * Creates a Valibot error with useful information.
+     *
+     * @param issues The error issues.
+     */
+    constructor(issues) {
+      super(issues[0].message);
+      this.name = "ValiError";
+      this.issues = issues;
+    }
+  };
+  function maxValue(requirement, message) {
+    return {
+      kind: "validation",
+      type: "max_value",
+      reference: maxValue,
+      async: false,
+      expects: `<=${requirement instanceof Date ? requirement.toJSON() : _stringify(requirement)}`,
+      requirement,
+      message,
+      _run(dataset, config2) {
+        if (dataset.typed && dataset.value > this.requirement) {
+          _addIssue(this, "value", dataset, config2, {
+            received: dataset.value instanceof Date ? dataset.value.toJSON() : _stringify(dataset.value)
+          });
+        }
+        return dataset;
+      }
+    };
+  }
+  function minValue(requirement, message) {
+    return {
+      kind: "validation",
+      type: "min_value",
+      reference: minValue,
+      async: false,
+      expects: `>=${requirement instanceof Date ? requirement.toJSON() : _stringify(requirement)}`,
+      requirement,
+      message,
+      _run(dataset, config2) {
+        if (dataset.typed && dataset.value < this.requirement) {
+          _addIssue(this, "value", dataset, config2, {
+            received: dataset.value instanceof Date ? dataset.value.toJSON() : _stringify(dataset.value)
+          });
+        }
+        return dataset;
+      }
+    };
+  }
+  function readonly() {
+    return {
+      kind: "transformation",
+      type: "readonly",
+      reference: readonly,
+      async: false,
+      _run(dataset) {
+        return dataset;
+      }
+    };
+  }
+  function transform(operation) {
+    return {
+      kind: "transformation",
+      type: "transform",
+      reference: transform,
+      async: false,
+      operation,
+      _run(dataset) {
+        dataset.value = this.operation(dataset.value);
+        return dataset;
+      }
+    };
+  }
+  function getDefault(schema, dataset, config2) {
+    return typeof schema.default === "function" ? (
+      // @ts-expect-error
+      schema.default(dataset, config2)
+    ) : (
+      // @ts-expect-error
+      schema.default
+    );
+  }
+  function array(item, message) {
+    return {
+      kind: "schema",
+      type: "array",
+      reference: array,
+      expects: "Array",
+      async: false,
+      item,
+      message,
+      _run(dataset, config2) {
+        const input = dataset.value;
+        if (Array.isArray(input)) {
+          dataset.typed = true;
+          dataset.value = [];
+          for (let key = 0; key < input.length; key++) {
+            const value2 = input[key];
+            const itemDataset = this.item._run({ typed: false, value: value2 }, config2);
+            if (itemDataset.issues) {
+              const pathItem = {
+                type: "array",
+                origin: "value",
+                input,
+                key,
+                value: value2
+              };
+              for (const issue of itemDataset.issues) {
+                if (issue.path) {
+                  issue.path.unshift(pathItem);
+                } else {
+                  issue.path = [pathItem];
+                }
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) {
+                dataset.issues = itemDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!itemDataset.typed) {
+              dataset.typed = false;
+            }
+            dataset.value.push(itemDataset.value);
+          }
+        } else {
+          _addIssue(this, "type", dataset, config2);
+        }
+        return dataset;
+      }
+    };
+  }
+  function boolean(message) {
+    return {
+      kind: "schema",
+      type: "boolean",
+      reference: boolean,
+      expects: "boolean",
+      async: false,
+      message,
+      _run(dataset, config2) {
+        if (typeof dataset.value === "boolean") {
+          dataset.typed = true;
+        } else {
+          _addIssue(this, "type", dataset, config2);
+        }
+        return dataset;
+      }
+    };
+  }
+  function enum_(enum__, message) {
+    const options = Object.entries(enum__).filter(([key]) => isNaN(+key)).map(([, value2]) => value2);
+    return {
+      kind: "schema",
+      type: "enum",
+      reference: enum_,
+      expects: _joinExpects(options.map(_stringify), "|"),
+      async: false,
+      enum: enum__,
+      options,
+      message,
+      _run(dataset, config2) {
+        if (this.options.includes(dataset.value)) {
+          dataset.typed = true;
+        } else {
+          _addIssue(this, "type", dataset, config2);
+        }
+        return dataset;
+      }
+    };
+  }
+  function function_(message) {
+    return {
+      kind: "schema",
+      type: "function",
+      reference: function_,
+      expects: "Function",
+      async: false,
+      message,
+      _run(dataset, config2) {
+        if (typeof dataset.value === "function") {
+          dataset.typed = true;
+        } else {
+          _addIssue(this, "type", dataset, config2);
+        }
+        return dataset;
+      }
+    };
+  }
+  function _merge(value1, value2) {
+    if (typeof value1 === typeof value2) {
+      if (value1 === value2 || value1 instanceof Date && value2 instanceof Date && +value1 === +value2) {
+        return { value: value1 };
+      }
+      if (value1 && value2 && value1.constructor === Object && value2.constructor === Object) {
+        for (const key in value2) {
+          if (key in value1) {
+            const dataset = _merge(value1[key], value2[key]);
+            if (dataset.issue) {
+              return dataset;
+            }
+            value1[key] = dataset.value;
+          } else {
+            value1[key] = value2[key];
+          }
+        }
+        return { value: value1 };
+      }
+      if (Array.isArray(value1) && Array.isArray(value2)) {
+        if (value1.length === value2.length) {
+          for (let index = 0; index < value1.length; index++) {
+            const dataset = _merge(value1[index], value2[index]);
+            if (dataset.issue) {
+              return dataset;
+            }
+            value1[index] = dataset.value;
+          }
+          return { value: value1 };
+        }
+      }
+    }
+    return { issue: true };
+  }
+  function intersect(options, message) {
+    return {
+      kind: "schema",
+      type: "intersect",
+      reference: intersect,
+      expects: _joinExpects(
+        options.map((option) => option.expects),
+        "&"
+      ),
+      async: false,
+      options,
+      message,
+      _run(dataset, config2) {
+        if (this.options.length) {
+          const input = dataset.value;
+          let outputs;
+          dataset.typed = true;
+          for (const schema of this.options) {
+            const optionDataset = schema._run(
+              { typed: false, value: input },
+              config2
+            );
+            if (optionDataset.issues) {
+              if (dataset.issues) {
+                dataset.issues.push(...optionDataset.issues);
+              } else {
+                dataset.issues = optionDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!optionDataset.typed) {
+              dataset.typed = false;
+            }
+            if (dataset.typed) {
+              if (outputs) {
+                outputs.push(optionDataset.value);
+              } else {
+                outputs = [optionDataset.value];
+              }
+            }
+          }
+          if (dataset.typed) {
+            dataset.value = outputs[0];
+            for (let index = 1; index < outputs.length; index++) {
+              const mergeDataset = _merge(dataset.value, outputs[index]);
+              if (mergeDataset.issue) {
+                _addIssue(this, "type", dataset, config2, {
+                  received: "unknown"
+                });
+                break;
+              }
+              dataset.value = mergeDataset.value;
+            }
+          }
+        } else {
+          _addIssue(this, "type", dataset, config2);
+        }
+        return dataset;
+      }
+    };
+  }
+  function number(message) {
+    return {
+      kind: "schema",
+      type: "number",
+      reference: number,
+      expects: "number",
+      async: false,
+      message,
+      _run(dataset, config2) {
+        if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
+          dataset.typed = true;
+        } else {
+          _addIssue(this, "type", dataset, config2);
+        }
+        return dataset;
+      }
+    };
+  }
+  function object(entries, message) {
+    return {
+      kind: "schema",
+      type: "object",
+      reference: object,
+      expects: "Object",
+      async: false,
+      entries,
+      message,
+      _run(dataset, config2) {
+        const input = dataset.value;
+        if (input && typeof input === "object") {
+          dataset.typed = true;
+          dataset.value = {};
+          for (const key in this.entries) {
+            const value2 = input[key];
+            const valueDataset = this.entries[key]._run(
+              { typed: false, value: value2 },
+              config2
+            );
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value2
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) {
+                  issue.path.unshift(pathItem);
+                } else {
+                  issue.path = [pathItem];
+                }
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) {
+                dataset.issues = valueDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) {
+              dataset.typed = false;
+            }
+            if (valueDataset.value !== void 0 || key in input) {
+              dataset.value[key] = valueDataset.value;
+            }
+          }
+        } else {
+          _addIssue(this, "type", dataset, config2);
+        }
+        return dataset;
+      }
+    };
+  }
+  function optional(wrapped, ...args) {
+    const schema = {
+      kind: "schema",
+      type: "optional",
+      reference: optional,
+      expects: `(${wrapped.expects} | undefined)`,
+      async: false,
+      wrapped,
+      _run(dataset, config2) {
+        if (dataset.value === void 0) {
+          if ("default" in this) {
+            dataset.value = getDefault(
+              this,
+              dataset,
+              config2
+            );
+          }
+          if (dataset.value === void 0) {
+            dataset.typed = true;
+            return dataset;
+          }
+        }
+        return this.wrapped._run(dataset, config2);
+      }
+    };
+    if (0 in args) {
+      schema.default = args[0];
+    }
+    return schema;
+  }
+  function string(message) {
+    return {
+      kind: "schema",
+      type: "string",
+      reference: string,
+      expects: "string",
+      async: false,
+      message,
+      _run(dataset, config2) {
+        if (typeof dataset.value === "string") {
+          dataset.typed = true;
+        } else {
+          _addIssue(this, "type", dataset, config2);
+        }
+        return dataset;
+      }
+    };
+  }
+  function undefined_(message) {
+    return {
+      kind: "schema",
+      type: "undefined",
+      reference: undefined_,
+      expects: "undefined",
+      async: false,
+      message,
+      _run(dataset, config2) {
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+        } else {
+          _addIssue(this, "type", dataset, config2);
+        }
+        return dataset;
+      }
+    };
+  }
+  function _subIssues(datasets) {
+    let issues;
+    if (datasets) {
+      for (const dataset of datasets) {
+        if (issues) {
+          issues.push(...dataset.issues);
+        } else {
+          issues = dataset.issues;
+        }
+      }
+    }
+    return issues;
+  }
+  function union(options, message) {
+    return {
+      kind: "schema",
+      type: "union",
+      reference: union,
+      expects: _joinExpects(
+        options.map((option) => option.expects),
+        "|"
+      ),
+      async: false,
+      options,
+      message,
+      _run(dataset, config2) {
+        let validDataset;
+        let typedDatasets;
+        let untypedDatasets;
+        for (const schema of this.options) {
+          const optionDataset = schema._run(
+            { typed: false, value: dataset.value },
+            config2
+          );
+          if (optionDataset.typed) {
+            if (optionDataset.issues) {
+              if (typedDatasets) {
+                typedDatasets.push(optionDataset);
+              } else {
+                typedDatasets = [optionDataset];
+              }
+            } else {
+              validDataset = optionDataset;
+              break;
+            }
+          } else {
+            if (untypedDatasets) {
+              untypedDatasets.push(optionDataset);
+            } else {
+              untypedDatasets = [optionDataset];
+            }
+          }
+        }
+        if (validDataset) {
+          return validDataset;
+        }
+        if (typedDatasets) {
+          if (typedDatasets.length === 1) {
+            return typedDatasets[0];
+          }
+          _addIssue(this, "type", dataset, config2, {
+            issues: _subIssues(typedDatasets)
+          });
+          dataset.typed = true;
+        } else if (untypedDatasets?.length === 1) {
+          return untypedDatasets[0];
+        } else {
+          _addIssue(this, "type", dataset, config2, {
+            issues: _subIssues(untypedDatasets)
+          });
+        }
+        return dataset;
+      }
+    };
+  }
+  function parse(schema, input, config2) {
+    const dataset = schema._run(
+      { typed: false, value: input },
+      getGlobalConfig(config2)
+    );
+    if (dataset.issues) {
+      throw new ValiError(dataset.issues);
+    }
+    return dataset.value;
+  }
+  function pipe(...pipe2) {
+    return {
+      ...pipe2[0],
+      pipe: pipe2,
+      _run(dataset, config2) {
+        for (const item of pipe2) {
+          if (item.kind !== "metadata") {
+            if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+              dataset.typed = false;
+              break;
+            }
+            if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) {
+              dataset = item._run(dataset, config2);
+            }
+          }
+        }
+        return dataset;
+      }
+    };
+  }
+
   // src/SpeechServices/resolveFunctionOrReturnValue.ts
   function isFunction(value) {
     return typeof value === "function";
@@ -23440,98 +24067,136 @@
     return isFunction(fnOrValue) ? fnOrValue() : fnOrValue;
   }
 
+  // src/SpeechServices/SpeechSDK.ts
+  var import_microsoft_cognitiveservices_speech = __toESM(require_microsoft_cognitiveservices_speech_sdk());
+  var SpeechSDK_default = {
+    AudioConfig: import_microsoft_cognitiveservices_speech.AudioConfig,
+    OutputFormat: import_microsoft_cognitiveservices_speech.OutputFormat,
+    ResultReason: import_microsoft_cognitiveservices_speech.ResultReason,
+    SpeechConfig: import_microsoft_cognitiveservices_speech.SpeechConfig,
+    SpeechRecognizer: import_microsoft_cognitiveservices_speech.SpeechRecognizer
+  };
+
+  // src/SpeechServices/SpeechToText/validation/credentialsSchema.ts
+  var credentialsSchema = pipe(
+    intersect([
+      union(
+        [
+          object({
+            authorizationToken: string(),
+            subscriptionKey: optional(undefined_('"subscriptionKey" must be unset when "authorizationToken" is set.'))
+          }),
+          object({
+            authorizationToken: optional(undefined_('"authorizationToken" must be unset when "subscriptionKey" is set.')),
+            subscriptionKey: string()
+          })
+        ],
+        'The object must either have either "authorizationToken" or "subscriptionKey" set, but not both.'
+      ),
+      union(
+        [
+          object({
+            customVoiceHostname: optional(undefined_('"customVoiceHostname" must be unest when "region" is set.')),
+            region: string(),
+            speechRecognitionHostname: optional(
+              undefined_('"speechRecognitionHostname" must be unest when "region" is set.')
+            ),
+            speechSynthesisHostname: optional(undefined_('"speechSynthesisHostname" must be unest when "region" is set.'))
+          }),
+          object({
+            customVoiceHostname: optional(union([string(), undefined_()])),
+            region: optional(undefined_('"region" must be unset when "*Hostname" is set.')),
+            speechRecognitionHostname: string(),
+            speechSynthesisHostname: string()
+          })
+        ],
+        'The object must either have either "region" or "*Hostname" set, but not both.'
+      )
+    ]),
+    readonly()
+  );
+  var credentialsSchema_default = credentialsSchema;
+
+  // src/SpeechServices/SpeechToText/validation/enableTelemetrySchema.ts
+  var enableTelemetrySchema = optional(boolean());
+  var enableTelemetrySchema_default = enableTelemetrySchema;
+
+  // src/SpeechServices/SpeechToText/validation/initialSilenceTimeoutSchema.ts
+  var initialSilenceTimeoutSchema = optional(pipe(number(), minValue(1), maxValue(6e4)));
+  var initialSilenceTimeoutSchema_default = initialSilenceTimeoutSchema;
+
+  // src/SpeechServices/SpeechToText/validation/looseEventsSchema.ts
+  var looseEventsSchema = optional(boolean(), false);
+  var looseEventsSchema_default = looseEventsSchema;
+
+  // src/SpeechServices/SpeechToText/validation/referenceGrammarsSchema.ts
+  var referenceGrammarsSchema = pipe(
+    optional(array(string()), []),
+    // any(),
+    // array(string()),
+    // transform<string[], readonly string[]>(value => (Object.isFrozen(value) ? value : Object.freeze([...value])))
+    transform((value) => Object.isFrozen(value) ? value : Object.freeze([...value]))
+  );
+  var referenceGrammarsSchema_default = referenceGrammarsSchema;
+
+  // src/SpeechServices/SpeechToText/validation/speechRecognitionEndpointIdSchema.ts
+  var speechRecognitionEndpointIdSchema = optional(string());
+  var speechRecognitionEndpointIdSchema_default = speechRecognitionEndpointIdSchema;
+
+  // src/SpeechServices/SpeechToText/validation/textNormalizationSchema.ts
+  var textNormalizationSchema = optional(
+    enum_({
+      display: "display",
+      itn: "itn",
+      lexical: "lexical",
+      maskeditn: "maskeditn"
+    }),
+    "display"
+  );
+  var textNormalizationSchema_default = textNormalizationSchema;
+
   // src/SpeechServices/patchOptions.ts
+  var { AudioConfig: AudioConfig2 } = SpeechSDK_default;
   var shouldWarnOnSubscriptionKey = true;
   function patchOptions(init) {
     const {
       audioConfig,
-      authorizationToken,
+      credentials,
       enableTelemetry,
+      initialSilenceTimeout,
       looseEvent,
       referenceGrammars,
-      region = "westus",
       speechRecognitionEndpointId,
-      subscriptionKey,
       textNormalization
     } = init;
-    let { credentials, looseEvents } = init;
+    let { looseEvents } = init;
     if (typeof looseEvent !== "undefined") {
       console.warn('web-speech-cognitive-services: The option "looseEvent" should be named as "looseEvents".');
       looseEvents = looseEvent;
     }
-    if (!credentials) {
-      if (!authorizationToken && !subscriptionKey) {
-        throw new Error("web-speech-cognitive-services: Credentials must be specified.");
-      } else {
-        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 () => typeof init.authorizationToken !== "undefined" ? { authorizationToken: await resolveFunctionOrReturnValue(init.authorizationToken), region } : { region, subscriptionKey: await resolveFunctionOrReturnValue(init.subscriptionKey) };
-      }
-    }
     return Object.freeze({
-      audioConfig,
-      enableTelemetry,
+      audioConfig: audioConfig || AudioConfig2.fromDefaultMicrophoneInput(),
+      // We set telemetry to true to honor the default telemetry settings of Speech SDK
+      // https://github.com/Microsoft/cognitive-services-speech-sdk-js#data--telemetry
+      enableTelemetry: parse(enableTelemetrySchema_default, enableTelemetry),
       fetchCredentials: async () => {
-        const {
-          authorizationToken: authorizationToken2,
-          customVoiceHostname,
-          region: region2,
-          speechRecognitionHostname,
-          speechSynthesisHostname,
-          subscriptionKey: subscriptionKey2
-        } = await resolveFunctionOrReturnValue(credentials);
-        if (!authorizationToken2 && !subscriptionKey2 || authorizationToken2 && subscriptionKey2) {
-          throw new Error(
-            'web-speech-cognitive-services: Either "authorizationToken" or "subscriptionKey" must be provided.'
-          );
-        } else if (!region2 && !(speechRecognitionHostname && speechSynthesisHostname)) {
-          throw new Error(
-            'web-speech-cognitive-services: Either "region" or "speechRecognitionHostname" and "speechSynthesisHostname" must be set.'
-          );
-        } else if (region2 && (customVoiceHostname || speechRecognitionHostname || speechSynthesisHostname)) {
-          throw new Error(
-            'web-speech-cognitive-services: Only either "region" or "customVoiceHostname", "speechRecognitionHostname" and "speechSynthesisHostname" can be set.'
-          );
-        } else if (authorizationToken2) {
-          if (typeof authorizationToken2 !== "string") {
-            throw new Error('web-speech-cognitive-services: "authorizationToken" must be a string.');
-          }
-        } else if (typeof subscriptionKey2 !== "string") {
-          throw new Error('web-speech-cognitive-services: "subscriptionKey" must be a string.');
-        }
-        if (shouldWarnOnSubscriptionKey && subscriptionKey2) {
+        const parsedCredentials = parse(credentialsSchema_default, await resolveFunctionOrReturnValue(credentials));
+        if (shouldWarnOnSubscriptionKey && parsedCredentials.subscriptionKey) {
           console.warn(
             "web-speech-cognitive-services: In production environment, subscription key should not be used, authorization token should be used instead."
           );
           shouldWarnOnSubscriptionKey = false;
         }
-        return {
-          ...typeof authorizationToken2 !== "undefined" ? { authorizationToken: authorizationToken2 } : { subscriptionKey: subscriptionKey2 },
-          ...typeof region2 !== "undefined" ? { region: region2 } : {
-            customVoiceHostname,
-            speechRecognitionHostname,
-            speechSynthesisHostname
-          }
-        };
+        return parsedCredentials;
       },
-      looseEvents: !!looseEvents,
-      referenceGrammars: referenceGrammars && Object.freeze([...referenceGrammars]),
-      speechRecognitionEndpointId,
-      textNormalization
+      initialSilenceTimeout: parse(initialSilenceTimeoutSchema_default, initialSilenceTimeout),
+      looseEvents: parse(looseEventsSchema_default, looseEvents),
+      referenceGrammars: parse(referenceGrammarsSchema_default, referenceGrammars),
+      speechRecognitionEndpointId: parse(speechRecognitionEndpointIdSchema_default, speechRecognitionEndpointId),
+      textNormalization: parse(textNormalizationSchema_default, textNormalization)
     });
   }
 
-  // src/SpeechServices/SpeechSDK.ts
-  var import_microsoft_cognitiveservices_speech = __toESM(require_microsoft_cognitiveservices_speech_sdk());
-  var SpeechSDK_default = {
-    AudioConfig: import_microsoft_cognitiveservices_speech.AudioConfig,
-    OutputFormat: import_microsoft_cognitiveservices_speech.OutputFormat,
-    ResultReason: import_microsoft_cognitiveservices_speech.ResultReason,
-    SpeechConfig: import_microsoft_cognitiveservices_speech.SpeechConfig,
-    SpeechRecognizer: import_microsoft_cognitiveservices_speech.SpeechRecognizer
-  };
-
   // ../../node_modules/p-defer/index.js
   function pDefer() {
     const deferred = {};
@@ -23585,16 +24250,16 @@
 
   // src/SpeechServices/SpeechToText/private/FakeArray.ts
   var FakeArray = class {
-    constructor(array) {
-      if (!array) {
+    constructor(array2) {
+      if (!array2) {
         throw new Error("array must be set.");
       }
-      this.#array = array;
-      for (const key in array) {
+      this.#array = array2;
+      for (const key in array2) {
         Object.defineProperty(this, key, {
           enumerable: true,
           get() {
-            return array[key];
+            return array2[key];
           }
         });
       }
@@ -23685,8 +24350,8 @@
 
   // 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;
+    const array2 = Array.from(new Int16Array(arrayBuffer));
+    return array2.reduce((averageAmplitude2, amplitude) => averageAmplitude2 + Math.abs(amplitude), 0) / array2.length;
   }
 
   // src/SpeechServices/SpeechToText/private/prepareAudioConfig.ts
@@ -23834,6 +24499,7 @@
 
   // src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfillFromRecognizer.ts
   var { ResultReason: ResultReason2, SpeechRecognizer: SpeechRecognizer2 } = SpeechSDK_default;
+  var enableTelemetrySchema2 = union([boolean(), undefined_()]);
   function createSpeechRecognitionPonyfillFromRecognizer({
     createRecognizer,
     enableTelemetry,
@@ -23841,7 +24507,12 @@
     referenceGrammars,
     textNormalization
   }) {
-    SpeechRecognizer2.enableTelemetry(enableTelemetry !== false);
+    createRecognizer = parse(function_(), createRecognizer);
+    enableTelemetry = parse(enableTelemetrySchema2, enableTelemetry);
+    looseEvents = parse(boolean(), looseEvents);
+    referenceGrammars = parse(referenceGrammarsSchema_default, referenceGrammars);
+    textNormalization = parse(textNormalizationSchema_default, textNormalization);
+    typeof enableTelemetry !== "undefined" && SpeechRecognizer2.enableTelemetry(enableTelemetry);
     class SpeechRecognition extends EventTarget {
       #continuous = false;
       #eventListenerMap = new EventListenerMap(this);
@@ -24211,18 +24882,17 @@
   }
 
   // src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfill.ts
-  var { AudioConfig: AudioConfig2, OutputFormat: OutputFormat2, SpeechConfig: SpeechConfig2, SpeechRecognizer: SpeechRecognizer3 } = SpeechSDK_default;
+  var { 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
-      // https://github.com/Microsoft/cognitive-services-speech-sdk-js#data--telemetry
-      enableTelemetry = true,
+      audioConfig,
+      enableTelemetry,
       fetchCredentials,
+      initialSilenceTimeout,
       looseEvents,
       referenceGrammars,
       speechRecognitionEndpointId,
-      textNormalization = "display"
+      textNormalization
     } = patchOptions(options);
     if (!audioConfig && (!window.navigator.mediaDevices || !window.navigator.mediaDevices.getUserMedia)) {
       throw new Error(
@@ -24233,7 +24903,7 @@
       const credentials = await fetchCredentials();
       let speechConfig;
       if (typeof credentials.speechRecognitionHostname !== "undefined") {
-        const host = new URL("wss://hostname:443");
+        const host = new URL("wss://localhost:443");
         host.hostname = credentials.speechRecognitionHostname;
         if (credentials.authorizationToken) {
           speechConfig = SpeechConfig2.fromHost(host);
@@ -24249,6 +24919,7 @@
       }
       speechConfig.outputFormat = OutputFormat2.Detailed;
       speechConfig.speechRecognitionLanguage = lang || "en-US";
+      typeof initialSilenceTimeout === "number" && speechConfig.setProperty(import_microsoft_cognitiveservices_speech_sdk.PropertyId.SpeechServiceConnection_InitialSilenceTimeoutMs, "" + initialSilenceTimeout);
       return new SpeechRecognizer3(speechConfig, audioConfig);
     };
     return createSpeechRecognitionPonyfillFromRecognizer({
@@ -25734,7 +26405,7 @@
   }
   var meta = document.createElement("meta");
   meta.setAttribute("name", "web-speech-cognitive-services");
-  meta.setAttribute("content", `version=${"8.0.1-main.8743165"}`);
+  meta.setAttribute("content", `version=${"8.1.0"}`);
   document.head.appendChild(meta);
 
   // src/index.umd.js