{"version":3,"sources":["webpack:///./node_modules/@azure/web-pubsub-client/dist-esm/src/webPubSubClient.js","webpack:///./node_modules/@azure/web-pubsub-client/dist-esm/src/index.js","webpack:///./node_modules/@azure/abort-controller/dist-esm/src/AbortSignal.js","webpack:///./node_modules/@azure/abort-controller/dist-esm/src/AbortController.js","webpack:///./node_modules/@azure/web-pubsub-client/dist-esm/src/utils/abortablePromise.js","webpack:///./node_modules/@azure/web-pubsub-client/dist-esm/src/protocols/jsonProtocolBase.js","webpack:///./node_modules/@azure/web-pubsub-client/dist-esm/src/protocols/webPubSubJsonProtocol.js","webpack:///./node_modules/@azure/web-pubsub-client/dist-esm/src/protocols/webPubSubJsonReliableProtocol.js","webpack:///./node_modules/@azure/web-pubsub-client/dist-esm/src/protocols/index.js","webpack:///./node_modules/core-js/internals/function-apply.js","webpack:///./src/services/socket.js","webpack:///./node_modules/@azure/logger/dist-esm/src/debug.js","webpack:///./node_modules/@azure/web-pubsub-client/dist-esm/src/logger.js","webpack:///./node_modules/@azure/web-pubsub-client/dist-esm/src/websocket/websocketClient.browser.js","webpack:///./src/services/phone.js","webpack:///./node_modules/@azure/core-util/dist-esm/src/createAbortablePromise.js","webpack:///./node_modules/@azure/core-util/dist-esm/src/delay.js","webpack:///./node_modules/core-js/internals/error-stack-install.js","webpack:///./node_modules/@azure/logger/dist-esm/src/index.js","webpack:///./node_modules/@azure/logger/dist-esm/src/log.browser.js","webpack:///./node_modules/core-js/internals/install-error-cause.js","webpack:///./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack:///./node_modules/@babel/runtime/helpers/esm/toPrimitive.js","webpack:///./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","webpack:///./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack:///./node_modules/core-js/internals/proxy-accessor.js","webpack:///./node_modules/core-js/internals/error-stack-installable.js","webpack:///./node_modules/core-js/modules/es.error.cause.js","webpack:///./node_modules/core-js/internals/wrap-error-constructor-with-cause.js","webpack:///./node_modules/@azure/web-pubsub-client/dist-esm/src/errors/index.js","webpack:///./node_modules/events/events.js"],"names":["WebPubSubClientState","WebPubSubClient","credential","options","this","_emitter","_isStopping","_isInitialConnected","_credential","getClientAccessUrl","_buildDefaultOptions","_options","_messageRetryPolicy","RetryPolicy","messageRetryOptions","_reconnectRetryPolicy","reconnectRetryOptions","_protocol","protocol","_groupMap","Map","_ackMap","_sequenceId","SequenceId","_state","Stopped","_ackId","Error","abortSignal","_startCore","err","_changeState","Disconnected","verbose","Connecting","info","reset","_lastCloseEvent","undefined","_lastDisconnectedMessage","_connectionId","_reconnectionToken","_uri","_connectCore","_wsClient","isOpen","close","event","listener","on","removeListener","args","emit","eventName","content","dataType","_operationExecuteWithRetry","_sendEventAttempt","_a","fireAndForget","_sendMessageWithAckId","id","kind","data","ackId","message","_sendMessage","groupName","_joinGroupAttempt","group","_getOrAddGroup","result","_joinGroupCore","isJoined","_leaveGroupAttempt","_sendToGroupAttempt","_b","noEcho","uri","Promise","resolve","reject","client","_getWebSocketClientFactory","create","name","onopen","Connected","isReliableSubProtocol","_sequenceAckTask","abort","AbortableTask","async","isUpdated","seqId","tryGetSequenceId","sequenceId","onerror","e","onclose","code","reason","_handleConnectionClose","call","onmessage","handleAckMessage","has","entity","get","delete","isDuplicated","error","success","errorDetail","handleConnectedMessage","connectionId","reconnectionToken","autoRejoinGroups","groupPromises","forEach","g","push","_safeEmitRejoinGroupFailed","all","_safeEmitConnected","userId","handleDisconnectedMessage","handleGroupDataMessage","tryUpdate","_safeEmitGroupMessage","handleServerDataMessage","_safeEmitServerMessage","convertedData","Array","isArray","Buffer","concat","parseMessages","warning","_safeEmitDisconnected","autoReconnect","_autoReconnect","_handleConnectionStopped","isSuccess","attempt","_startFromRestarting","delayInMs","nextRetryDelayInMs","_safeEmitStopped","payload","writeMessage","send","messageProvider","nextAckId","set","AckEntity","errorMessage","promise","value","key","_handleConnectionCloseAndNoRecovery","recoveryUri","_buildRecoveryUri","recovered","Recovering","timeout","aborted","_emitEvent","lastDisconnectedMessage","clientOptions","_buildMessageRetryOptions","_buildReconnectRetryOptions","maxRetries","retryDelayInMs","maxRetryDelayInMs","mode","Number","MAX_VALUE","url","URL","searchParams","append","toString","WebPubSubGroup","newState","inner","signal","retryAttempt","retryOptions","_retryOptions","_maxRetriesToGetMaxDelay","Math","ceil","log2","_calculateExponentialDelay","_promise","_resolve","_reject","_isUpdate","func","interval","obj","_func","_abortController","_interval","_obj","_start","listenersMap","WeakMap","abortedMap","AbortSignal","onabort","TypeError","_type","listeners","index","indexOf","splice","_event","slice","type","AbortError","super","parentSignals","_signal","arguments","parentSignal","addEventListener","ms","timer","setTimeout","unref","abortablePromise","onAbort","p","_","race","removeEventListener","input","parsedMessage","JSON","parse","typedMessage","returnMessage","Object","assign","from","parsePayload","getPayload","stringify","ArrayBuffer","buf","buffer","byteOffset","byteLength","WebPubSubJsonProtocol","WebPubSubJsonReliableProtocol","NATIVE_BIND","FunctionPrototype","Function","prototype","apply","module","exports","Reflect","bind","require","Socket","constructor","ws_url","_defineProperty","_instance","socket","console","log","connected","start","joinGroup","sendToGroup","filter","callback","off","destroy","length","debugEnvVariable","process","DEBUG","enabledString","enabledNamespaces","skippedNamespaces","debuggers","enable","debugObj","namespace","createDebugger","enabled","disable","namespaces","wildcard","namespaceList","split","map","ns","trim","replace","startsWith","RegExp","substr","instance","endsWith","skipped","test","enabledNamespace","newDebugger","debug","extend","logger","WebSocketClient","protocolName","_socket","WebSocket","binaryType","fn","ev","readyState","OPEN","WebSocketClientFactory","Phone","started","axios","headers","authHeader","token","initializeDevice","setInterval","checkToken","startUp","tokenParts","tokenDecoded","atob","tokenExp","exp","dateNow","Date","dateNowSeconds","round","getTime","tokenValid","device","markRaw","Twilio","Device","logLevel","codecPreferences","addDeviceListeners","getAudioDevices","register","ready","warn","connection","parameters","From","updateAllAudioDevices","audio","isOutputSelectionSupported","showOutputSelection","navigator","mediaDevices","getUserMedia","speakerDevices","ringtoneDevices","availableOutputDevices","label","deviceId","availableInputDevices","inputDevice","outputDevice","updateOutputDevice","updateInputDevice","to","site_id","claim_reference","makeOutgoingCall","params","To","recipient","notes","connect","CallSid","onCall","submitCall","sid","digit","sendDigits","disconnect","callDetails","post","then","response","catch","createAbortablePromise","buildPromise","cleanupBeforeAbort","abortErrorMsg","rejectOnAbort","removeListeners","x","StandardAbortMessage","delay","timeInMs","clearTimeout","createNonEnumerableProperty","clearErrorStack","ERROR_STACK_INSTALLABLE","captureStackTrace","C","stack","dropEntries","registeredLoggers","Set","logLevelFromEnv","AZURE_LOG_LEVEL","azureLogLevel","AzureLogger","AZURE_LOG_LEVELS","setLogLevel","level","isAzureLogLevel","join","shouldEnable","levelMap","createClientLogger","clientRootLogger","patchLogMethod","createLogger","parent","child","add","Boolean","includes","firstArg","String","isObject","O","cause","_typeof","o","Symbol","iterator","_toPrimitive","hint","prim","toPrimitive","res","_toPropertyKey","arg","toPropertyKey","defineProperty","enumerable","configurable","writable","f","Target","Source","it","fails","createPropertyDescriptor","$","global","wrapErrorConstructorWithCause","WEB_ASSEMBLY","WebAssembly","FORCED","exportGlobalErrorCauseWrapper","ERROR_NAME","wrapper","arity","forced","exportWebAssemblyErrorCauseWrapper","target","stat","init","getBuiltIn","hasOwn","isPrototypeOf","setPrototypeOf","copyConstructorProperties","proxyAccessor","inheritIfRequired","normalizeStringArgument","installErrorCause","installErrorStack","DESCRIPTORS","IS_PURE","FULL_NAME","IS_AGGREGATE_ERROR","STACK_TRACE_LIMIT","OPTIONS_POSITION","path","OriginalError","OriginalErrorPrototype","BaseError","WrappedError","a","b","SendMessageError","ReflectOwnKeys","R","ReflectApply","receiver","ProcessEmitWarning","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","isNaN","EventEmitter","once","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","_getMaxListeners","that","_addListener","prepend","m","events","existing","newListener","unshift","warned","w","emitter","count","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","arr","n","copy","i","spliceOne","list","pop","ret","errorListener","resolver","eventTargetAgnosticAddListener","addErrorHandlerIfEventEmitter","handler","flags","wrapListener","RangeError","getPrototypeOf","setMaxListeners","getMaxListeners","doError","er","context","len","addListener","prependListener","prependOnceListener","position","originalListener","shift","removeAllListeners","keys","rawListeners","eventNames"],"mappings":"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","file":"js/chunk-2bc9ab23.dc4429b8.js","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { AbortController } from \"@azure/abort-controller\";\nimport { delay } from \"@azure/core-util\";\nimport EventEmitter from \"events\";\nimport { SendMessageError } from \"./errors\";\nimport { logger } from \"./logger\";\nimport { WebPubSubJsonReliableProtocol } from \"./protocols\";\nimport { WebSocketClientFactory } from \"./websocket/websocketClient\";\nimport { abortablePromise } from \"./utils/abortablePromise\";\nvar WebPubSubClientState;\n(function (WebPubSubClientState) {\n    WebPubSubClientState[\"Stopped\"] = \"Stopped\";\n    WebPubSubClientState[\"Disconnected\"] = \"Disconnected\";\n    WebPubSubClientState[\"Connecting\"] = \"Connecting\";\n    WebPubSubClientState[\"Connected\"] = \"Connected\";\n    WebPubSubClientState[\"Recovering\"] = \"Recovering\";\n})(WebPubSubClientState || (WebPubSubClientState = {}));\n/**\n * The WebPubSub client\n */\nexport class WebPubSubClient {\n    constructor(credential, options) {\n        this._emitter = new EventEmitter();\n        this._isStopping = false;\n        this._isInitialConnected = false;\n        if (typeof credential === \"string\") {\n            this._credential = { getClientAccessUrl: credential };\n        }\n        else {\n            this._credential = credential;\n        }\n        if (options == null) {\n            options = {};\n        }\n        this._buildDefaultOptions(options);\n        this._options = options;\n        this._messageRetryPolicy = new RetryPolicy(this._options.messageRetryOptions);\n        this._reconnectRetryPolicy = new RetryPolicy(this._options.reconnectRetryOptions);\n        this._protocol = this._options.protocol;\n        this._groupMap = new Map();\n        this._ackMap = new Map();\n        this._sequenceId = new SequenceId();\n        this._state = WebPubSubClientState.Stopped;\n        this._ackId = 0;\n    }\n    nextAckId() {\n        this._ackId = this._ackId + 1;\n        return this._ackId;\n    }\n    /**\n     * Start to start to the service.\n     * @param abortSignal - The abort signal\n     */\n    async start(options) {\n        if (this._isStopping) {\n            throw new Error(\"Can't start a client during stopping\");\n        }\n        if (this._state !== WebPubSubClientState.Stopped) {\n            throw new Error(\"Client can be only started when it's Stopped\");\n        }\n        let abortSignal;\n        if (options) {\n            abortSignal = options.abortSignal;\n        }\n        try {\n            await this._startCore(abortSignal);\n        }\n        catch (err) {\n            // this two sentense should be set together. Consider client.stop() is called during _startCore()\n            this._changeState(WebPubSubClientState.Stopped);\n            this._isStopping = false;\n            throw err;\n        }\n    }\n    async _startFromRestarting(abortSignal) {\n        if (this._state !== WebPubSubClientState.Disconnected) {\n            throw new Error(\"Client can be only restarted when it's Disconnected\");\n        }\n        try {\n            logger.verbose(\"Staring reconnecting.\");\n            await this._startCore(abortSignal);\n        }\n        catch (err) {\n            this._changeState(WebPubSubClientState.Disconnected);\n            throw err;\n        }\n    }\n    async _startCore(abortSignal) {\n        this._changeState(WebPubSubClientState.Connecting);\n        logger.info(\"Staring a new connection\");\n        // Reset before a pure new connection\n        this._sequenceId.reset();\n        this._isInitialConnected = false;\n        this._lastCloseEvent = undefined;\n        this._lastDisconnectedMessage = undefined;\n        this._connectionId = undefined;\n        this._reconnectionToken = undefined;\n        this._uri = undefined;\n        if (typeof this._credential.getClientAccessUrl === \"string\") {\n            this._uri = this._credential.getClientAccessUrl;\n        }\n        else {\n            this._uri = await this._credential.getClientAccessUrl({\n                abortSignal: abortSignal,\n            });\n        }\n        if (typeof this._uri !== \"string\") {\n            throw new Error(`The clientAccessUrl must be a string but currently it's ${typeof this._uri}`);\n        }\n        await this._connectCore(this._uri);\n    }\n    /**\n     * Stop the client.\n     */\n    stop() {\n        if (this._state === WebPubSubClientState.Stopped || this._isStopping) {\n            return;\n        }\n        // TODO: Maybe we need a better logic for stopping control\n        this._isStopping = true;\n        if (this._wsClient && this._wsClient.isOpen()) {\n            this._wsClient.close();\n        }\n        else {\n            this._isStopping = false;\n        }\n    }\n    on(event, listener) {\n        this._emitter.on(event, listener);\n    }\n    off(event, listener) {\n        this._emitter.removeListener(event, listener);\n    }\n    _emitEvent(event, args) {\n        this._emitter.emit(event, args);\n    }\n    /**\n     * Send custom event to server\n     * @param eventName - The event name\n     * @param content - The data content\n     * @param dataType - The data type\n     * @param ackId - The optional ackId. If not specified, client will generate one.\n     * @param options - The options\n     * @param abortSignal - The abort signal\n     */\n    async sendEvent(eventName, content, dataType, options) {\n        return await this._operationExecuteWithRetry(() => this._sendEventAttempt(eventName, content, dataType, options), options === null || options === void 0 ? void 0 : options.abortSignal);\n    }\n    async _sendEventAttempt(eventName, content, dataType, options) {\n        var _a;\n        const fireAndForget = (_a = options === null || options === void 0 ? void 0 : options.fireAndForget) !== null && _a !== void 0 ? _a : false;\n        if (!fireAndForget) {\n            return await this._sendMessageWithAckId((id) => {\n                return {\n                    kind: \"sendEvent\",\n                    dataType: dataType,\n                    data: content,\n                    ackId: id,\n                    event: eventName,\n                };\n            }, options === null || options === void 0 ? void 0 : options.ackId, options === null || options === void 0 ? void 0 : options.abortSignal);\n        }\n        const message = {\n            kind: \"sendEvent\",\n            dataType: dataType,\n            data: content,\n            event: eventName,\n        };\n        await this._sendMessage(message, options === null || options === void 0 ? void 0 : options.abortSignal);\n        return {};\n    }\n    /**\n     * Join the client to group\n     * @param groupName - The group name\n     * @param options - The join group options\n     */\n    async joinGroup(groupName, options) {\n        return await this._operationExecuteWithRetry(() => this._joinGroupAttempt(groupName, options), options === null || options === void 0 ? void 0 : options.abortSignal);\n    }\n    async _joinGroupAttempt(groupName, options) {\n        const group = this._getOrAddGroup(groupName);\n        const result = await this._joinGroupCore(groupName, options);\n        group.isJoined = true;\n        return result;\n    }\n    async _joinGroupCore(groupName, options) {\n        return await this._sendMessageWithAckId((id) => {\n            return {\n                group: groupName,\n                ackId: id,\n                kind: \"joinGroup\",\n            };\n        }, options === null || options === void 0 ? void 0 : options.ackId, options === null || options === void 0 ? void 0 : options.abortSignal);\n    }\n    /**\n     * Leave the client from group\n     * @param groupName - The group name\n     * @param ackId - The optional ackId. If not specified, client will generate one.\n     * @param abortSignal - The abort signal\n     */\n    async leaveGroup(groupName, options) {\n        return await this._operationExecuteWithRetry(() => this._leaveGroupAttempt(groupName, options), options === null || options === void 0 ? void 0 : options.abortSignal);\n    }\n    async _leaveGroupAttempt(groupName, options) {\n        const group = this._getOrAddGroup(groupName);\n        const result = await this._sendMessageWithAckId((id) => {\n            return {\n                group: groupName,\n                ackId: id,\n                kind: \"leaveGroup\",\n            };\n        }, options === null || options === void 0 ? void 0 : options.ackId, options === null || options === void 0 ? void 0 : options.abortSignal);\n        group.isJoined = false;\n        return result;\n    }\n    /**\n     * Send message to group.\n     * @param groupName - The group name\n     * @param content - The data content\n     * @param dataType - The data type\n     * @param ackId - The optional ackId. If not specified, client will generate one.\n     * @param options - The options\n     * @param abortSignal - The abort signal\n     */\n    async sendToGroup(groupName, content, dataType, options) {\n        return await this._operationExecuteWithRetry(() => this._sendToGroupAttempt(groupName, content, dataType, options), options === null || options === void 0 ? void 0 : options.abortSignal);\n    }\n    async _sendToGroupAttempt(groupName, content, dataType, options) {\n        var _a, _b;\n        const fireAndForget = (_a = options === null || options === void 0 ? void 0 : options.fireAndForget) !== null && _a !== void 0 ? _a : false;\n        const noEcho = (_b = options === null || options === void 0 ? void 0 : options.noEcho) !== null && _b !== void 0 ? _b : false;\n        if (!fireAndForget) {\n            return await this._sendMessageWithAckId((id) => {\n                return {\n                    kind: \"sendToGroup\",\n                    group: groupName,\n                    dataType: dataType,\n                    data: content,\n                    ackId: id,\n                    noEcho: noEcho,\n                };\n            }, options === null || options === void 0 ? void 0 : options.ackId, options === null || options === void 0 ? void 0 : options.abortSignal);\n        }\n        const message = {\n            kind: \"sendToGroup\",\n            group: groupName,\n            dataType: dataType,\n            data: content,\n            noEcho: noEcho,\n        };\n        await this._sendMessage(message, options === null || options === void 0 ? void 0 : options.abortSignal);\n        return {};\n    }\n    _getWebSocketClientFactory() {\n        return new WebSocketClientFactory();\n    }\n    _connectCore(uri) {\n        if (this._isStopping) {\n            throw new Error(\"Can't start a client during stopping\");\n        }\n        return new Promise((resolve, reject) => {\n            // This part is executed sync\n            const client = (this._wsClient = this._getWebSocketClientFactory().create(uri, this._protocol.name));\n            client.onopen(() => {\n                // There's a case that client called stop() before this method. We need to check and close it if it's the case.\n                if (this._isStopping) {\n                    try {\n                        client.close();\n                    }\n                    catch (_a) { }\n                    reject(new Error(`The client is stopped`));\n                }\n                logger.verbose(\"WebSocket connection has opened\");\n                this._changeState(WebPubSubClientState.Connected);\n                if (this._protocol.isReliableSubProtocol) {\n                    if (this._sequenceAckTask != null) {\n                        this._sequenceAckTask.abort();\n                    }\n                    this._sequenceAckTask = new AbortableTask(async () => {\n                        const [isUpdated, seqId] = this._sequenceId.tryGetSequenceId();\n                        if (isUpdated) {\n                            const message = {\n                                kind: \"sequenceAck\",\n                                sequenceId: seqId,\n                            };\n                            await this._sendMessage(message);\n                        }\n                    }, 1000);\n                }\n                resolve();\n            });\n            client.onerror((e) => {\n                if (this._sequenceAckTask != null) {\n                    this._sequenceAckTask.abort();\n                }\n                reject(new Error(e));\n            });\n            client.onclose((code, reason) => {\n                if (this._state === WebPubSubClientState.Connected) {\n                    logger.verbose(\"WebSocket closed after open\");\n                    if (this._sequenceAckTask != null) {\n                        this._sequenceAckTask.abort();\n                    }\n                    logger.info(`WebSocket connection closed. Code: ${code}, Reason: ${reason}`);\n                    this._lastCloseEvent = { code: code, reason: reason };\n                    this._handleConnectionClose.call(this);\n                }\n                else {\n                    logger.verbose(\"WebSocket closed before open\");\n                    reject(new Error(`Failed to start WebSocket: ${code}`));\n                }\n            });\n            client.onmessage((data) => {\n                const handleAckMessage = (message) => {\n                    if (this._ackMap.has(message.ackId)) {\n                        const entity = this._ackMap.get(message.ackId);\n                        this._ackMap.delete(message.ackId);\n                        const isDuplicated = message.error != null && message.error.name === \"Duplicate\";\n                        if (message.success || isDuplicated) {\n                            entity.resolve({\n                                ackId: message.ackId,\n                                isDuplicated: isDuplicated,\n                            });\n                        }\n                        else {\n                            entity.reject(new SendMessageError(\"Failed to send message.\", {\n                                ackId: message.ackId,\n                                errorDetail: message.error,\n                            }));\n                        }\n                    }\n                };\n                const handleConnectedMessage = async (message) => {\n                    this._connectionId = message.connectionId;\n                    this._reconnectionToken = message.reconnectionToken;\n                    if (!this._isInitialConnected) {\n                        this._isInitialConnected = true;\n                        if (this._options.autoRejoinGroups) {\n                            const groupPromises = [];\n                            this._groupMap.forEach((g) => {\n                                if (g.isJoined) {\n                                    groupPromises.push((async () => {\n                                        try {\n                                            await this._joinGroupCore(g.name);\n                                        }\n                                        catch (err) {\n                                            this._safeEmitRejoinGroupFailed(g.name, err);\n                                        }\n                                    })());\n                                }\n                            });\n                            try {\n                                await Promise.all(groupPromises);\n                            }\n                            catch (_a) { }\n                        }\n                        this._safeEmitConnected(message.connectionId, message.userId);\n                    }\n                };\n                const handleDisconnectedMessage = (message) => {\n                    this._lastDisconnectedMessage = message;\n                };\n                const handleGroupDataMessage = (message) => {\n                    if (message.sequenceId != null) {\n                        if (!this._sequenceId.tryUpdate(message.sequenceId)) {\n                            // drop duplicated message\n                            return;\n                        }\n                    }\n                    this._safeEmitGroupMessage(message);\n                };\n                const handleServerDataMessage = (message) => {\n                    if (message.sequenceId != null) {\n                        if (!this._sequenceId.tryUpdate(message.sequenceId)) {\n                            // drop duplicated message\n                            return;\n                        }\n                    }\n                    this._safeEmitServerMessage(message);\n                };\n                let message;\n                try {\n                    let convertedData;\n                    if (Array.isArray(data)) {\n                        convertedData = Buffer.concat(data);\n                    }\n                    else {\n                        convertedData = data;\n                    }\n                    message = this._protocol.parseMessages(convertedData);\n                    if (message === null) {\n                        // null means the message is not recognized.\n                        return;\n                    }\n                }\n                catch (err) {\n                    logger.warning(\"An error occurred while parsing the message from service\", err);\n                    throw err;\n                }\n                try {\n                    switch (message.kind) {\n                        case \"ack\": {\n                            handleAckMessage(message);\n                            break;\n                        }\n                        case \"connected\": {\n                            handleConnectedMessage(message);\n                            break;\n                        }\n                        case \"disconnected\": {\n                            handleDisconnectedMessage(message);\n                            break;\n                        }\n                        case \"groupData\": {\n                            handleGroupDataMessage(message);\n                            break;\n                        }\n                        case \"serverData\": {\n                            handleServerDataMessage(message);\n                            break;\n                        }\n                    }\n                }\n                catch (err) {\n                    logger.warning(`An error occurred while handling the message with kind: ${message.kind} from service`, err);\n                }\n            });\n        });\n    }\n    async _handleConnectionCloseAndNoRecovery() {\n        this._state = WebPubSubClientState.Disconnected;\n        this._safeEmitDisconnected(this._connectionId, this._lastDisconnectedMessage);\n        // Auto reconnect or stop\n        if (this._options.autoReconnect) {\n            await this._autoReconnect();\n        }\n        else {\n            await this._handleConnectionStopped();\n        }\n    }\n    async _autoReconnect() {\n        let isSuccess = false;\n        let attempt = 0;\n        try {\n            while (!this._isStopping) {\n                try {\n                    await this._startFromRestarting();\n                    isSuccess = true;\n                    break;\n                }\n                catch (err) {\n                    logger.warning(\"An attempt to reconnect connection failed.\", err);\n                    attempt++;\n                    const delayInMs = this._reconnectRetryPolicy.nextRetryDelayInMs(attempt);\n                    if (delayInMs == null) {\n                        break;\n                    }\n                    try {\n                        logger.verbose(`Delay time for reconnect attempt ${attempt}: ${delayInMs}`);\n                        await delay(delayInMs);\n                    }\n                    catch (_a) { }\n                }\n            }\n        }\n        finally {\n            if (!isSuccess) {\n                this._handleConnectionStopped();\n            }\n        }\n    }\n    _handleConnectionStopped() {\n        this._isStopping = false;\n        this._state = WebPubSubClientState.Stopped;\n        this._safeEmitStopped();\n    }\n    async _sendMessage(message, abortSignal) {\n        const payload = this._protocol.writeMessage(message);\n        if (!this._wsClient || !this._wsClient.isOpen()) {\n            throw new Error(\"The connection is not connected.\");\n        }\n        await this._wsClient.send(payload, abortSignal);\n    }\n    async _sendMessageWithAckId(messageProvider, ackId, abortSignal) {\n        if (ackId == null) {\n            ackId = this.nextAckId();\n        }\n        const message = messageProvider(ackId);\n        if (!this._ackMap.has(ackId)) {\n            this._ackMap.set(ackId, new AckEntity(ackId));\n        }\n        const entity = this._ackMap.get(ackId);\n        try {\n            await this._sendMessage(message, abortSignal);\n        }\n        catch (error) {\n            this._ackMap.delete(ackId);\n            let errorMessage = \"\";\n            if (error instanceof Error) {\n                errorMessage = error.message;\n            }\n            throw new SendMessageError(errorMessage, { ackId: ackId });\n        }\n        if (abortSignal) {\n            try {\n                return await abortablePromise(entity.promise(), abortSignal);\n            }\n            catch (err) {\n                if (err instanceof Error && err.name === \"AbortError\") {\n                    throw new SendMessageError(\"Cancelled by abortSignal\", { ackId: ackId });\n                }\n                throw err;\n            }\n        }\n        return await entity.promise();\n    }\n    async _handleConnectionClose() {\n        // Clean ack cache\n        this._ackMap.forEach((value, key) => {\n            if (this._ackMap.delete(key)) {\n                value.reject(new SendMessageError(\"Connection is disconnected before receive ack from the service\", {\n                    ackId: value.ackId,\n                }));\n            }\n        });\n        if (this._isStopping) {\n            logger.warning(\"The client is stopping state. Stop recovery.\");\n            this._handleConnectionCloseAndNoRecovery();\n            return;\n        }\n        if (this._lastCloseEvent && this._lastCloseEvent.code === 1008) {\n            logger.warning(\"The websocket close with status code 1008. Stop recovery.\");\n            this._handleConnectionCloseAndNoRecovery();\n            return;\n        }\n        if (!this._protocol.isReliableSubProtocol) {\n            logger.warning(\"The protocol is not reliable, recovery is not applicable\");\n            this._handleConnectionCloseAndNoRecovery();\n            return;\n        }\n        // Build recovery uri\n        const recoveryUri = this._buildRecoveryUri();\n        if (!recoveryUri) {\n            logger.warning(\"Connection id or reconnection token is not available\");\n            this._handleConnectionCloseAndNoRecovery();\n            return;\n        }\n        // Try recover connection\n        let recovered = false;\n        this._state = WebPubSubClientState.Recovering;\n        const abortSignal = AbortController.timeout(30 * 1000);\n        try {\n            while (!abortSignal.aborted || this._isStopping) {\n                try {\n                    await this._connectCore.call(this, recoveryUri);\n                    recovered = true;\n                    return;\n                }\n                catch (_a) {\n                    await delay(1000);\n                }\n            }\n        }\n        finally {\n            if (!recovered) {\n                logger.warning(\"Recovery attempts failed more then 30 seconds or the client is stopping\");\n                this._handleConnectionCloseAndNoRecovery();\n            }\n        }\n    }\n    _safeEmitConnected(connectionId, userId) {\n        this._emitEvent(\"connected\", {\n            connectionId: connectionId,\n            userId: userId,\n        });\n    }\n    _safeEmitDisconnected(connectionId, lastDisconnectedMessage) {\n        this._emitEvent(\"disconnected\", {\n            connectionId: connectionId,\n            message: lastDisconnectedMessage,\n        });\n    }\n    _safeEmitGroupMessage(message) {\n        this._emitEvent(\"group-message\", {\n            message: message,\n        });\n    }\n    _safeEmitServerMessage(message) {\n        this._emitEvent(\"server-message\", {\n            message: message,\n        });\n    }\n    _safeEmitStopped() {\n        this._emitEvent(\"stopped\", {});\n    }\n    _safeEmitRejoinGroupFailed(groupName, err) {\n        this._emitEvent(\"rejoin-group-failed\", {\n            group: groupName,\n            error: err,\n        });\n    }\n    _buildDefaultOptions(clientOptions) {\n        if (clientOptions.autoReconnect == null) {\n            clientOptions.autoReconnect = true;\n        }\n        if (clientOptions.autoRejoinGroups == null) {\n            clientOptions.autoRejoinGroups = true;\n        }\n        if (clientOptions.protocol == null) {\n            clientOptions.protocol = WebPubSubJsonReliableProtocol();\n        }\n        this._buildMessageRetryOptions(clientOptions);\n        this._buildReconnectRetryOptions(clientOptions);\n        return clientOptions;\n    }\n    _buildMessageRetryOptions(clientOptions) {\n        if (!clientOptions.messageRetryOptions) {\n            clientOptions.messageRetryOptions = {};\n        }\n        if (clientOptions.messageRetryOptions.maxRetries == null ||\n            clientOptions.messageRetryOptions.maxRetries < 0) {\n            clientOptions.messageRetryOptions.maxRetries = 3;\n        }\n        if (clientOptions.messageRetryOptions.retryDelayInMs == null ||\n            clientOptions.messageRetryOptions.retryDelayInMs < 0) {\n            clientOptions.messageRetryOptions.retryDelayInMs = 1000;\n        }\n        if (clientOptions.messageRetryOptions.maxRetryDelayInMs == null ||\n            clientOptions.messageRetryOptions.maxRetryDelayInMs < 0) {\n            clientOptions.messageRetryOptions.maxRetryDelayInMs = 30000;\n        }\n        if (clientOptions.messageRetryOptions.mode == null) {\n            clientOptions.messageRetryOptions.mode = \"Fixed\";\n        }\n    }\n    _buildReconnectRetryOptions(clientOptions) {\n        if (!clientOptions.reconnectRetryOptions) {\n            clientOptions.reconnectRetryOptions = {};\n        }\n        if (clientOptions.reconnectRetryOptions.maxRetries == null ||\n            clientOptions.reconnectRetryOptions.maxRetries < 0) {\n            clientOptions.reconnectRetryOptions.maxRetries = Number.MAX_VALUE;\n        }\n        if (clientOptions.reconnectRetryOptions.retryDelayInMs == null ||\n            clientOptions.reconnectRetryOptions.retryDelayInMs < 0) {\n            clientOptions.reconnectRetryOptions.retryDelayInMs = 1000;\n        }\n        if (clientOptions.reconnectRetryOptions.maxRetryDelayInMs == null ||\n            clientOptions.reconnectRetryOptions.maxRetryDelayInMs < 0) {\n            clientOptions.reconnectRetryOptions.maxRetryDelayInMs = 30000;\n        }\n        if (clientOptions.reconnectRetryOptions.mode == null) {\n            clientOptions.reconnectRetryOptions.mode = \"Fixed\";\n        }\n    }\n    _buildRecoveryUri() {\n        if (this._connectionId && this._reconnectionToken && this._uri) {\n            const url = new URL(this._uri);\n            url.searchParams.append(\"awps_connection_id\", this._connectionId);\n            url.searchParams.append(\"awps_reconnection_token\", this._reconnectionToken);\n            return url.toString();\n        }\n        return null;\n    }\n    _getOrAddGroup(name) {\n        if (!this._groupMap.has(name)) {\n            this._groupMap.set(name, new WebPubSubGroup(name));\n        }\n        return this._groupMap.get(name);\n    }\n    _changeState(newState) {\n        logger.verbose(`The client state transfer from ${this._state.toString()} to ${newState.toString()}`);\n        this._state = newState;\n    }\n    async _operationExecuteWithRetry(inner, signal) {\n        let retryAttempt = 0;\n        while (true) {\n            try {\n                return await inner.call(this);\n            }\n            catch (err) {\n                retryAttempt++;\n                const delayInMs = this._messageRetryPolicy.nextRetryDelayInMs(retryAttempt);\n                if (delayInMs == null) {\n                    throw err;\n                }\n                await delay(delayInMs);\n                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {\n                    throw err;\n                }\n            }\n        }\n    }\n}\nclass RetryPolicy {\n    constructor(retryOptions) {\n        this._retryOptions = retryOptions;\n        this._maxRetriesToGetMaxDelay = Math.ceil(Math.log2(this._retryOptions.maxRetryDelayInMs) -\n            Math.log2(this._retryOptions.retryDelayInMs) +\n            1);\n    }\n    nextRetryDelayInMs(retryAttempt) {\n        if (retryAttempt > this._retryOptions.maxRetries) {\n            return null;\n        }\n        else {\n            if (this._retryOptions.mode === \"Fixed\") {\n                return this._retryOptions.retryDelayInMs;\n            }\n            else {\n                return this._calculateExponentialDelay(retryAttempt);\n            }\n        }\n    }\n    _calculateExponentialDelay(attempt) {\n        if (attempt >= this._maxRetriesToGetMaxDelay) {\n            return this._retryOptions.maxRetryDelayInMs;\n        }\n        else {\n            return (1 << (attempt - 1)) * this._retryOptions.retryDelayInMs;\n        }\n    }\n}\nclass WebPubSubGroup {\n    constructor(name) {\n        this.isJoined = false;\n        this.name = name;\n    }\n}\nclass AckEntity {\n    constructor(ackId) {\n        this._promise = new Promise((resolve, reject) => {\n            this._resolve = resolve;\n            this._reject = reject;\n        });\n        this.ackId = ackId;\n    }\n    promise() {\n        return this._promise;\n    }\n    resolve(value) {\n        this._resolve(value);\n    }\n    reject(reason) {\n        this._reject(reason);\n    }\n}\nclass SequenceId {\n    constructor() {\n        this._sequenceId = 0;\n        this._isUpdate = false;\n    }\n    tryUpdate(sequenceId) {\n        this._isUpdate = true;\n        if (sequenceId > this._sequenceId) {\n            this._sequenceId = sequenceId;\n            return true;\n        }\n        return false;\n    }\n    tryGetSequenceId() {\n        if (this._isUpdate) {\n            this._isUpdate = false;\n            return [true, this._sequenceId];\n        }\n        return [false, null];\n    }\n    reset() {\n        this._sequenceId = 0;\n        this._isUpdate = false;\n    }\n}\nclass AbortableTask {\n    constructor(func, interval, obj) {\n        this._func = func;\n        this._abortController = new AbortController();\n        this._interval = interval;\n        this._obj = obj;\n        this._start();\n    }\n    abort() {\n        try {\n            this._abortController.abort();\n        }\n        catch (_a) { }\n    }\n    async _start() {\n        const signal = this._abortController.signal;\n        while (!signal.aborted) {\n            try {\n                await this._func(this._obj);\n            }\n            catch (_a) {\n            }\n            finally {\n                await delay(this._interval);\n            }\n        }\n    }\n}\n//# sourceMappingURL=webPubSubClient.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nexport * from \"./webPubSubClient\";\nexport * from \"./webPubSubClientCredential\";\nexport * from \"./models\";\nexport * from \"./protocols\";\nexport * from \"./errors\";\n//# sourceMappingURL=index.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/// <reference path=\"../shims-public.d.ts\" />\nconst listenersMap = new WeakMap();\nconst abortedMap = new WeakMap();\n/**\n * An aborter instance implements AbortSignal interface, can abort HTTP requests.\n *\n * - Call AbortSignal.none to create a new AbortSignal instance that cannot be cancelled.\n * Use `AbortSignal.none` when you are required to pass a cancellation token but the operation\n * cannot or will not ever be cancelled.\n *\n * @example\n * Abort without timeout\n * ```ts\n * await doAsyncWork(AbortSignal.none);\n * ```\n */\nexport class AbortSignal {\n    constructor() {\n        /**\n         * onabort event listener.\n         */\n        this.onabort = null;\n        listenersMap.set(this, []);\n        abortedMap.set(this, false);\n    }\n    /**\n     * Status of whether aborted or not.\n     *\n     * @readonly\n     */\n    get aborted() {\n        if (!abortedMap.has(this)) {\n            throw new TypeError(\"Expected `this` to be an instance of AbortSignal.\");\n        }\n        return abortedMap.get(this);\n    }\n    /**\n     * Creates a new AbortSignal instance that will never be aborted.\n     *\n     * @readonly\n     */\n    static get none() {\n        return new AbortSignal();\n    }\n    /**\n     * Added new \"abort\" event listener, only support \"abort\" event.\n     *\n     * @param _type - Only support \"abort\" event\n     * @param listener - The listener to be added\n     */\n    addEventListener(\n    // tslint:disable-next-line:variable-name\n    _type, listener) {\n        if (!listenersMap.has(this)) {\n            throw new TypeError(\"Expected `this` to be an instance of AbortSignal.\");\n        }\n        const listeners = listenersMap.get(this);\n        listeners.push(listener);\n    }\n    /**\n     * Remove \"abort\" event listener, only support \"abort\" event.\n     *\n     * @param _type - Only support \"abort\" event\n     * @param listener - The listener to be removed\n     */\n    removeEventListener(\n    // tslint:disable-next-line:variable-name\n    _type, listener) {\n        if (!listenersMap.has(this)) {\n            throw new TypeError(\"Expected `this` to be an instance of AbortSignal.\");\n        }\n        const listeners = listenersMap.get(this);\n        const index = listeners.indexOf(listener);\n        if (index > -1) {\n            listeners.splice(index, 1);\n        }\n    }\n    /**\n     * Dispatches a synthetic event to the AbortSignal.\n     */\n    dispatchEvent(_event) {\n        throw new Error(\"This is a stub dispatchEvent implementation that should not be used.  It only exists for type-checking purposes.\");\n    }\n}\n/**\n * Helper to trigger an abort event immediately, the onabort and all abort event listeners will be triggered.\n * Will try to trigger abort event for all linked AbortSignal nodes.\n *\n * - If there is a timeout, the timer will be cancelled.\n * - If aborted is true, nothing will happen.\n *\n * @internal\n */\n// eslint-disable-next-line @azure/azure-sdk/ts-use-interface-parameters\nexport function abortSignal(signal) {\n    if (signal.aborted) {\n        return;\n    }\n    if (signal.onabort) {\n        signal.onabort.call(signal);\n    }\n    const listeners = listenersMap.get(signal);\n    if (listeners) {\n        // Create a copy of listeners so mutations to the array\n        // (e.g. via removeListener calls) don't affect the listeners\n        // we invoke.\n        listeners.slice().forEach((listener) => {\n            listener.call(signal, { type: \"abort\" });\n        });\n    }\n    abortedMap.set(signal, true);\n}\n//# sourceMappingURL=AbortSignal.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { AbortSignal, abortSignal } from \"./AbortSignal\";\n/**\n * This error is thrown when an asynchronous operation has been aborted.\n * Check for this error by testing the `name` that the name property of the\n * error matches `\"AbortError\"`.\n *\n * @example\n * ```ts\n * const controller = new AbortController();\n * controller.abort();\n * try {\n *   doAsyncWork(controller.signal)\n * } catch (e) {\n *   if (e.name === 'AbortError') {\n *     // handle abort error here.\n *   }\n * }\n * ```\n */\nexport class AbortError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = \"AbortError\";\n    }\n}\n/**\n * An AbortController provides an AbortSignal and the associated controls to signal\n * that an asynchronous operation should be aborted.\n *\n * @example\n * Abort an operation when another event fires\n * ```ts\n * const controller = new AbortController();\n * const signal = controller.signal;\n * doAsyncWork(signal);\n * button.addEventListener('click', () => controller.abort());\n * ```\n *\n * @example\n * Share aborter cross multiple operations in 30s\n * ```ts\n * // Upload the same data to 2 different data centers at the same time,\n * // abort another when any of them is finished\n * const controller = AbortController.withTimeout(30 * 1000);\n * doAsyncWork(controller.signal).then(controller.abort);\n * doAsyncWork(controller.signal).then(controller.abort);\n *```\n *\n * @example\n * Cascaded aborting\n * ```ts\n * // All operations can't take more than 30 seconds\n * const aborter = Aborter.timeout(30 * 1000);\n *\n * // Following 2 operations can't take more than 25 seconds\n * await doAsyncWork(aborter.withTimeout(25 * 1000));\n * await doAsyncWork(aborter.withTimeout(25 * 1000));\n * ```\n */\nexport class AbortController {\n    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\n    constructor(parentSignals) {\n        this._signal = new AbortSignal();\n        if (!parentSignals) {\n            return;\n        }\n        // coerce parentSignals into an array\n        if (!Array.isArray(parentSignals)) {\n            // eslint-disable-next-line prefer-rest-params\n            parentSignals = arguments;\n        }\n        for (const parentSignal of parentSignals) {\n            // if the parent signal has already had abort() called,\n            // then call abort on this signal as well.\n            if (parentSignal.aborted) {\n                this.abort();\n            }\n            else {\n                // when the parent signal aborts, this signal should as well.\n                parentSignal.addEventListener(\"abort\", () => {\n                    this.abort();\n                });\n            }\n        }\n    }\n    /**\n     * The AbortSignal associated with this controller that will signal aborted\n     * when the abort method is called on this controller.\n     *\n     * @readonly\n     */\n    get signal() {\n        return this._signal;\n    }\n    /**\n     * Signal that any operations passed this controller's associated abort signal\n     * to cancel any remaining work and throw an `AbortError`.\n     */\n    abort() {\n        abortSignal(this._signal);\n    }\n    /**\n     * Creates a new AbortSignal instance that will abort after the provided ms.\n     * @param ms - Elapsed time in milliseconds to trigger an abort.\n     */\n    static timeout(ms) {\n        const signal = new AbortSignal();\n        const timer = setTimeout(abortSignal, ms, signal);\n        // Prevent the active Timer from keeping the Node.js event loop active.\n        if (typeof timer.unref === \"function\") {\n            timer.unref();\n        }\n        return signal;\n    }\n}\n//# sourceMappingURL=AbortController.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { AbortError } from \"@azure/abort-controller\";\nexport async function abortablePromise(promise, signal) {\n    if (signal.aborted) {\n        throw new AbortError(\"The operation was aborted.\");\n    }\n    let onAbort;\n    // eslint-disable-next-line promise/param-names\n    const p = new Promise((_, reject) => {\n        onAbort = () => {\n            reject(new AbortError(\"The operation was aborted.\"));\n        };\n        signal.addEventListener(\"abort\", onAbort);\n    });\n    try {\n        return await Promise.race([promise, p]);\n    }\n    finally {\n        signal.removeEventListener(\"abort\", onAbort);\n    }\n}\n//# sourceMappingURL=abortablePromise.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { Buffer } from \"buffer\";\nexport function parseMessages(input) {\n    // The interface does allow \"ArrayBuffer\" to be passed in, but this implementation does not. So let's throw a useful error.\n    if (typeof input !== \"string\") {\n        throw new Error(\"Invalid input for JSON hub protocol. Expected a string.\");\n    }\n    if (!input) {\n        throw new Error(\"No input\");\n    }\n    const parsedMessage = JSON.parse(input);\n    const typedMessage = parsedMessage;\n    let returnMessage;\n    if (typedMessage.type === \"system\") {\n        if (typedMessage.event === \"connected\") {\n            returnMessage = Object.assign(Object.assign({}, parsedMessage), { kind: \"connected\" });\n        }\n        else if (typedMessage.event === \"disconnected\") {\n            returnMessage = Object.assign(Object.assign({}, parsedMessage), { kind: \"disconnected\" });\n        }\n        else {\n            // Forward compatible\n            return null;\n        }\n    }\n    else if (typedMessage.type === \"message\") {\n        if (typedMessage.from === \"group\") {\n            const data = parsePayload(parsedMessage.data, parsedMessage.dataType);\n            if (data === null) {\n                return null;\n            }\n            returnMessage = Object.assign(Object.assign({}, parsedMessage), { data: data, kind: \"groupData\" });\n        }\n        else if (typedMessage.from === \"server\") {\n            const data = parsePayload(parsedMessage.data, parsedMessage.dataType);\n            if (data === null) {\n                return null;\n            }\n            returnMessage = Object.assign(Object.assign({}, parsedMessage), { data: data, kind: \"serverData\" });\n        }\n        else {\n            // Forward compatible\n            return null;\n        }\n    }\n    else if (typedMessage.type === \"ack\") {\n        returnMessage = Object.assign(Object.assign({}, parsedMessage), { kind: \"ack\" });\n    }\n    else {\n        // Forward compatible\n        return null;\n    }\n    return returnMessage;\n}\nexport function writeMessage(message) {\n    let data;\n    switch (message.kind) {\n        case \"joinGroup\": {\n            data = { type: \"joinGroup\", group: message.group, ackId: message.ackId };\n            break;\n        }\n        case \"leaveGroup\": {\n            data = { type: \"leaveGroup\", group: message.group, ackId: message.ackId };\n            break;\n        }\n        case \"sendEvent\": {\n            data = {\n                type: \"event\",\n                event: message.event,\n                ackId: message.ackId,\n                dataType: message.dataType,\n                data: getPayload(message.data, message.dataType),\n            };\n            break;\n        }\n        case \"sendToGroup\": {\n            data = {\n                type: \"sendToGroup\",\n                group: message.group,\n                ackId: message.ackId,\n                dataType: message.dataType,\n                data: getPayload(message.data, message.dataType),\n                noEcho: message.noEcho,\n            };\n            break;\n        }\n        case \"sequenceAck\": {\n            data = { type: \"sequenceAck\", sequenceId: message.sequenceId };\n            break;\n        }\n        default: {\n            throw new Error(`Unsupported type: ${message.kind}`);\n        }\n    }\n    return JSON.stringify(data);\n}\nfunction getPayload(data, dataType) {\n    switch (dataType) {\n        case \"text\": {\n            if (typeof data !== \"string\") {\n                throw new TypeError(\"Message must be a string.\");\n            }\n            return data;\n        }\n        case \"json\": {\n            return data;\n        }\n        case \"binary\":\n        case \"protobuf\": {\n            if (data instanceof ArrayBuffer) {\n                return Buffer.from(data).toString(\"base64\");\n            }\n            throw new TypeError(\"Message must be a ArrayBuffer\");\n        }\n    }\n}\nfunction parsePayload(data, dataType) {\n    if (dataType === \"text\") {\n        if (typeof data !== \"string\") {\n            throw new TypeError(\"Message must be a string when dataType is text\");\n        }\n        return data;\n    }\n    else if (dataType === \"json\") {\n        return data;\n    }\n    else if (dataType === \"binary\" || dataType === \"protobuf\") {\n        const buf = Buffer.from(data, \"base64\");\n        return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);\n    }\n    else {\n        // Forward compatible\n        return null;\n    }\n}\n//# sourceMappingURL=jsonProtocolBase.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport * as base from \"./jsonProtocolBase\";\n/**\n * The \"json.webpubsub.azure.v1\" protocol\n */\nexport class WebPubSubJsonProtocolImpl {\n    constructor() {\n        /**\n         * True if the protocol supports reliable features\n         */\n        this.isReliableSubProtocol = false;\n        /**\n         * The name of subprotocol. Name will be used in websocket subprotocol\n         */\n        this.name = \"json.webpubsub.azure.v1\";\n    }\n    /**\n     * Creates WebPubSubMessage objects from the specified serialized representation.\n     * @param input - The serialized representation\n     */\n    parseMessages(input) {\n        return base.parseMessages(input);\n    }\n    /**\n     * Write WebPubSubMessage to string\n     * @param message - The message to be written\n     */\n    writeMessage(message) {\n        return base.writeMessage(message);\n    }\n}\n//# sourceMappingURL=webPubSubJsonProtocol.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport * as base from \"./jsonProtocolBase\";\n/**\n * The \"json.reliable.webpubsub.azure.v1\" protocol\n */\nexport class WebPubSubJsonReliableProtocolImpl {\n    constructor() {\n        /**\n         * True if the protocol supports reliable features\n         */\n        this.isReliableSubProtocol = true;\n        /**\n         * The name of subprotocol. Name will be used in websocket subprotocol\n         */\n        this.name = \"json.reliable.webpubsub.azure.v1\";\n    }\n    /**\n     * Creates WebPubSubMessage objects from the specified serialized representation.\n     * @param input - The serialized representation\n     */\n    parseMessages(input) {\n        return base.parseMessages(input);\n    }\n    /**\n     * Write WebPubSubMessage to string\n     * @param message - The message to be written\n     */\n    writeMessage(message) {\n        return base.writeMessage(message);\n    }\n}\n//# sourceMappingURL=webPubSubJsonReliableProtocol.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { WebPubSubJsonProtocolImpl } from \"./webPubSubJsonProtocol\";\nimport { WebPubSubJsonReliableProtocolImpl } from \"./webPubSubJsonReliableProtocol\";\n/**\n * Return the \"json.webpubsub.azure.v1\" protocol\n */\nexport const WebPubSubJsonProtocol = () => {\n    return new WebPubSubJsonProtocolImpl();\n};\n/**\n * Return the \"json.reliable.webpubsub.azure.v1\" protocol\n */\nexport const WebPubSubJsonReliableProtocol = () => {\n    return new WebPubSubJsonReliableProtocolImpl();\n};\n//# sourceMappingURL=index.js.map","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {\n  return call.apply(apply, arguments);\n});\n","const { WebPubSubClient } = require(\"@azure/web-pubsub-client\");\n\nclass Socket {\n  url = null;\n  connected = false;\n  listeners = [];\n\n  constructor(ws_url) {\n    if (Socket._instance) {\n      return Socket._instance;\n    }\n    Socket._instance = this;\n    this.url = ws_url;\n    this.socket = new WebPubSubClient(ws_url);\n    this.socket.on(\"connected\", () => {\n      console.log(\"Connected\");\n      this.connected = true;\n    });\n    this.socket.on(\"disconnected\", () => {\n      console.log(\"Disconnected\");\n      this.connected = false;\n    });\n    this.socket.on(\"reconnecting\", () => {\n      console.log(\"Reconnecting\");\n      this.connected = false;\n    });\n    this.socket.on(\"reconnected\", () => {\n      console.log(\"Reconnected\");\n      this.connected = true;\n    });\n    this.socket.on(\"stopped\", () => {\n      console.log(\"Stopped\");\n      this.connected = false;\n    });\n    this.socket.on(\"group-message\", (message) => {\n      let data = JSON.parse(message.message.data);\n      // console.log(\"Group message received: \", data.event, data.content);\n      this.emit(data.event, data.content);\n    });\n    this.socket.on(\"server-message\", (message) => {\n      // console.log(\"Server message received: \", message.message);\n      this.emit(\"server-message\", message.message);\n    });\n    this.start();\n\n    console.log(\"Socket created\");\n  }\n\n  async start() {\n    await this.socket.start();\n    await this.joinGroup(\"claims\");\n    this.connected = true;\n    console.log(\"Socket started\");\n  }\n\n  async joinGroup(group) {\n    console.log(\"Joining group: \" + group);\n    await this.socket.joinGroup(group);\n  }\n\n  async sendToGroup(group, message) {\n    if (!this.connected) return;\n    // console.log(\"Sending to group: \" + group);\n    await this.socket.sendToGroup(group, JSON.stringify(message), \"text\");\n  }\n\n  emit(eventName, data) {\n    this.listeners\n      .filter(({ name }) => name === eventName)\n      .forEach(({ callback }) => setTimeout(callback(data), 0));\n  }\n\n  on(name, callback) {\n    if (typeof callback === \"function\" && typeof name === \"string\") {\n      this.listeners.push({ name, callback });\n    }\n  }\n\n  off(eventName, callback) {\n    this.listeners = this.listeners.filter((listener) => {\n      return listener.name !== eventName && listener.callback !== callback;\n    });\n  }\n\n  destroy() {\n    this.listeners.length = 0;\n  }\n}\n\nexport default Socket;\n","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { log } from \"./log\";\nconst debugEnvVariable = (typeof process !== \"undefined\" && process.env && process.env.DEBUG) || undefined;\nlet enabledString;\nlet enabledNamespaces = [];\nlet skippedNamespaces = [];\nconst debuggers = [];\nif (debugEnvVariable) {\n    enable(debugEnvVariable);\n}\nconst debugObj = Object.assign((namespace) => {\n    return createDebugger(namespace);\n}, {\n    enable,\n    enabled,\n    disable,\n    log,\n});\nfunction enable(namespaces) {\n    enabledString = namespaces;\n    enabledNamespaces = [];\n    skippedNamespaces = [];\n    const wildcard = /\\*/g;\n    const namespaceList = namespaces.split(\",\").map((ns) => ns.trim().replace(wildcard, \".*?\"));\n    for (const ns of namespaceList) {\n        if (ns.startsWith(\"-\")) {\n            skippedNamespaces.push(new RegExp(`^${ns.substr(1)}$`));\n        }\n        else {\n            enabledNamespaces.push(new RegExp(`^${ns}$`));\n        }\n    }\n    for (const instance of debuggers) {\n        instance.enabled = enabled(instance.namespace);\n    }\n}\nfunction enabled(namespace) {\n    if (namespace.endsWith(\"*\")) {\n        return true;\n    }\n    for (const skipped of skippedNamespaces) {\n        if (skipped.test(namespace)) {\n            return false;\n        }\n    }\n    for (const enabledNamespace of enabledNamespaces) {\n        if (enabledNamespace.test(namespace)) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction disable() {\n    const result = enabledString || \"\";\n    enable(\"\");\n    return result;\n}\nfunction createDebugger(namespace) {\n    const newDebugger = Object.assign(debug, {\n        enabled: enabled(namespace),\n        destroy,\n        log: debugObj.log,\n        namespace,\n        extend,\n    });\n    function debug(...args) {\n        if (!newDebugger.enabled) {\n            return;\n        }\n        if (args.length > 0) {\n            args[0] = `${namespace} ${args[0]}`;\n        }\n        newDebugger.log(...args);\n    }\n    debuggers.push(newDebugger);\n    return newDebugger;\n}\nfunction destroy() {\n    const index = debuggers.indexOf(this);\n    if (index >= 0) {\n        debuggers.splice(index, 1);\n        return true;\n    }\n    return false;\n}\nfunction extend(namespace) {\n    const newDebugger = createDebugger(`${this.namespace}:${namespace}`);\n    newDebugger.log = this.log;\n    return newDebugger;\n}\nexport default debugObj;\n//# sourceMappingURL=debug.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { createClientLogger } from \"@azure/logger\";\n/**\n * The \\@azure\\/logger configuration for this package.\n */\nexport const logger = createClientLogger(\"web-pubsub-client\");\n//# sourceMappingURL=logger.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nexport class WebSocketClient {\n    constructor(uri, protocolName) {\n        this._socket = new WebSocket(uri, protocolName);\n        this._socket.binaryType = \"arraybuffer\";\n    }\n    onopen(fn) {\n        this._socket.onopen = fn;\n    }\n    onclose(fn) {\n        this._socket.onclose = (ev) => fn(ev.code, ev.reason);\n    }\n    onerror(fn) {\n        this._socket.onerror = (ev) => fn(ev);\n    }\n    onmessage(fn) {\n        this._socket.onmessage = (event) => fn(event.data);\n    }\n    close(code, reason) {\n        this._socket.close(code, reason);\n    }\n    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\n    send(data, _) {\n        return new Promise((resolve, reject) => {\n            try {\n                this._socket.send(data);\n                resolve();\n            }\n            catch (err) {\n                reject(err);\n            }\n        });\n    }\n    isOpen() {\n        return this._socket.readyState === WebSocket.OPEN;\n    }\n}\nexport class WebSocketClientFactory {\n    create(uri, protocolName) {\n        return new WebSocketClient(uri, protocolName);\n    }\n}\n//# sourceMappingURL=websocketClient.browser.js.map","import axios from \"axios\";\nimport authHeader from \"./auth-header\";\nimport { markRaw } from \"vue\";\n\nclass Phone {\n  started = false;\n  token = null;\n  device = null;\n  ready = null;\n  showOutputSelection = false;\n  inputDevice = null;\n  outputDevice = null;\n  ringtoneDevices = [];\n  speakerDevices = [];\n  onCall = false;\n  timer = null;\n  recipient = null;\n  call = null;\n  listeners = [];\n\n  site_id = null;\n  claim_reference = null;\n\n  notes = \"Call Notes\\n\\n\";\n  sid = null;\n\n  constructor() {\n    if (Phone._instance) {\n      return Phone._instance;\n    }\n    Phone._instance = this;\n  }\n\n  async startUp() {\n    this.started = true;\n    let data = (\n      await axios.get(`https://api.varsanpr.com/api/calls/token`, {\n        headers: authHeader(),\n      })\n    ).data;\n    this.token = data.token;\n    this.initializeDevice();\n    if (!this.timer) {\n      this.timer = setInterval(() => {\n        if (!this.checkToken()) {\n          this.startUp();\n        }\n      }, 10000);\n    }\n  }\n\n  checkToken() {\n    if (!this.token) {\n      return false;\n    }\n    let tokenParts = this.token.split(\".\");\n    let tokenDecoded = JSON.parse(atob(tokenParts[1]));\n    let tokenExp = tokenDecoded.exp;\n    let dateNow = new Date();\n    let dateNowSeconds = Math.round(dateNow.getTime() / 1000);\n    let tokenValid = tokenExp > dateNowSeconds;\n    return tokenValid;\n  }\n\n  initializeDevice() {\n    this.device = markRaw(\n      new Twilio.Device(this.token, {\n        logLevel: 1,\n        codecPreferences: [\"opus\", \"pcmu\"],\n      })\n    );\n    this.addDeviceListeners();\n    this.getAudioDevices();\n    this.device.register();\n\n    this.emit(\"ready\", {});\n  }\n\n  addDeviceListeners() {\n    this.device.on(\"registered\", () => {\n      console.log(\"Twilio.Device Ready to make and receive calls\");\n      this.ready = true;\n    });\n    this.device.on(\"error\", (error) => {\n      console.warn(\"Twilio.Device Error: \" + error.message);\n    });\n    this.device.on(\"incoming\", (connection) => {\n      console.log(\"Incoming connection from \" + connection.parameters.From);\n    });\n    this.device.on(\n      \"deviceChange\",\n      this.updateAllAudioDevices.bind(this.device)\n    );\n\n    if (this.device.audio.isOutputSelectionSupported) {\n      this.showOutputSelection = true;\n    }\n  }\n\n  async getAudioDevices() {\n    await navigator.mediaDevices.getUserMedia({ audio: true });\n    this.updateAllAudioDevices();\n  }\n\n  updateAllAudioDevices() {\n    if (this.device) {\n      this.speakerDevices = [];\n      this.ringtoneDevices = [];\n      this.device.audio.availableOutputDevices.forEach((device, id) => {\n        this.speakerDevices.push({\n          id: id,\n          label: device.label || \"Speaker \" + (id + 1),\n          value: device.deviceId,\n          kind: device.kind,\n        });\n      });\n      this.device.audio.availableInputDevices.forEach((device, id) => {\n        this.ringtoneDevices.push({\n          id: id,\n          label: device.label || \"Microphone \" + (id + 1),\n          value: device.deviceId,\n          kind: device.kind,\n        });\n      });\n      if (!this.inputDevice) {\n        this.inputDevice = this.ringtoneDevices[0].value;\n      }\n      if (!this.outputDevice) {\n        this.outputDevice = this.speakerDevices[0].value;\n      }\n    }\n  }\n\n  updateOutputDevice() {\n    this.device.audio.speakerDevices.set(this.outputDevice);\n  }\n\n  updateInputDevice() {\n    this.device.audio.ringtoneDevices.set(this.inputDevice);\n  }\n\n  async makeOutgoingCall(to, site_id = null, claim_reference = null) {\n    if (!this.ready) {\n      this.startUp();\n      setTimeout(() => {\n        this.makeOutgoingCall(to, site_id, claim_reference);\n      }, 3000);\n      return;\n    }\n\n    var params = {\n      To: to,\n    };\n\n    this.recipient = to;\n    this.site_id = site_id;\n    this.claim_reference = claim_reference;\n    this.notes = \"Call Notes - \" + to + \"\\n\\n\";\n\n    if (this.device) {\n      console.log(\"Calling \" + this.to + \"...\");\n      const call = await this.device.connect({ params });\n      this.call = call;\n      console.log(\"Call SID:\", call.parameters.CallSid);\n      this.onCall = true;\n\n      call.on(\"accept\", () => {\n        console.log(\"Call accepted\");\n        this.emit(\"call-accepted\", {});\n      });\n      call.on(\"disconnect\", () => {\n        console.log(\"Call ended\");\n        this.onCall = false;\n        this.emit(\"call-disconnected\", {});\n        this.submitCall({\n          sid: call.parameters.CallSid,\n          notes: this.notes,\n          recipient: this.recipient,\n        });\n      });\n      call.on(\"cancel\", () => {\n        console.log(\"Call cancelled\");\n        this.onCall = false;\n        this.emit(\"call-disconnected\", {});\n      });\n    } else {\n      console.log(\"Device not ready\");\n    }\n  }\n\n  async sendDigits(digit) {\n    console.log(`Sending digits`, digit);\n    if (this.call) {\n      this.call.sendDigits(digit + \"\");\n    }\n  }\n\n  async hangUp() {\n    console.log(\"Hanging up\");\n    if (this.call) {\n      this.call.disconnect();\n      this.call = null;\n    }\n  }\n\n  submitCall(callDetails) {\n    console.log(\"Submitting call details\", callDetails);\n    axios\n      .post(\n        `https://api.varsanpr.com/api/calls/call`,\n        {\n          sid: callDetails.sid,\n          notes: callDetails.notes,\n          recipient: callDetails.recipient,\n          site_id: this.site_id || null,\n          claim_reference: this.claim_reference || null,\n        },\n        {\n          headers: authHeader(),\n        }\n      )\n      .then((response) => {\n        console.log(\"Call details submitted\", response);\n      })\n      .catch((error) => {\n        console.error(\"Error submitting call details\", error);\n      });\n  }\n\n  emit(eventName, data) {\n    this.listeners\n      .filter(({ name }) => name === eventName)\n      .forEach(({ callback }) => setTimeout(callback(data), 0));\n  }\n\n  on(name, callback) {\n    if (typeof callback === \"function\" && typeof name === \"string\") {\n      this.listeners.push({ name, callback });\n    }\n  }\n\n  off(eventName, callback) {\n    this.listeners = this.listeners.filter((listener) => {\n      return listener.name !== eventName && listener.callback !== callback;\n    });\n  }\n\n  destroy() {\n    this.listeners.length = 0;\n  }\n}\n\nexport default Phone;\n","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { AbortError } from \"@azure/abort-controller\";\n/**\n * Creates an abortable promise.\n * @param buildPromise - A function that takes the resolve and reject functions as parameters.\n * @param options - The options for the abortable promise.\n * @returns A promise that can be aborted.\n */\nexport function createAbortablePromise(buildPromise, options) {\n    const { cleanupBeforeAbort, abortSignal, abortErrorMsg } = options !== null && options !== void 0 ? options : {};\n    return new Promise((resolve, reject) => {\n        function rejectOnAbort() {\n            reject(new AbortError(abortErrorMsg !== null && abortErrorMsg !== void 0 ? abortErrorMsg : \"The operation was aborted.\"));\n        }\n        function removeListeners() {\n            abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.removeEventListener(\"abort\", onAbort);\n        }\n        function onAbort() {\n            cleanupBeforeAbort === null || cleanupBeforeAbort === void 0 ? void 0 : cleanupBeforeAbort();\n            removeListeners();\n            rejectOnAbort();\n        }\n        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {\n            return rejectOnAbort();\n        }\n        try {\n            buildPromise((x) => {\n                removeListeners();\n                resolve(x);\n            }, (x) => {\n                removeListeners();\n                reject(x);\n            });\n        }\n        catch (err) {\n            reject(err);\n        }\n        abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.addEventListener(\"abort\", onAbort);\n    });\n}\n//# sourceMappingURL=createAbortablePromise.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { createAbortablePromise } from \"./createAbortablePromise\";\nconst StandardAbortMessage = \"The delay was aborted.\";\n/**\n * A wrapper for setTimeout that resolves a promise after timeInMs milliseconds.\n * @param timeInMs - The number of milliseconds to be delayed.\n * @param options - The options for delay - currently abort options\n * @returns Promise that is resolved after timeInMs\n */\nexport function delay(timeInMs, options) {\n    let token;\n    const { abortSignal, abortErrorMsg } = options !== null && options !== void 0 ? options : {};\n    return createAbortablePromise((resolve) => {\n        token = setTimeout(resolve, timeInMs);\n    }, {\n        cleanupBeforeAbort: () => clearTimeout(token),\n        abortSignal,\n        abortErrorMsg: abortErrorMsg !== null && abortErrorMsg !== void 0 ? abortErrorMsg : StandardAbortMessage,\n    });\n}\n//# sourceMappingURL=delay.js.map","'use strict';\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar clearErrorStack = require('../internals/error-stack-clear');\nvar ERROR_STACK_INSTALLABLE = require('../internals/error-stack-installable');\n\n// non-standard V8\nvar captureStackTrace = Error.captureStackTrace;\n\nmodule.exports = function (error, C, stack, dropEntries) {\n  if (ERROR_STACK_INSTALLABLE) {\n    if (captureStackTrace) captureStackTrace(error, C);\n    else createNonEnumerableProperty(error, 'stack', clearErrorStack(stack, dropEntries));\n  }\n};\n","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport debug from \"./debug\";\nconst registeredLoggers = new Set();\nconst logLevelFromEnv = (typeof process !== \"undefined\" && process.env && process.env.AZURE_LOG_LEVEL) || undefined;\nlet azureLogLevel;\n/**\n * The AzureLogger provides a mechanism for overriding where logs are output to.\n * By default, logs are sent to stderr.\n * Override the `log` method to redirect logs to another location.\n */\nexport const AzureLogger = debug(\"azure\");\nAzureLogger.log = (...args) => {\n    debug.log(...args);\n};\nconst AZURE_LOG_LEVELS = [\"verbose\", \"info\", \"warning\", \"error\"];\nif (logLevelFromEnv) {\n    // avoid calling setLogLevel because we don't want a mis-set environment variable to crash\n    if (isAzureLogLevel(logLevelFromEnv)) {\n        setLogLevel(logLevelFromEnv);\n    }\n    else {\n        console.error(`AZURE_LOG_LEVEL set to unknown log level '${logLevelFromEnv}'; logging is not enabled. Acceptable values: ${AZURE_LOG_LEVELS.join(\", \")}.`);\n    }\n}\n/**\n * Immediately enables logging at the specified log level. If no level is specified, logging is disabled.\n * @param level - The log level to enable for logging.\n * Options from most verbose to least verbose are:\n * - verbose\n * - info\n * - warning\n * - error\n */\nexport function setLogLevel(level) {\n    if (level && !isAzureLogLevel(level)) {\n        throw new Error(`Unknown log level '${level}'. Acceptable values: ${AZURE_LOG_LEVELS.join(\",\")}`);\n    }\n    azureLogLevel = level;\n    const enabledNamespaces = [];\n    for (const logger of registeredLoggers) {\n        if (shouldEnable(logger)) {\n            enabledNamespaces.push(logger.namespace);\n        }\n    }\n    debug.enable(enabledNamespaces.join(\",\"));\n}\n/**\n * Retrieves the currently specified log level.\n */\nexport function getLogLevel() {\n    return azureLogLevel;\n}\nconst levelMap = {\n    verbose: 400,\n    info: 300,\n    warning: 200,\n    error: 100,\n};\n/**\n * Creates a logger for use by the Azure SDKs that inherits from `AzureLogger`.\n * @param namespace - The name of the SDK package.\n * @hidden\n */\nexport function createClientLogger(namespace) {\n    const clientRootLogger = AzureLogger.extend(namespace);\n    patchLogMethod(AzureLogger, clientRootLogger);\n    return {\n        error: createLogger(clientRootLogger, \"error\"),\n        warning: createLogger(clientRootLogger, \"warning\"),\n        info: createLogger(clientRootLogger, \"info\"),\n        verbose: createLogger(clientRootLogger, \"verbose\"),\n    };\n}\nfunction patchLogMethod(parent, child) {\n    child.log = (...args) => {\n        parent.log(...args);\n    };\n}\nfunction createLogger(parent, level) {\n    const logger = Object.assign(parent.extend(level), {\n        level,\n    });\n    patchLogMethod(parent, logger);\n    if (shouldEnable(logger)) {\n        const enabledNamespaces = debug.disable();\n        debug.enable(enabledNamespaces + \",\" + logger.namespace);\n    }\n    registeredLoggers.add(logger);\n    return logger;\n}\nfunction shouldEnable(logger) {\n    return Boolean(azureLogLevel && levelMap[logger.level] <= levelMap[azureLogLevel]);\n}\nfunction isAzureLogLevel(logLevel) {\n    return AZURE_LOG_LEVELS.includes(logLevel);\n}\n//# sourceMappingURL=index.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nexport function log(...args) {\n    if (args.length > 0) {\n        const firstArg = String(args[0]);\n        if (firstArg.includes(\":error\")) {\n            console.error(...args);\n        }\n        else if (firstArg.includes(\":warning\")) {\n            console.warn(...args);\n        }\n        else if (firstArg.includes(\":info\")) {\n            console.info(...args);\n        }\n        else if (firstArg.includes(\":verbose\")) {\n            console.debug(...args);\n        }\n        else {\n            console.debug(...args);\n        }\n    }\n}\n//# sourceMappingURL=log.browser.js.map","'use strict';\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\n// `InstallErrorCause` abstract operation\n// https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause\nmodule.exports = function (O, options) {\n  if (isObject(options) && 'cause' in options) {\n    createNonEnumerableProperty(O, 'cause', options.cause);\n  }\n};\n","export default function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}","import _typeof from \"./typeof.js\";\nexport default function _toPrimitive(input, hint) {\n  if (_typeof(input) !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (_typeof(res) !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nexport default function _toPropertyKey(arg) {\n  var key = toPrimitive(arg, \"string\");\n  return _typeof(key) === \"symbol\" ? key : String(key);\n}","import toPropertyKey from \"./toPropertyKey.js\";\nexport default function _defineProperty(obj, key, value) {\n  key = toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\n\nmodule.exports = function (Target, Source, key) {\n  key in Target || defineProperty(Target, key, {\n    configurable: true,\n    get: function () { return Source[key]; },\n    set: function (it) { Source[key] = it; }\n  });\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = !fails(function () {\n  var error = Error('a');\n  if (!('stack' in error)) return true;\n  // eslint-disable-next-line es/no-object-defineproperty -- safe\n  Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));\n  return error.stack !== 7;\n});\n","'use strict';\n/* eslint-disable no-unused-vars -- required for functions `.length` */\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar wrapErrorConstructorWithCause = require('../internals/wrap-error-constructor-with-cause');\n\nvar WEB_ASSEMBLY = 'WebAssembly';\nvar WebAssembly = global[WEB_ASSEMBLY];\n\nvar FORCED = Error('e', { cause: 7 }).cause !== 7;\n\nvar exportGlobalErrorCauseWrapper = function (ERROR_NAME, wrapper) {\n  var O = {};\n  O[ERROR_NAME] = wrapErrorConstructorWithCause(ERROR_NAME, wrapper, FORCED);\n  $({ global: true, constructor: true, arity: 1, forced: FORCED }, O);\n};\n\nvar exportWebAssemblyErrorCauseWrapper = function (ERROR_NAME, wrapper) {\n  if (WebAssembly && WebAssembly[ERROR_NAME]) {\n    var O = {};\n    O[ERROR_NAME] = wrapErrorConstructorWithCause(WEB_ASSEMBLY + '.' + ERROR_NAME, wrapper, FORCED);\n    $({ target: WEB_ASSEMBLY, stat: true, constructor: true, arity: 1, forced: FORCED }, O);\n  }\n};\n\n// https://tc39.es/ecma262/#sec-nativeerror\nexportGlobalErrorCauseWrapper('Error', function (init) {\n  return function Error(message) { return apply(init, this, arguments); };\n});\nexportGlobalErrorCauseWrapper('EvalError', function (init) {\n  return function EvalError(message) { return apply(init, this, arguments); };\n});\nexportGlobalErrorCauseWrapper('RangeError', function (init) {\n  return function RangeError(message) { return apply(init, this, arguments); };\n});\nexportGlobalErrorCauseWrapper('ReferenceError', function (init) {\n  return function ReferenceError(message) { return apply(init, this, arguments); };\n});\nexportGlobalErrorCauseWrapper('SyntaxError', function (init) {\n  return function SyntaxError(message) { return apply(init, this, arguments); };\n});\nexportGlobalErrorCauseWrapper('TypeError', function (init) {\n  return function TypeError(message) { return apply(init, this, arguments); };\n});\nexportGlobalErrorCauseWrapper('URIError', function (init) {\n  return function URIError(message) { return apply(init, this, arguments); };\n});\nexportWebAssemblyErrorCauseWrapper('CompileError', function (init) {\n  return function CompileError(message) { return apply(init, this, arguments); };\n});\nexportWebAssemblyErrorCauseWrapper('LinkError', function (init) {\n  return function LinkError(message) { return apply(init, this, arguments); };\n});\nexportWebAssemblyErrorCauseWrapper('RuntimeError', function (init) {\n  return function RuntimeError(message) { return apply(init, this, arguments); };\n});\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar hasOwn = require('../internals/has-own-property');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar proxyAccessor = require('../internals/proxy-accessor');\nvar inheritIfRequired = require('../internals/inherit-if-required');\nvar normalizeStringArgument = require('../internals/normalize-string-argument');\nvar installErrorCause = require('../internals/install-error-cause');\nvar installErrorStack = require('../internals/error-stack-install');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IS_PURE = require('../internals/is-pure');\n\nmodule.exports = function (FULL_NAME, wrapper, FORCED, IS_AGGREGATE_ERROR) {\n  var STACK_TRACE_LIMIT = 'stackTraceLimit';\n  var OPTIONS_POSITION = IS_AGGREGATE_ERROR ? 2 : 1;\n  var path = FULL_NAME.split('.');\n  var ERROR_NAME = path[path.length - 1];\n  var OriginalError = getBuiltIn.apply(null, path);\n\n  if (!OriginalError) return;\n\n  var OriginalErrorPrototype = OriginalError.prototype;\n\n  // V8 9.3- bug https://bugs.chromium.org/p/v8/issues/detail?id=12006\n  if (!IS_PURE && hasOwn(OriginalErrorPrototype, 'cause')) delete OriginalErrorPrototype.cause;\n\n  if (!FORCED) return OriginalError;\n\n  var BaseError = getBuiltIn('Error');\n\n  var WrappedError = wrapper(function (a, b) {\n    var message = normalizeStringArgument(IS_AGGREGATE_ERROR ? b : a, undefined);\n    var result = IS_AGGREGATE_ERROR ? new OriginalError(a) : new OriginalError();\n    if (message !== undefined) createNonEnumerableProperty(result, 'message', message);\n    installErrorStack(result, WrappedError, result.stack, 2);\n    if (this && isPrototypeOf(OriginalErrorPrototype, this)) inheritIfRequired(result, this, WrappedError);\n    if (arguments.length > OPTIONS_POSITION) installErrorCause(result, arguments[OPTIONS_POSITION]);\n    return result;\n  });\n\n  WrappedError.prototype = OriginalErrorPrototype;\n\n  if (ERROR_NAME !== 'Error') {\n    if (setPrototypeOf) setPrototypeOf(WrappedError, BaseError);\n    else copyConstructorProperties(WrappedError, BaseError, { name: true });\n  } else if (DESCRIPTORS && STACK_TRACE_LIMIT in OriginalError) {\n    proxyAccessor(WrappedError, OriginalError, STACK_TRACE_LIMIT);\n    proxyAccessor(WrappedError, OriginalError, 'prepareStackTrace');\n  }\n\n  copyConstructorProperties(WrappedError, OriginalError);\n\n  if (!IS_PURE) try {\n    // Safari 13- bug: WebAssembly errors does not have a proper `.name`\n    if (OriginalErrorPrototype.name !== ERROR_NAME) {\n      createNonEnumerableProperty(OriginalErrorPrototype, 'name', ERROR_NAME);\n    }\n    OriginalErrorPrototype.constructor = WrappedError;\n  } catch (error) { /* empty */ }\n\n  return WrappedError;\n};\n","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * Error when sending message failed\n */\nexport class SendMessageError extends Error {\n    /**\n     * Initialize a SendMessageError\n     * @param message - The error message\n     * @param ackMessage - The ack message\n     */\n    constructor(message, options) {\n        super(message);\n        this.name = \"SendMessageError\";\n        this.ackId = options.ackId;\n        this.errorDetail = options.errorDetail;\n    }\n}\n//# sourceMappingURL=index.js.map","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n"],"sourceRoot":""}