{"version":3,"sources":["webpack:///./node_modules/microsoft-cognitiveservices-speech-sdk/distrib/es2015/src/common.browser/ReplayableAudioNode.js","webpack:///./node_modules/microsoft-cognitiveservices-speech-sdk/distrib/es2015/src/common.browser/WebsocketMessageAdapter.js","webpack:///./node_modules/microsoft-cognitiveservices-speech-sdk/distrib/es2015/src/common.browser/WebsocketConnection.js","webpack:///./node_modules/microsoft-cognitiveservices-speech-sdk/distrib/es2015/src/common.browser/RestMessageAdapter.js","webpack:///./node_modules/microsoft-cognitiveservices-speech-sdk/distrib/es2015/src/common.browser/RestConfigBase.js","webpack:///./node_modules/microsoft-cognitiveservices-speech-sdk/distrib/es2015/src/common.browser/ConsoleLoggingListener.js","webpack:///./node_modules/microsoft-cognitiveservices-speech-sdk/distrib/es2015/microsoft.cognitiveservices.speech.sdk.js","webpack:///./node_modules/microsoft-cognitiveservices-speech-sdk/distrib/es2015/src/common.browser/ProxyInfo.js","webpack:///./node_modules/microsoft-cognitiveservices-speech-sdk/distrib/es2015/src/common.browser/PCMRecorder.js","webpack:///./node_modules/microsoft-cognitiveservices-speech-sdk/distrib/es2015/src/common.browser/FileAudioSource.js","webpack:///./node_modules/microsoft-cognitiveservices-speech-sdk/distrib/es2015/src/common.browser/MicAudioSource.js","webpack:///./node_modules/microsoft-cognitiveservices-speech-sdk/distrib/es2015/src/common.browser/CertChecks.js"],"names":["ReplayableAudioNode","audioSource","bytesPerSecond","this","privBuffers","privReplayOffset","privLastShrinkOffset","privBufferStartOffset","privBufferSerial","privBufferedBytes","privReplay","privLastChunkAcquiredTime","id","privAudioNode","privBytesPerSecond","length","offsetToSeek","bytesToSeek","Math","round","i","chunk","buffer","byteLength","retVal","slice","Promise","resolve","isEnd","timeReceived","read","then","result","push","BufferEntry","undefined","detach","offset","value","startOffset","byteOffset","endOffset","serial","__awaiter","thisArg","_arguments","P","generator","adopt","reject","fulfilled","step","next","e","rejected","done","apply","uri","connectionId","messageFormatter","proxyInfo","headers","enableCompression","open","privConnectionState","Disconnected","privConnectionEstablishDeferral","promise","privCertificateValidatedDeferral","Connecting","WebSocket","forceNpmWebSocket","options","privHeaders","perMessageDeflate","privEnableCompression","checkAgent","agent","GetAgent","privWebsocketClient","privUri","binaryType","privReceivingMessageQueue","Queue","privDisconnectDeferral","privSendMessageQueue","processSendQueue","catch","reason","Events","instance","onEvent","error","ConnectionOpenResponse","privConnectionId","onopen","Connected","onerror","message","type","privLastErrorReceived","onclose","code","onClose","onmessage","networkReceivedTime","Date","toISOString","deferred","enqueueFromPromise","data","ArrayBuffer","rawMessage","RawWebsocketMessage","Binary","privMessageFormatter","toConnectionMessage","connectionMessage","Text","send","messageSendStatusDeferral","messageSendDeferral","fromConnectionMessage","Message","sendStatusDeferral","dequeue","close","sendRawMessage","sendItem","isWebsocketOpen","payload","Error","stack","event","privConnectionEvents","EventSource","None","HeaderNames","ConnectionId","closeReason","drainAndDispose","pendingReceiveItem","pendingSendItem","itemToSend","sendError","readyState","OPEN","queryParameters","privIsDisposed","isDisposed","state","privConnectionMessageAdapter","queryParams","paramName","indexOf","val","encodeURIComponent","headerName","privId","events","RestRequestType","RestMessageAdapter","configParams","privTimeout","timeout","privIgnoreCache","ignoreCache","key","method","body","binaryBody","responseReceivedDeferral","xhr","XMLHttpRequest","requestCommand","File","withQuery","Object","keys","forEach","setRequestHeader","onload","parseXHRResult","errorResponse","ontimeout","Post","JSON","stringify","responseText","getAllResponseHeaders","json","parse","ok","status","statusText","url","params","queryString","map","k","join","RestConfigBase","privDefaultRequestOptions","privDefaultParams","privRestErrors","Accept","authInvalidSubscriptionKey","authInvalidSubscriptionRegion","invalidArgs","invalidCreateJoinConversationResponse","invalidParticipantRequest","permissionDeniedConnect","permissionDeniedConversation","permissionDeniedParticipant","permissionDeniedSend","permissionDeniedStart","apiVersion","authorization","clientAppId","contentTypeKey","correlationId","languageCode","nickname","profanity","requestId","roomId","sessionToken","subscriptionKey","subscriptionRegion","token","logLevelFilter","Warning","eventType","privLogLevelFilter","log","toString","Debug","console","debug","Info","info","warn","logFragments","EventTime","Name","prop","hasOwnProperty","valueToLog","attachListener","ProxyInfo","proxyHostName","proxyPort","proxyUserName","proxyPassword","privProxyHostName","privProxyPort","privProxyUserName","privProxyPassword","parameters","getProperty","SpeechServiceConnection_ProxyHostName","parseInt","SpeechServiceConnection_ProxyPort","SpeechServiceConnection_ProxyUserName","SpeechServiceConnection_ProxyPassword","config","fromParameters","PcmRecorder","record","context","mediaStream","outputStream","desiredSampleRate","scriptNode","bufferSize","createScriptProcessor","audioSampleRate","sampleRate","waveStreamEncoder","needHeader","onaudioprocess","inputFrame","inputBuffer","getChannelData","isClosed","waveFrame","encode","writeStreamChunk","now","micInput","createMediaStreamSource","privSpeechProcessorScript","audioWorklet","addModule","workletNode","AudioWorkletNode","port","ev","connect","destination","privMediaResources","scriptProcessorNode","source","stream","releaseMediaResources","disconnect","getTracks","track","stop","FileAudioSource","file","audioSourceId","privStreams","privHeaderEnd","turnOn","FileReader","errorMsg","privFile","name","lastIndexOf","attach","audioNodeId","upload","readEnded","turnOff","streamId","privEvents","privAudioFormatPromise","readHeader","bitspersample","bitsPerSample","channelcount","channels","connectivity","Unknown","manufacturer","model","samplerate","samplesPerSec","maxHeaderSize","header","headerReader","headerResult","processHeader","target","view","DataView","getWord","index","String","fromCharCode","getUint8","formatSize","getInt32","channelCount","getUint16","getUint32","pos","max","getWaveFormatPCM","readAsArrayBuffer","format","reader","avgBytesPerSec","processFile","AudioWorkletSourceURLPropertyName","MicAudioSource","privRecorder","deviceId","privInitializeDeferral","createAudioContext","typedError","nav","window","navigator","getUserMedia","webkitGetUserMedia","mozGetUserMedia","msGetUserMedia","mediaDevices","constraints","successCallback","errorCallback","privMediaStream","active","audio","video","privContext","resume","listen","privOutputChunkSize","getAudioContext","AUDIOFORMAT","destroyAudioContext","getMicrophoneLabel","label","Microphones","setWorkletUrl","defaultMicrophoneName","privMicrophoneLabel","microphoneDeviceId","getSettings","enumerateDevices","devices","device","hasClose","suspend","getDefaultInputFormat","CertCheckAgent","privProxyInfo","privDiskCache","supportBuffer","location","process","SPEECH_OCSP_CACHE_ROOT","privMemCache","disableStapling","Agent","CreateConnection","HostName","Port","proxyName","httpProxyOptions","host","UserName","Buffer","Password","requestOCSP","httpProxyAgent","socketPromise","ocspRequest","stapling","resolved","socket","cork","tlsSocket","on","destroy","peer","getPeerCertificate","issuer","GetIssuer","generate","raw","sig","cacheEntry","GetResponseFromCache","VerifyOCSPResponse","uncork","issuerCertificate","ocspAgent","fetchIssuer","signature","cachedResponse","diskCacheResponse","get","isCached","StoreMemoryCacheEntry","cachedOcspResponse","parseResponse","tbsData","tbsResponseData","responses","cachedStartTime","thisUpdate","cachedNextTime","nextUpdate","testTimeOffset","minUpdate","min","UpdateCache","cacheValue","ocspResponse","certID","GetOCSPResponse","request","response","StoreCacheEntry","req","rawResponse","StoreDiskCacheEntry","set","ocspMethod","GetProxyAgent","getAuthorityInfo","cert","parsedUri","assign","getResponse","enableOCSP","NODE_TLS_REJECT_UNAUTHORIZED","SPEECH_CONDUCT_OCSP_CHECK","secureEndpoint","forceDisableOCSPStapling","servername","baseAgent","callback","OCSPCheck"],"mappings":"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","file":"js/AnswerShortQuestion~5f1a04a9.49f525b5.js","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT license.\nexport class ReplayableAudioNode {\n    constructor(audioSource, bytesPerSecond) {\n        this.privBuffers = [];\n        this.privReplayOffset = 0;\n        this.privLastShrinkOffset = 0;\n        this.privBufferStartOffset = 0;\n        this.privBufferSerial = 0;\n        this.privBufferedBytes = 0;\n        this.privReplay = false;\n        this.privLastChunkAcquiredTime = 0;\n        this.id = () => {\n            return this.privAudioNode.id();\n        };\n        this.privAudioNode = audioSource;\n        this.privBytesPerSecond = bytesPerSecond;\n    }\n    // Reads and returns the next chunk of audio buffer.\n    // If replay of existing buffers are needed, read() will first seek and replay\n    // existing content, and upoin completion it will read new content from the underlying\n    // audio node, saving that content into the replayable buffers.\n    read() {\n        // if there is a replay request to honor.\n        if (!!this.privReplay && this.privBuffers.length !== 0) {\n            // Find the start point in the buffers.\n            // Offsets are in 100ns increments.\n            // So how many bytes do we need to seek to get the right offset?\n            const offsetToSeek = this.privReplayOffset - this.privBufferStartOffset;\n            let bytesToSeek = Math.round(offsetToSeek * this.privBytesPerSecond * 1e-7);\n            if (0 !== (bytesToSeek % 2)) {\n                bytesToSeek++;\n            }\n            let i = 0;\n            while (i < this.privBuffers.length && bytesToSeek >= this.privBuffers[i].chunk.buffer.byteLength) {\n                bytesToSeek -= this.privBuffers[i++].chunk.buffer.byteLength;\n            }\n            const retVal = this.privBuffers[i].chunk.buffer.slice(bytesToSeek);\n            this.privReplayOffset += (retVal.byteLength / this.privBytesPerSecond) * 1e+7;\n            // If we've reached the end of the buffers, stop replaying.\n            if (i === this.privBuffers.length - 1) {\n                this.privReplay = false;\n            }\n            return Promise.resolve({\n                buffer: retVal,\n                isEnd: false,\n                timeReceived: this.privBuffers[i].chunk.timeReceived,\n            });\n        }\n        return this.privAudioNode.read()\n            .then((result) => {\n            if (result && result.buffer) {\n                this.privBuffers.push(new BufferEntry(result, this.privBufferSerial++, this.privBufferedBytes));\n                this.privBufferedBytes += result.buffer.byteLength;\n            }\n            return result;\n        });\n    }\n    detach() {\n        this.privBuffers = undefined;\n        return this.privAudioNode.detach();\n    }\n    replay() {\n        if (this.privBuffers && 0 !== this.privBuffers.length) {\n            this.privReplay = true;\n            this.privReplayOffset = this.privLastShrinkOffset;\n        }\n    }\n    // Shrinks the existing audio buffers to start at the new offset, or at the\n    // beginning of the buffer closest to the requested offset.\n    // A replay request will start from the last shrink point.\n    shrinkBuffers(offset) {\n        if (this.privBuffers === undefined || this.privBuffers.length === 0) {\n            return;\n        }\n        this.privLastShrinkOffset = offset;\n        // Find the start point in the buffers.\n        // Offsets are in 100ns increments.\n        // So how many bytes do we need to seek to get the right offset?\n        const offsetToSeek = offset - this.privBufferStartOffset;\n        let bytesToSeek = Math.round(offsetToSeek * this.privBytesPerSecond * 1e-7);\n        let i = 0;\n        while (i < this.privBuffers.length && bytesToSeek >= this.privBuffers[i].chunk.buffer.byteLength) {\n            bytesToSeek -= this.privBuffers[i++].chunk.buffer.byteLength;\n        }\n        this.privBufferStartOffset = Math.round(offset - ((bytesToSeek / this.privBytesPerSecond) * 1e+7));\n        this.privBuffers = this.privBuffers.slice(i);\n    }\n    // Finds the time a buffer of audio was first seen by offset.\n    findTimeAtOffset(offset) {\n        if (offset < this.privBufferStartOffset || this.privBuffers === undefined) {\n            return 0;\n        }\n        for (const value of this.privBuffers) {\n            const startOffset = (value.byteOffset / this.privBytesPerSecond) * 1e7;\n            const endOffset = startOffset + ((value.chunk.buffer.byteLength / this.privBytesPerSecond) * 1e7);\n            if (offset >= startOffset && offset <= endOffset) {\n                return value.chunk.timeReceived;\n            }\n        }\n        return 0;\n    }\n}\n// Primary use of this class is to help debugging problems with the replay\n// code. If the memory cost of alloc / dealloc gets too much, drop it and just use\n// the ArrayBuffer directly.\n// tslint:disable-next-line:max-classes-per-file\nclass BufferEntry {\n    constructor(chunk, serial, byteOffset) {\n        this.chunk = chunk;\n        this.serial = serial;\n        this.byteOffset = byteOffset;\n    }\n}\n\n//# sourceMappingURL=ReplayableAudioNode.js.map\n","// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT license.\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { HeaderNames } from \"../common.speech/HeaderNames\";\nimport { ArgumentNullError, BackgroundEvent, ConnectionClosedEvent, ConnectionErrorEvent, ConnectionEstablishedEvent, ConnectionMessageReceivedEvent, ConnectionMessageSentEvent, ConnectionOpenResponse, ConnectionStartEvent, ConnectionState, Deferred, Events, EventSource, MessageType, Queue, RawWebsocketMessage, } from \"../common/Exports\";\n// Node.JS specific web socket / browser support.\nimport ws from \"ws\";\nimport { CertCheckAgent } from \"./CertChecks\";\nexport class WebsocketMessageAdapter {\n    constructor(uri, connectionId, messageFormatter, proxyInfo, headers, enableCompression) {\n        this.open = () => {\n            if (this.privConnectionState === ConnectionState.Disconnected) {\n                return Promise.reject(`Cannot open a connection that is in ${this.privConnectionState} state`);\n            }\n            if (this.privConnectionEstablishDeferral) {\n                return this.privConnectionEstablishDeferral.promise;\n            }\n            this.privConnectionEstablishDeferral = new Deferred();\n            this.privCertificateValidatedDeferral = new Deferred();\n            this.privConnectionState = ConnectionState.Connecting;\n            try {\n                if (typeof WebSocket !== \"undefined\" && !WebsocketMessageAdapter.forceNpmWebSocket) {\n                    // Browser handles cert checks.\n                    this.privCertificateValidatedDeferral.resolve();\n                    this.privWebsocketClient = new WebSocket(this.privUri);\n                }\n                else {\n                    const options = { headers: this.privHeaders, perMessageDeflate: this.privEnableCompression };\n                    // The ocsp library will handle validation for us and fail the connection if needed.\n                    this.privCertificateValidatedDeferral.resolve();\n                    const checkAgent = new CertCheckAgent(this.proxyInfo);\n                    options.agent = checkAgent.GetAgent();\n                    this.privWebsocketClient = new ws(this.privUri, options);\n                }\n                this.privWebsocketClient.binaryType = \"arraybuffer\";\n                this.privReceivingMessageQueue = new Queue();\n                this.privDisconnectDeferral = new Deferred();\n                this.privSendMessageQueue = new Queue();\n                this.processSendQueue().catch((reason) => {\n                    Events.instance.onEvent(new BackgroundEvent(reason));\n                });\n            }\n            catch (error) {\n                this.privConnectionEstablishDeferral.resolve(new ConnectionOpenResponse(500, error));\n                return this.privConnectionEstablishDeferral.promise;\n            }\n            this.onEvent(new ConnectionStartEvent(this.privConnectionId, this.privUri));\n            this.privWebsocketClient.onopen = (e) => {\n                this.privCertificateValidatedDeferral.promise.then(() => {\n                    this.privConnectionState = ConnectionState.Connected;\n                    this.onEvent(new ConnectionEstablishedEvent(this.privConnectionId));\n                    this.privConnectionEstablishDeferral.resolve(new ConnectionOpenResponse(200, \"\"));\n                }, (error) => {\n                    this.privConnectionEstablishDeferral.reject(error);\n                });\n            };\n            this.privWebsocketClient.onerror = (e) => {\n                this.onEvent(new ConnectionErrorEvent(this.privConnectionId, e.message, e.type));\n                this.privLastErrorReceived = e.message;\n            };\n            this.privWebsocketClient.onclose = (e) => {\n                if (this.privConnectionState === ConnectionState.Connecting) {\n                    this.privConnectionState = ConnectionState.Disconnected;\n                    // this.onEvent(new ConnectionEstablishErrorEvent(this.connectionId, e.code, e.reason));\n                    this.privConnectionEstablishDeferral.resolve(new ConnectionOpenResponse(e.code, e.reason + \" \" + this.privLastErrorReceived));\n                }\n                else {\n                    this.privConnectionState = ConnectionState.Disconnected;\n                    this.onEvent(new ConnectionClosedEvent(this.privConnectionId, e.code, e.reason));\n                }\n                this.onClose(e.code, e.reason).catch((reason) => {\n                    Events.instance.onEvent(new BackgroundEvent(reason));\n                });\n            };\n            this.privWebsocketClient.onmessage = (e) => {\n                const networkReceivedTime = new Date().toISOString();\n                if (this.privConnectionState === ConnectionState.Connected) {\n                    const deferred = new Deferred();\n                    // let id = ++this.idCounter;\n                    this.privReceivingMessageQueue.enqueueFromPromise(deferred.promise);\n                    if (e.data instanceof ArrayBuffer) {\n                        const rawMessage = new RawWebsocketMessage(MessageType.Binary, e.data);\n                        this.privMessageFormatter\n                            .toConnectionMessage(rawMessage)\n                            .then((connectionMessage) => {\n                            this.onEvent(new ConnectionMessageReceivedEvent(this.privConnectionId, networkReceivedTime, connectionMessage));\n                            deferred.resolve(connectionMessage);\n                        }, (error) => {\n                            // TODO: Events for these ?\n                            deferred.reject(`Invalid binary message format. Error: ${error}`);\n                        });\n                    }\n                    else {\n                        const rawMessage = new RawWebsocketMessage(MessageType.Text, e.data);\n                        this.privMessageFormatter\n                            .toConnectionMessage(rawMessage)\n                            .then((connectionMessage) => {\n                            this.onEvent(new ConnectionMessageReceivedEvent(this.privConnectionId, networkReceivedTime, connectionMessage));\n                            deferred.resolve(connectionMessage);\n                        }, (error) => {\n                            // TODO: Events for these ?\n                            deferred.reject(`Invalid text message format. Error: ${error}`);\n                        });\n                    }\n                }\n            };\n            return this.privConnectionEstablishDeferral.promise;\n        };\n        this.send = (message) => {\n            if (this.privConnectionState !== ConnectionState.Connected) {\n                return Promise.reject(`Cannot send on connection that is in ${ConnectionState[this.privConnectionState]} state`);\n            }\n            const messageSendStatusDeferral = new Deferred();\n            const messageSendDeferral = new Deferred();\n            this.privSendMessageQueue.enqueueFromPromise(messageSendDeferral.promise);\n            this.privMessageFormatter\n                .fromConnectionMessage(message)\n                .then((rawMessage) => {\n                messageSendDeferral.resolve({\n                    Message: message,\n                    RawWebsocketMessage: rawMessage,\n                    sendStatusDeferral: messageSendStatusDeferral,\n                });\n            }, (error) => {\n                messageSendDeferral.reject(`Error formatting the message. ${error}`);\n            });\n            return messageSendStatusDeferral.promise;\n        };\n        this.read = () => {\n            if (this.privConnectionState !== ConnectionState.Connected) {\n                return Promise.reject(`Cannot read on connection that is in ${this.privConnectionState} state`);\n            }\n            return this.privReceivingMessageQueue.dequeue();\n        };\n        this.close = (reason) => {\n            if (this.privWebsocketClient) {\n                if (this.privConnectionState !== ConnectionState.Disconnected) {\n                    this.privWebsocketClient.close(1000, reason ? reason : \"Normal closure by client\");\n                }\n            }\n            else {\n                return Promise.resolve();\n            }\n            return this.privDisconnectDeferral.promise;\n        };\n        this.sendRawMessage = (sendItem) => {\n            try {\n                // indicates we are draining the queue and it came with no message;\n                if (!sendItem) {\n                    return Promise.resolve();\n                }\n                this.onEvent(new ConnectionMessageSentEvent(this.privConnectionId, new Date().toISOString(), sendItem.Message));\n                // add a check for the ws readystate in order to stop the red console error 'WebSocket is already in CLOSING or CLOSED state' appearing\n                if (this.isWebsocketOpen) {\n                    this.privWebsocketClient.send(sendItem.RawWebsocketMessage.payload);\n                }\n                else {\n                    return Promise.reject(\"websocket send error: Websocket not ready \" + this.privConnectionId + \" \" + sendItem.Message.id + \" \" + new Error().stack);\n                }\n                return Promise.resolve();\n            }\n            catch (e) {\n                return Promise.reject(`websocket send error: ${e}`);\n            }\n        };\n        this.onEvent = (event) => {\n            this.privConnectionEvents.onEvent(event);\n            Events.instance.onEvent(event);\n        };\n        if (!uri) {\n            throw new ArgumentNullError(\"uri\");\n        }\n        if (!messageFormatter) {\n            throw new ArgumentNullError(\"messageFormatter\");\n        }\n        this.proxyInfo = proxyInfo;\n        this.privConnectionEvents = new EventSource();\n        this.privConnectionId = connectionId;\n        this.privMessageFormatter = messageFormatter;\n        this.privConnectionState = ConnectionState.None;\n        this.privUri = uri;\n        this.privHeaders = headers;\n        this.privEnableCompression = enableCompression;\n        // Add the connection ID to the headers\n        this.privHeaders[HeaderNames.ConnectionId] = this.privConnectionId;\n        this.privLastErrorReceived = \"\";\n    }\n    get state() {\n        return this.privConnectionState;\n    }\n    get events() {\n        return this.privConnectionEvents;\n    }\n    onClose(code, reason) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const closeReason = `Connection closed. ${code}: ${reason}`;\n            this.privConnectionState = ConnectionState.Disconnected;\n            this.privDisconnectDeferral.resolve();\n            yield this.privReceivingMessageQueue.drainAndDispose((pendingReceiveItem) => {\n                // TODO: Events for these ?\n                // Logger.instance.onEvent(new LoggingEvent(LogType.Warning, null, `Failed to process received message. Reason: ${closeReason}, Message: ${JSON.stringify(pendingReceiveItem)}`));\n            }, closeReason);\n            yield this.privSendMessageQueue.drainAndDispose((pendingSendItem) => {\n                pendingSendItem.sendStatusDeferral.reject(closeReason);\n            }, closeReason);\n        });\n    }\n    processSendQueue() {\n        return __awaiter(this, void 0, void 0, function* () {\n            const itemToSend = this.privSendMessageQueue.dequeue();\n            const sendItem = yield itemToSend;\n            // indicates we are draining the queue and it came with no message;\n            if (!sendItem) {\n                return;\n            }\n            try {\n                yield this.sendRawMessage(sendItem);\n                sendItem.sendStatusDeferral.resolve();\n            }\n            catch (sendError) {\n                sendItem.sendStatusDeferral.reject(sendError);\n            }\n            yield this.processSendQueue();\n        });\n    }\n    get isWebsocketOpen() {\n        return this.privWebsocketClient && this.privWebsocketClient.readyState === this.privWebsocketClient.OPEN;\n    }\n}\nWebsocketMessageAdapter.forceNpmWebSocket = false;\n\n//# sourceMappingURL=WebsocketMessageAdapter.js.map\n","// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT license.\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { ArgumentNullError, createNoDashGuid, } from \"../common/Exports\";\nimport { WebsocketMessageAdapter } from \"./WebsocketMessageAdapter\";\nexport class WebsocketConnection {\n    constructor(uri, queryParameters, headers, messageFormatter, proxyInfo, enableCompression = false, connectionId) {\n        this.privIsDisposed = false;\n        this.isDisposed = () => {\n            return this.privIsDisposed;\n        };\n        this.state = () => {\n            return this.privConnectionMessageAdapter.state;\n        };\n        this.open = () => {\n            return this.privConnectionMessageAdapter.open();\n        };\n        this.send = (message) => {\n            return this.privConnectionMessageAdapter.send(message);\n        };\n        this.read = () => {\n            return this.privConnectionMessageAdapter.read();\n        };\n        if (!uri) {\n            throw new ArgumentNullError(\"uri\");\n        }\n        if (!messageFormatter) {\n            throw new ArgumentNullError(\"messageFormatter\");\n        }\n        this.privMessageFormatter = messageFormatter;\n        let queryParams = \"\";\n        let i = 0;\n        if (queryParameters) {\n            for (const paramName in queryParameters) {\n                if (paramName) {\n                    queryParams += ((i === 0) && (uri.indexOf(\"?\") === -1)) ? \"?\" : \"&\";\n                    const val = encodeURIComponent(queryParameters[paramName]);\n                    queryParams += `${paramName}=${val}`;\n                    i++;\n                }\n            }\n        }\n        if (headers) {\n            for (const headerName in headers) {\n                if (headerName) {\n                    queryParams += ((i === 0) && (uri.indexOf(\"?\") === -1)) ? \"?\" : \"&\";\n                    const val = encodeURIComponent(headers[headerName]);\n                    queryParams += `${headerName}=${val}`;\n                    i++;\n                }\n            }\n        }\n        this.privUri = uri + queryParams;\n        this.privId = connectionId ? connectionId : createNoDashGuid();\n        this.privConnectionMessageAdapter = new WebsocketMessageAdapter(this.privUri, this.id, this.privMessageFormatter, proxyInfo, headers, enableCompression);\n    }\n    dispose() {\n        return __awaiter(this, void 0, void 0, function* () {\n            this.privIsDisposed = true;\n            if (this.privConnectionMessageAdapter) {\n                yield this.privConnectionMessageAdapter.close();\n            }\n        });\n    }\n    get id() {\n        return this.privId;\n    }\n    get events() {\n        return this.privConnectionMessageAdapter.events;\n    }\n}\n\n//# sourceMappingURL=WebsocketConnection.js.map\n","// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT license.\nimport { ArgumentNullError, Deferred } from \"../common/Exports\";\n// Node.JS specific xmlhttprequest / browser support.\nimport * as XHR from \"xmlhttprequest-ts\";\nexport var RestRequestType;\n(function (RestRequestType) {\n    RestRequestType[\"Get\"] = \"get\";\n    RestRequestType[\"Post\"] = \"post\";\n    RestRequestType[\"Delete\"] = \"delete\";\n    RestRequestType[\"File\"] = \"file\";\n})(RestRequestType || (RestRequestType = {}));\n// accept rest operations via request method and return abstracted objects from server response\nexport class RestMessageAdapter {\n    constructor(configParams, connectionId) {\n        if (!configParams) {\n            throw new ArgumentNullError(\"configParams\");\n        }\n        this.privHeaders = configParams.headers;\n        this.privTimeout = configParams.timeout;\n        this.privIgnoreCache = configParams.ignoreCache;\n    }\n    setHeaders(key, value) {\n        this.privHeaders[key] = value;\n    }\n    request(method, uri, queryParams = {}, body = null, binaryBody = null) {\n        const responseReceivedDeferral = new Deferred();\n        let xhr;\n        if (typeof (XMLHttpRequest) === \"undefined\") {\n            xhr = new XHR.XMLHttpRequest();\n        }\n        else {\n            xhr = new XMLHttpRequest();\n        }\n        const requestCommand = method === RestRequestType.File ? \"post\" : method;\n        xhr.open(requestCommand, this.withQuery(uri, queryParams), true);\n        if (this.privHeaders) {\n            Object.keys(this.privHeaders).forEach((key) => xhr.setRequestHeader(key, this.privHeaders[key]));\n        }\n        if (this.privIgnoreCache) {\n            xhr.setRequestHeader(\"Cache-Control\", \"no-cache\");\n        }\n        xhr.timeout = this.privTimeout;\n        xhr.onload = () => {\n            responseReceivedDeferral.resolve(this.parseXHRResult(xhr));\n        };\n        xhr.onerror = () => {\n            responseReceivedDeferral.resolve(this.errorResponse(xhr, \"Failed to make request.\"));\n        };\n        xhr.ontimeout = () => {\n            responseReceivedDeferral.resolve(this.errorResponse(xhr, \"Request took longer than expected.\"));\n        };\n        if (method === RestRequestType.File && binaryBody) {\n            xhr.setRequestHeader(\"Content-Type\", \"multipart/form-data\");\n            xhr.send(binaryBody);\n        }\n        else if (method === RestRequestType.Post && body) {\n            xhr.setRequestHeader(\"Content-Type\", \"application/json\");\n            xhr.send(JSON.stringify(body));\n        }\n        else {\n            xhr.send();\n        }\n        return responseReceivedDeferral.promise;\n    }\n    parseXHRResult(xhr) {\n        return {\n            data: xhr.responseText,\n            headers: xhr.getAllResponseHeaders(),\n            json: () => JSON.parse(xhr.responseText),\n            ok: xhr.status >= 200 && xhr.status < 300,\n            status: xhr.status,\n            statusText: xhr.statusText,\n        };\n    }\n    errorResponse(xhr, message = null) {\n        return {\n            data: message || xhr.statusText,\n            headers: xhr.getAllResponseHeaders(),\n            json: () => JSON.parse(message || (\"\\\"\" + xhr.statusText + \"\\\"\")),\n            ok: false,\n            status: xhr.status,\n            statusText: xhr.statusText,\n        };\n    }\n    withQuery(url, params = {}) {\n        const queryString = this.queryParams(params);\n        return queryString ? url + (url.indexOf(\"?\") === -1 ? \"?\" : \"&\") + queryString : url;\n    }\n    queryParams(params = {}) {\n        return Object.keys(params)\n            .map((k) => encodeURIComponent(k) + \"=\" + encodeURIComponent(params[k]))\n            .join(\"&\");\n    }\n}\n\n//# sourceMappingURL=RestMessageAdapter.js.map\n","// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT license.\nexport class RestConfigBase {\n    static get requestOptions() {\n        return RestConfigBase.privDefaultRequestOptions;\n    }\n    static get configParams() {\n        return RestConfigBase.privDefaultParams;\n    }\n    static get restErrors() {\n        return RestConfigBase.privRestErrors;\n    }\n}\nRestConfigBase.privDefaultRequestOptions = {\n    headers: {\n        Accept: \"application/json\",\n    },\n    ignoreCache: false,\n    timeout: 10000,\n};\nRestConfigBase.privRestErrors = {\n    authInvalidSubscriptionKey: \"You must specify either an authentication token to use, or a Cognitive Speech subscription key.\",\n    authInvalidSubscriptionRegion: \"You must specify the Cognitive Speech region to use.\",\n    invalidArgs: \"Required input not found: {arg}.\",\n    invalidCreateJoinConversationResponse: \"Creating/Joining conversation failed with HTTP {status}.\",\n    invalidParticipantRequest: \"The requested participant was not found.\",\n    permissionDeniedConnect: \"Required credentials not found.\",\n    permissionDeniedConversation: \"Invalid operation: only the host can {command} the conversation.\",\n    permissionDeniedParticipant: \"Invalid operation: only the host can {command} a participant.\",\n    permissionDeniedSend: \"Invalid operation: the conversation is not in a connected state.\",\n    permissionDeniedStart: \"Invalid operation: there is already an active conversation.\",\n};\nRestConfigBase.privDefaultParams = {\n    apiVersion: \"api-version\",\n    authorization: \"Authorization\",\n    clientAppId: \"X-ClientAppId\",\n    contentTypeKey: \"Content-Type\",\n    correlationId: \"X-CorrelationId\",\n    languageCode: \"language\",\n    nickname: \"nickname\",\n    profanity: \"profanity\",\n    requestId: \"X-RequestId\",\n    roomId: \"roomid\",\n    sessionToken: \"token\",\n    subscriptionKey: \"Ocp-Apim-Subscription-Key\",\n    subscriptionRegion: \"Ocp-Apim-Subscription-Region\",\n    token: \"X-CapitoToken\",\n};\n\n//# sourceMappingURL=RestConfigBase.js.map\n","// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT license.\nimport { EventType } from \"../common/Exports\";\nexport class ConsoleLoggingListener {\n    constructor(logLevelFilter = EventType.Warning) {\n        this.onEvent = (event) => {\n            if (event.eventType >= this.privLogLevelFilter) {\n                const log = this.toString(event);\n                switch (event.eventType) {\n                    case EventType.Debug:\n                        // tslint:disable-next-line:no-console\n                        console.debug(log);\n                        break;\n                    case EventType.Info:\n                        // tslint:disable-next-line:no-console\n                        console.info(log);\n                        break;\n                    case EventType.Warning:\n                        // tslint:disable-next-line:no-console\n                        console.warn(log);\n                        break;\n                    case EventType.Error:\n                        // tslint:disable-next-line:no-console\n                        console.error(log);\n                        break;\n                    default:\n                        // tslint:disable-next-line:no-console\n                        console.log(log);\n                        break;\n                }\n            }\n        };\n        this.toString = (event) => {\n            const logFragments = [\n                `${event.EventTime}`,\n                `${event.Name}`,\n            ];\n            for (const prop in event) {\n                if (prop && event.hasOwnProperty(prop) &&\n                    prop !== \"eventTime\" && prop !== \"eventType\" &&\n                    prop !== \"eventId\" && prop !== \"name\" &&\n                    prop !== \"constructor\") {\n                    const value = event[prop];\n                    let valueToLog = \"<NULL>\";\n                    if (value !== undefined && value !== null) {\n                        if (typeof (value) === \"number\" || typeof (value) === \"string\") {\n                            valueToLog = value.toString();\n                        }\n                        else {\n                            valueToLog = JSON.stringify(value);\n                        }\n                    }\n                    logFragments.push(`${prop}: ${valueToLog}`);\n                }\n            }\n            return logFragments.join(\" | \");\n        };\n        this.privLogLevelFilter = logLevelFilter;\n    }\n}\n\n//# sourceMappingURL=ConsoleLoggingListener.js.map\n","// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT license.\nimport { ConsoleLoggingListener } from \"./src/common.browser/Exports\";\nimport { Events } from \"./src/common/Exports\";\n// Common.Storage.SetLocalStorage(new Common.Browser.LocalStorage());\n// Common.Storage.SetSessionStorage(new Common.Browser.SessionStorage());\nEvents.instance.attachListener(new ConsoleLoggingListener());\n// Speech SDK API\nexport * from \"./src/sdk/Exports\";\n\n//# sourceMappingURL=microsoft.cognitiveservices.speech.sdk.js.map\n","// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT license.\nimport { PropertyId } from \"../sdk/Exports\";\nexport class ProxyInfo {\n    constructor(proxyHostName, proxyPort, proxyUserName, proxyPassword) {\n        this.privProxyHostName = proxyHostName;\n        this.privProxyPort = proxyPort;\n        this.privProxyUserName = proxyUserName;\n        this.privProxyPassword = proxyPassword;\n    }\n    static fromParameters(parameters) {\n        return new ProxyInfo(parameters.getProperty(PropertyId.SpeechServiceConnection_ProxyHostName), parseInt(parameters.getProperty(PropertyId.SpeechServiceConnection_ProxyPort), 10), parameters.getProperty(PropertyId.SpeechServiceConnection_ProxyUserName), parameters.getProperty(PropertyId.SpeechServiceConnection_ProxyPassword));\n    }\n    static fromRecognizerConfig(config) {\n        return this.fromParameters(config.parameters);\n    }\n    get HostName() {\n        return this.privProxyHostName;\n    }\n    get Port() {\n        return this.privProxyPort;\n    }\n    get UserName() {\n        return this.privProxyUserName;\n    }\n    get Password() {\n        return this.privProxyPassword;\n    }\n}\n\n//# sourceMappingURL=ProxyInfo.js.map\n","// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT license.\nimport { RiffPcmEncoder } from \"../common/Exports\";\nexport class PcmRecorder {\n    constructor() {\n        this.record = (context, mediaStream, outputStream) => {\n            const desiredSampleRate = 16000;\n            const scriptNode = (() => {\n                let bufferSize = 0;\n                try {\n                    return context.createScriptProcessor(bufferSize, 1, 1);\n                }\n                catch (error) {\n                    // Webkit (<= version 31) requires a valid bufferSize.\n                    bufferSize = 2048;\n                    let audioSampleRate = context.sampleRate;\n                    while (bufferSize < 16384 && audioSampleRate >= (2 * desiredSampleRate)) {\n                        bufferSize <<= 1;\n                        audioSampleRate >>= 1;\n                    }\n                    return context.createScriptProcessor(bufferSize, 1, 1);\n                }\n            })();\n            const waveStreamEncoder = new RiffPcmEncoder(context.sampleRate, desiredSampleRate);\n            let needHeader = true;\n            const that = this;\n            scriptNode.onaudioprocess = (event) => {\n                const inputFrame = event.inputBuffer.getChannelData(0);\n                if (outputStream && !outputStream.isClosed) {\n                    const waveFrame = waveStreamEncoder.encode(inputFrame);\n                    if (!!waveFrame) {\n                        outputStream.writeStreamChunk({\n                            buffer: waveFrame,\n                            isEnd: false,\n                            timeReceived: Date.now(),\n                        });\n                        needHeader = false;\n                    }\n                }\n            };\n            const micInput = context.createMediaStreamSource(mediaStream);\n            // https://webaudio.github.io/web-audio-api/#audioworklet\n            // Using AudioWorklet to improve audio quality and avoid audio glitches due to blocking the UI thread\n            if (!!this.privSpeechProcessorScript && !!context.audioWorklet) {\n                context.audioWorklet\n                    .addModule(this.privSpeechProcessorScript)\n                    .then(() => {\n                    const workletNode = new AudioWorkletNode(context, \"speech-processor\");\n                    workletNode.port.onmessage = (ev) => {\n                        const inputFrame = ev.data;\n                        if (outputStream && !outputStream.isClosed) {\n                            const waveFrame = waveStreamEncoder.encode(inputFrame);\n                            if (!!waveFrame) {\n                                outputStream.writeStreamChunk({\n                                    buffer: waveFrame,\n                                    isEnd: false,\n                                    timeReceived: Date.now(),\n                                });\n                                needHeader = false;\n                            }\n                        }\n                    };\n                    micInput.connect(workletNode);\n                    workletNode.connect(context.destination);\n                    this.privMediaResources = {\n                        scriptProcessorNode: workletNode,\n                        source: micInput,\n                        stream: mediaStream,\n                    };\n                })\n                    .catch(() => {\n                    micInput.connect(scriptNode);\n                    scriptNode.connect(context.destination);\n                    this.privMediaResources = {\n                        scriptProcessorNode: scriptNode,\n                        source: micInput,\n                        stream: mediaStream,\n                    };\n                });\n            }\n            else {\n                micInput.connect(scriptNode);\n                scriptNode.connect(context.destination);\n                this.privMediaResources = {\n                    scriptProcessorNode: scriptNode,\n                    source: micInput,\n                    stream: mediaStream,\n                };\n            }\n        };\n        this.releaseMediaResources = (context) => {\n            if (this.privMediaResources) {\n                if (this.privMediaResources.scriptProcessorNode) {\n                    this.privMediaResources.scriptProcessorNode.disconnect(context.destination);\n                    this.privMediaResources.scriptProcessorNode = null;\n                }\n                if (this.privMediaResources.source) {\n                    this.privMediaResources.source.disconnect();\n                    this.privMediaResources.stream.getTracks().forEach((track) => track.stop());\n                    this.privMediaResources.source = null;\n                }\n            }\n        };\n    }\n    setWorkletUrl(url) {\n        this.privSpeechProcessorScript = url;\n    }\n}\n\n//# sourceMappingURL=PCMRecorder.js.map\n","// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT license.\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { connectivity, type, } from \"../common.speech/Exports\";\nimport { AudioSourceErrorEvent, AudioSourceInitializingEvent, AudioSourceOffEvent, AudioSourceReadyEvent, AudioStreamNodeAttachedEvent, AudioStreamNodeAttachingEvent, AudioStreamNodeDetachedEvent, AudioStreamNodeErrorEvent, ChunkedArrayBufferStream, createNoDashGuid, Deferred, Events, EventSource, } from \"../common/Exports\";\nimport { AudioStreamFormat } from \"../sdk/Audio/AudioStreamFormat\";\nexport class FileAudioSource {\n    constructor(file, audioSourceId) {\n        this.privStreams = {};\n        this.privHeaderEnd = 44;\n        this.turnOn = () => {\n            if (typeof FileReader === \"undefined\") {\n                const errorMsg = \"Browser does not support FileReader.\";\n                this.onEvent(new AudioSourceErrorEvent(errorMsg, \"\")); // initialization error - no streamid at this point\n                return Promise.reject(errorMsg);\n            }\n            else if (this.privFile.name.lastIndexOf(\".wav\") !== this.privFile.name.length - 4) {\n                const errorMsg = this.privFile.name + \" is not supported. Only WAVE files are allowed at the moment.\";\n                this.onEvent(new AudioSourceErrorEvent(errorMsg, \"\"));\n                return Promise.reject(errorMsg);\n            }\n            this.onEvent(new AudioSourceInitializingEvent(this.privId)); // no stream id\n            this.onEvent(new AudioSourceReadyEvent(this.privId));\n            return;\n        };\n        this.id = () => {\n            return this.privId;\n        };\n        this.attach = (audioNodeId) => __awaiter(this, void 0, void 0, function* () {\n            this.onEvent(new AudioStreamNodeAttachingEvent(this.privId, audioNodeId));\n            const stream = yield this.upload(audioNodeId);\n            this.onEvent(new AudioStreamNodeAttachedEvent(this.privId, audioNodeId));\n            return Promise.resolve({\n                detach: () => __awaiter(this, void 0, void 0, function* () {\n                    stream.readEnded();\n                    delete this.privStreams[audioNodeId];\n                    this.onEvent(new AudioStreamNodeDetachedEvent(this.privId, audioNodeId));\n                    yield this.turnOff();\n                }),\n                id: () => {\n                    return audioNodeId;\n                },\n                read: () => {\n                    return stream.read();\n                },\n            });\n        });\n        this.detach = (audioNodeId) => {\n            if (audioNodeId && this.privStreams[audioNodeId]) {\n                this.privStreams[audioNodeId].close();\n                delete this.privStreams[audioNodeId];\n                this.onEvent(new AudioStreamNodeDetachedEvent(this.privId, audioNodeId));\n            }\n        };\n        this.turnOff = () => {\n            for (const streamId in this.privStreams) {\n                if (streamId) {\n                    const stream = this.privStreams[streamId];\n                    if (stream && !stream.isClosed) {\n                        stream.close();\n                    }\n                }\n            }\n            this.onEvent(new AudioSourceOffEvent(this.privId)); // no stream now\n            return Promise.resolve();\n        };\n        this.onEvent = (event) => {\n            this.privEvents.onEvent(event);\n            Events.instance.onEvent(event);\n        };\n        this.privId = audioSourceId ? audioSourceId : createNoDashGuid();\n        this.privEvents = new EventSource();\n        this.privFile = file;\n        // Read the header.\n        this.privAudioFormatPromise = this.readHeader();\n    }\n    get format() {\n        return this.privAudioFormatPromise;\n    }\n    get blob() {\n        return Promise.resolve(this.privFile);\n    }\n    get events() {\n        return this.privEvents;\n    }\n    get deviceInfo() {\n        return this.privAudioFormatPromise.then((result) => {\n            return Promise.resolve({\n                bitspersample: result.bitsPerSample,\n                channelcount: result.channels,\n                connectivity: connectivity.Unknown,\n                manufacturer: \"Speech SDK\",\n                model: \"File\",\n                samplerate: result.samplesPerSec,\n                type: type.File,\n            });\n        });\n    }\n    readHeader() {\n        // Read the wave header.\n        const maxHeaderSize = 128;\n        const header = this.privFile.slice(0, maxHeaderSize);\n        const headerReader = new FileReader();\n        const headerResult = new Deferred();\n        const processHeader = (event) => {\n            const header = event.target.result;\n            const view = new DataView(header);\n            const getWord = (index) => {\n                return String.fromCharCode(view.getUint8(index), view.getUint8(index + 1), view.getUint8(index + 2), view.getUint8(index + 3));\n            };\n            // RIFF 4 bytes.\n            if (\"RIFF\" !== getWord(0)) {\n                headerResult.reject(\"Invalid WAV header in file, RIFF was not found\");\n            }\n            // length, 4 bytes\n            // RIFF Type & fmt 8 bytes\n            if (\"WAVE\" !== getWord(8) || \"fmt \" !== getWord(12)) {\n                headerResult.reject(\"Invalid WAV header in file, WAVEfmt was not found\");\n            }\n            const formatSize = view.getInt32(16, true);\n            const channelCount = view.getUint16(22, true);\n            const sampleRate = view.getUint32(24, true);\n            const bitsPerSample = view.getUint16(34, true);\n            // Confirm if header is 44 bytes long.\n            let pos = 36 + Math.max(formatSize - 16, 0);\n            for (; getWord(pos) !== \"data\"; pos += 2) {\n                if (pos > maxHeaderSize - 8) {\n                    headerResult.reject(\"Invalid WAV header in file, data block was not found\");\n                }\n            }\n            this.privHeaderEnd = pos + 8;\n            headerResult.resolve(AudioStreamFormat.getWaveFormatPCM(sampleRate, bitsPerSample, channelCount));\n        };\n        headerReader.onload = processHeader;\n        headerReader.readAsArrayBuffer(header);\n        return headerResult.promise;\n    }\n    upload(audioNodeId) {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.turnOn();\n            const format = yield this.privAudioFormatPromise;\n            const reader = new FileReader();\n            const stream = new ChunkedArrayBufferStream(format.avgBytesPerSec / 10, audioNodeId);\n            this.privStreams[audioNodeId] = stream;\n            const processFile = (event) => {\n                if (stream.isClosed) {\n                    return; // output stream was closed (somebody called TurnOff). We're done here.\n                }\n                stream.writeStreamChunk({\n                    buffer: reader.result,\n                    isEnd: false,\n                    timeReceived: Date.now(),\n                });\n                stream.close();\n            };\n            reader.onload = processFile;\n            reader.onerror = (event) => {\n                const errorMsg = `Error occurred while processing '${this.privFile.name}'. ${event}`;\n                this.onEvent(new AudioStreamNodeErrorEvent(this.privId, audioNodeId, errorMsg));\n                throw new Error(errorMsg);\n            };\n            const chunk = this.privFile.slice(this.privHeaderEnd);\n            reader.readAsArrayBuffer(chunk);\n            return stream;\n        });\n    }\n}\n\n//# sourceMappingURL=FileAudioSource.js.map\n","// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT license.\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { connectivity, type } from \"../common.speech/Exports\";\nimport { AudioSourceErrorEvent, AudioSourceInitializingEvent, AudioSourceOffEvent, AudioSourceReadyEvent, AudioStreamNodeAttachedEvent, AudioStreamNodeAttachingEvent, AudioStreamNodeDetachedEvent, AudioStreamNodeErrorEvent, ChunkedArrayBufferStream, createNoDashGuid, Deferred, Events, EventSource, } from \"../common/Exports\";\nimport { AudioStreamFormat, AudioStreamFormatImpl, } from \"../sdk/Audio/AudioStreamFormat\";\nexport const AudioWorkletSourceURLPropertyName = \"MICROPHONE-WorkletSourceUrl\";\nexport class MicAudioSource {\n    constructor(privRecorder, deviceId, audioSourceId, mediaStream) {\n        this.privRecorder = privRecorder;\n        this.deviceId = deviceId;\n        this.privStreams = {};\n        this.turnOn = () => {\n            if (this.privInitializeDeferral) {\n                return this.privInitializeDeferral.promise;\n            }\n            this.privInitializeDeferral = new Deferred();\n            try {\n                this.createAudioContext();\n            }\n            catch (error) {\n                if (error instanceof Error) {\n                    const typedError = error;\n                    this.privInitializeDeferral.reject(typedError.name + \": \" + typedError.message);\n                }\n                else {\n                    this.privInitializeDeferral.reject(error);\n                }\n                return this.privInitializeDeferral.promise;\n            }\n            const nav = window.navigator;\n            let getUserMedia = (nav.getUserMedia ||\n                nav.webkitGetUserMedia ||\n                nav.mozGetUserMedia ||\n                nav.msGetUserMedia);\n            if (!!nav.mediaDevices) {\n                getUserMedia = (constraints, successCallback, errorCallback) => {\n                    nav.mediaDevices\n                        .getUserMedia(constraints)\n                        .then(successCallback)\n                        .catch(errorCallback);\n                };\n            }\n            if (!getUserMedia) {\n                const errorMsg = \"Browser does not support getUserMedia.\";\n                this.privInitializeDeferral.reject(errorMsg);\n                this.onEvent(new AudioSourceErrorEvent(errorMsg, \"\")); // mic initialized error - no streamid at this point\n            }\n            else {\n                const next = () => {\n                    this.onEvent(new AudioSourceInitializingEvent(this.privId)); // no stream id\n                    if (this.privMediaStream && this.privMediaStream.active) {\n                        this.onEvent(new AudioSourceReadyEvent(this.privId));\n                        this.privInitializeDeferral.resolve();\n                    }\n                    else {\n                        getUserMedia({ audio: this.deviceId ? { deviceId: this.deviceId } : true, video: false }, (mediaStream) => {\n                            this.privMediaStream = mediaStream;\n                            this.onEvent(new AudioSourceReadyEvent(this.privId));\n                            this.privInitializeDeferral.resolve();\n                        }, (error) => {\n                            const errorMsg = `Error occurred during microphone initialization: ${error}`;\n                            this.privInitializeDeferral.reject(errorMsg);\n                            this.onEvent(new AudioSourceErrorEvent(this.privId, errorMsg));\n                        });\n                    }\n                };\n                if (this.privContext.state === \"suspended\") {\n                    // NOTE: On iOS, the Web Audio API requires sounds to be triggered from an explicit user action.\n                    // https://github.com/WebAudio/web-audio-api/issues/790\n                    this.privContext.resume()\n                        .then(next)\n                        .catch((reason) => {\n                        this.privInitializeDeferral.reject(`Failed to initialize audio context: ${reason}`);\n                    });\n                }\n                else {\n                    next();\n                }\n            }\n            return this.privInitializeDeferral.promise;\n        };\n        this.id = () => {\n            return this.privId;\n        };\n        this.attach = (audioNodeId) => {\n            this.onEvent(new AudioStreamNodeAttachingEvent(this.privId, audioNodeId));\n            return this.listen(audioNodeId).then((stream) => {\n                this.onEvent(new AudioStreamNodeAttachedEvent(this.privId, audioNodeId));\n                return {\n                    detach: () => __awaiter(this, void 0, void 0, function* () {\n                        stream.readEnded();\n                        delete this.privStreams[audioNodeId];\n                        this.onEvent(new AudioStreamNodeDetachedEvent(this.privId, audioNodeId));\n                        return this.turnOff();\n                    }),\n                    id: () => {\n                        return audioNodeId;\n                    },\n                    read: () => {\n                        return stream.read();\n                    },\n                };\n            });\n        };\n        this.detach = (audioNodeId) => {\n            if (audioNodeId && this.privStreams[audioNodeId]) {\n                this.privStreams[audioNodeId].close();\n                delete this.privStreams[audioNodeId];\n                this.onEvent(new AudioStreamNodeDetachedEvent(this.privId, audioNodeId));\n            }\n        };\n        this.listen = (audioNodeId) => __awaiter(this, void 0, void 0, function* () {\n            yield this.turnOn();\n            const stream = new ChunkedArrayBufferStream(this.privOutputChunkSize, audioNodeId);\n            this.privStreams[audioNodeId] = stream;\n            try {\n                this.privRecorder.record(this.privContext, this.privMediaStream, stream);\n            }\n            catch (error) {\n                this.onEvent(new AudioStreamNodeErrorEvent(this.privId, audioNodeId, error));\n                throw error;\n            }\n            const result = stream;\n            return result;\n        });\n        this.onEvent = (event) => {\n            this.privEvents.onEvent(event);\n            Events.instance.onEvent(event);\n        };\n        this.createAudioContext = () => {\n            if (!!this.privContext) {\n                return;\n            }\n            this.privContext = AudioStreamFormatImpl.getAudioContext(MicAudioSource.AUDIOFORMAT.samplesPerSec);\n        };\n        this.privOutputChunkSize = MicAudioSource.AUDIOFORMAT.avgBytesPerSec / 10;\n        this.privId = audioSourceId ? audioSourceId : createNoDashGuid();\n        this.privEvents = new EventSource();\n        this.privMediaStream = mediaStream || null;\n    }\n    get format() {\n        return Promise.resolve(MicAudioSource.AUDIOFORMAT);\n    }\n    get blob() {\n        return Promise.reject(\"Not implemented for Mic input\");\n    }\n    turnOff() {\n        return __awaiter(this, void 0, void 0, function* () {\n            for (const streamId in this.privStreams) {\n                if (streamId) {\n                    const stream = this.privStreams[streamId];\n                    if (stream) {\n                        stream.close();\n                    }\n                }\n            }\n            this.onEvent(new AudioSourceOffEvent(this.privId)); // no stream now\n            this.privInitializeDeferral = null;\n            yield this.destroyAudioContext();\n            return;\n        });\n    }\n    get events() {\n        return this.privEvents;\n    }\n    get deviceInfo() {\n        return this.getMicrophoneLabel().then((label) => {\n            return {\n                bitspersample: MicAudioSource.AUDIOFORMAT.bitsPerSample,\n                channelcount: MicAudioSource.AUDIOFORMAT.channels,\n                connectivity: connectivity.Unknown,\n                manufacturer: \"Speech SDK\",\n                model: label,\n                samplerate: MicAudioSource.AUDIOFORMAT.samplesPerSec,\n                type: type.Microphones,\n            };\n        });\n    }\n    setProperty(name, value) {\n        if (name === AudioWorkletSourceURLPropertyName) {\n            this.privRecorder.setWorkletUrl(value);\n        }\n        else {\n            throw new Error(\"Property '\" + name + \"' is not supported on Microphone.\");\n        }\n    }\n    getMicrophoneLabel() {\n        const defaultMicrophoneName = \"microphone\";\n        // If we did this already, return the value.\n        if (this.privMicrophoneLabel !== undefined) {\n            return Promise.resolve(this.privMicrophoneLabel);\n        }\n        // If the stream isn't currently running, we can't query devices because security.\n        if (this.privMediaStream === undefined || !this.privMediaStream.active) {\n            return Promise.resolve(defaultMicrophoneName);\n        }\n        // Setup a default\n        this.privMicrophoneLabel = defaultMicrophoneName;\n        // Get the id of the device running the audio track.\n        const microphoneDeviceId = this.privMediaStream.getTracks()[0].getSettings().deviceId;\n        // If the browser doesn't support getting the device ID, set a default and return.\n        if (undefined === microphoneDeviceId) {\n            return Promise.resolve(this.privMicrophoneLabel);\n        }\n        const deferred = new Deferred();\n        // Enumerate the media devices.\n        navigator.mediaDevices.enumerateDevices().then((devices) => {\n            for (const device of devices) {\n                if (device.deviceId === microphoneDeviceId) {\n                    // Found the device\n                    this.privMicrophoneLabel = device.label;\n                    break;\n                }\n            }\n            deferred.resolve(this.privMicrophoneLabel);\n        }, () => deferred.resolve(this.privMicrophoneLabel));\n        return deferred.promise;\n    }\n    destroyAudioContext() {\n        return __awaiter(this, void 0, void 0, function* () {\n            if (!this.privContext) {\n                return;\n            }\n            this.privRecorder.releaseMediaResources(this.privContext);\n            // This pattern brought to you by a bug in the TypeScript compiler where it\n            // confuses the (\"close\" in this.privContext) with this.privContext always being null as the alternate.\n            // https://github.com/Microsoft/TypeScript/issues/11498\n            let hasClose = false;\n            if (\"close\" in this.privContext) {\n                hasClose = true;\n            }\n            if (hasClose) {\n                yield this.privContext.close();\n                this.privContext = null;\n            }\n            else if (null !== this.privContext && this.privContext.state === \"running\") {\n                // Suspend actually takes a callback, but analogous to the\n                // resume method, it'll be only fired if suspend is called\n                // in a direct response to a user action. The later is not always\n                // the case, as TurnOff is also called, when we receive an\n                // end-of-speech message from the service. So, doing a best effort\n                // fire-and-forget here.\n                yield this.privContext.suspend();\n            }\n        });\n    }\n}\nMicAudioSource.AUDIOFORMAT = AudioStreamFormat.getDefaultInputFormat();\n\n//# sourceMappingURL=MicAudioSource.js.map\n","// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT license.\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport * as tls from \"tls\";\nimport * as url from \"url\";\nimport * as ocsp from \"../../external/ocsp/ocsp\";\nimport { Events, OCSPCacheEntryExpiredEvent, OCSPCacheEntryNeedsRefreshEvent, OCSPCacheFetchErrorEvent, OCSPCacheHitEvent, OCSPCacheMissEvent, OCSPCacheUpdatehCompleteEvent, OCSPCacheUpdateNeededEvent, OCSPDiskCacheHitEvent, OCSPDiskCacheStoreEvent, OCSPMemoryCacheHitEvent, OCSPMemoryCacheStoreEvent, OCSPResponseRetrievedEvent, OCSPStapleReceivedEvent, OCSPVerificationFailedEvent } from \"../common/Exports\";\nimport Agent from \"agent-base\";\n// @ts-ignore\nimport Cache from \"async-disk-cache\";\nimport HttpsProxyAgent from \"https-proxy-agent\";\nimport * as net from \"net\";\nimport { OCSPCacheUpdateErrorEvent } from \"../common/OCSPEvents\";\nexport class CertCheckAgent {\n    constructor(proxyInfo) {\n        if (!!proxyInfo) {\n            this.privProxyInfo = proxyInfo;\n        }\n        // Initialize this here to allow tests to set the env variable before the cache is constructed.\n        if (!CertCheckAgent.privDiskCache) {\n            CertCheckAgent.privDiskCache = new Cache(\"microsoft-cognitiveservices-speech-sdk-cache\", { supportBuffer: true, location: (typeof process !== \"undefined\" && !!process.env.SPEECH_OCSP_CACHE_ROOT) ? process.env.SPEECH_OCSP_CACHE_ROOT : undefined });\n        }\n    }\n    // Test hook to force the disk cache to be recreated.\n    static forceReinitDiskCache() {\n        CertCheckAgent.privDiskCache = undefined;\n        CertCheckAgent.privMemCache = {};\n    }\n    GetAgent(disableStapling) {\n        const agent = new Agent.Agent(this.CreateConnection);\n        if (this.privProxyInfo !== undefined &&\n            this.privProxyInfo.HostName !== undefined &&\n            this.privProxyInfo.Port > 0) {\n            const proxyName = \"privProxyInfo\";\n            agent[proxyName] = this.privProxyInfo;\n        }\n        return agent;\n    }\n    static GetProxyAgent(proxyInfo) {\n        const httpProxyOptions = {\n            host: proxyInfo.HostName,\n            port: proxyInfo.Port,\n        };\n        if (!!proxyInfo.UserName) {\n            httpProxyOptions.headers = {\n                \"Proxy-Authentication\": \"Basic \" + new Buffer(proxyInfo.UserName + \":\" + (proxyInfo.Password === undefined) ? \"\" : proxyInfo.Password).toString(\"base64\"),\n            };\n        }\n        else {\n            httpProxyOptions.headers = {};\n        }\n        httpProxyOptions.headers.requestOCSP = \"true\";\n        const httpProxyAgent = new HttpsProxyAgent(httpProxyOptions);\n        return httpProxyAgent;\n    }\n    static OCSPCheck(socketPromise, proxyInfo) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let ocspRequest;\n            let stapling;\n            let resolved = false;\n            const socket = yield socketPromise;\n            socket.cork();\n            const tlsSocket = socket;\n            return new Promise((resolve, reject) => {\n                socket.on(\"OCSPResponse\", (data) => {\n                    if (!!data) {\n                        this.onEvent(new OCSPStapleReceivedEvent());\n                        stapling = data;\n                    }\n                });\n                socket.on(\"error\", (error) => {\n                    if (!resolved) {\n                        resolved = true;\n                        socket.destroy();\n                        reject(error);\n                    }\n                });\n                tlsSocket.on(\"secure\", () => __awaiter(this, void 0, void 0, function* () {\n                    const peer = tlsSocket.getPeerCertificate(true);\n                    try {\n                        const issuer = yield this.GetIssuer(peer);\n                        // We always need a request to verify the response.\n                        ocspRequest = ocsp.request.generate(peer.raw, issuer.raw);\n                        // Do we have a result for this certificate in our memory cache?\n                        const sig = ocspRequest.id.toString(\"hex\");\n                        // Stapled response trumps cached response.\n                        if (!stapling) {\n                            const cacheEntry = yield CertCheckAgent.GetResponseFromCache(sig, ocspRequest, proxyInfo);\n                            stapling = cacheEntry;\n                        }\n                        yield this.VerifyOCSPResponse(stapling, ocspRequest, proxyInfo);\n                        socket.uncork();\n                        resolved = true;\n                        resolve(socket);\n                    }\n                    catch (e) {\n                        socket.destroy();\n                        resolved = true;\n                        reject(e);\n                    }\n                }));\n            });\n        });\n    }\n    static GetIssuer(peer) {\n        if (peer.issuerCertificate) {\n            return Promise.resolve(peer.issuerCertificate);\n        }\n        return new Promise((resolve, reject) => {\n            const ocspAgent = new ocsp.Agent({});\n            ocspAgent.fetchIssuer(peer, null, (error, value) => {\n                if (!!error) {\n                    reject(error);\n                    return;\n                }\n                resolve(value);\n            });\n        });\n    }\n    static GetResponseFromCache(signature, ocspRequest, proxyInfo) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let cachedResponse = CertCheckAgent.privMemCache[signature];\n            if (!!cachedResponse) {\n                this.onEvent(new OCSPMemoryCacheHitEvent(signature));\n            }\n            // Do we have a result for this certificate on disk in %TMP%?\n            if (!cachedResponse) {\n                try {\n                    const diskCacheResponse = yield CertCheckAgent.privDiskCache.get(signature);\n                    if (!!diskCacheResponse.isCached) {\n                        CertCheckAgent.onEvent(new OCSPDiskCacheHitEvent(signature));\n                        CertCheckAgent.StoreMemoryCacheEntry(signature, diskCacheResponse.value);\n                        cachedResponse = diskCacheResponse.value;\n                    }\n                }\n                catch (error) {\n                    cachedResponse = null;\n                }\n            }\n            if (!cachedResponse) {\n                return cachedResponse;\n            }\n            try {\n                const cachedOcspResponse = ocsp.utils.parseResponse(cachedResponse);\n                const tbsData = cachedOcspResponse.value.tbsResponseData;\n                if (tbsData.responses.length < 1) {\n                    this.onEvent(new OCSPCacheFetchErrorEvent(signature, \"Not enough data in cached response\"));\n                    return;\n                }\n                const cachedStartTime = tbsData.responses[0].thisUpdate;\n                const cachedNextTime = tbsData.responses[0].nextUpdate;\n                if (cachedNextTime < (Date.now() + this.testTimeOffset - 60000)) {\n                    // Cached entry has expired.\n                    this.onEvent(new OCSPCacheEntryExpiredEvent(signature, cachedNextTime));\n                    cachedResponse = null;\n                }\n                else {\n                    // If we're within one day of the next update, or 50% of the way through the validity period,\n                    // background an update to the cache.\n                    const minUpdate = Math.min(24 * 60 * 60 * 1000, (cachedNextTime - cachedStartTime) / 2);\n                    if ((cachedNextTime - (Date.now() + this.testTimeOffset)) < minUpdate) {\n                        this.onEvent(new OCSPCacheEntryNeedsRefreshEvent(signature, cachedStartTime, cachedNextTime));\n                        this.UpdateCache(ocspRequest, proxyInfo).catch((error) => {\n                            // Well, not much we can do here.\n                            this.onEvent(new OCSPCacheUpdateErrorEvent(signature, error.toString()));\n                        });\n                    }\n                    else {\n                        this.onEvent(new OCSPCacheHitEvent(signature, cachedStartTime, cachedNextTime));\n                    }\n                }\n            }\n            catch (error) {\n                this.onEvent(new OCSPCacheFetchErrorEvent(signature, error));\n                cachedResponse = null;\n            }\n            if (!cachedResponse) {\n                this.onEvent(new OCSPCacheMissEvent(signature));\n            }\n            return cachedResponse;\n        });\n    }\n    static VerifyOCSPResponse(cacheValue, ocspRequest, proxyInfo) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let ocspResponse = cacheValue;\n            const sig = ocspRequest.certID.toString(\"hex\");\n            // Do we have a valid response?\n            if (!ocspResponse) {\n                ocspResponse = yield CertCheckAgent.GetOCSPResponse(ocspRequest, proxyInfo);\n            }\n            return new Promise((resolve, reject) => {\n                ocsp.verify({ request: ocspRequest, response: ocspResponse }, (error, result) => {\n                    if (!!error) {\n                        CertCheckAgent.onEvent(new OCSPVerificationFailedEvent(ocspRequest.id.toString(\"hex\"), error));\n                        // Bad Cached Value? One more try without the cache.\n                        if (!!cacheValue) {\n                            this.VerifyOCSPResponse(null, ocspRequest, proxyInfo).then(() => {\n                                resolve();\n                            }, (error) => {\n                                reject(error);\n                            });\n                        }\n                        else {\n                            reject(error);\n                        }\n                    }\n                    else {\n                        if (!cacheValue) {\n                            CertCheckAgent.StoreCacheEntry(ocspRequest.id.toString(\"hex\"), ocspResponse);\n                        }\n                        resolve();\n                    }\n                });\n            });\n        });\n    }\n    static UpdateCache(req, proxyInfo) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const signature = req.id.toString(\"hex\");\n            this.onEvent(new OCSPCacheUpdateNeededEvent(signature));\n            const rawResponse = yield this.GetOCSPResponse(req, proxyInfo);\n            this.StoreCacheEntry(signature, rawResponse);\n            this.onEvent(new OCSPCacheUpdatehCompleteEvent(req.id.toString(\"hex\")));\n        });\n    }\n    static StoreCacheEntry(sig, rawResponse) {\n        this.StoreMemoryCacheEntry(sig, rawResponse);\n        this.StoreDiskCacheEntry(sig, rawResponse);\n    }\n    static StoreMemoryCacheEntry(sig, rawResponse) {\n        this.privMemCache[sig] = rawResponse;\n        this.onEvent(new OCSPMemoryCacheStoreEvent(sig));\n    }\n    static StoreDiskCacheEntry(sig, rawResponse) {\n        this.privDiskCache.set(sig, rawResponse).then(() => {\n            this.onEvent(new OCSPDiskCacheStoreEvent(sig));\n        });\n    }\n    static GetOCSPResponse(req, proxyInfo) {\n        const ocspMethod = \"1.3.6.1.5.5.7.48.1\";\n        let options = {};\n        if (!!proxyInfo) {\n            const agent = CertCheckAgent.GetProxyAgent(proxyInfo);\n            options.agent = agent;\n        }\n        return new Promise((resolve, reject) => {\n            ocsp.utils.getAuthorityInfo(req.cert, ocspMethod, (error, uri) => {\n                if (error) {\n                    reject(error);\n                    return;\n                }\n                const parsedUri = url.parse(uri);\n                options = Object.assign(Object.assign({}, options), parsedUri);\n                ocsp.utils.getResponse(options, req.data, (error, raw) => {\n                    if (error) {\n                        reject(error);\n                        return;\n                    }\n                    this.onEvent(new OCSPResponseRetrievedEvent(req.certID.toString(\"hex\")));\n                    resolve(raw);\n                });\n            });\n        });\n    }\n    CreateConnection(request, options) {\n        const enableOCSP = (typeof process !== \"undefined\" && process.env.NODE_TLS_REJECT_UNAUTHORIZED !== \"0\" && process.env.SPEECH_CONDUCT_OCSP_CHECK !== \"0\") && options.secureEndpoint;\n        let socketPromise;\n        options = Object.assign(Object.assign({}, options), {\n            requestOCSP: !CertCheckAgent.forceDisableOCSPStapling,\n            servername: options.host\n        });\n        if (!!this.privProxyInfo) {\n            const httpProxyAgent = CertCheckAgent.GetProxyAgent(this.privProxyInfo);\n            const baseAgent = httpProxyAgent;\n            socketPromise = new Promise((resolve, reject) => {\n                baseAgent.callback(request, options, (error, socket) => {\n                    if (!!error) {\n                        reject(error);\n                    }\n                    else {\n                        resolve(socket);\n                    }\n                });\n            });\n        }\n        else {\n            if (!!options.secureEndpoint) {\n                socketPromise = Promise.resolve(tls.connect(options));\n            }\n            else {\n                socketPromise = Promise.resolve(net.connect(options));\n            }\n        }\n        if (!!enableOCSP) {\n            return CertCheckAgent.OCSPCheck(socketPromise, this.privProxyInfo);\n        }\n        else {\n            return socketPromise;\n        }\n    }\n}\n// Test hook to enable forcing expiration / refresh to happen.\nCertCheckAgent.testTimeOffset = 0;\n// Test hook to disable stapling for cache testing.\nCertCheckAgent.forceDisableOCSPStapling = false;\n// An in memory cache for recived responses.\nCertCheckAgent.privMemCache = {};\nCertCheckAgent.onEvent = (event) => {\n    Events.instance.onEvent(event);\n};\n\n//# sourceMappingURL=CertChecks.js.map\n"],"sourceRoot":""}