@jigging/jig 0.1.0-alpha.15 → 0.1.0-alpha.19

package/libexec/authoring/node_modules/vscode-jsonrpc/lib/common/connection.js

@@ -0,0 +1,1271 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+/// <reference path="../../typings/thenable.d.ts" preserve="true"/>
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionOptions = exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.RequestCancellationReceiverStrategy = exports.IdCancellationReceiverStrategy = exports.ConnectionStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.TraceValue = exports.Trace = exports.NullLogger = exports.ProgressType = exports.ProgressToken = void 0;
+exports.createMessageConnection = createMessageConnection;
+const ral_1 = __importDefault(require("./ral"));
+const Is = __importStar(require("./is"));
+const messages_1 = require("./messages");
+const linkedMap_1 = require("./linkedMap");
+const events_1 = require("./events");
+const cancellation_1 = require("./cancellation");
+var CancelNotification;
+(function (CancelNotification) {
+    CancelNotification.type = new messages_1.NotificationType('$/cancelRequest');
+})(CancelNotification || (CancelNotification = {}));
+var ProgressToken;
+(function (ProgressToken) {
+    function is(value) {
+        return typeof value === 'string' || typeof value === 'number';
+    }
+    ProgressToken.is = is;
+})(ProgressToken || (exports.ProgressToken = ProgressToken = {}));
+var ProgressNotification;
+(function (ProgressNotification) {
+    ProgressNotification.type = new messages_1.NotificationType('$/progress');
+})(ProgressNotification || (ProgressNotification = {}));
+class ProgressType {
+    /**
+     * Clients must not use these properties. They are here to ensure correct typing.
+     * in TypeScript
+     */
+    __;
+    _pr;
+    constructor() {
+    }
+}
+exports.ProgressType = ProgressType;
+var StarRequestHandler;
+(function (StarRequestHandler) {
+    function is(value) {
+        return Is.func(value);
+    }
+    StarRequestHandler.is = is;
+})(StarRequestHandler || (StarRequestHandler = {}));
+exports.NullLogger = Object.freeze({
+    error: () => { },
+    warn: () => { },
+    info: () => { },
+    log: () => { }
+});
+var Trace;
+(function (Trace) {
+    Trace[Trace["Off"] = 0] = "Off";
+    Trace[Trace["Messages"] = 1] = "Messages";
+    Trace[Trace["Compact"] = 2] = "Compact";
+    Trace[Trace["Verbose"] = 3] = "Verbose";
+})(Trace || (exports.Trace = Trace = {}));
+var TraceValue;
+(function (TraceValue) {
+    /**
+     * Turn tracing off.
+     */
+    TraceValue.Off = 'off';
+    /**
+     * Trace messages only.
+     */
+    TraceValue.Messages = 'messages';
+    /**
+     * Compact message tracing.
+     */
+    TraceValue.Compact = 'compact';
+    /**
+     * Verbose message tracing.
+     */
+    TraceValue.Verbose = 'verbose';
+})(TraceValue || (exports.TraceValue = TraceValue = {}));
+/**
+ * @deprecated Use TraceValue instead
+ */
+exports.TraceValues = TraceValue;
+(function (Trace) {
+    function fromString(value) {
+        if (!Is.string(value)) {
+            return Trace.Off;
+        }
+        value = value.toLowerCase();
+        switch (value) {
+            case 'off':
+                return Trace.Off;
+            case 'messages':
+                return Trace.Messages;
+            case 'compact':
+                return Trace.Compact;
+            case 'verbose':
+                return Trace.Verbose;
+            default:
+                return Trace.Off;
+        }
+    }
+    Trace.fromString = fromString;
+    function toString(value) {
+        switch (value) {
+            case Trace.Off:
+                return 'off';
+            case Trace.Messages:
+                return 'messages';
+            case Trace.Compact:
+                return 'compact';
+            case Trace.Verbose:
+                return 'verbose';
+            default:
+                return 'off';
+        }
+    }
+    Trace.toString = toString;
+})(Trace || (exports.Trace = Trace = {}));
+var TraceFormat;
+(function (TraceFormat) {
+    TraceFormat["Text"] = "text";
+    TraceFormat["JSON"] = "json";
+})(TraceFormat || (exports.TraceFormat = TraceFormat = {}));
+(function (TraceFormat) {
+    function fromString(value) {
+        if (!Is.string(value)) {
+            return TraceFormat.Text;
+        }
+        value = value.toLowerCase();
+        if (value === 'json') {
+            return TraceFormat.JSON;
+        }
+        else {
+            return TraceFormat.Text;
+        }
+    }
+    TraceFormat.fromString = fromString;
+})(TraceFormat || (exports.TraceFormat = TraceFormat = {}));
+var SetTraceNotification;
+(function (SetTraceNotification) {
+    SetTraceNotification.type = new messages_1.NotificationType('$/setTrace');
+})(SetTraceNotification || (exports.SetTraceNotification = SetTraceNotification = {}));
+var LogTraceNotification;
+(function (LogTraceNotification) {
+    LogTraceNotification.type = new messages_1.NotificationType('$/logTrace');
+})(LogTraceNotification || (exports.LogTraceNotification = LogTraceNotification = {}));
+var ConnectionErrors;
+(function (ConnectionErrors) {
+    /**
+     * The connection is closed.
+     */
+    ConnectionErrors[ConnectionErrors["Closed"] = 1] = "Closed";
+    /**
+     * The connection got disposed.
+     */
+    ConnectionErrors[ConnectionErrors["Disposed"] = 2] = "Disposed";
+    /**
+     * The connection is already in listening mode.
+     */
+    ConnectionErrors[ConnectionErrors["AlreadyListening"] = 3] = "AlreadyListening";
+})(ConnectionErrors || (exports.ConnectionErrors = ConnectionErrors = {}));
+class ConnectionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        Object.setPrototypeOf(this, ConnectionError.prototype);
+    }
+}
+exports.ConnectionError = ConnectionError;
+var ConnectionStrategy;
+(function (ConnectionStrategy) {
+    function is(value) {
+        const candidate = value;
+        return candidate && Is.func(candidate.cancelUndispatched);
+    }
+    ConnectionStrategy.is = is;
+})(ConnectionStrategy || (exports.ConnectionStrategy = ConnectionStrategy = {}));
+var IdCancellationReceiverStrategy;
+(function (IdCancellationReceiverStrategy) {
+    function is(value) {
+        const candidate = value;
+        return candidate && (candidate.kind === undefined || candidate.kind === 'id') && Is.func(candidate.createCancellationTokenSource) && (candidate.dispose === undefined || Is.func(candidate.dispose));
+    }
+    IdCancellationReceiverStrategy.is = is;
+})(IdCancellationReceiverStrategy || (exports.IdCancellationReceiverStrategy = IdCancellationReceiverStrategy = {}));
+var RequestCancellationReceiverStrategy;
+(function (RequestCancellationReceiverStrategy) {
+    function is(value) {
+        const candidate = value;
+        return candidate && candidate.kind === 'request' && Is.func(candidate.createCancellationTokenSource) && (candidate.dispose === undefined || Is.func(candidate.dispose));
+    }
+    RequestCancellationReceiverStrategy.is = is;
+})(RequestCancellationReceiverStrategy || (exports.RequestCancellationReceiverStrategy = RequestCancellationReceiverStrategy = {}));
+var CancellationReceiverStrategy;
+(function (CancellationReceiverStrategy) {
+    CancellationReceiverStrategy.Message = Object.freeze({
+        createCancellationTokenSource(_) {
+            return new cancellation_1.CancellationTokenSource();
+        }
+    });
+    function is(value) {
+        return IdCancellationReceiverStrategy.is(value) || RequestCancellationReceiverStrategy.is(value);
+    }
+    CancellationReceiverStrategy.is = is;
+})(CancellationReceiverStrategy || (exports.CancellationReceiverStrategy = CancellationReceiverStrategy = {}));
+var CancellationSenderStrategy;
+(function (CancellationSenderStrategy) {
+    CancellationSenderStrategy.Message = Object.freeze({
+        sendCancellation(conn, id) {
+            return conn.sendNotification(CancelNotification.type, { id });
+        },
+        cleanup(_) { }
+    });
+    function is(value) {
+        const candidate = value;
+        return candidate && Is.func(candidate.sendCancellation) && Is.func(candidate.cleanup);
+    }
+    CancellationSenderStrategy.is = is;
+})(CancellationSenderStrategy || (exports.CancellationSenderStrategy = CancellationSenderStrategy = {}));
+var CancellationStrategy;
+(function (CancellationStrategy) {
+    CancellationStrategy.Message = Object.freeze({
+        receiver: CancellationReceiverStrategy.Message,
+        sender: CancellationSenderStrategy.Message
+    });
+    function is(value) {
+        const candidate = value;
+        return candidate && CancellationReceiverStrategy.is(candidate.receiver) && CancellationSenderStrategy.is(candidate.sender);
+    }
+    CancellationStrategy.is = is;
+})(CancellationStrategy || (exports.CancellationStrategy = CancellationStrategy = {}));
+var MessageStrategy;
+(function (MessageStrategy) {
+    function is(value) {
+        const candidate = value;
+        return candidate && Is.func(candidate.handleMessage);
+    }
+    MessageStrategy.is = is;
+})(MessageStrategy || (exports.MessageStrategy = MessageStrategy = {}));
+var ConnectionOptions;
+(function (ConnectionOptions) {
+    function is(value) {
+        const candidate = value;
+        return candidate
+            && (CancellationStrategy.is(candidate.cancellationStrategy) || ConnectionStrategy.is(candidate.connectionStrategy) || MessageStrategy.is(candidate.messageStrategy) || Is.number(candidate.maxParallelism));
+    }
+    ConnectionOptions.is = is;
+})(ConnectionOptions || (exports.ConnectionOptions = ConnectionOptions = {}));
+var ConnectionState;
+(function (ConnectionState) {
+    ConnectionState[ConnectionState["New"] = 1] = "New";
+    ConnectionState[ConnectionState["Listening"] = 2] = "Listening";
+    ConnectionState[ConnectionState["Closed"] = 3] = "Closed";
+    ConnectionState[ConnectionState["Disposed"] = 4] = "Disposed";
+})(ConnectionState || (ConnectionState = {}));
+function createMessageConnection(messageReader, messageWriter, _logger, options) {
+    const logger = _logger !== undefined ? _logger : exports.NullLogger;
+    let sequenceNumber = 0;
+    let notificationSequenceNumber = 0;
+    let unknownResponseSequenceNumber = 0;
+    const version = '2.0';
+    const maxParallelism = options?.maxParallelism ?? -1;
+    let inFlight = 0;
+    let starRequestHandler = undefined;
+    const requestHandlers = new Map();
+    let starNotificationHandler = undefined;
+    const notificationHandlers = new Map();
+    const progressHandlers = new Map();
+    let timer;
+    let messageQueue = new linkedMap_1.LinkedMap();
+    let responsePromises = new Map();
+    let knownCanceledRequests = new Set();
+    let requestTokens = new Map();
+    let trace = Trace.Off;
+    let traceFormat = TraceFormat.Text;
+    let tracer;
+    let state = ConnectionState.New;
+    const errorEmitter = new events_1.Emitter();
+    const closeEmitter = new events_1.Emitter();
+    const unhandledNotificationEmitter = new events_1.Emitter();
+    const unhandledProgressEmitter = new events_1.Emitter();
+    const disposeEmitter = new events_1.Emitter();
+    const cancellationStrategy = (options && options.cancellationStrategy) ? options.cancellationStrategy : CancellationStrategy.Message;
+    function cancelUndispatched(_message) {
+        return undefined;
+    }
+    function isListening() {
+        return state === ConnectionState.Listening;
+    }
+    function isClosed() {
+        return state === ConnectionState.Closed;
+    }
+    function isDisposed() {
+        return state === ConnectionState.Disposed;
+    }
+    function closeHandler() {
+        if (state === ConnectionState.New || state === ConnectionState.Listening) {
+            state = ConnectionState.Closed;
+            closeEmitter.fire(undefined);
+        }
+        // If the connection is disposed don't sent close events.
+    }
+    function readErrorHandler(error) {
+        errorEmitter.fire([error, undefined, undefined]);
+    }
+    function writeErrorHandler(data) {
+        errorEmitter.fire(data);
+    }
+    messageReader.onClose(closeHandler);
+    messageReader.onError(readErrorHandler);
+    messageWriter.onClose(closeHandler);
+    messageWriter.onError(writeErrorHandler);
+    function createRequestQueueKey(id) {
+        if (id === null) {
+            throw new Error(`Can't send requests with id null since the response can't be correlated.`);
+        }
+        return 'req-' + id.toString();
+    }
+    function createResponseQueueKey(id) {
+        if (id === null) {
+            return 'res-unknown-' + (++unknownResponseSequenceNumber).toString();
+        }
+        else {
+            return 'res-' + id.toString();
+        }
+    }
+    function createNotificationQueueKey() {
+        return 'not-' + (++notificationSequenceNumber).toString();
+    }
+    function addMessageToQueue(queue, message) {
+        if (messages_1.Message.isRequest(message)) {
+            queue.set(createRequestQueueKey(message.id), message);
+        }
+        else if (messages_1.Message.isResponse(message)) {
+            // If we have unlimited parallelism we queue the response to keep
+            // the previous semantics.
+            if (maxParallelism === -1) {
+                queue.set(createResponseQueueKey(message.id), message);
+            }
+            else {
+                // If we have limited parallelism we resolve responses to avoid
+                // dead locks.
+                handleResponse(message);
+            }
+        }
+        else {
+            queue.set(createNotificationQueueKey(), message);
+        }
+    }
+    function triggerMessageQueue() {
+        if (timer || messageQueue.size === 0) {
+            return;
+        }
+        if (maxParallelism !== -1 && inFlight >= maxParallelism) {
+            return;
+        }
+        timer = (0, ral_1.default)().timer.setImmediate(async () => {
+            timer = undefined;
+            if (messageQueue.size === 0) {
+                return;
+            }
+            if (maxParallelism !== -1 && inFlight >= maxParallelism) {
+                return;
+            }
+            const message = messageQueue.shift();
+            let result;
+            try {
+                inFlight++;
+                const messageStrategy = options?.messageStrategy;
+                if (MessageStrategy.is(messageStrategy)) {
+                    result = messageStrategy.handleMessage(message, handleMessage);
+                }
+                else {
+                    result = handleMessage(message);
+                }
+            }
+            catch (error) {
+                logger.error(`Processing message queue failed: ${error.toString()}`);
+            }
+            finally {
+                if (result instanceof Promise) {
+                    result.then(() => {
+                        inFlight--;
+                        triggerMessageQueue();
+                    }).catch((error) => {
+                        logger.error(`Processing message queue failed: ${error.toString()}`);
+                    });
+                }
+                else {
+                    inFlight--;
+                }
+                triggerMessageQueue();
+            }
+        });
+    }
+    async function handleMessage(message) {
+        if (messages_1.Message.isRequest(message)) {
+            return handleRequest(message);
+        }
+        else if (messages_1.Message.isNotification(message)) {
+            return handleNotification(message);
+        }
+        else if (messages_1.Message.isResponse(message)) {
+            return handleResponse(message);
+        }
+        else {
+            return handleInvalidMessage(message);
+        }
+    }
+    const callback = (message) => {
+        try {
+            // We have received a cancellation message. Check if the message is still in the queue
+            // and cancel it if allowed to do so.
+            if (messages_1.Message.isNotification(message) && message.method === CancelNotification.type.method) {
+                const cancelId = message.params.id;
+                const key = createRequestQueueKey(cancelId);
+                const toCancel = messageQueue.get(key);
+                if (messages_1.Message.isRequest(toCancel)) {
+                    const strategy = options?.connectionStrategy;
+                    const response = (strategy && strategy.cancelUndispatched) ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
+                    if (response && (response.error !== undefined || response.result !== undefined)) {
+                        messageQueue.delete(key);
+                        requestTokens.delete(cancelId);
+                        response.id = toCancel.id;
+                        traceSendingResponse(response, message.method, Date.now());
+                        messageWriter.write(response).catch(() => logger.error(`Sending response for canceled message failed.`));
+                        return;
+                    }
+                }
+                const cancellationToken = requestTokens.get(cancelId);
+                // The request is already running. Cancel the token
+                if (cancellationToken !== undefined) {
+                    cancellationToken.cancel();
+                    traceReceivedNotification(message);
+                    return;
+                }
+                else {
+                    // Remember the cancel but still queue the message to
+                    // clean up state in process message.
+                    knownCanceledRequests.add(cancelId);
+                }
+            }
+            addMessageToQueue(messageQueue, message);
+        }
+        finally {
+            triggerMessageQueue();
+        }
+    };
+    async function handleRequest(requestMessage) {
+        if (isDisposed()) {
+            // we return here silently since we fired an event when the
+            // connection got disposed.
+            return Promise.resolve();
+        }
+        function reply(resultOrError, method, startTime) {
+            const message = {
+                jsonrpc: version,
+                id: requestMessage.id
+            };
+            if (resultOrError instanceof messages_1.ResponseError) {
+                message.error = resultOrError.toJson();
+            }
+            else {
+                message.result = resultOrError === undefined ? null : resultOrError;
+            }
+            traceSendingResponse(message, method, startTime);
+            return messageWriter.write(message);
+        }
+        function replyError(error, method, startTime) {
+            const message = {
+                jsonrpc: version,
+                id: requestMessage.id,
+                error: error.toJson()
+            };
+            traceSendingResponse(message, method, startTime);
+            return messageWriter.write(message);
+        }
+        traceReceivedRequest(requestMessage);
+        const element = requestHandlers.get(requestMessage.method);
+        let type;
+        let requestHandler;
+        if (element) {
+            type = element.type;
+            requestHandler = element.handler;
+        }
+        const startTime = Date.now();
+        if (requestHandler || starRequestHandler) {
+            const tokenKey = requestMessage.id ?? String(Date.now()); //
+            const cancellationSource = IdCancellationReceiverStrategy.is(cancellationStrategy.receiver)
+                ? cancellationStrategy.receiver.createCancellationTokenSource(tokenKey)
+                : cancellationStrategy.receiver.createCancellationTokenSource(requestMessage);
+            if (requestMessage.id !== null && knownCanceledRequests.has(requestMessage.id)) {
+                cancellationSource.cancel();
+            }
+            if (requestMessage.id !== null) {
+                requestTokens.set(tokenKey, cancellationSource);
+            }
+            try {
+                let handlerResult;
+                if (requestHandler) {
+                    if (requestMessage.params === undefined) {
+                        if (type !== undefined && type.numberOfParams !== 0) {
+                            return replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines ${type.numberOfParams} params but received none.`), requestMessage.method, startTime);
+                        }
+                        handlerResult = requestHandler(cancellationSource.token);
+                    }
+                    else if (Array.isArray(requestMessage.params)) {
+                        if (type !== undefined && type.parameterStructures === messages_1.ParameterStructures.byName) {
+                            return replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by name but received parameters by position`), requestMessage.method, startTime);
+                        }
+                        handlerResult = requestHandler(...requestMessage.params, cancellationSource.token);
+                    }
+                    else {
+                        if (type !== undefined && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
+                            return replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by position but received parameters by name`), requestMessage.method, startTime);
+                        }
+                        handlerResult = requestHandler(requestMessage.params, cancellationSource.token);
+                    }
+                }
+                else if (starRequestHandler) {
+                    handlerResult = starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);
+                }
+                const resultOrError = await handlerResult;
+                await reply(resultOrError, requestMessage.method, startTime);
+            }
+            catch (error) {
+                if (error instanceof messages_1.ResponseError) {
+                    await reply(error, requestMessage.method, startTime);
+                }
+                else if (error && Is.string(error.message)) {
+                    await replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
+                }
+                else {
+                    await replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
+                }
+            }
+            finally {
+                requestTokens.delete(tokenKey);
+            }
+        }
+        else {
+            await replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);
+        }
+    }
+    function handleResponse(responseMessage) {
+        if (isDisposed()) {
+            // See handle request.
+            return;
+        }
+        if (responseMessage.id === null) {
+            if (responseMessage.error) {
+                logger.error(`Received response message without id: Error is: \n${JSON.stringify(responseMessage.error, undefined, 4)}`);
+            }
+            else {
+                logger.error(`Received response message without id. No further error information provided.`);
+            }
+        }
+        else {
+            const key = responseMessage.id;
+            const responsePromise = responsePromises.get(key);
+            traceReceivedResponse(responseMessage, responsePromise);
+            if (responsePromise !== undefined) {
+                responsePromises.delete(key);
+                try {
+                    if (responseMessage.error) {
+                        const error = responseMessage.error;
+                        responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data));
+                    }
+                    else if (responseMessage.result !== undefined) {
+                        responsePromise.resolve(responseMessage.result);
+                    }
+                    else {
+                        throw new Error('Should never happen.');
+                    }
+                }
+                catch (error) {
+                    if (error.message) {
+                        logger.error(`Response handler '${responsePromise.method}' failed with message: ${error.message}`);
+                    }
+                    else {
+                        logger.error(`Response handler '${responsePromise.method}' failed unexpectedly.`);
+                    }
+                }
+            }
+        }
+    }
+    async function handleNotification(message) {
+        if (isDisposed()) {
+            // See handle request.
+            return;
+        }
+        let type = undefined;
+        let notificationHandler;
+        if (message.method === CancelNotification.type.method) {
+            const cancelId = message.params.id;
+            knownCanceledRequests.delete(cancelId);
+            traceReceivedNotification(message);
+            return;
+        }
+        else {
+            const element = notificationHandlers.get(message.method);
+            if (element) {
+                notificationHandler = element.handler;
+                type = element.type;
+            }
+        }
+        if (notificationHandler || starNotificationHandler) {
+            try {
+                traceReceivedNotification(message);
+                if (notificationHandler) {
+                    if (message.params === undefined) {
+                        if (type !== undefined) {
+                            if (type.numberOfParams !== 0 && type.parameterStructures !== messages_1.ParameterStructures.byName) {
+                                logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received none.`);
+                            }
+                        }
+                        await notificationHandler();
+                    }
+                    else if (Array.isArray(message.params)) {
+                        // There are JSON-RPC libraries that send progress message as positional params although
+                        // specified as named. So convert them if this is the case.
+                        const params = message.params;
+                        if (message.method === ProgressNotification.type.method && params.length === 2 && ProgressToken.is(params[0])) {
+                            await notificationHandler({ token: params[0], value: params[1] });
+                        }
+                        else {
+                            if (type !== undefined) {
+                                if (type.parameterStructures === messages_1.ParameterStructures.byName) {
+                                    logger.error(`Notification ${message.method} defines parameters by name but received parameters by position`);
+                                }
+                                if (type.numberOfParams !== message.params.length) {
+                                    logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received ${params.length} arguments`);
+                                }
+                            }
+                            await notificationHandler(...params);
+                        }
+                    }
+                    else {
+                        if (type !== undefined && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
+                            logger.error(`Notification ${message.method} defines parameters by position but received parameters by name`);
+                        }
+                        await notificationHandler(message.params);
+                    }
+                }
+                else if (starNotificationHandler) {
+                    await starNotificationHandler(message.method, message.params);
+                }
+            }
+            catch (error) {
+                if (error.message) {
+                    logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);
+                }
+                else {
+                    logger.error(`Notification handler '${message.method}' failed unexpectedly.`);
+                }
+            }
+        }
+        else {
+            unhandledNotificationEmitter.fire(message);
+        }
+    }
+    function handleInvalidMessage(message) {
+        if (!message) {
+            logger.error('Received empty message.');
+            return;
+        }
+        logger.error(`Received message which is neither a response nor a notification message:\n${JSON.stringify(message, null, 4)}`);
+        // Test whether we find an id to reject the promise
+        const responseMessage = message;
+        if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) {
+            const key = responseMessage.id;
+            const responseHandler = responsePromises.get(key);
+            if (responseHandler) {
+                responseHandler.reject(new Error('The received response has neither a result nor an error property.'));
+            }
+        }
+    }
+    function stringifyTrace(params) {
+        if (params === undefined || params === null) {
+            return undefined;
+        }
+        switch (trace) {
+            case Trace.Verbose:
+                return JSON.stringify(params, null, 4);
+            case Trace.Compact:
+                return JSON.stringify(params);
+            default:
+                return undefined;
+        }
+    }
+    function traceSendingRequest(message) {
+        if (trace === Trace.Off || !tracer) {
+            return;
+        }
+        if (traceFormat === TraceFormat.Text) {
+            let data = undefined;
+            if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
+                data = `Params: ${stringifyTrace(message.params)}`;
+            }
+            tracer.log(`Sending request '${message.method} - (${message.id})'.`, data);
+        }
+        else {
+            logLSPMessage('send-request', message);
+        }
+    }
+    function traceSendingNotification(message) {
+        if (trace === Trace.Off || !tracer) {
+            return;
+        }
+        if (traceFormat === TraceFormat.Text) {
+            let data = undefined;
+            if (trace === Trace.Verbose || trace === Trace.Compact) {
+                if (message.params) {
+                    data = `Params: ${stringifyTrace(message.params)}`;
+                }
+                else {
+                    data = 'No parameters provided.';
+                }
+            }
+            tracer.log(`Sending notification '${message.method}'.`, data);
+        }
+        else {
+            logLSPMessage('send-notification', message);
+        }
+    }
+    function traceSendingResponse(message, method, startTime) {
+        if (trace === Trace.Off || !tracer) {
+            return;
+        }
+        if (traceFormat === TraceFormat.Text) {
+            let data = undefined;
+            if (trace === Trace.Verbose || trace === Trace.Compact) {
+                if (message.error && message.error.data) {
+                    data = `Error data: ${stringifyTrace(message.error.data)}`;
+                }
+                else {
+                    if (message.result) {
+                        data = `Result: ${stringifyTrace(message.result)}`;
+                    }
+                    else if (message.error === undefined) {
+                        data = 'No result returned.';
+                    }
+                }
+            }
+            tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms`, data);
+        }
+        else {
+            logLSPMessage('send-response', message);
+        }
+    }
+    function traceReceivedRequest(message) {
+        if (trace === Trace.Off || !tracer) {
+            return;
+        }
+        if (traceFormat === TraceFormat.Text) {
+            let data = undefined;
+            if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
+                data = `Params: ${stringifyTrace(message.params)}`;
+            }
+            tracer.log(`Received request '${message.method} - (${message.id})'.`, data);
+        }
+        else {
+            logLSPMessage('receive-request', message);
+        }
+    }
+    function traceReceivedNotification(message) {
+        if (trace === Trace.Off || !tracer || message.method === LogTraceNotification.type.method) {
+            return;
+        }
+        if (traceFormat === TraceFormat.Text) {
+            let data = undefined;
+            if (trace === Trace.Verbose || trace === Trace.Compact) {
+                if (message.params) {
+                    data = `Params: ${stringifyTrace(message.params)}`;
+                }
+                else {
+                    data = 'No parameters provided.';
+                }
+            }
+            tracer.log(`Received notification '${message.method}'.`, data);
+        }
+        else {
+            logLSPMessage('receive-notification', message);
+        }
+    }
+    function traceReceivedResponse(message, responsePromise) {
+        if (trace === Trace.Off || !tracer) {
+            return;
+        }
+        if (traceFormat === TraceFormat.Text) {
+            let data = undefined;
+            if (trace === Trace.Verbose || trace === Trace.Compact) {
+                if (message.error && message.error.data) {
+                    data = `Error data: ${stringifyTrace(message.error.data)}`;
+                }
+                else {
+                    if (message.result) {
+                        data = `Result: ${stringifyTrace(message.result)}`;
+                    }
+                    else if (message.error === undefined) {
+                        data = 'No result returned.';
+                    }
+                }
+            }
+            if (responsePromise) {
+                const error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : '';
+                tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);
+            }
+            else {
+                tracer.log(`Received response ${message.id} without active response promise.`, data);
+            }
+        }
+        else {
+            logLSPMessage('receive-response', message);
+        }
+    }
+    function logLSPMessage(type, message) {
+        if (!tracer || trace === Trace.Off) {
+            return;
+        }
+        const lspMessage = {
+            isLSPMessage: true,
+            type,
+            message,
+            timestamp: Date.now()
+        };
+        tracer.log(lspMessage);
+    }
+    function throwIfClosedOrDisposed() {
+        if (isClosed()) {
+            throw new ConnectionError(ConnectionErrors.Closed, 'Connection is closed.');
+        }
+        if (isDisposed()) {
+            throw new ConnectionError(ConnectionErrors.Disposed, 'Connection is disposed.');
+        }
+    }
+    function throwIfListening() {
+        if (isListening()) {
+            throw new ConnectionError(ConnectionErrors.AlreadyListening, 'Connection is already listening');
+        }
+    }
+    function throwIfNotListening() {
+        if (!isListening()) {
+            throw new Error('Call listen() first.');
+        }
+    }
+    function undefinedToNull(param) {
+        if (param === undefined) {
+            return null;
+        }
+        else {
+            return param;
+        }
+    }
+    function nullToUndefined(param) {
+        if (param === null) {
+            return undefined;
+        }
+        else {
+            return param;
+        }
+    }
+    function isNamedParam(param) {
+        return param !== undefined && param !== null && !Array.isArray(param) && typeof param === 'object';
+    }
+    function computeSingleParam(parameterStructures, param) {
+        switch (parameterStructures) {
+            case messages_1.ParameterStructures.auto:
+                if (isNamedParam(param)) {
+                    return nullToUndefined(param);
+                }
+                else {
+                    return [undefinedToNull(param)];
+                }
+            case messages_1.ParameterStructures.byName:
+                if (!isNamedParam(param)) {
+                    throw new Error(`Received parameters by name but param is not an object literal.`);
+                }
+                return nullToUndefined(param);
+            case messages_1.ParameterStructures.byPosition:
+                return [undefinedToNull(param)];
+            default:
+                throw new Error(`Unknown parameter structure ${parameterStructures.toString()}`);
+        }
+    }
+    function computeMessageParams(type, params) {
+        let result;
+        const numberOfParams = type.numberOfParams;
+        switch (numberOfParams) {
+            case 0:
+                result = undefined;
+                break;
+            case 1:
+                result = computeSingleParam(type.parameterStructures, params[0]);
+                break;
+            default:
+                result = [];
+                for (let i = 0; i < params.length && i < numberOfParams; i++) {
+                    result.push(undefinedToNull(params[i]));
+                }
+                if (params.length < numberOfParams) {
+                    for (let i = params.length; i < numberOfParams; i++) {
+                        result.push(null);
+                    }
+                }
+                break;
+        }
+        return result;
+    }
+    const connection = {
+        sendNotification: (type, ...args) => {
+            throwIfClosedOrDisposed();
+            let method;
+            let messageParams;
+            if (Is.string(type)) {
+                method = type;
+                const first = args[0];
+                let paramStart = 0;
+                let parameterStructures = messages_1.ParameterStructures.auto;
+                if (messages_1.ParameterStructures.is(first)) {
+                    paramStart = 1;
+                    parameterStructures = first;
+                }
+                const paramEnd = args.length;
+                const numberOfParams = paramEnd - paramStart;
+                switch (numberOfParams) {
+                    case 0:
+                        messageParams = undefined;
+                        break;
+                    case 1:
+                        messageParams = computeSingleParam(parameterStructures, args[paramStart]);
+                        break;
+                    default:
+                        if (parameterStructures === messages_1.ParameterStructures.byName) {
+                            throw new Error(`Received ${numberOfParams} parameters for 'by Name' notification parameter structure.`);
+                        }
+                        messageParams = args.slice(paramStart, paramEnd).map(value => undefinedToNull(value));
+                        break;
+                }
+            }
+            else {
+                const params = args;
+                method = type.method;
+                messageParams = computeMessageParams(type, params);
+            }
+            const notificationMessage = {
+                jsonrpc: version,
+                method: method,
+                params: messageParams
+            };
+            traceSendingNotification(notificationMessage);
+            return messageWriter.write(notificationMessage).catch((error) => {
+                logger.error(`Sending notification failed.`);
+                throw error;
+            });
+        },
+        onNotification: (type, handler) => {
+            throwIfClosedOrDisposed();
+            let method;
+            if (Is.func(type)) {
+                starNotificationHandler = type;
+            }
+            else if (handler) {
+                if (Is.string(type)) {
+                    method = type;
+                    notificationHandlers.set(type, { type: undefined, handler });
+                }
+                else {
+                    method = type.method;
+                    notificationHandlers.set(type.method, { type, handler });
+                }
+            }
+            return {
+                dispose: () => {
+                    if (method !== undefined) {
+                        if (notificationHandlers.get(method)?.handler === handler) {
+                            notificationHandlers.delete(method);
+                        }
+                    }
+                    else if (starNotificationHandler === type) {
+                        starNotificationHandler = undefined;
+                    }
+                }
+            };
+        },
+        onProgress: (_type, token, handler) => {
+            if (progressHandlers.has(token)) {
+                throw new Error(`Progress handler for token ${token} already registered`);
+            }
+            progressHandlers.set(token, handler);
+            return {
+                dispose: () => {
+                    if (progressHandlers.get(token) === handler) {
+                        progressHandlers.delete(token);
+                    }
+                }
+            };
+        },
+        sendProgress: (_type, token, value) => {
+            // This should not await but simple return to ensure that we don't have another
+            // async scheduling. Otherwise one send could overtake another send.
+            return connection.sendNotification(ProgressNotification.type, { token, value });
+        },
+        onUnhandledProgress: unhandledProgressEmitter.event,
+        sendRequest: (type, ...args) => {
+            throwIfClosedOrDisposed();
+            throwIfNotListening();
+            function sendCancellation(connection, id) {
+                const p = cancellationStrategy.sender.sendCancellation(connection, id);
+                if (p === undefined) {
+                    logger.log(`Received no promise from cancellation strategy when cancelling id ${id}`);
+                }
+                else {
+                    p.catch(() => {
+                        logger.log(`Sending cancellation messages for id ${id} failed.`);
+                    });
+                }
+            }
+            let method;
+            let messageParams;
+            let token = undefined;
+            if (Is.string(type)) {
+                method = type;
+                const first = args[0];
+                const last = args[args.length - 1];
+                let paramStart = 0;
+                let parameterStructures = messages_1.ParameterStructures.auto;
+                if (messages_1.ParameterStructures.is(first)) {
+                    paramStart = 1;
+                    parameterStructures = first;
+                }
+                let paramEnd = args.length;
+                if (cancellation_1.CancellationToken.is(last)) {
+                    paramEnd = paramEnd - 1;
+                    token = last;
+                }
+                const numberOfParams = paramEnd - paramStart;
+                switch (numberOfParams) {
+                    case 0:
+                        messageParams = undefined;
+                        break;
+                    case 1:
+                        messageParams = computeSingleParam(parameterStructures, args[paramStart]);
+                        break;
+                    default:
+                        if (parameterStructures === messages_1.ParameterStructures.byName) {
+                            throw new Error(`Received ${numberOfParams} parameters for 'by Name' request parameter structure.`);
+                        }
+                        messageParams = args.slice(paramStart, paramEnd).map(value => undefinedToNull(value));
+                        break;
+                }
+            }
+            else {
+                const params = args;
+                method = type.method;
+                messageParams = computeMessageParams(type, params);
+                const numberOfParams = type.numberOfParams;
+                token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : undefined;
+            }
+            const id = sequenceNumber++;
+            let disposable;
+            let tokenWasCancelled = false;
+            if (token !== undefined) {
+                if (token.isCancellationRequested) {
+                    tokenWasCancelled = true;
+                }
+                else {
+                    disposable = token.onCancellationRequested(() => {
+                        sendCancellation(connection, id);
+                    });
+                }
+            }
+            const requestMessage = {
+                jsonrpc: version,
+                id: id,
+                method: method,
+                params: messageParams
+            };
+            traceSendingRequest(requestMessage);
+            if (typeof cancellationStrategy.sender.enableCancellation === 'function') {
+                cancellationStrategy.sender.enableCancellation(requestMessage);
+            }
+            // eslint-disable-next-line no-async-promise-executor
+            return new Promise(async (resolve, reject) => {
+                const resolveWithCleanup = (r) => {
+                    resolve(r);
+                    cancellationStrategy.sender.cleanup(id);
+                    disposable?.dispose();
+                };
+                const rejectWithCleanup = (r) => {
+                    reject(r);
+                    cancellationStrategy.sender.cleanup(id);
+                    disposable?.dispose();
+                };
+                const responsePromise = { method: method, timerStart: Date.now(), resolve: resolveWithCleanup, reject: rejectWithCleanup };
+                try {
+                    responsePromises.set(id, responsePromise);
+                    await messageWriter.write(requestMessage);
+                    if (tokenWasCancelled) {
+                        sendCancellation(connection, id);
+                    }
+                }
+                catch (error) {
+                    // Writing the message failed. So we need to delete it from the response promises and
+                    // reject it.
+                    responsePromises.delete(id);
+                    responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, error.message ? error.message : 'Unknown reason'));
+                    logger.error(`Sending request failed.`);
+                    throw error;
+                }
+            });
+        },
+        onRequest: (type, handler) => {
+            throwIfClosedOrDisposed();
+            let method = null;
+            if (StarRequestHandler.is(type)) {
+                method = undefined;
+                starRequestHandler = type;
+            }
+            else if (Is.string(type)) {
+                method = null;
+                if (handler !== undefined) {
+                    method = type;
+                    requestHandlers.set(type, { handler: handler, type: undefined });
+                }
+            }
+            else {
+                if (handler !== undefined) {
+                    method = type.method;
+                    requestHandlers.set(type.method, { type, handler });
+                }
+            }
+            return {
+                dispose: () => {
+                    if (method === null) {
+                        return;
+                    }
+                    if (method !== undefined) {
+                        if (requestHandlers.get(method)?.handler === handler) {
+                            requestHandlers.delete(method);
+                        }
+                    }
+                    else if (starRequestHandler === type) {
+                        starRequestHandler = undefined;
+                    }
+                }
+            };
+        },
+        hasPendingResponse: () => {
+            return responsePromises.size > 0;
+        },
+        trace: async (_value, _tracer, sendNotificationOrTraceOptions) => {
+            let _sendNotification = false;
+            let _traceFormat = TraceFormat.Text;
+            if (sendNotificationOrTraceOptions !== undefined) {
+                if (Is.boolean(sendNotificationOrTraceOptions)) {
+                    _sendNotification = sendNotificationOrTraceOptions;
+                }
+                else {
+                    _sendNotification = sendNotificationOrTraceOptions.sendNotification || false;
+                    _traceFormat = sendNotificationOrTraceOptions.traceFormat || TraceFormat.Text;
+                }
+            }
+            trace = _value;
+            traceFormat = _traceFormat;
+            if (trace === Trace.Off) {
+                tracer = undefined;
+            }
+            else {
+                tracer = _tracer;
+            }
+            if (_sendNotification && !isClosed() && !isDisposed()) {
+                await connection.sendNotification(SetTraceNotification.type, { value: Trace.toString(_value) });
+            }
+        },
+        onError: errorEmitter.event,
+        onClose: closeEmitter.event,
+        onUnhandledNotification: unhandledNotificationEmitter.event,
+        onDispose: disposeEmitter.event,
+        end: () => {
+            messageWriter.end();
+        },
+        dispose: () => {
+            if (isDisposed()) {
+                return;
+            }
+            state = ConnectionState.Disposed;
+            disposeEmitter.fire(undefined);
+            const error = new messages_1.ResponseError(messages_1.ErrorCodes.PendingResponseRejected, 'Pending response rejected since connection got disposed');
+            for (const promise of responsePromises.values()) {
+                promise.reject(error);
+            }
+            responsePromises = new Map();
+            requestTokens = new Map();
+            knownCanceledRequests = new Set();
+            messageQueue = new linkedMap_1.LinkedMap();
+            // Test for backwards compatibility
+            if (Is.func(messageWriter.dispose)) {
+                messageWriter.dispose();
+            }
+            if (Is.func(messageReader.dispose)) {
+                messageReader.dispose();
+            }
+        },
+        listen: () => {
+            throwIfClosedOrDisposed();
+            throwIfListening();
+            state = ConnectionState.Listening;
+            messageReader.listen(callback);
+        },
+        inspect: () => {
+            (0, ral_1.default)().console.log('inspect');
+        }
+    };
+    connection.onNotification(LogTraceNotification.type, (params) => {
+        if (trace === Trace.Off || !tracer) {
+            return;
+        }
+        const verbose = trace === Trace.Verbose || trace === Trace.Compact;
+        tracer.log(params.message, verbose ? params.verbose : undefined);
+    });
+    connection.onNotification(ProgressNotification.type, async (params) => {
+        const handler = progressHandlers.get(params.token);
+        if (handler) {
+            await handler(params.value);
+        }
+        else {
+            unhandledProgressEmitter.fire(params);
+        }
+    });
+    return connection;
+}