{"version":3,"file":"react/js/vendor.microsoft@current-c090949d.0df2d1ba6c662c3075da.js","mappings":"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","sources":["webpack:///./node_modules/@microsoft/signalr/dist/esm/HttpClient.js","webpack:///./node_modules/@microsoft/signalr/dist/esm/HubConnection.js","webpack:///./node_modules/@microsoft/signalr/dist/esm/HttpConnection.js","webpack:///./node_modules/@microsoft/signalr/dist/esm/JsonHubProtocol.js","webpack:///./node_modules/@microsoft/signalr/dist/esm/HubConnectionBuilder.js","webpack:///./node_modules/@microsoft/signalr/dist/esm/IHubProtocol.js","webpack:///./node_modules/@microsoft/signalr/dist/esm/ILogger.js","webpack:///./node_modules/@microsoft/signalr/dist/esm/ITransport.js"],"sourcesContent":["// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n/** Represents an HTTP response. */\r\nexport class HttpResponse {\r\n    constructor(statusCode, statusText, content) {\r\n        this.statusCode = statusCode;\r\n        this.statusText = statusText;\r\n        this.content = content;\r\n    }\r\n}\r\n/** Abstraction over an HTTP client.\r\n *\r\n * This class provides an abstraction over an HTTP client so that a different implementation can be provided on different platforms.\r\n */\r\nexport class HttpClient {\r\n    get(url, options) {\r\n        return this.send({\r\n            ...options,\r\n            method: \"GET\",\r\n            url,\r\n        });\r\n    }\r\n    post(url, options) {\r\n        return this.send({\r\n            ...options,\r\n            method: \"POST\",\r\n            url,\r\n        });\r\n    }\r\n    delete(url, options) {\r\n        return this.send({\r\n            ...options,\r\n            method: \"DELETE\",\r\n            url,\r\n        });\r\n    }\r\n    /** Gets all cookies that apply to the specified URL.\r\n     *\r\n     * @param url The URL that the cookies are valid for.\r\n     * @returns {string} A string containing all the key-value cookie pairs for the specified URL.\r\n     */\r\n    // @ts-ignore\r\n    getCookieString(url) {\r\n        return \"\";\r\n    }\r\n}\r\n//# sourceMappingURL=HttpClient.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { HandshakeProtocol } from \"./HandshakeProtocol\";\r\nimport { AbortError } from \"./Errors\";\r\nimport { MessageType } from \"./IHubProtocol\";\r\nimport { LogLevel } from \"./ILogger\";\r\nimport { Subject } from \"./Subject\";\r\nimport { Arg, getErrorString, Platform } from \"./Utils\";\r\nimport { MessageBuffer } from \"./MessageBuffer\";\r\nconst DEFAULT_TIMEOUT_IN_MS = 30 * 1000;\r\nconst DEFAULT_PING_INTERVAL_IN_MS = 15 * 1000;\r\nconst DEFAULT_STATEFUL_RECONNECT_BUFFER_SIZE = 100000;\r\n/** Describes the current state of the {@link HubConnection} to the server. */\r\nexport var HubConnectionState;\r\n(function (HubConnectionState) {\r\n    /** The hub connection is disconnected. */\r\n    HubConnectionState[\"Disconnected\"] = \"Disconnected\";\r\n    /** The hub connection is connecting. */\r\n    HubConnectionState[\"Connecting\"] = \"Connecting\";\r\n    /** The hub connection is connected. */\r\n    HubConnectionState[\"Connected\"] = \"Connected\";\r\n    /** The hub connection is disconnecting. */\r\n    HubConnectionState[\"Disconnecting\"] = \"Disconnecting\";\r\n    /** The hub connection is reconnecting. */\r\n    HubConnectionState[\"Reconnecting\"] = \"Reconnecting\";\r\n})(HubConnectionState || (HubConnectionState = {}));\r\n/** Represents a connection to a SignalR Hub. */\r\nexport class HubConnection {\r\n    /** @internal */\r\n    // Using a public static factory method means we can have a private constructor and an _internal_\r\n    // create method that can be used by HubConnectionBuilder. An \"internal\" constructor would just\r\n    // be stripped away and the '.d.ts' file would have no constructor, which is interpreted as a\r\n    // public parameter-less constructor.\r\n    static create(connection, logger, protocol, reconnectPolicy, serverTimeoutInMilliseconds, keepAliveIntervalInMilliseconds, statefulReconnectBufferSize) {\r\n        return new HubConnection(connection, logger, protocol, reconnectPolicy, serverTimeoutInMilliseconds, keepAliveIntervalInMilliseconds, statefulReconnectBufferSize);\r\n    }\r\n    constructor(connection, logger, protocol, reconnectPolicy, serverTimeoutInMilliseconds, keepAliveIntervalInMilliseconds, statefulReconnectBufferSize) {\r\n        this._nextKeepAlive = 0;\r\n        this._freezeEventListener = () => {\r\n            this._logger.log(LogLevel.Warning, \"The page is being frozen, this will likely lead to the connection being closed and messages being lost. For more information see the docs at https://learn.microsoft.com/aspnet/core/signalr/javascript-client#bsleep\");\r\n        };\r\n        Arg.isRequired(connection, \"connection\");\r\n        Arg.isRequired(logger, \"logger\");\r\n        Arg.isRequired(protocol, \"protocol\");\r\n        this.serverTimeoutInMilliseconds = serverTimeoutInMilliseconds !== null && serverTimeoutInMilliseconds !== void 0 ? serverTimeoutInMilliseconds : DEFAULT_TIMEOUT_IN_MS;\r\n        this.keepAliveIntervalInMilliseconds = keepAliveIntervalInMilliseconds !== null && keepAliveIntervalInMilliseconds !== void 0 ? keepAliveIntervalInMilliseconds : DEFAULT_PING_INTERVAL_IN_MS;\r\n        this._statefulReconnectBufferSize = statefulReconnectBufferSize !== null && statefulReconnectBufferSize !== void 0 ? statefulReconnectBufferSize : DEFAULT_STATEFUL_RECONNECT_BUFFER_SIZE;\r\n        this._logger = logger;\r\n        this._protocol = protocol;\r\n        this.connection = connection;\r\n        this._reconnectPolicy = reconnectPolicy;\r\n        this._handshakeProtocol = new HandshakeProtocol();\r\n        this.connection.onreceive = (data) => this._processIncomingData(data);\r\n        this.connection.onclose = (error) => this._connectionClosed(error);\r\n        this._callbacks = {};\r\n        this._methods = {};\r\n        this._closedCallbacks = [];\r\n        this._reconnectingCallbacks = [];\r\n        this._reconnectedCallbacks = [];\r\n        this._invocationId = 0;\r\n        this._receivedHandshakeResponse = false;\r\n        this._connectionState = HubConnectionState.Disconnected;\r\n        this._connectionStarted = false;\r\n        this._cachedPingMessage = this._protocol.writeMessage({ type: MessageType.Ping });\r\n    }\r\n    /** Indicates the state of the {@link HubConnection} to the server. */\r\n    get state() {\r\n        return this._connectionState;\r\n    }\r\n    /** Represents the connection id of the {@link HubConnection} on the server. The connection id will be null when the connection is either\r\n     *  in the disconnected state or if the negotiation step was skipped.\r\n     */\r\n    get connectionId() {\r\n        return this.connection ? (this.connection.connectionId || null) : null;\r\n    }\r\n    /** Indicates the url of the {@link HubConnection} to the server. */\r\n    get baseUrl() {\r\n        return this.connection.baseUrl || \"\";\r\n    }\r\n    /**\r\n     * Sets a new url for the HubConnection. Note that the url can only be changed when the connection is in either the Disconnected or\r\n     * Reconnecting states.\r\n     * @param {string} url The url to connect to.\r\n     */\r\n    set baseUrl(url) {\r\n        if (this._connectionState !== HubConnectionState.Disconnected && this._connectionState !== HubConnectionState.Reconnecting) {\r\n            throw new Error(\"The HubConnection must be in the Disconnected or Reconnecting state to change the url.\");\r\n        }\r\n        if (!url) {\r\n            throw new Error(\"The HubConnection url must be a valid url.\");\r\n        }\r\n        this.connection.baseUrl = url;\r\n    }\r\n    /** Starts the connection.\r\n     *\r\n     * @returns {Promise<void>} A Promise that resolves when the connection has been successfully established, or rejects with an error.\r\n     */\r\n    start() {\r\n        this._startPromise = this._startWithStateTransitions();\r\n        return this._startPromise;\r\n    }\r\n    async _startWithStateTransitions() {\r\n        if (this._connectionState !== HubConnectionState.Disconnected) {\r\n            return Promise.reject(new Error(\"Cannot start a HubConnection that is not in the 'Disconnected' state.\"));\r\n        }\r\n        this._connectionState = HubConnectionState.Connecting;\r\n        this._logger.log(LogLevel.Debug, \"Starting HubConnection.\");\r\n        try {\r\n            await this._startInternal();\r\n            if (Platform.isBrowser) {\r\n                // Log when the browser freezes the tab so users know why their connection unexpectedly stopped working\r\n                window.document.addEventListener(\"freeze\", this._freezeEventListener);\r\n            }\r\n            this._connectionState = HubConnectionState.Connected;\r\n            this._connectionStarted = true;\r\n            this._logger.log(LogLevel.Debug, \"HubConnection connected successfully.\");\r\n        }\r\n        catch (e) {\r\n            this._connectionState = HubConnectionState.Disconnected;\r\n            this._logger.log(LogLevel.Debug, `HubConnection failed to start successfully because of error '${e}'.`);\r\n            return Promise.reject(e);\r\n        }\r\n    }\r\n    async _startInternal() {\r\n        this._stopDuringStartError = undefined;\r\n        this._receivedHandshakeResponse = false;\r\n        // Set up the promise before any connection is (re)started otherwise it could race with received messages\r\n        const handshakePromise = new Promise((resolve, reject) => {\r\n            this._handshakeResolver = resolve;\r\n            this._handshakeRejecter = reject;\r\n        });\r\n        await this.connection.start(this._protocol.transferFormat);\r\n        try {\r\n            let version = this._protocol.version;\r\n            if (!this.connection.features.reconnect) {\r\n                // Stateful Reconnect starts with HubProtocol version 2, newer clients connecting to older servers will fail to connect due to\r\n                // the handshake only supporting version 1, so we will try to send version 1 during the handshake to keep old servers working.\r\n                version = 1;\r\n            }\r\n            const handshakeRequest = {\r\n                protocol: this._protocol.name,\r\n                version,\r\n            };\r\n            this._logger.log(LogLevel.Debug, \"Sending handshake request.\");\r\n            await this._sendMessage(this._handshakeProtocol.writeHandshakeRequest(handshakeRequest));\r\n            this._logger.log(LogLevel.Information, `Using HubProtocol '${this._protocol.name}'.`);\r\n            // defensively cleanup timeout in case we receive a message from the server before we finish start\r\n            this._cleanupTimeout();\r\n            this._resetTimeoutPeriod();\r\n            this._resetKeepAliveInterval();\r\n            await handshakePromise;\r\n            // It's important to check the stopDuringStartError instead of just relying on the handshakePromise\r\n            // being rejected on close, because this continuation can run after both the handshake completed successfully\r\n            // and the connection was closed.\r\n            if (this._stopDuringStartError) {\r\n                // It's important to throw instead of returning a rejected promise, because we don't want to allow any state\r\n                // transitions to occur between now and the calling code observing the exceptions. Returning a rejected promise\r\n                // will cause the calling continuation to get scheduled to run later.\r\n                // eslint-disable-next-line @typescript-eslint/no-throw-literal\r\n                throw this._stopDuringStartError;\r\n            }\r\n            const useStatefulReconnect = this.connection.features.reconnect || false;\r\n            if (useStatefulReconnect) {\r\n                this._messageBuffer = new MessageBuffer(this._protocol, this.connection, this._statefulReconnectBufferSize);\r\n                this.connection.features.disconnected = this._messageBuffer._disconnected.bind(this._messageBuffer);\r\n                this.connection.features.resend = () => {\r\n                    if (this._messageBuffer) {\r\n                        return this._messageBuffer._resend();\r\n                    }\r\n                };\r\n            }\r\n            if (!this.connection.features.inherentKeepAlive) {\r\n                await this._sendMessage(this._cachedPingMessage);\r\n            }\r\n        }\r\n        catch (e) {\r\n            this._logger.log(LogLevel.Debug, `Hub handshake failed with error '${e}' during start(). Stopping HubConnection.`);\r\n            this._cleanupTimeout();\r\n            this._cleanupPingTimer();\r\n            // HttpConnection.stop() should not complete until after the onclose callback is invoked.\r\n            // This will transition the HubConnection to the disconnected state before HttpConnection.stop() completes.\r\n            await this.connection.stop(e);\r\n            throw e;\r\n        }\r\n    }\r\n    /** Stops the connection.\r\n     *\r\n     * @returns {Promise<void>} A Promise that resolves when the connection has been successfully terminated, or rejects with an error.\r\n     */\r\n    async stop() {\r\n        // Capture the start promise before the connection might be restarted in an onclose callback.\r\n        const startPromise = this._startPromise;\r\n        this.connection.features.reconnect = false;\r\n        this._stopPromise = this._stopInternal();\r\n        await this._stopPromise;\r\n        try {\r\n            // Awaiting undefined continues immediately\r\n            await startPromise;\r\n        }\r\n        catch (e) {\r\n            // This exception is returned to the user as a rejected Promise from the start method.\r\n        }\r\n    }\r\n    _stopInternal(error) {\r\n        if (this._connectionState === HubConnectionState.Disconnected) {\r\n            this._logger.log(LogLevel.Debug, `Call to HubConnection.stop(${error}) ignored because it is already in the disconnected state.`);\r\n            return Promise.resolve();\r\n        }\r\n        if (this._connectionState === HubConnectionState.Disconnecting) {\r\n            this._logger.log(LogLevel.Debug, `Call to HttpConnection.stop(${error}) ignored because the connection is already in the disconnecting state.`);\r\n            return this._stopPromise;\r\n        }\r\n        const state = this._connectionState;\r\n        this._connectionState = HubConnectionState.Disconnecting;\r\n        this._logger.log(LogLevel.Debug, \"Stopping HubConnection.\");\r\n        if (this._reconnectDelayHandle) {\r\n            // We're in a reconnect delay which means the underlying connection is currently already stopped.\r\n            // Just clear the handle to stop the reconnect loop (which no one is waiting on thankfully) and\r\n            // fire the onclose callbacks.\r\n            this._logger.log(LogLevel.Debug, \"Connection stopped during reconnect delay. Done reconnecting.\");\r\n            clearTimeout(this._reconnectDelayHandle);\r\n            this._reconnectDelayHandle = undefined;\r\n            this._completeClose();\r\n            return Promise.resolve();\r\n        }\r\n        if (state === HubConnectionState.Connected) {\r\n            // eslint-disable-next-line @typescript-eslint/no-floating-promises\r\n            this._sendCloseMessage();\r\n        }\r\n        this._cleanupTimeout();\r\n        this._cleanupPingTimer();\r\n        this._stopDuringStartError = error || new AbortError(\"The connection was stopped before the hub handshake could complete.\");\r\n        // HttpConnection.stop() should not complete until after either HttpConnection.start() fails\r\n        // or the onclose callback is invoked. The onclose callback will transition the HubConnection\r\n        // to the disconnected state if need be before HttpConnection.stop() completes.\r\n        return this.connection.stop(error);\r\n    }\r\n    async _sendCloseMessage() {\r\n        try {\r\n            await this._sendWithProtocol(this._createCloseMessage());\r\n        }\r\n        catch {\r\n            // Ignore, this is a best effort attempt to let the server know the client closed gracefully.\r\n        }\r\n    }\r\n    /** Invokes a streaming hub method on the server using the specified name and arguments.\r\n     *\r\n     * @typeparam T The type of the items returned by the server.\r\n     * @param {string} methodName The name of the server method to invoke.\r\n     * @param {any[]} args The arguments used to invoke the server method.\r\n     * @returns {IStreamResult<T>} An object that yields results from the server as they are received.\r\n     */\r\n    stream(methodName, ...args) {\r\n        const [streams, streamIds] = this._replaceStreamingParams(args);\r\n        const invocationDescriptor = this._createStreamInvocation(methodName, args, streamIds);\r\n        // eslint-disable-next-line prefer-const\r\n        let promiseQueue;\r\n        const subject = new Subject();\r\n        subject.cancelCallback = () => {\r\n            const cancelInvocation = this._createCancelInvocation(invocationDescriptor.invocationId);\r\n            delete this._callbacks[invocationDescriptor.invocationId];\r\n            return promiseQueue.then(() => {\r\n                return this._sendWithProtocol(cancelInvocation);\r\n            });\r\n        };\r\n        this._callbacks[invocationDescriptor.invocationId] = (invocationEvent, error) => {\r\n            if (error) {\r\n                subject.error(error);\r\n                return;\r\n            }\r\n            else if (invocationEvent) {\r\n                // invocationEvent will not be null when an error is not passed to the callback\r\n                if (invocationEvent.type === MessageType.Completion) {\r\n                    if (invocationEvent.error) {\r\n                        subject.error(new Error(invocationEvent.error));\r\n                    }\r\n                    else {\r\n                        subject.complete();\r\n                    }\r\n                }\r\n                else {\r\n                    subject.next((invocationEvent.item));\r\n                }\r\n            }\r\n        };\r\n        promiseQueue = this._sendWithProtocol(invocationDescriptor)\r\n            .catch((e) => {\r\n            subject.error(e);\r\n            delete this._callbacks[invocationDescriptor.invocationId];\r\n        });\r\n        this._launchStreams(streams, promiseQueue);\r\n        return subject;\r\n    }\r\n    _sendMessage(message) {\r\n        this._resetKeepAliveInterval();\r\n        return this.connection.send(message);\r\n    }\r\n    /**\r\n     * Sends a js object to the server.\r\n     * @param message The js object to serialize and send.\r\n     */\r\n    _sendWithProtocol(message) {\r\n        if (this._messageBuffer) {\r\n            return this._messageBuffer._send(message);\r\n        }\r\n        else {\r\n            return this._sendMessage(this._protocol.writeMessage(message));\r\n        }\r\n    }\r\n    /** Invokes a hub method on the server using the specified name and arguments. Does not wait for a response from the receiver.\r\n     *\r\n     * The Promise returned by this method resolves when the client has sent the invocation to the server. The server may still\r\n     * be processing the invocation.\r\n     *\r\n     * @param {string} methodName The name of the server method to invoke.\r\n     * @param {any[]} args The arguments used to invoke the server method.\r\n     * @returns {Promise<void>} A Promise that resolves when the invocation has been successfully sent, or rejects with an error.\r\n     */\r\n    send(methodName, ...args) {\r\n        const [streams, streamIds] = this._replaceStreamingParams(args);\r\n        const sendPromise = this._sendWithProtocol(this._createInvocation(methodName, args, true, streamIds));\r\n        this._launchStreams(streams, sendPromise);\r\n        return sendPromise;\r\n    }\r\n    /** Invokes a hub method on the server using the specified name and arguments.\r\n     *\r\n     * The Promise returned by this method resolves when the server indicates it has finished invoking the method. When the promise\r\n     * resolves, the server has finished invoking the method. If the server method returns a result, it is produced as the result of\r\n     * resolving the Promise.\r\n     *\r\n     * @typeparam T The expected return type.\r\n     * @param {string} methodName The name of the server method to invoke.\r\n     * @param {any[]} args The arguments used to invoke the server method.\r\n     * @returns {Promise<T>} A Promise that resolves with the result of the server method (if any), or rejects with an error.\r\n     */\r\n    invoke(methodName, ...args) {\r\n        const [streams, streamIds] = this._replaceStreamingParams(args);\r\n        const invocationDescriptor = this._createInvocation(methodName, args, false, streamIds);\r\n        const p = new Promise((resolve, reject) => {\r\n            // invocationId will always have a value for a non-blocking invocation\r\n            this._callbacks[invocationDescriptor.invocationId] = (invocationEvent, error) => {\r\n                if (error) {\r\n                    reject(error);\r\n                    return;\r\n                }\r\n                else if (invocationEvent) {\r\n                    // invocationEvent will not be null when an error is not passed to the callback\r\n                    if (invocationEvent.type === MessageType.Completion) {\r\n                        if (invocationEvent.error) {\r\n                            reject(new Error(invocationEvent.error));\r\n                        }\r\n                        else {\r\n                            resolve(invocationEvent.result);\r\n                        }\r\n                    }\r\n                    else {\r\n                        reject(new Error(`Unexpected message type: ${invocationEvent.type}`));\r\n                    }\r\n                }\r\n            };\r\n            const promiseQueue = this._sendWithProtocol(invocationDescriptor)\r\n                .catch((e) => {\r\n                reject(e);\r\n                // invocationId will always have a value for a non-blocking invocation\r\n                delete this._callbacks[invocationDescriptor.invocationId];\r\n            });\r\n            this._launchStreams(streams, promiseQueue);\r\n        });\r\n        return p;\r\n    }\r\n    on(methodName, newMethod) {\r\n        if (!methodName || !newMethod) {\r\n            return;\r\n        }\r\n        methodName = methodName.toLowerCase();\r\n        if (!this._methods[methodName]) {\r\n            this._methods[methodName] = [];\r\n        }\r\n        // Preventing adding the same handler multiple times.\r\n        if (this._methods[methodName].indexOf(newMethod) !== -1) {\r\n            return;\r\n        }\r\n        this._methods[methodName].push(newMethod);\r\n    }\r\n    off(methodName, method) {\r\n        if (!methodName) {\r\n            return;\r\n        }\r\n        methodName = methodName.toLowerCase();\r\n        const handlers = this._methods[methodName];\r\n        if (!handlers) {\r\n            return;\r\n        }\r\n        if (method) {\r\n            const removeIdx = handlers.indexOf(method);\r\n            if (removeIdx !== -1) {\r\n                handlers.splice(removeIdx, 1);\r\n                if (handlers.length === 0) {\r\n                    delete this._methods[methodName];\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            delete this._methods[methodName];\r\n        }\r\n    }\r\n    /** Registers a handler that will be invoked when the connection is closed.\r\n     *\r\n     * @param {Function} callback The handler that will be invoked when the connection is closed. Optionally receives a single argument containing the error that caused the connection to close (if any).\r\n     */\r\n    onclose(callback) {\r\n        if (callback) {\r\n            this._closedCallbacks.push(callback);\r\n        }\r\n    }\r\n    /** Registers a handler that will be invoked when the connection starts reconnecting.\r\n     *\r\n     * @param {Function} callback The handler that will be invoked when the connection starts reconnecting. Optionally receives a single argument containing the error that caused the connection to start reconnecting (if any).\r\n     */\r\n    onreconnecting(callback) {\r\n        if (callback) {\r\n            this._reconnectingCallbacks.push(callback);\r\n        }\r\n    }\r\n    /** Registers a handler that will be invoked when the connection successfully reconnects.\r\n     *\r\n     * @param {Function} callback The handler that will be invoked when the connection successfully reconnects.\r\n     */\r\n    onreconnected(callback) {\r\n        if (callback) {\r\n            this._reconnectedCallbacks.push(callback);\r\n        }\r\n    }\r\n    _processIncomingData(data) {\r\n        this._cleanupTimeout();\r\n        if (!this._receivedHandshakeResponse) {\r\n            data = this._processHandshakeResponse(data);\r\n            this._receivedHandshakeResponse = true;\r\n        }\r\n        // Data may have all been read when processing handshake response\r\n        if (data) {\r\n            // Parse the messages\r\n            const messages = this._protocol.parseMessages(data, this._logger);\r\n            for (const message of messages) {\r\n                if (this._messageBuffer && !this._messageBuffer._shouldProcessMessage(message)) {\r\n                    // Don't process the message, we are either waiting for a SequenceMessage or received a duplicate message\r\n                    continue;\r\n                }\r\n                switch (message.type) {\r\n                    case MessageType.Invocation:\r\n                        // eslint-disable-next-line @typescript-eslint/no-floating-promises\r\n                        this._invokeClientMethod(message);\r\n                        break;\r\n                    case MessageType.StreamItem:\r\n                    case MessageType.Completion: {\r\n                        const callback = this._callbacks[message.invocationId];\r\n                        if (callback) {\r\n                            if (message.type === MessageType.Completion) {\r\n                                delete this._callbacks[message.invocationId];\r\n                            }\r\n                            try {\r\n                                callback(message);\r\n                            }\r\n                            catch (e) {\r\n                                this._logger.log(LogLevel.Error, `Stream callback threw error: ${getErrorString(e)}`);\r\n                            }\r\n                        }\r\n                        break;\r\n                    }\r\n                    case MessageType.Ping:\r\n                        // Don't care about pings\r\n                        break;\r\n                    case MessageType.Close: {\r\n                        this._logger.log(LogLevel.Information, \"Close message received from server.\");\r\n                        const error = message.error ? new Error(\"Server returned an error on close: \" + message.error) : undefined;\r\n                        if (message.allowReconnect === true) {\r\n                            // It feels wrong not to await connection.stop() here, but processIncomingData is called as part of an onreceive callback which is not async,\r\n                            // this is already the behavior for serverTimeout(), and HttpConnection.Stop() should catch and log all possible exceptions.\r\n                            // eslint-disable-next-line @typescript-eslint/no-floating-promises\r\n                            this.connection.stop(error);\r\n                        }\r\n                        else {\r\n                            // We cannot await stopInternal() here, but subsequent calls to stop() will await this if stopInternal() is still ongoing.\r\n                            this._stopPromise = this._stopInternal(error);\r\n                        }\r\n                        break;\r\n                    }\r\n                    case MessageType.Ack:\r\n                        if (this._messageBuffer) {\r\n                            this._messageBuffer._ack(message);\r\n                        }\r\n                        break;\r\n                    case MessageType.Sequence:\r\n                        if (this._messageBuffer) {\r\n                            this._messageBuffer._resetSequence(message);\r\n                        }\r\n                        break;\r\n                    default:\r\n                        this._logger.log(LogLevel.Warning, `Invalid message type: ${message.type}.`);\r\n                        break;\r\n                }\r\n            }\r\n        }\r\n        this._resetTimeoutPeriod();\r\n    }\r\n    _processHandshakeResponse(data) {\r\n        let responseMessage;\r\n        let remainingData;\r\n        try {\r\n            [remainingData, responseMessage] = this._handshakeProtocol.parseHandshakeResponse(data);\r\n        }\r\n        catch (e) {\r\n            const message = \"Error parsing handshake response: \" + e;\r\n            this._logger.log(LogLevel.Error, message);\r\n            const error = new Error(message);\r\n            this._handshakeRejecter(error);\r\n            throw error;\r\n        }\r\n        if (responseMessage.error) {\r\n            const message = \"Server returned handshake error: \" + responseMessage.error;\r\n            this._logger.log(LogLevel.Error, message);\r\n            const error = new Error(message);\r\n            this._handshakeRejecter(error);\r\n            throw error;\r\n        }\r\n        else {\r\n            this._logger.log(LogLevel.Debug, \"Server handshake complete.\");\r\n        }\r\n        this._handshakeResolver();\r\n        return remainingData;\r\n    }\r\n    _resetKeepAliveInterval() {\r\n        if (this.connection.features.inherentKeepAlive) {\r\n            return;\r\n        }\r\n        // Set the time we want the next keep alive to be sent\r\n        // Timer will be setup on next message receive\r\n        this._nextKeepAlive = new Date().getTime() + this.keepAliveIntervalInMilliseconds;\r\n        this._cleanupPingTimer();\r\n    }\r\n    _resetTimeoutPeriod() {\r\n        if (!this.connection.features || !this.connection.features.inherentKeepAlive) {\r\n            // Set the timeout timer\r\n            this._timeoutHandle = setTimeout(() => this.serverTimeout(), this.serverTimeoutInMilliseconds);\r\n            // Set keepAlive timer if there isn't one\r\n            if (this._pingServerHandle === undefined) {\r\n                let nextPing = this._nextKeepAlive - new Date().getTime();\r\n                if (nextPing < 0) {\r\n                    nextPing = 0;\r\n                }\r\n                // The timer needs to be set from a networking callback to avoid Chrome timer throttling from causing timers to run once a minute\r\n                this._pingServerHandle = setTimeout(async () => {\r\n                    if (this._connectionState === HubConnectionState.Connected) {\r\n                        try {\r\n                            await this._sendMessage(this._cachedPingMessage);\r\n                        }\r\n                        catch {\r\n                            // We don't care about the error. It should be seen elsewhere in the client.\r\n                            // The connection is probably in a bad or closed state now, cleanup the timer so it stops triggering\r\n                            this._cleanupPingTimer();\r\n                        }\r\n                    }\r\n                }, nextPing);\r\n            }\r\n        }\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/naming-convention\r\n    serverTimeout() {\r\n        // The server hasn't talked to us in a while. It doesn't like us anymore ... :(\r\n        // Terminate the connection, but we don't need to wait on the promise. This could trigger reconnecting.\r\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\r\n        this.connection.stop(new Error(\"Server timeout elapsed without receiving a message from the server.\"));\r\n    }\r\n    async _invokeClientMethod(invocationMessage) {\r\n        const methodName = invocationMessage.target.toLowerCase();\r\n        const methods = this._methods[methodName];\r\n        if (!methods) {\r\n            this._logger.log(LogLevel.Warning, `No client method with the name '${methodName}' found.`);\r\n            // No handlers provided by client but the server is expecting a response still, so we send an error\r\n            if (invocationMessage.invocationId) {\r\n                this._logger.log(LogLevel.Warning, `No result given for '${methodName}' method and invocation ID '${invocationMessage.invocationId}'.`);\r\n                await this._sendWithProtocol(this._createCompletionMessage(invocationMessage.invocationId, \"Client didn't provide a result.\", null));\r\n            }\r\n            return;\r\n        }\r\n        // Avoid issues with handlers removing themselves thus modifying the list while iterating through it\r\n        const methodsCopy = methods.slice();\r\n        // Server expects a response\r\n        const expectsResponse = invocationMessage.invocationId ? true : false;\r\n        // We preserve the last result or exception but still call all handlers\r\n        let res;\r\n        let exception;\r\n        let completionMessage;\r\n        for (const m of methodsCopy) {\r\n            try {\r\n                const prevRes = res;\r\n                res = await m.apply(this, invocationMessage.arguments);\r\n                if (expectsResponse && res && prevRes) {\r\n                    this._logger.log(LogLevel.Error, `Multiple results provided for '${methodName}'. Sending error to server.`);\r\n                    completionMessage = this._createCompletionMessage(invocationMessage.invocationId, `Client provided multiple results.`, null);\r\n                }\r\n                // Ignore exception if we got a result after, the exception will be logged\r\n                exception = undefined;\r\n            }\r\n            catch (e) {\r\n                exception = e;\r\n                this._logger.log(LogLevel.Error, `A callback for the method '${methodName}' threw error '${e}'.`);\r\n            }\r\n        }\r\n        if (completionMessage) {\r\n            await this._sendWithProtocol(completionMessage);\r\n        }\r\n        else if (expectsResponse) {\r\n            // If there is an exception that means either no result was given or a handler after a result threw\r\n            if (exception) {\r\n                completionMessage = this._createCompletionMessage(invocationMessage.invocationId, `${exception}`, null);\r\n            }\r\n            else if (res !== undefined) {\r\n                completionMessage = this._createCompletionMessage(invocationMessage.invocationId, null, res);\r\n            }\r\n            else {\r\n                this._logger.log(LogLevel.Warning, `No result given for '${methodName}' method and invocation ID '${invocationMessage.invocationId}'.`);\r\n                // Client didn't provide a result or throw from a handler, server expects a response so we send an error\r\n                completionMessage = this._createCompletionMessage(invocationMessage.invocationId, \"Client didn't provide a result.\", null);\r\n            }\r\n            await this._sendWithProtocol(completionMessage);\r\n        }\r\n        else {\r\n            if (res) {\r\n                this._logger.log(LogLevel.Error, `Result given for '${methodName}' method but server is not expecting a result.`);\r\n            }\r\n        }\r\n    }\r\n    _connectionClosed(error) {\r\n        this._logger.log(LogLevel.Debug, `HubConnection.connectionClosed(${error}) called while in state ${this._connectionState}.`);\r\n        // Triggering this.handshakeRejecter is insufficient because it could already be resolved without the continuation having run yet.\r\n        this._stopDuringStartError = this._stopDuringStartError || error || new AbortError(\"The underlying connection was closed before the hub handshake could complete.\");\r\n        // If the handshake is in progress, start will be waiting for the handshake promise, so we complete it.\r\n        // If it has already completed, this should just noop.\r\n        if (this._handshakeResolver) {\r\n            this._handshakeResolver();\r\n        }\r\n        this._cancelCallbacksWithError(error || new Error(\"Invocation canceled due to the underlying connection being closed.\"));\r\n        this._cleanupTimeout();\r\n        this._cleanupPingTimer();\r\n        if (this._connectionState === HubConnectionState.Disconnecting) {\r\n            this._completeClose(error);\r\n        }\r\n        else if (this._connectionState === HubConnectionState.Connected && this._reconnectPolicy) {\r\n            // eslint-disable-next-line @typescript-eslint/no-floating-promises\r\n            this._reconnect(error);\r\n        }\r\n        else if (this._connectionState === HubConnectionState.Connected) {\r\n            this._completeClose(error);\r\n        }\r\n        // If none of the above if conditions were true were called the HubConnection must be in either:\r\n        // 1. The Connecting state in which case the handshakeResolver will complete it and stopDuringStartError will fail it.\r\n        // 2. The Reconnecting state in which case the handshakeResolver will complete it and stopDuringStartError will fail the current reconnect attempt\r\n        //    and potentially continue the reconnect() loop.\r\n        // 3. The Disconnected state in which case we're already done.\r\n    }\r\n    _completeClose(error) {\r\n        if (this._connectionStarted) {\r\n            this._connectionState = HubConnectionState.Disconnected;\r\n            this._connectionStarted = false;\r\n            if (this._messageBuffer) {\r\n                this._messageBuffer._dispose(error !== null && error !== void 0 ? error : new Error(\"Connection closed.\"));\r\n                this._messageBuffer = undefined;\r\n            }\r\n            if (Platform.isBrowser) {\r\n                window.document.removeEventListener(\"freeze\", this._freezeEventListener);\r\n            }\r\n            try {\r\n                this._closedCallbacks.forEach((c) => c.apply(this, [error]));\r\n            }\r\n            catch (e) {\r\n                this._logger.log(LogLevel.Error, `An onclose callback called with error '${error}' threw error '${e}'.`);\r\n            }\r\n        }\r\n    }\r\n    async _reconnect(error) {\r\n        const reconnectStartTime = Date.now();\r\n        let previousReconnectAttempts = 0;\r\n        let retryError = error !== undefined ? error : new Error(\"Attempting to reconnect due to a unknown error.\");\r\n        let nextRetryDelay = this._getNextRetryDelay(previousReconnectAttempts++, 0, retryError);\r\n        if (nextRetryDelay === null) {\r\n            this._logger.log(LogLevel.Debug, \"Connection not reconnecting because the IRetryPolicy returned null on the first reconnect attempt.\");\r\n            this._completeClose(error);\r\n            return;\r\n        }\r\n        this._connectionState = HubConnectionState.Reconnecting;\r\n        if (error) {\r\n            this._logger.log(LogLevel.Information, `Connection reconnecting because of error '${error}'.`);\r\n        }\r\n        else {\r\n            this._logger.log(LogLevel.Information, \"Connection reconnecting.\");\r\n        }\r\n        if (this._reconnectingCallbacks.length !== 0) {\r\n            try {\r\n                this._reconnectingCallbacks.forEach((c) => c.apply(this, [error]));\r\n            }\r\n            catch (e) {\r\n                this._logger.log(LogLevel.Error, `An onreconnecting callback called with error '${error}' threw error '${e}'.`);\r\n            }\r\n            // Exit early if an onreconnecting callback called connection.stop().\r\n            if (this._connectionState !== HubConnectionState.Reconnecting) {\r\n                this._logger.log(LogLevel.Debug, \"Connection left the reconnecting state in onreconnecting callback. Done reconnecting.\");\r\n                return;\r\n            }\r\n        }\r\n        while (nextRetryDelay !== null) {\r\n            this._logger.log(LogLevel.Information, `Reconnect attempt number ${previousReconnectAttempts} will start in ${nextRetryDelay} ms.`);\r\n            await new Promise((resolve) => {\r\n                this._reconnectDelayHandle = setTimeout(resolve, nextRetryDelay);\r\n            });\r\n            this._reconnectDelayHandle = undefined;\r\n            if (this._connectionState !== HubConnectionState.Reconnecting) {\r\n                this._logger.log(LogLevel.Debug, \"Connection left the reconnecting state during reconnect delay. Done reconnecting.\");\r\n                return;\r\n            }\r\n            try {\r\n                await this._startInternal();\r\n                this._connectionState = HubConnectionState.Connected;\r\n                this._logger.log(LogLevel.Information, \"HubConnection reconnected successfully.\");\r\n                if (this._reconnectedCallbacks.length !== 0) {\r\n                    try {\r\n                        this._reconnectedCallbacks.forEach((c) => c.apply(this, [this.connection.connectionId]));\r\n                    }\r\n                    catch (e) {\r\n                        this._logger.log(LogLevel.Error, `An onreconnected callback called with connectionId '${this.connection.connectionId}; threw error '${e}'.`);\r\n                    }\r\n                }\r\n                return;\r\n            }\r\n            catch (e) {\r\n                this._logger.log(LogLevel.Information, `Reconnect attempt failed because of error '${e}'.`);\r\n                if (this._connectionState !== HubConnectionState.Reconnecting) {\r\n                    this._logger.log(LogLevel.Debug, `Connection moved to the '${this._connectionState}' from the reconnecting state during reconnect attempt. Done reconnecting.`);\r\n                    // The TypeScript compiler thinks that connectionState must be Connected here. The TypeScript compiler is wrong.\r\n                    if (this._connectionState === HubConnectionState.Disconnecting) {\r\n                        this._completeClose();\r\n                    }\r\n                    return;\r\n                }\r\n                retryError = e instanceof Error ? e : new Error(e.toString());\r\n                nextRetryDelay = this._getNextRetryDelay(previousReconnectAttempts++, Date.now() - reconnectStartTime, retryError);\r\n            }\r\n        }\r\n        this._logger.log(LogLevel.Information, `Reconnect retries have been exhausted after ${Date.now() - reconnectStartTime} ms and ${previousReconnectAttempts} failed attempts. Connection disconnecting.`);\r\n        this._completeClose();\r\n    }\r\n    _getNextRetryDelay(previousRetryCount, elapsedMilliseconds, retryReason) {\r\n        try {\r\n            return this._reconnectPolicy.nextRetryDelayInMilliseconds({\r\n                elapsedMilliseconds,\r\n                previousRetryCount,\r\n                retryReason,\r\n            });\r\n        }\r\n        catch (e) {\r\n            this._logger.log(LogLevel.Error, `IRetryPolicy.nextRetryDelayInMilliseconds(${previousRetryCount}, ${elapsedMilliseconds}) threw error '${e}'.`);\r\n            return null;\r\n        }\r\n    }\r\n    _cancelCallbacksWithError(error) {\r\n        const callbacks = this._callbacks;\r\n        this._callbacks = {};\r\n        Object.keys(callbacks)\r\n            .forEach((key) => {\r\n            const callback = callbacks[key];\r\n            try {\r\n                callback(null, error);\r\n            }\r\n            catch (e) {\r\n                this._logger.log(LogLevel.Error, `Stream 'error' callback called with '${error}' threw error: ${getErrorString(e)}`);\r\n            }\r\n        });\r\n    }\r\n    _cleanupPingTimer() {\r\n        if (this._pingServerHandle) {\r\n            clearTimeout(this._pingServerHandle);\r\n            this._pingServerHandle = undefined;\r\n        }\r\n    }\r\n    _cleanupTimeout() {\r\n        if (this._timeoutHandle) {\r\n            clearTimeout(this._timeoutHandle);\r\n        }\r\n    }\r\n    _createInvocation(methodName, args, nonblocking, streamIds) {\r\n        if (nonblocking) {\r\n            if (streamIds.length !== 0) {\r\n                return {\r\n                    arguments: args,\r\n                    streamIds,\r\n                    target: methodName,\r\n                    type: MessageType.Invocation,\r\n                };\r\n            }\r\n            else {\r\n                return {\r\n                    arguments: args,\r\n                    target: methodName,\r\n                    type: MessageType.Invocation,\r\n                };\r\n            }\r\n        }\r\n        else {\r\n            const invocationId = this._invocationId;\r\n            this._invocationId++;\r\n            if (streamIds.length !== 0) {\r\n                return {\r\n                    arguments: args,\r\n                    invocationId: invocationId.toString(),\r\n                    streamIds,\r\n                    target: methodName,\r\n                    type: MessageType.Invocation,\r\n                };\r\n            }\r\n            else {\r\n                return {\r\n                    arguments: args,\r\n                    invocationId: invocationId.toString(),\r\n                    target: methodName,\r\n                    type: MessageType.Invocation,\r\n                };\r\n            }\r\n        }\r\n    }\r\n    _launchStreams(streams, promiseQueue) {\r\n        if (streams.length === 0) {\r\n            return;\r\n        }\r\n        // Synchronize stream data so they arrive in-order on the server\r\n        if (!promiseQueue) {\r\n            promiseQueue = Promise.resolve();\r\n        }\r\n        // We want to iterate over the keys, since the keys are the stream ids\r\n        // eslint-disable-next-line guard-for-in\r\n        for (const streamId in streams) {\r\n            streams[streamId].subscribe({\r\n                complete: () => {\r\n                    promiseQueue = promiseQueue.then(() => this._sendWithProtocol(this._createCompletionMessage(streamId)));\r\n                },\r\n                error: (err) => {\r\n                    let message;\r\n                    if (err instanceof Error) {\r\n                        message = err.message;\r\n                    }\r\n                    else if (err && err.toString) {\r\n                        message = err.toString();\r\n                    }\r\n                    else {\r\n                        message = \"Unknown error\";\r\n                    }\r\n                    promiseQueue = promiseQueue.then(() => this._sendWithProtocol(this._createCompletionMessage(streamId, message)));\r\n                },\r\n                next: (item) => {\r\n                    promiseQueue = promiseQueue.then(() => this._sendWithProtocol(this._createStreamItemMessage(streamId, item)));\r\n                },\r\n            });\r\n        }\r\n    }\r\n    _replaceStreamingParams(args) {\r\n        const streams = [];\r\n        const streamIds = [];\r\n        for (let i = 0; i < args.length; i++) {\r\n            const argument = args[i];\r\n            if (this._isObservable(argument)) {\r\n                const streamId = this._invocationId;\r\n                this._invocationId++;\r\n                // Store the stream for later use\r\n                streams[streamId] = argument;\r\n                streamIds.push(streamId.toString());\r\n                // remove stream from args\r\n                args.splice(i, 1);\r\n            }\r\n        }\r\n        return [streams, streamIds];\r\n    }\r\n    _isObservable(arg) {\r\n        // This allows other stream implementations to just work (like rxjs)\r\n        return arg && arg.subscribe && typeof arg.subscribe === \"function\";\r\n    }\r\n    _createStreamInvocation(methodName, args, streamIds) {\r\n        const invocationId = this._invocationId;\r\n        this._invocationId++;\r\n        if (streamIds.length !== 0) {\r\n            return {\r\n                arguments: args,\r\n                invocationId: invocationId.toString(),\r\n                streamIds,\r\n                target: methodName,\r\n                type: MessageType.StreamInvocation,\r\n            };\r\n        }\r\n        else {\r\n            return {\r\n                arguments: args,\r\n                invocationId: invocationId.toString(),\r\n                target: methodName,\r\n                type: MessageType.StreamInvocation,\r\n            };\r\n        }\r\n    }\r\n    _createCancelInvocation(id) {\r\n        return {\r\n            invocationId: id,\r\n            type: MessageType.CancelInvocation,\r\n        };\r\n    }\r\n    _createStreamItemMessage(id, item) {\r\n        return {\r\n            invocationId: id,\r\n            item,\r\n            type: MessageType.StreamItem,\r\n        };\r\n    }\r\n    _createCompletionMessage(id, error, result) {\r\n        if (error) {\r\n            return {\r\n                error,\r\n                invocationId: id,\r\n                type: MessageType.Completion,\r\n            };\r\n        }\r\n        return {\r\n            invocationId: id,\r\n            result,\r\n            type: MessageType.Completion,\r\n        };\r\n    }\r\n    _createCloseMessage() {\r\n        return { type: MessageType.Close };\r\n    }\r\n}\r\n//# sourceMappingURL=HubConnection.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { AccessTokenHttpClient } from \"./AccessTokenHttpClient\";\r\nimport { DefaultHttpClient } from \"./DefaultHttpClient\";\r\nimport { getEventSource, getWS } from \"./DynamicImports\";\r\nimport { AggregateErrors, DisabledTransportError, FailedToNegotiateWithServerError, FailedToStartTransportError, HttpError, UnsupportedTransportError, AbortError } from \"./Errors\";\r\nimport { LogLevel } from \"./ILogger\";\r\nimport { HttpTransportType, TransferFormat } from \"./ITransport\";\r\nimport { LongPollingTransport } from \"./LongPollingTransport\";\r\nimport { ServerSentEventsTransport } from \"./ServerSentEventsTransport\";\r\nimport { Arg, createLogger, getUserAgentHeader, Platform } from \"./Utils\";\r\nimport { WebSocketTransport } from \"./WebSocketTransport\";\r\nconst MAX_REDIRECTS = 100;\r\n/** @private */\r\nexport class HttpConnection {\r\n    constructor(url, options = {}) {\r\n        this._stopPromiseResolver = () => { };\r\n        this.features = {};\r\n        this._negotiateVersion = 1;\r\n        Arg.isRequired(url, \"url\");\r\n        this._logger = createLogger(options.logger);\r\n        this.baseUrl = this._resolveUrl(url);\r\n        options = options || {};\r\n        options.logMessageContent = options.logMessageContent === undefined ? false : options.logMessageContent;\r\n        if (typeof options.withCredentials === \"boolean\" || options.withCredentials === undefined) {\r\n            options.withCredentials = options.withCredentials === undefined ? true : options.withCredentials;\r\n        }\r\n        else {\r\n            throw new Error(\"withCredentials option was not a 'boolean' or 'undefined' value\");\r\n        }\r\n        options.timeout = options.timeout === undefined ? 100 * 1000 : options.timeout;\r\n        let webSocketModule = null;\r\n        let eventSourceModule = null;\r\n        if (Platform.isNode && typeof require !== \"undefined\") {\r\n            webSocketModule = getWS();\r\n            eventSourceModule = getEventSource();\r\n        }\r\n        if (!Platform.isNode && typeof WebSocket !== \"undefined\" && !options.WebSocket) {\r\n            options.WebSocket = WebSocket;\r\n        }\r\n        else if (Platform.isNode && !options.WebSocket) {\r\n            if (webSocketModule) {\r\n                options.WebSocket = webSocketModule;\r\n            }\r\n        }\r\n        if (!Platform.isNode && typeof EventSource !== \"undefined\" && !options.EventSource) {\r\n            options.EventSource = EventSource;\r\n        }\r\n        else if (Platform.isNode && !options.EventSource) {\r\n            if (typeof eventSourceModule !== \"undefined\") {\r\n                options.EventSource = eventSourceModule;\r\n            }\r\n        }\r\n        this._httpClient = new AccessTokenHttpClient(options.httpClient || new DefaultHttpClient(this._logger), options.accessTokenFactory);\r\n        this._connectionState = \"Disconnected\" /* ConnectionState.Disconnected */;\r\n        this._connectionStarted = false;\r\n        this._options = options;\r\n        this.onreceive = null;\r\n        this.onclose = null;\r\n    }\r\n    async start(transferFormat) {\r\n        transferFormat = transferFormat || TransferFormat.Binary;\r\n        Arg.isIn(transferFormat, TransferFormat, \"transferFormat\");\r\n        this._logger.log(LogLevel.Debug, `Starting connection with transfer format '${TransferFormat[transferFormat]}'.`);\r\n        if (this._connectionState !== \"Disconnected\" /* ConnectionState.Disconnected */) {\r\n            return Promise.reject(new Error(\"Cannot start an HttpConnection that is not in the 'Disconnected' state.\"));\r\n        }\r\n        this._connectionState = \"Connecting\" /* ConnectionState.Connecting */;\r\n        this._startInternalPromise = this._startInternal(transferFormat);\r\n        await this._startInternalPromise;\r\n        // The TypeScript compiler thinks that connectionState must be Connecting here. The TypeScript compiler is wrong.\r\n        if (this._connectionState === \"Disconnecting\" /* ConnectionState.Disconnecting */) {\r\n            // stop() was called and transitioned the client into the Disconnecting state.\r\n            const message = \"Failed to start the HttpConnection before stop() was called.\";\r\n            this._logger.log(LogLevel.Error, message);\r\n            // We cannot await stopPromise inside startInternal since stopInternal awaits the startInternalPromise.\r\n            await this._stopPromise;\r\n            return Promise.reject(new AbortError(message));\r\n        }\r\n        else if (this._connectionState !== \"Connected\" /* ConnectionState.Connected */) {\r\n            // stop() was called and transitioned the client into the Disconnecting state.\r\n            const message = \"HttpConnection.startInternal completed gracefully but didn't enter the connection into the connected state!\";\r\n            this._logger.log(LogLevel.Error, message);\r\n            return Promise.reject(new AbortError(message));\r\n        }\r\n        this._connectionStarted = true;\r\n    }\r\n    send(data) {\r\n        if (this._connectionState !== \"Connected\" /* ConnectionState.Connected */) {\r\n            return Promise.reject(new Error(\"Cannot send data if the connection is not in the 'Connected' State.\"));\r\n        }\r\n        if (!this._sendQueue) {\r\n            this._sendQueue = new TransportSendQueue(this.transport);\r\n        }\r\n        // Transport will not be null if state is connected\r\n        return this._sendQueue.send(data);\r\n    }\r\n    async stop(error) {\r\n        if (this._connectionState === \"Disconnected\" /* ConnectionState.Disconnected */) {\r\n            this._logger.log(LogLevel.Debug, `Call to HttpConnection.stop(${error}) ignored because the connection is already in the disconnected state.`);\r\n            return Promise.resolve();\r\n        }\r\n        if (this._connectionState === \"Disconnecting\" /* ConnectionState.Disconnecting */) {\r\n            this._logger.log(LogLevel.Debug, `Call to HttpConnection.stop(${error}) ignored because the connection is already in the disconnecting state.`);\r\n            return this._stopPromise;\r\n        }\r\n        this._connectionState = \"Disconnecting\" /* ConnectionState.Disconnecting */;\r\n        this._stopPromise = new Promise((resolve) => {\r\n            // Don't complete stop() until stopConnection() completes.\r\n            this._stopPromiseResolver = resolve;\r\n        });\r\n        // stopInternal should never throw so just observe it.\r\n        await this._stopInternal(error);\r\n        await this._stopPromise;\r\n    }\r\n    async _stopInternal(error) {\r\n        // Set error as soon as possible otherwise there is a race between\r\n        // the transport closing and providing an error and the error from a close message\r\n        // We would prefer the close message error.\r\n        this._stopError = error;\r\n        try {\r\n            await this._startInternalPromise;\r\n        }\r\n        catch (e) {\r\n            // This exception is returned to the user as a rejected Promise from the start method.\r\n        }\r\n        // The transport's onclose will trigger stopConnection which will run our onclose event.\r\n        // The transport should always be set if currently connected. If it wasn't set, it's likely because\r\n        // stop was called during start() and start() failed.\r\n        if (this.transport) {\r\n            try {\r\n                await this.transport.stop();\r\n            }\r\n            catch (e) {\r\n                this._logger.log(LogLevel.Error, `HttpConnection.transport.stop() threw error '${e}'.`);\r\n                this._stopConnection();\r\n            }\r\n            this.transport = undefined;\r\n        }\r\n        else {\r\n            this._logger.log(LogLevel.Debug, \"HttpConnection.transport is undefined in HttpConnection.stop() because start() failed.\");\r\n        }\r\n    }\r\n    async _startInternal(transferFormat) {\r\n        // Store the original base url and the access token factory since they may change\r\n        // as part of negotiating\r\n        let url = this.baseUrl;\r\n        this._accessTokenFactory = this._options.accessTokenFactory;\r\n        this._httpClient._accessTokenFactory = this._accessTokenFactory;\r\n        try {\r\n            if (this._options.skipNegotiation) {\r\n                if (this._options.transport === HttpTransportType.WebSockets) {\r\n                    // No need to add a connection ID in this case\r\n                    this.transport = this._constructTransport(HttpTransportType.WebSockets);\r\n                    // We should just call connect directly in this case.\r\n                    // No fallback or negotiate in this case.\r\n                    await this._startTransport(url, transferFormat);\r\n                }\r\n                else {\r\n                    throw new Error(\"Negotiation can only be skipped when using the WebSocket transport directly.\");\r\n                }\r\n            }\r\n            else {\r\n                let negotiateResponse = null;\r\n                let redirects = 0;\r\n                do {\r\n                    negotiateResponse = await this._getNegotiationResponse(url);\r\n                    // the user tries to stop the connection when it is being started\r\n                    if (this._connectionState === \"Disconnecting\" /* ConnectionState.Disconnecting */ || this._connectionState === \"Disconnected\" /* ConnectionState.Disconnected */) {\r\n                        throw new AbortError(\"The connection was stopped during negotiation.\");\r\n                    }\r\n                    if (negotiateResponse.error) {\r\n                        throw new Error(negotiateResponse.error);\r\n                    }\r\n                    if (negotiateResponse.ProtocolVersion) {\r\n                        throw new Error(\"Detected a connection attempt to an ASP.NET SignalR Server. This client only supports connecting to an ASP.NET Core SignalR Server. See https://aka.ms/signalr-core-differences for details.\");\r\n                    }\r\n                    if (negotiateResponse.url) {\r\n                        url = negotiateResponse.url;\r\n                    }\r\n                    if (negotiateResponse.accessToken) {\r\n                        // Replace the current access token factory with one that uses\r\n                        // the returned access token\r\n                        const accessToken = negotiateResponse.accessToken;\r\n                        this._accessTokenFactory = () => accessToken;\r\n                        // set the factory to undefined so the AccessTokenHttpClient won't retry with the same token, since we know it won't change until a connection restart\r\n                        this._httpClient._accessToken = accessToken;\r\n                        this._httpClient._accessTokenFactory = undefined;\r\n                    }\r\n                    redirects++;\r\n                } while (negotiateResponse.url && redirects < MAX_REDIRECTS);\r\n                if (redirects === MAX_REDIRECTS && negotiateResponse.url) {\r\n                    throw new Error(\"Negotiate redirection limit exceeded.\");\r\n                }\r\n                await this._createTransport(url, this._options.transport, negotiateResponse, transferFormat);\r\n            }\r\n            if (this.transport instanceof LongPollingTransport) {\r\n                this.features.inherentKeepAlive = true;\r\n            }\r\n            if (this._connectionState === \"Connecting\" /* ConnectionState.Connecting */) {\r\n                // Ensure the connection transitions to the connected state prior to completing this.startInternalPromise.\r\n                // start() will handle the case when stop was called and startInternal exits still in the disconnecting state.\r\n                this._logger.log(LogLevel.Debug, \"The HttpConnection connected successfully.\");\r\n                this._connectionState = \"Connected\" /* ConnectionState.Connected */;\r\n            }\r\n            // stop() is waiting on us via this.startInternalPromise so keep this.transport around so it can clean up.\r\n            // This is the only case startInternal can exit in neither the connected nor disconnected state because stopConnection()\r\n            // will transition to the disconnected state. start() will wait for the transition using the stopPromise.\r\n        }\r\n        catch (e) {\r\n            this._logger.log(LogLevel.Error, \"Failed to start the connection: \" + e);\r\n            this._connectionState = \"Disconnected\" /* ConnectionState.Disconnected */;\r\n            this.transport = undefined;\r\n            // if start fails, any active calls to stop assume that start will complete the stop promise\r\n            this._stopPromiseResolver();\r\n            return Promise.reject(e);\r\n        }\r\n    }\r\n    async _getNegotiationResponse(url) {\r\n        const headers = {};\r\n        const [name, value] = getUserAgentHeader();\r\n        headers[name] = value;\r\n        const negotiateUrl = this._resolveNegotiateUrl(url);\r\n        this._logger.log(LogLevel.Debug, `Sending negotiation request: ${negotiateUrl}.`);\r\n        try {\r\n            const response = await this._httpClient.post(negotiateUrl, {\r\n                content: \"\",\r\n                headers: { ...headers, ...this._options.headers },\r\n                timeout: this._options.timeout,\r\n                withCredentials: this._options.withCredentials,\r\n            });\r\n            if (response.statusCode !== 200) {\r\n                return Promise.reject(new Error(`Unexpected status code returned from negotiate '${response.statusCode}'`));\r\n            }\r\n            const negotiateResponse = JSON.parse(response.content);\r\n            if (!negotiateResponse.negotiateVersion || negotiateResponse.negotiateVersion < 1) {\r\n                // Negotiate version 0 doesn't use connectionToken\r\n                // So we set it equal to connectionId so all our logic can use connectionToken without being aware of the negotiate version\r\n                negotiateResponse.connectionToken = negotiateResponse.connectionId;\r\n            }\r\n            if (negotiateResponse.useStatefulReconnect && this._options._useStatefulReconnect !== true) {\r\n                return Promise.reject(new FailedToNegotiateWithServerError(\"Client didn't negotiate Stateful Reconnect but the server did.\"));\r\n            }\r\n            return negotiateResponse;\r\n        }\r\n        catch (e) {\r\n            let errorMessage = \"Failed to complete negotiation with the server: \" + e;\r\n            if (e instanceof HttpError) {\r\n                if (e.statusCode === 404) {\r\n                    errorMessage = errorMessage + \" Either this is not a SignalR endpoint or there is a proxy blocking the connection.\";\r\n                }\r\n            }\r\n            this._logger.log(LogLevel.Error, errorMessage);\r\n            return Promise.reject(new FailedToNegotiateWithServerError(errorMessage));\r\n        }\r\n    }\r\n    _createConnectUrl(url, connectionToken) {\r\n        if (!connectionToken) {\r\n            return url;\r\n        }\r\n        return url + (url.indexOf(\"?\") === -1 ? \"?\" : \"&\") + `id=${connectionToken}`;\r\n    }\r\n    async _createTransport(url, requestedTransport, negotiateResponse, requestedTransferFormat) {\r\n        let connectUrl = this._createConnectUrl(url, negotiateResponse.connectionToken);\r\n        if (this._isITransport(requestedTransport)) {\r\n            this._logger.log(LogLevel.Debug, \"Connection was provided an instance of ITransport, using that directly.\");\r\n            this.transport = requestedTransport;\r\n            await this._startTransport(connectUrl, requestedTransferFormat);\r\n            this.connectionId = negotiateResponse.connectionId;\r\n            return;\r\n        }\r\n        const transportExceptions = [];\r\n        const transports = negotiateResponse.availableTransports || [];\r\n        let negotiate = negotiateResponse;\r\n        for (const endpoint of transports) {\r\n            const transportOrError = this._resolveTransportOrError(endpoint, requestedTransport, requestedTransferFormat, (negotiate === null || negotiate === void 0 ? void 0 : negotiate.useStatefulReconnect) === true);\r\n            if (transportOrError instanceof Error) {\r\n                // Store the error and continue, we don't want to cause a re-negotiate in these cases\r\n                transportExceptions.push(`${endpoint.transport} failed:`);\r\n                transportExceptions.push(transportOrError);\r\n            }\r\n            else if (this._isITransport(transportOrError)) {\r\n                this.transport = transportOrError;\r\n                if (!negotiate) {\r\n                    try {\r\n                        negotiate = await this._getNegotiationResponse(url);\r\n                    }\r\n                    catch (ex) {\r\n                        return Promise.reject(ex);\r\n                    }\r\n                    connectUrl = this._createConnectUrl(url, negotiate.connectionToken);\r\n                }\r\n                try {\r\n                    await this._startTransport(connectUrl, requestedTransferFormat);\r\n                    this.connectionId = negotiate.connectionId;\r\n                    return;\r\n                }\r\n                catch (ex) {\r\n                    this._logger.log(LogLevel.Error, `Failed to start the transport '${endpoint.transport}': ${ex}`);\r\n                    negotiate = undefined;\r\n                    transportExceptions.push(new FailedToStartTransportError(`${endpoint.transport} failed: ${ex}`, HttpTransportType[endpoint.transport]));\r\n                    if (this._connectionState !== \"Connecting\" /* ConnectionState.Connecting */) {\r\n                        const message = \"Failed to select transport before stop() was called.\";\r\n                        this._logger.log(LogLevel.Debug, message);\r\n                        return Promise.reject(new AbortError(message));\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        if (transportExceptions.length > 0) {\r\n            return Promise.reject(new AggregateErrors(`Unable to connect to the server with any of the available transports. ${transportExceptions.join(\" \")}`, transportExceptions));\r\n        }\r\n        return Promise.reject(new Error(\"None of the transports supported by the client are supported by the server.\"));\r\n    }\r\n    _constructTransport(transport) {\r\n        switch (transport) {\r\n            case HttpTransportType.WebSockets:\r\n                if (!this._options.WebSocket) {\r\n                    throw new Error(\"'WebSocket' is not supported in your environment.\");\r\n                }\r\n                return new WebSocketTransport(this._httpClient, this._accessTokenFactory, this._logger, this._options.logMessageContent, this._options.WebSocket, this._options.headers || {});\r\n            case HttpTransportType.ServerSentEvents:\r\n                if (!this._options.EventSource) {\r\n                    throw new Error(\"'EventSource' is not supported in your environment.\");\r\n                }\r\n                return new ServerSentEventsTransport(this._httpClient, this._httpClient._accessToken, this._logger, this._options);\r\n            case HttpTransportType.LongPolling:\r\n                return new LongPollingTransport(this._httpClient, this._logger, this._options);\r\n            default:\r\n                throw new Error(`Unknown transport: ${transport}.`);\r\n        }\r\n    }\r\n    _startTransport(url, transferFormat) {\r\n        this.transport.onreceive = this.onreceive;\r\n        if (this.features.reconnect) {\r\n            this.transport.onclose = async (e) => {\r\n                let callStop = false;\r\n                if (this.features.reconnect) {\r\n                    try {\r\n                        this.features.disconnected();\r\n                        await this.transport.connect(url, transferFormat);\r\n                        await this.features.resend();\r\n                    }\r\n                    catch {\r\n                        callStop = true;\r\n                    }\r\n                }\r\n                else {\r\n                    this._stopConnection(e);\r\n                    return;\r\n                }\r\n                if (callStop) {\r\n                    this._stopConnection(e);\r\n                }\r\n            };\r\n        }\r\n        else {\r\n            this.transport.onclose = (e) => this._stopConnection(e);\r\n        }\r\n        return this.transport.connect(url, transferFormat);\r\n    }\r\n    _resolveTransportOrError(endpoint, requestedTransport, requestedTransferFormat, useStatefulReconnect) {\r\n        const transport = HttpTransportType[endpoint.transport];\r\n        if (transport === null || transport === undefined) {\r\n            this._logger.log(LogLevel.Debug, `Skipping transport '${endpoint.transport}' because it is not supported by this client.`);\r\n            return new Error(`Skipping transport '${endpoint.transport}' because it is not supported by this client.`);\r\n        }\r\n        else {\r\n            if (transportMatches(requestedTransport, transport)) {\r\n                const transferFormats = endpoint.transferFormats.map((s) => TransferFormat[s]);\r\n                if (transferFormats.indexOf(requestedTransferFormat) >= 0) {\r\n                    if ((transport === HttpTransportType.WebSockets && !this._options.WebSocket) ||\r\n                        (transport === HttpTransportType.ServerSentEvents && !this._options.EventSource)) {\r\n                        this._logger.log(LogLevel.Debug, `Skipping transport '${HttpTransportType[transport]}' because it is not supported in your environment.'`);\r\n                        return new UnsupportedTransportError(`'${HttpTransportType[transport]}' is not supported in your environment.`, transport);\r\n                    }\r\n                    else {\r\n                        this._logger.log(LogLevel.Debug, `Selecting transport '${HttpTransportType[transport]}'.`);\r\n                        try {\r\n                            this.features.reconnect = transport === HttpTransportType.WebSockets ? useStatefulReconnect : undefined;\r\n                            return this._constructTransport(transport);\r\n                        }\r\n                        catch (ex) {\r\n                            return ex;\r\n                        }\r\n                    }\r\n                }\r\n                else {\r\n                    this._logger.log(LogLevel.Debug, `Skipping transport '${HttpTransportType[transport]}' because it does not support the requested transfer format '${TransferFormat[requestedTransferFormat]}'.`);\r\n                    return new Error(`'${HttpTransportType[transport]}' does not support ${TransferFormat[requestedTransferFormat]}.`);\r\n                }\r\n            }\r\n            else {\r\n                this._logger.log(LogLevel.Debug, `Skipping transport '${HttpTransportType[transport]}' because it was disabled by the client.`);\r\n                return new DisabledTransportError(`'${HttpTransportType[transport]}' is disabled by the client.`, transport);\r\n            }\r\n        }\r\n    }\r\n    _isITransport(transport) {\r\n        return transport && typeof (transport) === \"object\" && \"connect\" in transport;\r\n    }\r\n    _stopConnection(error) {\r\n        this._logger.log(LogLevel.Debug, `HttpConnection.stopConnection(${error}) called while in state ${this._connectionState}.`);\r\n        this.transport = undefined;\r\n        // If we have a stopError, it takes precedence over the error from the transport\r\n        error = this._stopError || error;\r\n        this._stopError = undefined;\r\n        if (this._connectionState === \"Disconnected\" /* ConnectionState.Disconnected */) {\r\n            this._logger.log(LogLevel.Debug, `Call to HttpConnection.stopConnection(${error}) was ignored because the connection is already in the disconnected state.`);\r\n            return;\r\n        }\r\n        if (this._connectionState === \"Connecting\" /* ConnectionState.Connecting */) {\r\n            this._logger.log(LogLevel.Warning, `Call to HttpConnection.stopConnection(${error}) was ignored because the connection is still in the connecting state.`);\r\n            throw new Error(`HttpConnection.stopConnection(${error}) was called while the connection is still in the connecting state.`);\r\n        }\r\n        if (this._connectionState === \"Disconnecting\" /* ConnectionState.Disconnecting */) {\r\n            // A call to stop() induced this call to stopConnection and needs to be completed.\r\n            // Any stop() awaiters will be scheduled to continue after the onclose callback fires.\r\n            this._stopPromiseResolver();\r\n        }\r\n        if (error) {\r\n            this._logger.log(LogLevel.Error, `Connection disconnected with error '${error}'.`);\r\n        }\r\n        else {\r\n            this._logger.log(LogLevel.Information, \"Connection disconnected.\");\r\n        }\r\n        if (this._sendQueue) {\r\n            this._sendQueue.stop().catch((e) => {\r\n                this._logger.log(LogLevel.Error, `TransportSendQueue.stop() threw error '${e}'.`);\r\n            });\r\n            this._sendQueue = undefined;\r\n        }\r\n        this.connectionId = undefined;\r\n        this._connectionState = \"Disconnected\" /* ConnectionState.Disconnected */;\r\n        if (this._connectionStarted) {\r\n            this._connectionStarted = false;\r\n            try {\r\n                if (this.onclose) {\r\n                    this.onclose(error);\r\n                }\r\n            }\r\n            catch (e) {\r\n                this._logger.log(LogLevel.Error, `HttpConnection.onclose(${error}) threw error '${e}'.`);\r\n            }\r\n        }\r\n    }\r\n    _resolveUrl(url) {\r\n        // startsWith is not supported in IE\r\n        if (url.lastIndexOf(\"https://\", 0) === 0 || url.lastIndexOf(\"http://\", 0) === 0) {\r\n            return url;\r\n        }\r\n        if (!Platform.isBrowser) {\r\n            throw new Error(`Cannot resolve '${url}'.`);\r\n        }\r\n        // Setting the url to the href propery of an anchor tag handles normalization\r\n        // for us. There are 3 main cases.\r\n        // 1. Relative path normalization e.g \"b\" -> \"http://localhost:5000/a/b\"\r\n        // 2. Absolute path normalization e.g \"/a/b\" -> \"http://localhost:5000/a/b\"\r\n        // 3. Networkpath reference normalization e.g \"//localhost:5000/a/b\" -> \"http://localhost:5000/a/b\"\r\n        const aTag = window.document.createElement(\"a\");\r\n        aTag.href = url;\r\n        this._logger.log(LogLevel.Information, `Normalizing '${url}' to '${aTag.href}'.`);\r\n        return aTag.href;\r\n    }\r\n    _resolveNegotiateUrl(url) {\r\n        const negotiateUrl = new URL(url);\r\n        if (negotiateUrl.pathname.endsWith('/')) {\r\n            negotiateUrl.pathname += \"negotiate\";\r\n        }\r\n        else {\r\n            negotiateUrl.pathname += \"/negotiate\";\r\n        }\r\n        const searchParams = new URLSearchParams(negotiateUrl.searchParams);\r\n        if (!searchParams.has(\"negotiateVersion\")) {\r\n            searchParams.append(\"negotiateVersion\", this._negotiateVersion.toString());\r\n        }\r\n        if (searchParams.has(\"useStatefulReconnect\")) {\r\n            if (searchParams.get(\"useStatefulReconnect\") === \"true\") {\r\n                this._options._useStatefulReconnect = true;\r\n            }\r\n        }\r\n        else if (this._options._useStatefulReconnect === true) {\r\n            searchParams.append(\"useStatefulReconnect\", \"true\");\r\n        }\r\n        negotiateUrl.search = searchParams.toString();\r\n        return negotiateUrl.toString();\r\n    }\r\n}\r\nfunction transportMatches(requestedTransport, actualTransport) {\r\n    return !requestedTransport || ((actualTransport & requestedTransport) !== 0);\r\n}\r\n/** @private */\r\nexport class TransportSendQueue {\r\n    constructor(_transport) {\r\n        this._transport = _transport;\r\n        this._buffer = [];\r\n        this._executing = true;\r\n        this._sendBufferedData = new PromiseSource();\r\n        this._transportResult = new PromiseSource();\r\n        this._sendLoopPromise = this._sendLoop();\r\n    }\r\n    send(data) {\r\n        this._bufferData(data);\r\n        if (!this._transportResult) {\r\n            this._transportResult = new PromiseSource();\r\n        }\r\n        return this._transportResult.promise;\r\n    }\r\n    stop() {\r\n        this._executing = false;\r\n        this._sendBufferedData.resolve();\r\n        return this._sendLoopPromise;\r\n    }\r\n    _bufferData(data) {\r\n        if (this._buffer.length && typeof (this._buffer[0]) !== typeof (data)) {\r\n            throw new Error(`Expected data to be of type ${typeof (this._buffer)} but was of type ${typeof (data)}`);\r\n        }\r\n        this._buffer.push(data);\r\n        this._sendBufferedData.resolve();\r\n    }\r\n    async _sendLoop() {\r\n        while (true) {\r\n            await this._sendBufferedData.promise;\r\n            if (!this._executing) {\r\n                if (this._transportResult) {\r\n                    this._transportResult.reject(\"Connection stopped.\");\r\n                }\r\n                break;\r\n            }\r\n            this._sendBufferedData = new PromiseSource();\r\n            const transportResult = this._transportResult;\r\n            this._transportResult = undefined;\r\n            const data = typeof (this._buffer[0]) === \"string\" ?\r\n                this._buffer.join(\"\") :\r\n                TransportSendQueue._concatBuffers(this._buffer);\r\n            this._buffer.length = 0;\r\n            try {\r\n                await this._transport.send(data);\r\n                transportResult.resolve();\r\n            }\r\n            catch (error) {\r\n                transportResult.reject(error);\r\n            }\r\n        }\r\n    }\r\n    static _concatBuffers(arrayBuffers) {\r\n        const totalLength = arrayBuffers.map((b) => b.byteLength).reduce((a, b) => a + b);\r\n        const result = new Uint8Array(totalLength);\r\n        let offset = 0;\r\n        for (const item of arrayBuffers) {\r\n            result.set(new Uint8Array(item), offset);\r\n            offset += item.byteLength;\r\n        }\r\n        return result.buffer;\r\n    }\r\n}\r\nclass PromiseSource {\r\n    constructor() {\r\n        this.promise = new Promise((resolve, reject) => [this._resolver, this._rejecter] = [resolve, reject]);\r\n    }\r\n    resolve() {\r\n        this._resolver();\r\n    }\r\n    reject(reason) {\r\n        this._rejecter(reason);\r\n    }\r\n}\r\n//# sourceMappingURL=HttpConnection.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { MessageType } from \"./IHubProtocol\";\r\nimport { LogLevel } from \"./ILogger\";\r\nimport { TransferFormat } from \"./ITransport\";\r\nimport { NullLogger } from \"./Loggers\";\r\nimport { TextMessageFormat } from \"./TextMessageFormat\";\r\nconst JSON_HUB_PROTOCOL_NAME = \"json\";\r\n/** Implements the JSON Hub Protocol. */\r\nexport class JsonHubProtocol {\r\n    constructor() {\r\n        /** @inheritDoc */\r\n        this.name = JSON_HUB_PROTOCOL_NAME;\r\n        /** @inheritDoc */\r\n        this.version = 2;\r\n        /** @inheritDoc */\r\n        this.transferFormat = TransferFormat.Text;\r\n    }\r\n    /** Creates an array of {@link @microsoft/signalr.HubMessage} objects from the specified serialized representation.\r\n     *\r\n     * @param {string} input A string containing the serialized representation.\r\n     * @param {ILogger} logger A logger that will be used to log messages that occur during parsing.\r\n     */\r\n    parseMessages(input, logger) {\r\n        // The interface does allow \"ArrayBuffer\" to be passed in, but this implementation does not. So let's throw a useful error.\r\n        if (typeof input !== \"string\") {\r\n            throw new Error(\"Invalid input for JSON hub protocol. Expected a string.\");\r\n        }\r\n        if (!input) {\r\n            return [];\r\n        }\r\n        if (logger === null) {\r\n            logger = NullLogger.instance;\r\n        }\r\n        // Parse the messages\r\n        const messages = TextMessageFormat.parse(input);\r\n        const hubMessages = [];\r\n        for (const message of messages) {\r\n            const parsedMessage = JSON.parse(message);\r\n            if (typeof parsedMessage.type !== \"number\") {\r\n                throw new Error(\"Invalid payload.\");\r\n            }\r\n            switch (parsedMessage.type) {\r\n                case MessageType.Invocation:\r\n                    this._isInvocationMessage(parsedMessage);\r\n                    break;\r\n                case MessageType.StreamItem:\r\n                    this._isStreamItemMessage(parsedMessage);\r\n                    break;\r\n                case MessageType.Completion:\r\n                    this._isCompletionMessage(parsedMessage);\r\n                    break;\r\n                case MessageType.Ping:\r\n                    // Single value, no need to validate\r\n                    break;\r\n                case MessageType.Close:\r\n                    // All optional values, no need to validate\r\n                    break;\r\n                case MessageType.Ack:\r\n                    this._isAckMessage(parsedMessage);\r\n                    break;\r\n                case MessageType.Sequence:\r\n                    this._isSequenceMessage(parsedMessage);\r\n                    break;\r\n                default:\r\n                    // Future protocol changes can add message types, old clients can ignore them\r\n                    logger.log(LogLevel.Information, \"Unknown message type '\" + parsedMessage.type + \"' ignored.\");\r\n                    continue;\r\n            }\r\n            hubMessages.push(parsedMessage);\r\n        }\r\n        return hubMessages;\r\n    }\r\n    /** Writes the specified {@link @microsoft/signalr.HubMessage} to a string and returns it.\r\n     *\r\n     * @param {HubMessage} message The message to write.\r\n     * @returns {string} A string containing the serialized representation of the message.\r\n     */\r\n    writeMessage(message) {\r\n        return TextMessageFormat.write(JSON.stringify(message));\r\n    }\r\n    _isInvocationMessage(message) {\r\n        this._assertNotEmptyString(message.target, \"Invalid payload for Invocation message.\");\r\n        if (message.invocationId !== undefined) {\r\n            this._assertNotEmptyString(message.invocationId, \"Invalid payload for Invocation message.\");\r\n        }\r\n    }\r\n    _isStreamItemMessage(message) {\r\n        this._assertNotEmptyString(message.invocationId, \"Invalid payload for StreamItem message.\");\r\n        if (message.item === undefined) {\r\n            throw new Error(\"Invalid payload for StreamItem message.\");\r\n        }\r\n    }\r\n    _isCompletionMessage(message) {\r\n        if (message.result && message.error) {\r\n            throw new Error(\"Invalid payload for Completion message.\");\r\n        }\r\n        if (!message.result && message.error) {\r\n            this._assertNotEmptyString(message.error, \"Invalid payload for Completion message.\");\r\n        }\r\n        this._assertNotEmptyString(message.invocationId, \"Invalid payload for Completion message.\");\r\n    }\r\n    _isAckMessage(message) {\r\n        if (typeof message.sequenceId !== 'number') {\r\n            throw new Error(\"Invalid SequenceId for Ack message.\");\r\n        }\r\n    }\r\n    _isSequenceMessage(message) {\r\n        if (typeof message.sequenceId !== 'number') {\r\n            throw new Error(\"Invalid SequenceId for Sequence message.\");\r\n        }\r\n    }\r\n    _assertNotEmptyString(value, errorMessage) {\r\n        if (typeof value !== \"string\" || value === \"\") {\r\n            throw new Error(errorMessage);\r\n        }\r\n    }\r\n}\r\n//# sourceMappingURL=JsonHubProtocol.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { DefaultReconnectPolicy } from \"./DefaultReconnectPolicy\";\r\nimport { HttpConnection } from \"./HttpConnection\";\r\nimport { HubConnection } from \"./HubConnection\";\r\nimport { LogLevel } from \"./ILogger\";\r\nimport { JsonHubProtocol } from \"./JsonHubProtocol\";\r\nimport { NullLogger } from \"./Loggers\";\r\nimport { Arg, ConsoleLogger } from \"./Utils\";\r\nconst LogLevelNameMapping = {\r\n    trace: LogLevel.Trace,\r\n    debug: LogLevel.Debug,\r\n    info: LogLevel.Information,\r\n    information: LogLevel.Information,\r\n    warn: LogLevel.Warning,\r\n    warning: LogLevel.Warning,\r\n    error: LogLevel.Error,\r\n    critical: LogLevel.Critical,\r\n    none: LogLevel.None,\r\n};\r\nfunction parseLogLevel(name) {\r\n    // Case-insensitive matching via lower-casing\r\n    // Yes, I know case-folding is a complicated problem in Unicode, but we only support\r\n    // the ASCII strings defined in LogLevelNameMapping anyway, so it's fine -anurse.\r\n    const mapping = LogLevelNameMapping[name.toLowerCase()];\r\n    if (typeof mapping !== \"undefined\") {\r\n        return mapping;\r\n    }\r\n    else {\r\n        throw new Error(`Unknown log level: ${name}`);\r\n    }\r\n}\r\n/** A builder for configuring {@link @microsoft/signalr.HubConnection} instances. */\r\nexport class HubConnectionBuilder {\r\n    configureLogging(logging) {\r\n        Arg.isRequired(logging, \"logging\");\r\n        if (isLogger(logging)) {\r\n            this.logger = logging;\r\n        }\r\n        else if (typeof logging === \"string\") {\r\n            const logLevel = parseLogLevel(logging);\r\n            this.logger = new ConsoleLogger(logLevel);\r\n        }\r\n        else {\r\n            this.logger = new ConsoleLogger(logging);\r\n        }\r\n        return this;\r\n    }\r\n    withUrl(url, transportTypeOrOptions) {\r\n        Arg.isRequired(url, \"url\");\r\n        Arg.isNotEmpty(url, \"url\");\r\n        this.url = url;\r\n        // Flow-typing knows where it's at. Since HttpTransportType is a number and IHttpConnectionOptions is guaranteed\r\n        // to be an object, we know (as does TypeScript) this comparison is all we need to figure out which overload was called.\r\n        if (typeof transportTypeOrOptions === \"object\") {\r\n            this.httpConnectionOptions = { ...this.httpConnectionOptions, ...transportTypeOrOptions };\r\n        }\r\n        else {\r\n            this.httpConnectionOptions = {\r\n                ...this.httpConnectionOptions,\r\n                transport: transportTypeOrOptions,\r\n            };\r\n        }\r\n        return this;\r\n    }\r\n    /** Configures the {@link @microsoft/signalr.HubConnection} to use the specified Hub Protocol.\r\n     *\r\n     * @param {IHubProtocol} protocol The {@link @microsoft/signalr.IHubProtocol} implementation to use.\r\n     */\r\n    withHubProtocol(protocol) {\r\n        Arg.isRequired(protocol, \"protocol\");\r\n        this.protocol = protocol;\r\n        return this;\r\n    }\r\n    withAutomaticReconnect(retryDelaysOrReconnectPolicy) {\r\n        if (this.reconnectPolicy) {\r\n            throw new Error(\"A reconnectPolicy has already been set.\");\r\n        }\r\n        if (!retryDelaysOrReconnectPolicy) {\r\n            this.reconnectPolicy = new DefaultReconnectPolicy();\r\n        }\r\n        else if (Array.isArray(retryDelaysOrReconnectPolicy)) {\r\n            this.reconnectPolicy = new DefaultReconnectPolicy(retryDelaysOrReconnectPolicy);\r\n        }\r\n        else {\r\n            this.reconnectPolicy = retryDelaysOrReconnectPolicy;\r\n        }\r\n        return this;\r\n    }\r\n    /** Configures {@link @microsoft/signalr.HubConnection.serverTimeoutInMilliseconds} for the {@link @microsoft/signalr.HubConnection}.\r\n     *\r\n     * @returns The {@link @microsoft/signalr.HubConnectionBuilder} instance, for chaining.\r\n     */\r\n    withServerTimeout(milliseconds) {\r\n        Arg.isRequired(milliseconds, \"milliseconds\");\r\n        this._serverTimeoutInMilliseconds = milliseconds;\r\n        return this;\r\n    }\r\n    /** Configures {@link @microsoft/signalr.HubConnection.keepAliveIntervalInMilliseconds} for the {@link @microsoft/signalr.HubConnection}.\r\n     *\r\n     * @returns The {@link @microsoft/signalr.HubConnectionBuilder} instance, for chaining.\r\n     */\r\n    withKeepAliveInterval(milliseconds) {\r\n        Arg.isRequired(milliseconds, \"milliseconds\");\r\n        this._keepAliveIntervalInMilliseconds = milliseconds;\r\n        return this;\r\n    }\r\n    /** Enables and configures options for the Stateful Reconnect feature.\r\n     *\r\n     * @returns The {@link @microsoft/signalr.HubConnectionBuilder} instance, for chaining.\r\n     */\r\n    withStatefulReconnect(options) {\r\n        if (this.httpConnectionOptions === undefined) {\r\n            this.httpConnectionOptions = {};\r\n        }\r\n        this.httpConnectionOptions._useStatefulReconnect = true;\r\n        this._statefulReconnectBufferSize = options === null || options === void 0 ? void 0 : options.bufferSize;\r\n        return this;\r\n    }\r\n    /** Creates a {@link @microsoft/signalr.HubConnection} from the configuration options specified in this builder.\r\n     *\r\n     * @returns {HubConnection} The configured {@link @microsoft/signalr.HubConnection}.\r\n     */\r\n    build() {\r\n        // If httpConnectionOptions has a logger, use it. Otherwise, override it with the one\r\n        // provided to configureLogger\r\n        const httpConnectionOptions = this.httpConnectionOptions || {};\r\n        // If it's 'null', the user **explicitly** asked for null, don't mess with it.\r\n        if (httpConnectionOptions.logger === undefined) {\r\n            // If our logger is undefined or null, that's OK, the HttpConnection constructor will handle it.\r\n            httpConnectionOptions.logger = this.logger;\r\n        }\r\n        // Now create the connection\r\n        if (!this.url) {\r\n            throw new Error(\"The 'HubConnectionBuilder.withUrl' method must be called before building the connection.\");\r\n        }\r\n        const connection = new HttpConnection(this.url, httpConnectionOptions);\r\n        return HubConnection.create(connection, this.logger || NullLogger.instance, this.protocol || new JsonHubProtocol(), this.reconnectPolicy, this._serverTimeoutInMilliseconds, this._keepAliveIntervalInMilliseconds, this._statefulReconnectBufferSize);\r\n    }\r\n}\r\nfunction isLogger(logger) {\r\n    return logger.log !== undefined;\r\n}\r\n//# sourceMappingURL=HubConnectionBuilder.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n/** Defines the type of a Hub Message. */\r\nexport var MessageType;\r\n(function (MessageType) {\r\n    /** Indicates the message is an Invocation message and implements the {@link @microsoft/signalr.InvocationMessage} interface. */\r\n    MessageType[MessageType[\"Invocation\"] = 1] = \"Invocation\";\r\n    /** Indicates the message is a StreamItem message and implements the {@link @microsoft/signalr.StreamItemMessage} interface. */\r\n    MessageType[MessageType[\"StreamItem\"] = 2] = \"StreamItem\";\r\n    /** Indicates the message is a Completion message and implements the {@link @microsoft/signalr.CompletionMessage} interface. */\r\n    MessageType[MessageType[\"Completion\"] = 3] = \"Completion\";\r\n    /** Indicates the message is a Stream Invocation message and implements the {@link @microsoft/signalr.StreamInvocationMessage} interface. */\r\n    MessageType[MessageType[\"StreamInvocation\"] = 4] = \"StreamInvocation\";\r\n    /** Indicates the message is a Cancel Invocation message and implements the {@link @microsoft/signalr.CancelInvocationMessage} interface. */\r\n    MessageType[MessageType[\"CancelInvocation\"] = 5] = \"CancelInvocation\";\r\n    /** Indicates the message is a Ping message and implements the {@link @microsoft/signalr.PingMessage} interface. */\r\n    MessageType[MessageType[\"Ping\"] = 6] = \"Ping\";\r\n    /** Indicates the message is a Close message and implements the {@link @microsoft/signalr.CloseMessage} interface. */\r\n    MessageType[MessageType[\"Close\"] = 7] = \"Close\";\r\n    MessageType[MessageType[\"Ack\"] = 8] = \"Ack\";\r\n    MessageType[MessageType[\"Sequence\"] = 9] = \"Sequence\";\r\n})(MessageType || (MessageType = {}));\r\n//# sourceMappingURL=IHubProtocol.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n// These values are designed to match the ASP.NET Log Levels since that's the pattern we're emulating here.\r\n/** Indicates the severity of a log message.\r\n *\r\n * Log Levels are ordered in increasing severity. So `Debug` is more severe than `Trace`, etc.\r\n */\r\nexport var LogLevel;\r\n(function (LogLevel) {\r\n    /** Log level for very low severity diagnostic messages. */\r\n    LogLevel[LogLevel[\"Trace\"] = 0] = \"Trace\";\r\n    /** Log level for low severity diagnostic messages. */\r\n    LogLevel[LogLevel[\"Debug\"] = 1] = \"Debug\";\r\n    /** Log level for informational diagnostic messages. */\r\n    LogLevel[LogLevel[\"Information\"] = 2] = \"Information\";\r\n    /** Log level for diagnostic messages that indicate a non-fatal problem. */\r\n    LogLevel[LogLevel[\"Warning\"] = 3] = \"Warning\";\r\n    /** Log level for diagnostic messages that indicate a failure in the current operation. */\r\n    LogLevel[LogLevel[\"Error\"] = 4] = \"Error\";\r\n    /** Log level for diagnostic messages that indicate a failure that will terminate the entire application. */\r\n    LogLevel[LogLevel[\"Critical\"] = 5] = \"Critical\";\r\n    /** The highest possible log level. Used when configuring logging to indicate that no log messages should be emitted. */\r\n    LogLevel[LogLevel[\"None\"] = 6] = \"None\";\r\n})(LogLevel || (LogLevel = {}));\r\n//# sourceMappingURL=ILogger.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n// This will be treated as a bit flag in the future, so we keep it using power-of-two values.\r\n/** Specifies a specific HTTP transport type. */\r\nexport var HttpTransportType;\r\n(function (HttpTransportType) {\r\n    /** Specifies no transport preference. */\r\n    HttpTransportType[HttpTransportType[\"None\"] = 0] = \"None\";\r\n    /** Specifies the WebSockets transport. */\r\n    HttpTransportType[HttpTransportType[\"WebSockets\"] = 1] = \"WebSockets\";\r\n    /** Specifies the Server-Sent Events transport. */\r\n    HttpTransportType[HttpTransportType[\"ServerSentEvents\"] = 2] = \"ServerSentEvents\";\r\n    /** Specifies the Long Polling transport. */\r\n    HttpTransportType[HttpTransportType[\"LongPolling\"] = 4] = \"LongPolling\";\r\n})(HttpTransportType || (HttpTransportType = {}));\r\n/** Specifies the transfer format for a connection. */\r\nexport var TransferFormat;\r\n(function (TransferFormat) {\r\n    /** Specifies that only text data will be transmitted over the connection. */\r\n    TransferFormat[TransferFormat[\"Text\"] = 1] = \"Text\";\r\n    /** Specifies that binary data will be transmitted over the connection. */\r\n    TransferFormat[TransferFormat[\"Binary\"] = 2] = \"Binary\";\r\n})(TransferFormat || (TransferFormat = {}));\r\n//# sourceMappingURL=ITransport.js.map"],"names":["HttpResponse","constructor","statusCode","statusText","content","this","HttpClient","get","url","options","send","method","post","getCookieString","HubConnectionState","HubConnection","create","connection","logger","protocol","reconnectPolicy","serverTimeoutInMilliseconds","keepAliveIntervalInMilliseconds","statefulReconnectBufferSize","_nextKeepAlive","_freezeEventListener","_logger","log","Warning","isRequired","_statefulReconnectBufferSize","_protocol","_reconnectPolicy","_handshakeProtocol","onreceive","data","_processIncomingData","onclose","error","_connectionClosed","_callbacks","_methods","_closedCallbacks","_reconnectingCallbacks","_reconnectedCallbacks","_invocationId","_receivedHandshakeResponse","_connectionState","Disconnected","_connectionStarted","_cachedPingMessage","writeMessage","type","Ping","state","connectionId","baseUrl","Reconnecting","Error","start","_startPromise","_startWithStateTransitions","Promise","reject","Connecting","Debug","_startInternal","isBrowser","window","document","addEventListener","Connected","e","_stopDuringStartError","undefined","handshakePromise","resolve","_handshakeResolver","_handshakeRejecter","transferFormat","version","features","reconnect","handshakeRequest","name","_sendMessage","writeHandshakeRequest","Information","_cleanupTimeout","_resetTimeoutPeriod","_resetKeepAliveInterval","_messageBuffer","disconnected","_disconnected","bind","resend","_resend","inherentKeepAlive","_cleanupPingTimer","stop","startPromise","_stopPromise","_stopInternal","Disconnecting","_reconnectDelayHandle","clearTimeout","_completeClose","_sendCloseMessage","_sendWithProtocol","_createCloseMessage","stream","methodName","args","streams","streamIds","_replaceStreamingParams","invocationDescriptor","_createStreamInvocation","promiseQueue","subject","cancelCallback","cancelInvocation","_createCancelInvocation","invocationId","then","invocationEvent","Completion","complete","next","catch","_launchStreams","message","_send","sendPromise","_createInvocation","invoke","result","on","newMethod","toLowerCase","indexOf","push","off","handlers","removeIdx","splice","length","callback","onreconnecting","onreconnected","_processHandshakeResponse","messages","parseMessages","_shouldProcessMessage","Invocation","_invokeClientMethod","StreamItem","Close","allowReconnect","Ack","_ack","Sequence","_resetSequence","responseMessage","remainingData","parseHandshakeResponse","Date","getTime","_timeoutHandle","setTimeout","serverTimeout","_pingServerHandle","nextPing","async","invocationMessage","target","methods","_createCompletionMessage","methodsCopy","slice","expectsResponse","res","exception","completionMessage","m","prevRes","apply","arguments","_cancelCallbacksWithError","_reconnect","_dispose","removeEventListener","forEach","c","reconnectStartTime","now","previousReconnectAttempts","retryError","nextRetryDelay","_getNextRetryDelay","toString","previousRetryCount","elapsedMilliseconds","retryReason","nextRetryDelayInMilliseconds","callbacks","Object","keys","key","nonblocking","streamId","subscribe","err","item","_createStreamItemMessage","i","argument","_isObservable","arg","StreamInvocation","id","CancelInvocation","HttpConnection","_stopPromiseResolver","_negotiateVersion","_resolveUrl","logMessageContent","withCredentials","timeout","webSocketModule","eventSourceModule","isNode","WebSocket","EventSource","_httpClient","AccessTokenHttpClient","httpClient","DefaultHttpClient","accessTokenFactory","_options","Binary","isIn","_startInternalPromise","_sendQueue","TransportSendQueue","transport","_stopError","_stopConnection","_accessTokenFactory","skipNegotiation","WebSockets","_constructTransport","_startTransport","negotiateResponse","redirects","_getNegotiationResponse","ProtocolVersion","accessToken","_accessToken","_createTransport","LongPollingTransport","headers","value","negotiateUrl","_resolveNegotiateUrl","response","JSON","parse","negotiateVersion","connectionToken","useStatefulReconnect","_useStatefulReconnect","errorMessage","_createConnectUrl","requestedTransport","requestedTransferFormat","connectUrl","_isITransport","transportExceptions","transports","availableTransports","negotiate","endpoint","transportOrError","_resolveTransportOrError","ex","join","WebSocketTransport","ServerSentEvents","ServerSentEventsTransport","LongPolling","callStop","connect","actualTransport","transportMatches","transferFormats","map","s","lastIndexOf","aTag","createElement","href","URL","pathname","endsWith","searchParams","URLSearchParams","has","append","search","_transport","_buffer","_executing","_sendBufferedData","PromiseSource","_transportResult","_sendLoopPromise","_sendLoop","_bufferData","promise","transportResult","_concatBuffers","arrayBuffers","totalLength","b","byteLength","reduce","a","Uint8Array","offset","set","buffer","_resolver","_rejecter","reason","JsonHubProtocol","Text","input","instance","TextMessageFormat","hubMessages","parsedMessage","_isInvocationMessage","_isStreamItemMessage","_isCompletionMessage","_isAckMessage","_isSequenceMessage","write","stringify","_assertNotEmptyString","sequenceId","LogLevelNameMapping","trace","Trace","debug","info","information","warn","warning","critical","Critical","none","None","HubConnectionBuilder","configureLogging","logging","logLevel","mapping","parseLogLevel","withUrl","transportTypeOrOptions","isNotEmpty","httpConnectionOptions","withHubProtocol","withAutomaticReconnect","retryDelaysOrReconnectPolicy","Array","isArray","DefaultReconnectPolicy","withServerTimeout","milliseconds","_serverTimeoutInMilliseconds","withKeepAliveInterval","_keepAliveIntervalInMilliseconds","withStatefulReconnect","bufferSize","build","MessageType","LogLevel","HttpTransportType","TransferFormat"],"sourceRoot":""}