@nice2dev/game-engine 0.1.0

package/dist/cjs/node_modules/@microsoft/signalr/dist/esm/HttpConnection.js

@@ -0,0 +1,576 @@
+'use strict';
+
+var AccessTokenHttpClient = require('./AccessTokenHttpClient.js');
+var DefaultHttpClient = require('./DefaultHttpClient.js');
+var Errors = require('./Errors.js');
+var ILogger = require('./ILogger.js');
+var ITransport = require('./ITransport.js');
+var LongPollingTransport = require('./LongPollingTransport.js');
+var ServerSentEventsTransport = require('./ServerSentEventsTransport.js');
+var Utils = require('./Utils.js');
+var WebSocketTransport = require('./WebSocketTransport.js');
+
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+const MAX_REDIRECTS = 100;
+/** @private */
+class HttpConnection {
+    constructor(url, options = {}) {
+        this._stopPromiseResolver = () => { };
+        this.features = {};
+        this._negotiateVersion = 1;
+        Utils.Arg.isRequired(url, "url");
+        this._logger = Utils.createLogger(options.logger);
+        this.baseUrl = this._resolveUrl(url);
+        options = options || {};
+        options.logMessageContent = options.logMessageContent === undefined ? false : options.logMessageContent;
+        if (typeof options.withCredentials === "boolean" || options.withCredentials === undefined) {
+            options.withCredentials = options.withCredentials === undefined ? true : options.withCredentials;
+        }
+        else {
+            throw new Error("withCredentials option was not a 'boolean' or 'undefined' value");
+        }
+        options.timeout = options.timeout === undefined ? 100 * 1000 : options.timeout;
+        let webSocketModule = null;
+        let eventSourceModule = null;
+        if (Utils.Platform.isNode && typeof require !== "undefined") {
+            // In order to ignore the dynamic require in webpack builds we need to do this magic
+            // @ts-ignore: TS doesn't know about these names
+            const requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+            webSocketModule = requireFunc("ws");
+            eventSourceModule = requireFunc("eventsource");
+        }
+        if (!Utils.Platform.isNode && typeof WebSocket !== "undefined" && !options.WebSocket) {
+            options.WebSocket = WebSocket;
+        }
+        else if (Utils.Platform.isNode && !options.WebSocket) {
+            if (webSocketModule) {
+                options.WebSocket = webSocketModule;
+            }
+        }
+        if (!Utils.Platform.isNode && typeof EventSource !== "undefined" && !options.EventSource) {
+            options.EventSource = EventSource;
+        }
+        else if (Utils.Platform.isNode && !options.EventSource) {
+            if (typeof eventSourceModule !== "undefined") {
+                options.EventSource = eventSourceModule;
+            }
+        }
+        this._httpClient = new AccessTokenHttpClient.AccessTokenHttpClient(options.httpClient || new DefaultHttpClient.DefaultHttpClient(this._logger), options.accessTokenFactory);
+        this._connectionState = "Disconnected" /* ConnectionState.Disconnected */;
+        this._connectionStarted = false;
+        this._options = options;
+        this.onreceive = null;
+        this.onclose = null;
+    }
+    async start(transferFormat) {
+        transferFormat = transferFormat || ITransport.TransferFormat.Binary;
+        Utils.Arg.isIn(transferFormat, ITransport.TransferFormat, "transferFormat");
+        this._logger.log(ILogger.LogLevel.Debug, `Starting connection with transfer format '${ITransport.TransferFormat[transferFormat]}'.`);
+        if (this._connectionState !== "Disconnected" /* ConnectionState.Disconnected */) {
+            return Promise.reject(new Error("Cannot start an HttpConnection that is not in the 'Disconnected' state."));
+        }
+        this._connectionState = "Connecting" /* ConnectionState.Connecting */;
+        this._startInternalPromise = this._startInternal(transferFormat);
+        await this._startInternalPromise;
+        // The TypeScript compiler thinks that connectionState must be Connecting here. The TypeScript compiler is wrong.
+        if (this._connectionState === "Disconnecting" /* ConnectionState.Disconnecting */) {
+            // stop() was called and transitioned the client into the Disconnecting state.
+            const message = "Failed to start the HttpConnection before stop() was called.";
+            this._logger.log(ILogger.LogLevel.Error, message);
+            // We cannot await stopPromise inside startInternal since stopInternal awaits the startInternalPromise.
+            await this._stopPromise;
+            return Promise.reject(new Errors.AbortError(message));
+        }
+        else if (this._connectionState !== "Connected" /* ConnectionState.Connected */) {
+            // stop() was called and transitioned the client into the Disconnecting state.
+            const message = "HttpConnection.startInternal completed gracefully but didn't enter the connection into the connected state!";
+            this._logger.log(ILogger.LogLevel.Error, message);
+            return Promise.reject(new Errors.AbortError(message));
+        }
+        this._connectionStarted = true;
+    }
+    send(data) {
+        if (this._connectionState !== "Connected" /* ConnectionState.Connected */) {
+            return Promise.reject(new Error("Cannot send data if the connection is not in the 'Connected' State."));
+        }
+        if (!this._sendQueue) {
+            this._sendQueue = new TransportSendQueue(this.transport);
+        }
+        // Transport will not be null if state is connected
+        return this._sendQueue.send(data);
+    }
+    async stop(error) {
+        if (this._connectionState === "Disconnected" /* ConnectionState.Disconnected */) {
+            this._logger.log(ILogger.LogLevel.Debug, `Call to HttpConnection.stop(${error}) ignored because the connection is already in the disconnected state.`);
+            return Promise.resolve();
+        }
+        if (this._connectionState === "Disconnecting" /* ConnectionState.Disconnecting */) {
+            this._logger.log(ILogger.LogLevel.Debug, `Call to HttpConnection.stop(${error}) ignored because the connection is already in the disconnecting state.`);
+            return this._stopPromise;
+        }
+        this._connectionState = "Disconnecting" /* ConnectionState.Disconnecting */;
+        this._stopPromise = new Promise((resolve) => {
+            // Don't complete stop() until stopConnection() completes.
+            this._stopPromiseResolver = resolve;
+        });
+        // stopInternal should never throw so just observe it.
+        await this._stopInternal(error);
+        await this._stopPromise;
+    }
+    async _stopInternal(error) {
+        // Set error as soon as possible otherwise there is a race between
+        // the transport closing and providing an error and the error from a close message
+        // We would prefer the close message error.
+        this._stopError = error;
+        try {
+            await this._startInternalPromise;
+        }
+        catch (e) {
+            // This exception is returned to the user as a rejected Promise from the start method.
+        }
+        // The transport's onclose will trigger stopConnection which will run our onclose event.
+        // The transport should always be set if currently connected. If it wasn't set, it's likely because
+        // stop was called during start() and start() failed.
+        if (this.transport) {
+            try {
+                await this.transport.stop();
+            }
+            catch (e) {
+                this._logger.log(ILogger.LogLevel.Error, `HttpConnection.transport.stop() threw error '${e}'.`);
+                this._stopConnection();
+            }
+            this.transport = undefined;
+        }
+        else {
+            this._logger.log(ILogger.LogLevel.Debug, "HttpConnection.transport is undefined in HttpConnection.stop() because start() failed.");
+        }
+    }
+    async _startInternal(transferFormat) {
+        // Store the original base url and the access token factory since they may change
+        // as part of negotiating
+        let url = this.baseUrl;
+        this._accessTokenFactory = this._options.accessTokenFactory;
+        this._httpClient._accessTokenFactory = this._accessTokenFactory;
+        try {
+            if (this._options.skipNegotiation) {
+                if (this._options.transport === ITransport.HttpTransportType.WebSockets) {
+                    // No need to add a connection ID in this case
+                    this.transport = this._constructTransport(ITransport.HttpTransportType.WebSockets);
+                    // We should just call connect directly in this case.
+                    // No fallback or negotiate in this case.
+                    await this._startTransport(url, transferFormat);
+                }
+                else {
+                    throw new Error("Negotiation can only be skipped when using the WebSocket transport directly.");
+                }
+            }
+            else {
+                let negotiateResponse = null;
+                let redirects = 0;
+                do {
+                    negotiateResponse = await this._getNegotiationResponse(url);
+                    // the user tries to stop the connection when it is being started
+                    if (this._connectionState === "Disconnecting" /* ConnectionState.Disconnecting */ || this._connectionState === "Disconnected" /* ConnectionState.Disconnected */) {
+                        throw new Errors.AbortError("The connection was stopped during negotiation.");
+                    }
+                    if (negotiateResponse.error) {
+                        throw new Error(negotiateResponse.error);
+                    }
+                    if (negotiateResponse.ProtocolVersion) {
+                        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.");
+                    }
+                    if (negotiateResponse.url) {
+                        url = negotiateResponse.url;
+                    }
+                    if (negotiateResponse.accessToken) {
+                        // Replace the current access token factory with one that uses
+                        // the returned access token
+                        const accessToken = negotiateResponse.accessToken;
+                        this._accessTokenFactory = () => accessToken;
+                        // 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
+                        this._httpClient._accessToken = accessToken;
+                        this._httpClient._accessTokenFactory = undefined;
+                    }
+                    redirects++;
+                } while (negotiateResponse.url && redirects < MAX_REDIRECTS);
+                if (redirects === MAX_REDIRECTS && negotiateResponse.url) {
+                    throw new Error("Negotiate redirection limit exceeded.");
+                }
+                await this._createTransport(url, this._options.transport, negotiateResponse, transferFormat);
+            }
+            if (this.transport instanceof LongPollingTransport.LongPollingTransport) {
+                this.features.inherentKeepAlive = true;
+            }
+            if (this._connectionState === "Connecting" /* ConnectionState.Connecting */) {
+                // Ensure the connection transitions to the connected state prior to completing this.startInternalPromise.
+                // start() will handle the case when stop was called and startInternal exits still in the disconnecting state.
+                this._logger.log(ILogger.LogLevel.Debug, "The HttpConnection connected successfully.");
+                this._connectionState = "Connected" /* ConnectionState.Connected */;
+            }
+            // stop() is waiting on us via this.startInternalPromise so keep this.transport around so it can clean up.
+            // This is the only case startInternal can exit in neither the connected nor disconnected state because stopConnection()
+            // will transition to the disconnected state. start() will wait for the transition using the stopPromise.
+        }
+        catch (e) {
+            this._logger.log(ILogger.LogLevel.Error, "Failed to start the connection: " + e);
+            this._connectionState = "Disconnected" /* ConnectionState.Disconnected */;
+            this.transport = undefined;
+            // if start fails, any active calls to stop assume that start will complete the stop promise
+            this._stopPromiseResolver();
+            return Promise.reject(e);
+        }
+    }
+    async _getNegotiationResponse(url) {
+        const headers = {};
+        const [name, value] = Utils.getUserAgentHeader();
+        headers[name] = value;
+        const negotiateUrl = this._resolveNegotiateUrl(url);
+        this._logger.log(ILogger.LogLevel.Debug, `Sending negotiation request: ${negotiateUrl}.`);
+        try {
+            const response = await this._httpClient.post(negotiateUrl, {
+                content: "",
+                headers: { ...headers, ...this._options.headers },
+                timeout: this._options.timeout,
+                withCredentials: this._options.withCredentials,
+            });
+            if (response.statusCode !== 200) {
+                return Promise.reject(new Error(`Unexpected status code returned from negotiate '${response.statusCode}'`));
+            }
+            const negotiateResponse = JSON.parse(response.content);
+            if (!negotiateResponse.negotiateVersion || negotiateResponse.negotiateVersion < 1) {
+                // Negotiate version 0 doesn't use connectionToken
+                // So we set it equal to connectionId so all our logic can use connectionToken without being aware of the negotiate version
+                negotiateResponse.connectionToken = negotiateResponse.connectionId;
+            }
+            if (negotiateResponse.useStatefulReconnect && this._options._useStatefulReconnect !== true) {
+                return Promise.reject(new Errors.FailedToNegotiateWithServerError("Client didn't negotiate Stateful Reconnect but the server did."));
+            }
+            return negotiateResponse;
+        }
+        catch (e) {
+            let errorMessage = "Failed to complete negotiation with the server: " + e;
+            if (e instanceof Errors.HttpError) {
+                if (e.statusCode === 404) {
+                    errorMessage = errorMessage + " Either this is not a SignalR endpoint or there is a proxy blocking the connection.";
+                }
+            }
+            this._logger.log(ILogger.LogLevel.Error, errorMessage);
+            return Promise.reject(new Errors.FailedToNegotiateWithServerError(errorMessage));
+        }
+    }
+    _createConnectUrl(url, connectionToken) {
+        if (!connectionToken) {
+            return url;
+        }
+        return url + (url.indexOf("?") === -1 ? "?" : "&") + `id=${connectionToken}`;
+    }
+    async _createTransport(url, requestedTransport, negotiateResponse, requestedTransferFormat) {
+        let connectUrl = this._createConnectUrl(url, negotiateResponse.connectionToken);
+        if (this._isITransport(requestedTransport)) {
+            this._logger.log(ILogger.LogLevel.Debug, "Connection was provided an instance of ITransport, using that directly.");
+            this.transport = requestedTransport;
+            await this._startTransport(connectUrl, requestedTransferFormat);
+            this.connectionId = negotiateResponse.connectionId;
+            return;
+        }
+        const transportExceptions = [];
+        const transports = negotiateResponse.availableTransports || [];
+        let negotiate = negotiateResponse;
+        for (const endpoint of transports) {
+            const transportOrError = this._resolveTransportOrError(endpoint, requestedTransport, requestedTransferFormat, (negotiate === null || negotiate === void 0 ? void 0 : negotiate.useStatefulReconnect) === true);
+            if (transportOrError instanceof Error) {
+                // Store the error and continue, we don't want to cause a re-negotiate in these cases
+                transportExceptions.push(`${endpoint.transport} failed:`);
+                transportExceptions.push(transportOrError);
+            }
+            else if (this._isITransport(transportOrError)) {
+                this.transport = transportOrError;
+                if (!negotiate) {
+                    try {
+                        negotiate = await this._getNegotiationResponse(url);
+                    }
+                    catch (ex) {
+                        return Promise.reject(ex);
+                    }
+                    connectUrl = this._createConnectUrl(url, negotiate.connectionToken);
+                }
+                try {
+                    await this._startTransport(connectUrl, requestedTransferFormat);
+                    this.connectionId = negotiate.connectionId;
+                    return;
+                }
+                catch (ex) {
+                    this._logger.log(ILogger.LogLevel.Error, `Failed to start the transport '${endpoint.transport}': ${ex}`);
+                    negotiate = undefined;
+                    transportExceptions.push(new Errors.FailedToStartTransportError(`${endpoint.transport} failed: ${ex}`, ITransport.HttpTransportType[endpoint.transport]));
+                    if (this._connectionState !== "Connecting" /* ConnectionState.Connecting */) {
+                        const message = "Failed to select transport before stop() was called.";
+                        this._logger.log(ILogger.LogLevel.Debug, message);
+                        return Promise.reject(new Errors.AbortError(message));
+                    }
+                }
+            }
+        }
+        if (transportExceptions.length > 0) {
+            return Promise.reject(new Errors.AggregateErrors(`Unable to connect to the server with any of the available transports. ${transportExceptions.join(" ")}`, transportExceptions));
+        }
+        return Promise.reject(new Error("None of the transports supported by the client are supported by the server."));
+    }
+    _constructTransport(transport) {
+        switch (transport) {
+            case ITransport.HttpTransportType.WebSockets:
+                if (!this._options.WebSocket) {
+                    throw new Error("'WebSocket' is not supported in your environment.");
+                }
+                return new WebSocketTransport.WebSocketTransport(this._httpClient, this._accessTokenFactory, this._logger, this._options.logMessageContent, this._options.WebSocket, this._options.headers || {});
+            case ITransport.HttpTransportType.ServerSentEvents:
+                if (!this._options.EventSource) {
+                    throw new Error("'EventSource' is not supported in your environment.");
+                }
+                return new ServerSentEventsTransport.ServerSentEventsTransport(this._httpClient, this._httpClient._accessToken, this._logger, this._options);
+            case ITransport.HttpTransportType.LongPolling:
+                return new LongPollingTransport.LongPollingTransport(this._httpClient, this._logger, this._options);
+            default:
+                throw new Error(`Unknown transport: ${transport}.`);
+        }
+    }
+    _startTransport(url, transferFormat) {
+        this.transport.onreceive = this.onreceive;
+        if (this.features.reconnect) {
+            this.transport.onclose = async (e) => {
+                let callStop = false;
+                if (this.features.reconnect) {
+                    try {
+                        this.features.disconnected();
+                        await this.transport.connect(url, transferFormat);
+                        await this.features.resend();
+                    }
+                    catch {
+                        callStop = true;
+                    }
+                }
+                else {
+                    this._stopConnection(e);
+                    return;
+                }
+                if (callStop) {
+                    this._stopConnection(e);
+                }
+            };
+        }
+        else {
+            this.transport.onclose = (e) => this._stopConnection(e);
+        }
+        return this.transport.connect(url, transferFormat);
+    }
+    _resolveTransportOrError(endpoint, requestedTransport, requestedTransferFormat, useStatefulReconnect) {
+        const transport = ITransport.HttpTransportType[endpoint.transport];
+        if (transport === null || transport === undefined) {
+            this._logger.log(ILogger.LogLevel.Debug, `Skipping transport '${endpoint.transport}' because it is not supported by this client.`);
+            return new Error(`Skipping transport '${endpoint.transport}' because it is not supported by this client.`);
+        }
+        else {
+            if (transportMatches(requestedTransport, transport)) {
+                const transferFormats = endpoint.transferFormats.map((s) => ITransport.TransferFormat[s]);
+                if (transferFormats.indexOf(requestedTransferFormat) >= 0) {
+                    if ((transport === ITransport.HttpTransportType.WebSockets && !this._options.WebSocket) ||
+                        (transport === ITransport.HttpTransportType.ServerSentEvents && !this._options.EventSource)) {
+                        this._logger.log(ILogger.LogLevel.Debug, `Skipping transport '${ITransport.HttpTransportType[transport]}' because it is not supported in your environment.'`);
+                        return new Errors.UnsupportedTransportError(`'${ITransport.HttpTransportType[transport]}' is not supported in your environment.`, transport);
+                    }
+                    else {
+                        this._logger.log(ILogger.LogLevel.Debug, `Selecting transport '${ITransport.HttpTransportType[transport]}'.`);
+                        try {
+                            this.features.reconnect = transport === ITransport.HttpTransportType.WebSockets ? useStatefulReconnect : undefined;
+                            return this._constructTransport(transport);
+                        }
+                        catch (ex) {
+                            return ex;
+                        }
+                    }
+                }
+                else {
+                    this._logger.log(ILogger.LogLevel.Debug, `Skipping transport '${ITransport.HttpTransportType[transport]}' because it does not support the requested transfer format '${ITransport.TransferFormat[requestedTransferFormat]}'.`);
+                    return new Error(`'${ITransport.HttpTransportType[transport]}' does not support ${ITransport.TransferFormat[requestedTransferFormat]}.`);
+                }
+            }
+            else {
+                this._logger.log(ILogger.LogLevel.Debug, `Skipping transport '${ITransport.HttpTransportType[transport]}' because it was disabled by the client.`);
+                return new Errors.DisabledTransportError(`'${ITransport.HttpTransportType[transport]}' is disabled by the client.`, transport);
+            }
+        }
+    }
+    _isITransport(transport) {
+        return transport && typeof (transport) === "object" && "connect" in transport;
+    }
+    _stopConnection(error) {
+        this._logger.log(ILogger.LogLevel.Debug, `HttpConnection.stopConnection(${error}) called while in state ${this._connectionState}.`);
+        this.transport = undefined;
+        // If we have a stopError, it takes precedence over the error from the transport
+        error = this._stopError || error;
+        this._stopError = undefined;
+        if (this._connectionState === "Disconnected" /* ConnectionState.Disconnected */) {
+            this._logger.log(ILogger.LogLevel.Debug, `Call to HttpConnection.stopConnection(${error}) was ignored because the connection is already in the disconnected state.`);
+            return;
+        }
+        if (this._connectionState === "Connecting" /* ConnectionState.Connecting */) {
+            this._logger.log(ILogger.LogLevel.Warning, `Call to HttpConnection.stopConnection(${error}) was ignored because the connection is still in the connecting state.`);
+            throw new Error(`HttpConnection.stopConnection(${error}) was called while the connection is still in the connecting state.`);
+        }
+        if (this._connectionState === "Disconnecting" /* ConnectionState.Disconnecting */) {
+            // A call to stop() induced this call to stopConnection and needs to be completed.
+            // Any stop() awaiters will be scheduled to continue after the onclose callback fires.
+            this._stopPromiseResolver();
+        }
+        if (error) {
+            this._logger.log(ILogger.LogLevel.Error, `Connection disconnected with error '${error}'.`);
+        }
+        else {
+            this._logger.log(ILogger.LogLevel.Information, "Connection disconnected.");
+        }
+        if (this._sendQueue) {
+            this._sendQueue.stop().catch((e) => {
+                this._logger.log(ILogger.LogLevel.Error, `TransportSendQueue.stop() threw error '${e}'.`);
+            });
+            this._sendQueue = undefined;
+        }
+        this.connectionId = undefined;
+        this._connectionState = "Disconnected" /* ConnectionState.Disconnected */;
+        if (this._connectionStarted) {
+            this._connectionStarted = false;
+            try {
+                if (this.onclose) {
+                    this.onclose(error);
+                }
+            }
+            catch (e) {
+                this._logger.log(ILogger.LogLevel.Error, `HttpConnection.onclose(${error}) threw error '${e}'.`);
+            }
+        }
+    }
+    _resolveUrl(url) {
+        // startsWith is not supported in IE
+        if (url.lastIndexOf("https://", 0) === 0 || url.lastIndexOf("http://", 0) === 0) {
+            return url;
+        }
+        if (!Utils.Platform.isBrowser) {
+            throw new Error(`Cannot resolve '${url}'.`);
+        }
+        // Setting the url to the href propery of an anchor tag handles normalization
+        // for us. There are 3 main cases.
+        // 1. Relative path normalization e.g "b" -> "http://localhost:5000/a/b"
+        // 2. Absolute path normalization e.g "/a/b" -> "http://localhost:5000/a/b"
+        // 3. Networkpath reference normalization e.g "//localhost:5000/a/b" -> "http://localhost:5000/a/b"
+        const aTag = window.document.createElement("a");
+        aTag.href = url;
+        this._logger.log(ILogger.LogLevel.Information, `Normalizing '${url}' to '${aTag.href}'.`);
+        return aTag.href;
+    }
+    _resolveNegotiateUrl(url) {
+        const negotiateUrl = new URL(url);
+        if (negotiateUrl.pathname.endsWith('/')) {
+            negotiateUrl.pathname += "negotiate";
+        }
+        else {
+            negotiateUrl.pathname += "/negotiate";
+        }
+        const searchParams = new URLSearchParams(negotiateUrl.searchParams);
+        if (!searchParams.has("negotiateVersion")) {
+            searchParams.append("negotiateVersion", this._negotiateVersion.toString());
+        }
+        if (searchParams.has("useStatefulReconnect")) {
+            if (searchParams.get("useStatefulReconnect") === "true") {
+                this._options._useStatefulReconnect = true;
+            }
+        }
+        else if (this._options._useStatefulReconnect === true) {
+            searchParams.append("useStatefulReconnect", "true");
+        }
+        negotiateUrl.search = searchParams.toString();
+        return negotiateUrl.toString();
+    }
+}
+function transportMatches(requestedTransport, actualTransport) {
+    return !requestedTransport || ((actualTransport & requestedTransport) !== 0);
+}
+/** @private */
+class TransportSendQueue {
+    constructor(_transport) {
+        this._transport = _transport;
+        this._buffer = [];
+        this._executing = true;
+        this._sendBufferedData = new PromiseSource();
+        this._transportResult = new PromiseSource();
+        this._sendLoopPromise = this._sendLoop();
+    }
+    send(data) {
+        this._bufferData(data);
+        if (!this._transportResult) {
+            this._transportResult = new PromiseSource();
+        }
+        return this._transportResult.promise;
+    }
+    stop() {
+        this._executing = false;
+        this._sendBufferedData.resolve();
+        return this._sendLoopPromise;
+    }
+    _bufferData(data) {
+        if (this._buffer.length && typeof (this._buffer[0]) !== typeof (data)) {
+            throw new Error(`Expected data to be of type ${typeof (this._buffer)} but was of type ${typeof (data)}`);
+        }
+        this._buffer.push(data);
+        this._sendBufferedData.resolve();
+    }
+    async _sendLoop() {
+        while (true) {
+            await this._sendBufferedData.promise;
+            if (!this._executing) {
+                if (this._transportResult) {
+                    this._transportResult.reject("Connection stopped.");
+                }
+                break;
+            }
+            this._sendBufferedData = new PromiseSource();
+            const transportResult = this._transportResult;
+            this._transportResult = undefined;
+            const data = typeof (this._buffer[0]) === "string" ?
+                this._buffer.join("") :
+                TransportSendQueue._concatBuffers(this._buffer);
+            this._buffer.length = 0;
+            try {
+                await this._transport.send(data);
+                transportResult.resolve();
+            }
+            catch (error) {
+                transportResult.reject(error);
+            }
+        }
+    }
+    static _concatBuffers(arrayBuffers) {
+        const totalLength = arrayBuffers.map((b) => b.byteLength).reduce((a, b) => a + b);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const item of arrayBuffers) {
+            result.set(new Uint8Array(item), offset);
+            offset += item.byteLength;
+        }
+        return result.buffer;
+    }
+}
+class PromiseSource {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => [this._resolver, this._rejecter] = [resolve, reject]);
+    }
+    resolve() {
+        this._resolver();
+    }
+    reject(reason) {
+        this._rejecter(reason);
+    }
+}
+
+exports.HttpConnection = HttpConnection;
+exports.TransportSendQueue = TransportSendQueue;
+//# sourceMappingURL=HttpConnection.js.map