module.exports = /******/ (() => { // webpackBootstrap /******/ var __webpack_modules__ = ({ /***/ "./src/extension.ts": /*!**************************!*\ !*** ./src/extension.ts ***! \**************************/ /*! flagged exports */ /*! export __esModule [provided] [maybe used in main (runtime-defined)] [usage prevents renaming] */ /*! export activate [provided] [maybe used in main (runtime-defined)] [usage prevents renaming] */ /*! export deactivate [provided] [maybe used in main (runtime-defined)] [usage prevents renaming] */ /*! other exports [not provided] [maybe used in main (runtime-defined)] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.deactivate = exports.activate = void 0; const net = __webpack_require__(/*! net */ "net"); const path = __webpack_require__(/*! path */ "path"); const vscode_1 = __webpack_require__(/*! vscode */ "vscode"); const vscode_languageclient_1 = __webpack_require__(/*! vscode-languageclient */ "../node_modules/vscode-languageclient/lib/main.js"); let client; function spawnLanguageClient(context) { if (client) { return; } const config = vscode_1.workspace.getConfiguration('bolt'); const watchLanguageServer = config.get('watchLanguageServer'); let pathToLanguageServer = config.get('pathToLanguageServer'); if (pathToLanguageServer === null) { pathToLanguageServer = context.asAbsolutePath(path.join('bin', 'langserver.js')); } let serverOptions; const languageServerPort = process.env['VSCODE_BOLT_LANGUAGE_SERVER_PORT']; if (languageServerPort !== undefined) { const port = Number(languageServerPort); if (isNaN(port)) { return; } serverOptions = () => { const socket = net.connect(port); return Promise.resolve({ reader: socket, writer: socket }); }; } else { serverOptions = { module: pathToLanguageServer, transport: vscode_languageclient_1.TransportKind.ipc }; } ; // Options to control the language client let clientOptions = { // Register the server for plain text documents documentSelector: [{ scheme: 'file', language: 'bolt' }], synchronize: { // Notify the server about file changes to '.clientrc files contained in the workspace fileEvents: vscode_1.workspace.createFileSystemWatcher('**/*.bolt') } }; // Create the language client and start the client. client = new vscode_languageclient_1.LanguageClient('bolt-client', 'Bolt Language Server', serverOptions, clientOptions); // Start the client. This will also launch the server client.start(); } function activate(context) { spawnLanguageClient(context); } exports.activate = activate; function deactivate() { if (!client) { return undefined; } return client.stop(); } exports.deactivate = deactivate; /***/ }), /***/ "../node_modules/vscode-jsonrpc/lib/cancellation.js": /*!**********************************************************!*\ !*** ../node_modules/vscode-jsonrpc/lib/cancellation.js ***! \**********************************************************/ /*! flagged exports */ /*! export CancellationToken [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CancellationTokenSource [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /*--------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ Object.defineProperty(exports, "__esModule", ({ value: true })); const events_1 = __webpack_require__(/*! ./events */ "../node_modules/vscode-jsonrpc/lib/events.js"); const Is = __webpack_require__(/*! ./is */ "../node_modules/vscode-jsonrpc/lib/is.js"); var CancellationToken; (function (CancellationToken) { CancellationToken.None = Object.freeze({ isCancellationRequested: false, onCancellationRequested: events_1.Event.None }); CancellationToken.Cancelled = Object.freeze({ isCancellationRequested: true, onCancellationRequested: events_1.Event.None }); function is(value) { let candidate = value; return candidate && (candidate === CancellationToken.None || candidate === CancellationToken.Cancelled || (Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested)); } CancellationToken.is = is; })(CancellationToken = exports.CancellationToken || (exports.CancellationToken = {})); const shortcutEvent = Object.freeze(function (callback, context) { let handle = setTimeout(callback.bind(context), 0); return { dispose() { clearTimeout(handle); } }; }); class MutableToken { constructor() { this._isCancelled = false; } cancel() { if (!this._isCancelled) { this._isCancelled = true; if (this._emitter) { this._emitter.fire(undefined); this.dispose(); } } } get isCancellationRequested() { return this._isCancelled; } get onCancellationRequested() { if (this._isCancelled) { return shortcutEvent; } if (!this._emitter) { this._emitter = new events_1.Emitter(); } return this._emitter.event; } dispose() { if (this._emitter) { this._emitter.dispose(); this._emitter = undefined; } } } class CancellationTokenSource { get token() { if (!this._token) { // be lazy and create the token only when // actually needed this._token = new MutableToken(); } return this._token; } cancel() { if (!this._token) { // save an object by returning the default // cancelled token when cancellation happens // before someone asks for the token this._token = CancellationToken.Cancelled; } else { this._token.cancel(); } } dispose() { if (!this._token) { // ensure to initialize with an empty token if we had none this._token = CancellationToken.None; } else if (this._token instanceof MutableToken) { // actually dispose this._token.dispose(); } } } exports.CancellationTokenSource = CancellationTokenSource; /***/ }), /***/ "../node_modules/vscode-jsonrpc/lib/events.js": /*!****************************************************!*\ !*** ../node_modules/vscode-jsonrpc/lib/events.js ***! \****************************************************/ /*! flagged exports */ /*! export Disposable [provided] [no usage info] [missing usage info prevents renaming] */ /*! export Emitter [provided] [no usage info] [missing usage info prevents renaming] */ /*! export Event [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__ */ /***/ ((__unused_webpack_module, exports) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); var Disposable; (function (Disposable) { function create(func) { return { dispose: func }; } Disposable.create = create; })(Disposable = exports.Disposable || (exports.Disposable = {})); var Event; (function (Event) { const _disposable = { dispose() { } }; Event.None = function () { return _disposable; }; })(Event = exports.Event || (exports.Event = {})); class CallbackList { add(callback, context = null, bucket) { if (!this._callbacks) { this._callbacks = []; this._contexts = []; } this._callbacks.push(callback); this._contexts.push(context); if (Array.isArray(bucket)) { bucket.push({ dispose: () => this.remove(callback, context) }); } } remove(callback, context = null) { if (!this._callbacks) { return; } var foundCallbackWithDifferentContext = false; for (var i = 0, len = this._callbacks.length; i < len; i++) { if (this._callbacks[i] === callback) { if (this._contexts[i] === context) { // callback & context match => remove it this._callbacks.splice(i, 1); this._contexts.splice(i, 1); return; } else { foundCallbackWithDifferentContext = true; } } } if (foundCallbackWithDifferentContext) { throw new Error('When adding a listener with a context, you should remove it with the same context'); } } invoke(...args) { if (!this._callbacks) { return []; } var ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0); for (var i = 0, len = callbacks.length; i < len; i++) { try { ret.push(callbacks[i].apply(contexts[i], args)); } catch (e) { // eslint-disable-next-line no-console console.error(e); } } return ret; } isEmpty() { return !this._callbacks || this._callbacks.length === 0; } dispose() { this._callbacks = undefined; this._contexts = undefined; } } class Emitter { constructor(_options) { this._options = _options; } /** * For the public to allow to subscribe * to events from this Emitter */ get event() { if (!this._event) { this._event = (listener, thisArgs, disposables) => { if (!this._callbacks) { this._callbacks = new CallbackList(); } if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) { this._options.onFirstListenerAdd(this); } this._callbacks.add(listener, thisArgs); let result; result = { dispose: () => { this._callbacks.remove(listener, thisArgs); result.dispose = Emitter._noop; if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) { this._options.onLastListenerRemove(this); } } }; if (Array.isArray(disposables)) { disposables.push(result); } return result; }; } return this._event; } /** * To be kept private to fire an event to * subscribers */ fire(event) { if (this._callbacks) { this._callbacks.invoke.call(this._callbacks, event); } } dispose() { if (this._callbacks) { this._callbacks.dispose(); this._callbacks = undefined; } } } exports.Emitter = Emitter; Emitter._noop = function () { }; /***/ }), /***/ "../node_modules/vscode-jsonrpc/lib/is.js": /*!************************************************!*\ !*** ../node_modules/vscode-jsonrpc/lib/is.js ***! \************************************************/ /*! flagged exports */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export array [provided] [no usage info] [missing usage info prevents renaming] */ /*! export boolean [provided] [no usage info] [missing usage info prevents renaming] */ /*! export error [provided] [no usage info] [missing usage info prevents renaming] */ /*! export func [provided] [no usage info] [missing usage info prevents renaming] */ /*! export number [provided] [no usage info] [missing usage info prevents renaming] */ /*! export string [provided] [no usage info] [missing usage info prevents renaming] */ /*! export stringArray [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__ */ /***/ ((__unused_webpack_module, exports) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); function boolean(value) { return value === true || value === false; } exports.boolean = boolean; function string(value) { return typeof value === 'string' || value instanceof String; } exports.string = string; function number(value) { return typeof value === 'number' || value instanceof Number; } exports.number = number; function error(value) { return value instanceof Error; } exports.error = error; function func(value) { return typeof value === 'function'; } exports.func = func; function array(value) { return Array.isArray(value); } exports.array = array; function stringArray(value) { return array(value) && value.every(elem => string(elem)); } exports.stringArray = stringArray; /***/ }), /***/ "../node_modules/vscode-jsonrpc/lib/linkedMap.js": /*!*******************************************************!*\ !*** ../node_modules/vscode-jsonrpc/lib/linkedMap.js ***! \*******************************************************/ /*! flagged exports */ /*! export LinkedMap [provided] [no usage info] [missing usage info prevents renaming] */ /*! export Touch [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__ */ /***/ ((__unused_webpack_module, exports) => { "use strict"; /*--------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ Object.defineProperty(exports, "__esModule", ({ value: true })); var Touch; (function (Touch) { Touch.None = 0; Touch.First = 1; Touch.Last = 2; })(Touch = exports.Touch || (exports.Touch = {})); class LinkedMap { constructor() { this._map = new Map(); this._head = undefined; this._tail = undefined; this._size = 0; } clear() { this._map.clear(); this._head = undefined; this._tail = undefined; this._size = 0; } isEmpty() { return !this._head && !this._tail; } get size() { return this._size; } has(key) { return this._map.has(key); } get(key) { const item = this._map.get(key); if (!item) { return undefined; } return item.value; } set(key, value, touch = Touch.None) { let item = this._map.get(key); if (item) { item.value = value; if (touch !== Touch.None) { this.touch(item, touch); } } else { item = { key, value, next: undefined, previous: undefined }; switch (touch) { case Touch.None: this.addItemLast(item); break; case Touch.First: this.addItemFirst(item); break; case Touch.Last: this.addItemLast(item); break; default: this.addItemLast(item); break; } this._map.set(key, item); this._size++; } } delete(key) { const item = this._map.get(key); if (!item) { return false; } this._map.delete(key); this.removeItem(item); this._size--; return true; } shift() { if (!this._head && !this._tail) { return undefined; } if (!this._head || !this._tail) { throw new Error('Invalid list'); } const item = this._head; this._map.delete(item.key); this.removeItem(item); this._size--; return item.value; } forEach(callbackfn, thisArg) { let current = this._head; while (current) { if (thisArg) { callbackfn.bind(thisArg)(current.value, current.key, this); } else { callbackfn(current.value, current.key, this); } current = current.next; } } forEachReverse(callbackfn, thisArg) { let current = this._tail; while (current) { if (thisArg) { callbackfn.bind(thisArg)(current.value, current.key, this); } else { callbackfn(current.value, current.key, this); } current = current.previous; } } values() { let result = []; let current = this._head; while (current) { result.push(current.value); current = current.next; } return result; } keys() { let result = []; let current = this._head; while (current) { result.push(current.key); current = current.next; } return result; } /* JSON RPC run on es5 which has no Symbol.iterator public keys(): IterableIterator { let current = this._head; let iterator: IterableIterator = { [Symbol.iterator]() { return iterator; }, next():IteratorResult { if (current) { let result = { value: current.key, done: false }; current = current.next; return result; } else { return { value: undefined, done: true }; } } }; return iterator; } public values(): IterableIterator { let current = this._head; let iterator: IterableIterator = { [Symbol.iterator]() { return iterator; }, next():IteratorResult { if (current) { let result = { value: current.value, done: false }; current = current.next; return result; } else { return { value: undefined, done: true }; } } }; return iterator; } */ addItemFirst(item) { // First time Insert if (!this._head && !this._tail) { this._tail = item; } else if (!this._head) { throw new Error('Invalid list'); } else { item.next = this._head; this._head.previous = item; } this._head = item; } addItemLast(item) { // First time Insert if (!this._head && !this._tail) { this._head = item; } else if (!this._tail) { throw new Error('Invalid list'); } else { item.previous = this._tail; this._tail.next = item; } this._tail = item; } removeItem(item) { if (item === this._head && item === this._tail) { this._head = undefined; this._tail = undefined; } else if (item === this._head) { this._head = item.next; } else if (item === this._tail) { this._tail = item.previous; } else { const next = item.next; const previous = item.previous; if (!next || !previous) { throw new Error('Invalid list'); } next.previous = previous; previous.next = next; } } touch(item, touch) { if (!this._head || !this._tail) { throw new Error('Invalid list'); } if ((touch !== Touch.First && touch !== Touch.Last)) { return; } if (touch === Touch.First) { if (item === this._head) { return; } const next = item.next; const previous = item.previous; // Unlink the item if (item === this._tail) { // previous must be defined since item was not head but is tail // So there are more than on item in the map previous.next = undefined; this._tail = previous; } else { // Both next and previous are not undefined since item was neither head nor tail. next.previous = previous; previous.next = next; } // Insert the node at head item.previous = undefined; item.next = this._head; this._head.previous = item; this._head = item; } else if (touch === Touch.Last) { if (item === this._tail) { return; } const next = item.next; const previous = item.previous; // Unlink the item. if (item === this._head) { // next must be defined since item was not tail but is head // So there are more than on item in the map next.previous = undefined; this._head = next; } else { // Both next and previous are not undefined since item was neither head nor tail. next.previous = previous; previous.next = next; } item.next = undefined; item.previous = this._tail; this._tail.next = item; this._tail = item; } } } exports.LinkedMap = LinkedMap; /***/ }), /***/ "../node_modules/vscode-jsonrpc/lib/main.js": /*!**************************************************!*\ !*** ../node_modules/vscode-jsonrpc/lib/main.js ***! \**************************************************/ /*! unknown exports (runtime-defined) */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /*! CommonJS bailout: exports.hasOwnProperty(...) prevents optimization as exports is passed as call context at 8:26-48 */ /*! CommonJS bailout: exports is used directly at 8:53-60 */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ /// function __export(m) { for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; } Object.defineProperty(exports, "__esModule", ({ value: true })); const Is = __webpack_require__(/*! ./is */ "../node_modules/vscode-jsonrpc/lib/is.js"); const messages_1 = __webpack_require__(/*! ./messages */ "../node_modules/vscode-jsonrpc/lib/messages.js"); exports.RequestType = messages_1.RequestType; exports.RequestType0 = messages_1.RequestType0; exports.RequestType1 = messages_1.RequestType1; exports.RequestType2 = messages_1.RequestType2; exports.RequestType3 = messages_1.RequestType3; exports.RequestType4 = messages_1.RequestType4; exports.RequestType5 = messages_1.RequestType5; exports.RequestType6 = messages_1.RequestType6; exports.RequestType7 = messages_1.RequestType7; exports.RequestType8 = messages_1.RequestType8; exports.RequestType9 = messages_1.RequestType9; exports.ResponseError = messages_1.ResponseError; exports.ErrorCodes = messages_1.ErrorCodes; exports.NotificationType = messages_1.NotificationType; exports.NotificationType0 = messages_1.NotificationType0; exports.NotificationType1 = messages_1.NotificationType1; exports.NotificationType2 = messages_1.NotificationType2; exports.NotificationType3 = messages_1.NotificationType3; exports.NotificationType4 = messages_1.NotificationType4; exports.NotificationType5 = messages_1.NotificationType5; exports.NotificationType6 = messages_1.NotificationType6; exports.NotificationType7 = messages_1.NotificationType7; exports.NotificationType8 = messages_1.NotificationType8; exports.NotificationType9 = messages_1.NotificationType9; const messageReader_1 = __webpack_require__(/*! ./messageReader */ "../node_modules/vscode-jsonrpc/lib/messageReader.js"); exports.MessageReader = messageReader_1.MessageReader; exports.StreamMessageReader = messageReader_1.StreamMessageReader; exports.IPCMessageReader = messageReader_1.IPCMessageReader; exports.SocketMessageReader = messageReader_1.SocketMessageReader; const messageWriter_1 = __webpack_require__(/*! ./messageWriter */ "../node_modules/vscode-jsonrpc/lib/messageWriter.js"); exports.MessageWriter = messageWriter_1.MessageWriter; exports.StreamMessageWriter = messageWriter_1.StreamMessageWriter; exports.IPCMessageWriter = messageWriter_1.IPCMessageWriter; exports.SocketMessageWriter = messageWriter_1.SocketMessageWriter; const events_1 = __webpack_require__(/*! ./events */ "../node_modules/vscode-jsonrpc/lib/events.js"); exports.Disposable = events_1.Disposable; exports.Event = events_1.Event; exports.Emitter = events_1.Emitter; const cancellation_1 = __webpack_require__(/*! ./cancellation */ "../node_modules/vscode-jsonrpc/lib/cancellation.js"); exports.CancellationTokenSource = cancellation_1.CancellationTokenSource; exports.CancellationToken = cancellation_1.CancellationToken; const linkedMap_1 = __webpack_require__(/*! ./linkedMap */ "../node_modules/vscode-jsonrpc/lib/linkedMap.js"); __export(__webpack_require__(/*! ./pipeSupport */ "../node_modules/vscode-jsonrpc/lib/pipeSupport.js")); __export(__webpack_require__(/*! ./socketSupport */ "../node_modules/vscode-jsonrpc/lib/socketSupport.js")); var CancelNotification; (function (CancelNotification) { CancelNotification.type = new messages_1.NotificationType('$/cancelRequest'); })(CancelNotification || (CancelNotification = {})); var ProgressNotification; (function (ProgressNotification) { ProgressNotification.type = new messages_1.NotificationType('$/progress'); })(ProgressNotification || (ProgressNotification = {})); class ProgressType { constructor() { } } exports.ProgressType = ProgressType; exports.NullLogger = Object.freeze({ error: () => { }, warn: () => { }, info: () => { }, log: () => { } }); var Trace; (function (Trace) { Trace[Trace["Off"] = 0] = "Off"; Trace[Trace["Messages"] = 1] = "Messages"; Trace[Trace["Verbose"] = 2] = "Verbose"; })(Trace = exports.Trace || (exports.Trace = {})); (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 '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.Verbose: return 'verbose'; default: return 'off'; } } Trace.toString = toString; })(Trace = exports.Trace || (exports.Trace = {})); var TraceFormat; (function (TraceFormat) { TraceFormat["Text"] = "text"; TraceFormat["JSON"] = "json"; })(TraceFormat = exports.TraceFormat || (exports.TraceFormat = {})); (function (TraceFormat) { function fromString(value) { value = value.toLowerCase(); if (value === 'json') { return TraceFormat.JSON; } else { return TraceFormat.Text; } } TraceFormat.fromString = fromString; })(TraceFormat = exports.TraceFormat || (exports.TraceFormat = {})); var SetTraceNotification; (function (SetTraceNotification) { SetTraceNotification.type = new messages_1.NotificationType('$/setTraceNotification'); })(SetTraceNotification = exports.SetTraceNotification || (exports.SetTraceNotification = {})); var LogTraceNotification; (function (LogTraceNotification) { LogTraceNotification.type = new messages_1.NotificationType('$/logTraceNotification'); })(LogTraceNotification = exports.LogTraceNotification || (exports.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 || (exports.ConnectionErrors = {})); class ConnectionError extends Error { constructor(code, message) { super(message); this.code = code; Object.setPrototypeOf(this, ConnectionError.prototype); } } exports.ConnectionError = ConnectionError; var ConnectionStrategy; (function (ConnectionStrategy) { function is(value) { let candidate = value; return candidate && Is.func(candidate.cancelUndispatched); } ConnectionStrategy.is = is; })(ConnectionStrategy = exports.ConnectionStrategy || (exports.ConnectionStrategy = {})); 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, strategy) { let sequenceNumber = 0; let notificationSquenceNumber = 0; let unknownResponseSquenceNumber = 0; const version = '2.0'; let starRequestHandler = undefined; let requestHandlers = Object.create(null); let starNotificationHandler = undefined; let notificationHandlers = Object.create(null); let progressHandlers = new Map(); let timer; let messageQueue = new linkedMap_1.LinkedMap(); let responsePromises = Object.create(null); let requestTokens = Object.create(null); let trace = Trace.Off; let traceFormat = TraceFormat.Text; let tracer; let state = ConnectionState.New; let errorEmitter = new events_1.Emitter(); let closeEmitter = new events_1.Emitter(); let unhandledNotificationEmitter = new events_1.Emitter(); let unhandledProgressEmitter = new events_1.Emitter(); let disposeEmitter = new events_1.Emitter(); function createRequestQueueKey(id) { return 'req-' + id.toString(); } function createResponseQueueKey(id) { if (id === null) { return 'res-unknown-' + (++unknownResponseSquenceNumber).toString(); } else { return 'res-' + id.toString(); } } function createNotificationQueueKey() { return 'not-' + (++notificationSquenceNumber).toString(); } function addMessageToQueue(queue, message) { if (messages_1.isRequestMessage(message)) { queue.set(createRequestQueueKey(message.id), message); } else if (messages_1.isResponseMessage(message)) { queue.set(createResponseQueueKey(message.id), message); } else { queue.set(createNotificationQueueKey(), 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 triggerMessageQueue() { if (timer || messageQueue.size === 0) { return; } timer = setImmediate(() => { timer = undefined; processMessageQueue(); }); } function processMessageQueue() { if (messageQueue.size === 0) { return; } let message = messageQueue.shift(); try { if (messages_1.isRequestMessage(message)) { handleRequest(message); } else if (messages_1.isNotificationMessage(message)) { handleNotification(message); } else if (messages_1.isResponseMessage(message)) { handleResponse(message); } else { handleInvalidMessage(message); } } finally { triggerMessageQueue(); } } let 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.isNotificationMessage(message) && message.method === CancelNotification.type.method) { let key = createRequestQueueKey(message.params.id); let toCancel = messageQueue.get(key); if (messages_1.isRequestMessage(toCancel)) { let response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel); if (response && (response.error !== void 0 || response.result !== void 0)) { messageQueue.delete(key); response.id = toCancel.id; traceSendingResponse(response, message.method, Date.now()); messageWriter.write(response); return; } } } addMessageToQueue(messageQueue, message); } finally { triggerMessageQueue(); } }; function handleRequest(requestMessage) { if (isDisposed()) { // we return here silently since we fired an event when the // connection got disposed. return; } function reply(resultOrError, method, startTime) { let message = { jsonrpc: version, id: requestMessage.id }; if (resultOrError instanceof messages_1.ResponseError) { message.error = resultOrError.toJson(); } else { message.result = resultOrError === void 0 ? null : resultOrError; } traceSendingResponse(message, method, startTime); messageWriter.write(message); } function replyError(error, method, startTime) { let message = { jsonrpc: version, id: requestMessage.id, error: error.toJson() }; traceSendingResponse(message, method, startTime); messageWriter.write(message); } function replySuccess(result, method, startTime) { // The JSON RPC defines that a response must either have a result or an error // So we can't treat undefined as a valid response result. if (result === void 0) { result = null; } let message = { jsonrpc: version, id: requestMessage.id, result: result }; traceSendingResponse(message, method, startTime); messageWriter.write(message); } traceReceivedRequest(requestMessage); let element = requestHandlers[requestMessage.method]; let type; let requestHandler; if (element) { type = element.type; requestHandler = element.handler; } let startTime = Date.now(); if (requestHandler || starRequestHandler) { let cancellationSource = new cancellation_1.CancellationTokenSource(); let tokenKey = String(requestMessage.id); requestTokens[tokenKey] = cancellationSource; try { let handlerResult; if (requestMessage.params === void 0 || (type !== void 0 && type.numberOfParams === 0)) { handlerResult = requestHandler ? requestHandler(cancellationSource.token) : starRequestHandler(requestMessage.method, cancellationSource.token); } else if (Is.array(requestMessage.params) && (type === void 0 || type.numberOfParams > 1)) { handlerResult = requestHandler ? requestHandler(...requestMessage.params, cancellationSource.token) : starRequestHandler(requestMessage.method, ...requestMessage.params, cancellationSource.token); } else { handlerResult = requestHandler ? requestHandler(requestMessage.params, cancellationSource.token) : starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token); } let promise = handlerResult; if (!handlerResult) { delete requestTokens[tokenKey]; replySuccess(handlerResult, requestMessage.method, startTime); } else if (promise.then) { promise.then((resultOrError) => { delete requestTokens[tokenKey]; reply(resultOrError, requestMessage.method, startTime); }, error => { delete requestTokens[tokenKey]; if (error instanceof messages_1.ResponseError) { replyError(error, requestMessage.method, startTime); } else if (error && Is.string(error.message)) { replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime); } else { replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime); } }); } else { delete requestTokens[tokenKey]; reply(handlerResult, requestMessage.method, startTime); } } catch (error) { delete requestTokens[tokenKey]; if (error instanceof messages_1.ResponseError) { reply(error, requestMessage.method, startTime); } else if (error && Is.string(error.message)) { replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime); } else { replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime); } } } else { 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 { let key = String(responseMessage.id); let responsePromise = responsePromises[key]; traceReceivedResponse(responseMessage, responsePromise); if (responsePromise) { delete responsePromises[key]; try { if (responseMessage.error) { let error = responseMessage.error; responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data)); } else if (responseMessage.result !== void 0) { 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.`); } } } } } function handleNotification(message) { if (isDisposed()) { // See handle request. return; } let type = undefined; let notificationHandler; if (message.method === CancelNotification.type.method) { notificationHandler = (params) => { let id = params.id; let source = requestTokens[String(id)]; if (source) { source.cancel(); } }; } else { let element = notificationHandlers[message.method]; if (element) { notificationHandler = element.handler; type = element.type; } } if (notificationHandler || starNotificationHandler) { try { traceReceivedNotification(message); if (message.params === void 0 || (type !== void 0 && type.numberOfParams === 0)) { notificationHandler ? notificationHandler() : starNotificationHandler(message.method); } else if (Is.array(message.params) && (type === void 0 || type.numberOfParams > 1)) { notificationHandler ? notificationHandler(...message.params) : starNotificationHandler(message.method, ...message.params); } else { notificationHandler ? notificationHandler(message.params) : 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 let responseMessage = message; if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) { let key = String(responseMessage.id); let responseHandler = responsePromises[key]; if (responseHandler) { responseHandler.reject(new Error('The received response has neither a result nor an error property.')); } } } function traceSendingRequest(message) { if (trace === Trace.Off || !tracer) { return; } if (traceFormat === TraceFormat.Text) { let data = undefined; if (trace === Trace.Verbose && message.params) { data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`; } 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) { if (message.params) { data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`; } else { data = 'No parameters provided.\n\n'; } } 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) { if (message.error && message.error.data) { data = `Error data: ${JSON.stringify(message.error.data, null, 4)}\n\n`; } else { if (message.result) { data = `Result: ${JSON.stringify(message.result, null, 4)}\n\n`; } else if (message.error === void 0) { data = 'No result returned.\n\n'; } } } 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 && message.params) { data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`; } 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) { if (message.params) { data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`; } else { data = 'No parameters provided.\n\n'; } } 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) { if (message.error && message.error.data) { data = `Error data: ${JSON.stringify(message.error.data, null, 4)}\n\n`; } else { if (message.result) { data = `Result: ${JSON.stringify(message.result, null, 4)}\n\n`; } else if (message.error === void 0) { data = 'No result returned.\n\n'; } } } if (responsePromise) { let 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 === void 0) { return null; } else { return param; } } function computeMessageParams(type, params) { let result; let numberOfParams = type.numberOfParams; switch (numberOfParams) { case 0: result = null; break; case 1: result = undefinedToNull(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; } let connection = { sendNotification: (type, ...params) => { throwIfClosedOrDisposed(); let method; let messageParams; if (Is.string(type)) { method = type; switch (params.length) { case 0: messageParams = null; break; case 1: messageParams = params[0]; break; default: messageParams = params; break; } } else { method = type.method; messageParams = computeMessageParams(type, params); } let notificationMessage = { jsonrpc: version, method: method, params: messageParams }; traceSendingNotification(notificationMessage); messageWriter.write(notificationMessage); }, onNotification: (type, handler) => { throwIfClosedOrDisposed(); if (Is.func(type)) { starNotificationHandler = type; } else if (handler) { if (Is.string(type)) { notificationHandlers[type] = { type: undefined, handler }; } else { notificationHandlers[type.method] = { type, handler }; } } }, onProgress: (_type, token, handler) => { if (progressHandlers.has(token)) { throw new Error(`Progress handler for token ${token} already registered`); } progressHandlers.set(token, handler); return { dispose: () => { progressHandlers.delete(token); } }; }, sendProgress: (_type, token, value) => { connection.sendNotification(ProgressNotification.type, { token, value }); }, onUnhandledProgress: unhandledProgressEmitter.event, sendRequest: (type, ...params) => { throwIfClosedOrDisposed(); throwIfNotListening(); let method; let messageParams; let token = undefined; if (Is.string(type)) { method = type; switch (params.length) { case 0: messageParams = null; break; case 1: // The cancellation token is optional so it can also be undefined. if (cancellation_1.CancellationToken.is(params[0])) { messageParams = null; token = params[0]; } else { messageParams = undefinedToNull(params[0]); } break; default: const last = params.length - 1; if (cancellation_1.CancellationToken.is(params[last])) { token = params[last]; if (params.length === 2) { messageParams = undefinedToNull(params[0]); } else { messageParams = params.slice(0, last).map(value => undefinedToNull(value)); } } else { messageParams = params.map(value => undefinedToNull(value)); } break; } } else { method = type.method; messageParams = computeMessageParams(type, params); let numberOfParams = type.numberOfParams; token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : undefined; } let id = sequenceNumber++; let result = new Promise((resolve, reject) => { let requestMessage = { jsonrpc: version, id: id, method: method, params: messageParams }; let responsePromise = { method: method, timerStart: Date.now(), resolve, reject }; traceSendingRequest(requestMessage); try { messageWriter.write(requestMessage); } catch (e) { // Writing the message failed. So we need to reject the promise. responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, e.message ? e.message : 'Unknown reason')); responsePromise = null; } if (responsePromise) { responsePromises[String(id)] = responsePromise; } }); if (token) { token.onCancellationRequested(() => { connection.sendNotification(CancelNotification.type, { id }); }); } return result; }, onRequest: (type, handler) => { throwIfClosedOrDisposed(); if (Is.func(type)) { starRequestHandler = type; } else if (handler) { if (Is.string(type)) { requestHandlers[type] = { type: undefined, handler }; } else { requestHandlers[type.method] = { type, handler }; } } }, trace: (_value, _tracer, sendNotificationOrTraceOptions) => { let _sendNotification = false; let _traceFormat = TraceFormat.Text; if (sendNotificationOrTraceOptions !== void 0) { 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()) { connection.sendNotification(SetTraceNotification.type, { value: Trace.toString(_value) }); } }, onError: errorEmitter.event, onClose: closeEmitter.event, onUnhandledNotification: unhandledNotificationEmitter.event, onDispose: disposeEmitter.event, dispose: () => { if (isDisposed()) { return; } state = ConnectionState.Disposed; disposeEmitter.fire(undefined); let error = new Error('Connection got disposed.'); Object.keys(responsePromises).forEach((key) => { responsePromises[key].reject(error); }); responsePromises = Object.create(null); requestTokens = Object.create(null); 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: () => { // eslint-disable-next-line no-console console.log('inspect'); } }; connection.onNotification(LogTraceNotification.type, (params) => { if (trace === Trace.Off || !tracer) { return; } tracer.log(params.message, trace === Trace.Verbose ? params.verbose : undefined); }); connection.onNotification(ProgressNotification.type, (params) => { const handler = progressHandlers.get(params.token); if (handler) { handler(params.value); } else { unhandledProgressEmitter.fire(params); } }); return connection; } function isMessageReader(value) { return value.listen !== void 0 && value.read === void 0; } function isMessageWriter(value) { return value.write !== void 0 && value.end === void 0; } function createMessageConnection(input, output, logger, strategy) { if (!logger) { logger = exports.NullLogger; } let reader = isMessageReader(input) ? input : new messageReader_1.StreamMessageReader(input); let writer = isMessageWriter(output) ? output : new messageWriter_1.StreamMessageWriter(output); return _createMessageConnection(reader, writer, logger, strategy); } exports.createMessageConnection = createMessageConnection; /***/ }), /***/ "../node_modules/vscode-jsonrpc/lib/messageReader.js": /*!***********************************************************!*\ !*** ../node_modules/vscode-jsonrpc/lib/messageReader.js ***! \***********************************************************/ /*! flagged exports */ /*! export AbstractMessageReader [provided] [no usage info] [missing usage info prevents renaming] */ /*! export IPCMessageReader [provided] [no usage info] [missing usage info prevents renaming] */ /*! export MessageReader [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SocketMessageReader [provided] [no usage info] [missing usage info prevents renaming] */ /*! export StreamMessageReader [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const events_1 = __webpack_require__(/*! ./events */ "../node_modules/vscode-jsonrpc/lib/events.js"); const Is = __webpack_require__(/*! ./is */ "../node_modules/vscode-jsonrpc/lib/is.js"); let DefaultSize = 8192; let CR = Buffer.from('\r', 'ascii')[0]; let LF = Buffer.from('\n', 'ascii')[0]; let CRLF = '\r\n'; class MessageBuffer { constructor(encoding = 'utf8') { this.encoding = encoding; this.index = 0; this.buffer = Buffer.allocUnsafe(DefaultSize); } append(chunk) { var toAppend = chunk; if (typeof (chunk) === 'string') { var str = chunk; var bufferLen = Buffer.byteLength(str, this.encoding); toAppend = Buffer.allocUnsafe(bufferLen); toAppend.write(str, 0, bufferLen, this.encoding); } if (this.buffer.length - this.index >= toAppend.length) { toAppend.copy(this.buffer, this.index, 0, toAppend.length); } else { var newSize = (Math.ceil((this.index + toAppend.length) / DefaultSize) + 1) * DefaultSize; if (this.index === 0) { this.buffer = Buffer.allocUnsafe(newSize); toAppend.copy(this.buffer, 0, 0, toAppend.length); } else { this.buffer = Buffer.concat([this.buffer.slice(0, this.index), toAppend], newSize); } } this.index += toAppend.length; } tryReadHeaders() { let result = undefined; let current = 0; while (current + 3 < this.index && (this.buffer[current] !== CR || this.buffer[current + 1] !== LF || this.buffer[current + 2] !== CR || this.buffer[current + 3] !== LF)) { current++; } // No header / body separator found (e.g CRLFCRLF) if (current + 3 >= this.index) { return result; } result = Object.create(null); let headers = this.buffer.toString('ascii', 0, current).split(CRLF); headers.forEach((header) => { let index = header.indexOf(':'); if (index === -1) { throw new Error('Message header must separate key and value using :'); } let key = header.substr(0, index); let value = header.substr(index + 1).trim(); result[key] = value; }); let nextStart = current + 4; this.buffer = this.buffer.slice(nextStart); this.index = this.index - nextStart; return result; } tryReadContent(length) { if (this.index < length) { return null; } let result = this.buffer.toString(this.encoding, 0, length); let nextStart = length; this.buffer.copy(this.buffer, 0, nextStart); this.index = this.index - nextStart; return result; } get numberOfBytes() { return this.index; } } var MessageReader; (function (MessageReader) { function is(value) { let candidate = value; return candidate && Is.func(candidate.listen) && Is.func(candidate.dispose) && Is.func(candidate.onError) && Is.func(candidate.onClose) && Is.func(candidate.onPartialMessage); } MessageReader.is = is; })(MessageReader = exports.MessageReader || (exports.MessageReader = {})); class AbstractMessageReader { constructor() { this.errorEmitter = new events_1.Emitter(); this.closeEmitter = new events_1.Emitter(); this.partialMessageEmitter = new events_1.Emitter(); } dispose() { this.errorEmitter.dispose(); this.closeEmitter.dispose(); } get onError() { return this.errorEmitter.event; } fireError(error) { this.errorEmitter.fire(this.asError(error)); } get onClose() { return this.closeEmitter.event; } fireClose() { this.closeEmitter.fire(undefined); } get onPartialMessage() { return this.partialMessageEmitter.event; } firePartialMessage(info) { this.partialMessageEmitter.fire(info); } asError(error) { if (error instanceof Error) { return error; } else { return new Error(`Reader received error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`); } } } exports.AbstractMessageReader = AbstractMessageReader; class StreamMessageReader extends AbstractMessageReader { constructor(readable, encoding = 'utf8') { super(); this.readable = readable; this.buffer = new MessageBuffer(encoding); this._partialMessageTimeout = 10000; } set partialMessageTimeout(timeout) { this._partialMessageTimeout = timeout; } get partialMessageTimeout() { return this._partialMessageTimeout; } listen(callback) { this.nextMessageLength = -1; this.messageToken = 0; this.partialMessageTimer = undefined; this.callback = callback; this.readable.on('data', (data) => { this.onData(data); }); this.readable.on('error', (error) => this.fireError(error)); this.readable.on('close', () => this.fireClose()); } onData(data) { this.buffer.append(data); while (true) { if (this.nextMessageLength === -1) { let headers = this.buffer.tryReadHeaders(); if (!headers) { return; } let contentLength = headers['Content-Length']; if (!contentLength) { throw new Error('Header must provide a Content-Length property.'); } let length = parseInt(contentLength); if (isNaN(length)) { throw new Error('Content-Length value must be a number.'); } this.nextMessageLength = length; // Take the encoding form the header. For compatibility // treat both utf-8 and utf8 as node utf8 } var msg = this.buffer.tryReadContent(this.nextMessageLength); if (msg === null) { /** We haven't received the full message yet. */ this.setPartialMessageTimer(); return; } this.clearPartialMessageTimer(); this.nextMessageLength = -1; this.messageToken++; var json = JSON.parse(msg); this.callback(json); } } clearPartialMessageTimer() { if (this.partialMessageTimer) { clearTimeout(this.partialMessageTimer); this.partialMessageTimer = undefined; } } setPartialMessageTimer() { this.clearPartialMessageTimer(); if (this._partialMessageTimeout <= 0) { return; } this.partialMessageTimer = setTimeout((token, timeout) => { this.partialMessageTimer = undefined; if (token === this.messageToken) { this.firePartialMessage({ messageToken: token, waitingTime: timeout }); this.setPartialMessageTimer(); } }, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout); } } exports.StreamMessageReader = StreamMessageReader; class IPCMessageReader extends AbstractMessageReader { constructor(process) { super(); this.process = process; let eventEmitter = this.process; eventEmitter.on('error', (error) => this.fireError(error)); eventEmitter.on('close', () => this.fireClose()); } listen(callback) { this.process.on('message', callback); } } exports.IPCMessageReader = IPCMessageReader; class SocketMessageReader extends StreamMessageReader { constructor(socket, encoding = 'utf-8') { super(socket, encoding); } } exports.SocketMessageReader = SocketMessageReader; /***/ }), /***/ "../node_modules/vscode-jsonrpc/lib/messageWriter.js": /*!***********************************************************!*\ !*** ../node_modules/vscode-jsonrpc/lib/messageWriter.js ***! \***********************************************************/ /*! flagged exports */ /*! export AbstractMessageWriter [provided] [no usage info] [missing usage info prevents renaming] */ /*! export IPCMessageWriter [provided] [no usage info] [missing usage info prevents renaming] */ /*! export MessageWriter [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SocketMessageWriter [provided] [no usage info] [missing usage info prevents renaming] */ /*! export StreamMessageWriter [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const events_1 = __webpack_require__(/*! ./events */ "../node_modules/vscode-jsonrpc/lib/events.js"); const Is = __webpack_require__(/*! ./is */ "../node_modules/vscode-jsonrpc/lib/is.js"); let ContentLength = 'Content-Length: '; let CRLF = '\r\n'; var MessageWriter; (function (MessageWriter) { function is(value) { let candidate = value; return candidate && Is.func(candidate.dispose) && Is.func(candidate.onClose) && Is.func(candidate.onError) && Is.func(candidate.write); } MessageWriter.is = is; })(MessageWriter = exports.MessageWriter || (exports.MessageWriter = {})); class AbstractMessageWriter { constructor() { this.errorEmitter = new events_1.Emitter(); this.closeEmitter = new events_1.Emitter(); } dispose() { this.errorEmitter.dispose(); this.closeEmitter.dispose(); } get onError() { return this.errorEmitter.event; } fireError(error, message, count) { this.errorEmitter.fire([this.asError(error), message, count]); } get onClose() { return this.closeEmitter.event; } fireClose() { this.closeEmitter.fire(undefined); } asError(error) { if (error instanceof Error) { return error; } else { return new Error(`Writer received error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`); } } } exports.AbstractMessageWriter = AbstractMessageWriter; class StreamMessageWriter extends AbstractMessageWriter { constructor(writable, encoding = 'utf8') { super(); this.writable = writable; this.encoding = encoding; this.errorCount = 0; this.writable.on('error', (error) => this.fireError(error)); this.writable.on('close', () => this.fireClose()); } write(msg) { let json = JSON.stringify(msg); let contentLength = Buffer.byteLength(json, this.encoding); let headers = [ ContentLength, contentLength.toString(), CRLF, CRLF ]; try { // Header must be written in ASCII encoding this.writable.write(headers.join(''), 'ascii'); // Now write the content. This can be written in any encoding this.writable.write(json, this.encoding); this.errorCount = 0; } catch (error) { this.errorCount++; this.fireError(error, msg, this.errorCount); } } } exports.StreamMessageWriter = StreamMessageWriter; class IPCMessageWriter extends AbstractMessageWriter { constructor(process) { super(); this.process = process; this.errorCount = 0; this.queue = []; this.sending = false; let eventEmitter = this.process; eventEmitter.on('error', (error) => this.fireError(error)); eventEmitter.on('close', () => this.fireClose); } write(msg) { if (!this.sending && this.queue.length === 0) { // See https://github.com/nodejs/node/issues/7657 this.doWriteMessage(msg); } else { this.queue.push(msg); } } doWriteMessage(msg) { try { if (this.process.send) { this.sending = true; this.process.send(msg, undefined, undefined, (error) => { this.sending = false; if (error) { this.errorCount++; this.fireError(error, msg, this.errorCount); } else { this.errorCount = 0; } if (this.queue.length > 0) { this.doWriteMessage(this.queue.shift()); } }); } } catch (error) { this.errorCount++; this.fireError(error, msg, this.errorCount); } } } exports.IPCMessageWriter = IPCMessageWriter; class SocketMessageWriter extends AbstractMessageWriter { constructor(socket, encoding = 'utf8') { super(); this.socket = socket; this.queue = []; this.sending = false; this.encoding = encoding; this.errorCount = 0; this.socket.on('error', (error) => this.fireError(error)); this.socket.on('close', () => this.fireClose()); } dispose() { super.dispose(); this.socket.destroy(); } write(msg) { if (!this.sending && this.queue.length === 0) { // See https://github.com/nodejs/node/issues/7657 this.doWriteMessage(msg); } else { this.queue.push(msg); } } doWriteMessage(msg) { let json = JSON.stringify(msg); let contentLength = Buffer.byteLength(json, this.encoding); let headers = [ ContentLength, contentLength.toString(), CRLF, CRLF ]; try { // Header must be written in ASCII encoding this.sending = true; this.socket.write(headers.join(''), 'ascii', (error) => { if (error) { this.handleError(error, msg); } try { // Now write the content. This can be written in any encoding this.socket.write(json, this.encoding, (error) => { this.sending = false; if (error) { this.handleError(error, msg); } else { this.errorCount = 0; } if (this.queue.length > 0) { this.doWriteMessage(this.queue.shift()); } }); } catch (error) { this.handleError(error, msg); } }); } catch (error) { this.handleError(error, msg); } } handleError(error, msg) { this.errorCount++; this.fireError(error, msg, this.errorCount); } } exports.SocketMessageWriter = SocketMessageWriter; /***/ }), /***/ "../node_modules/vscode-jsonrpc/lib/messages.js": /*!******************************************************!*\ !*** ../node_modules/vscode-jsonrpc/lib/messages.js ***! \******************************************************/ /*! flagged exports */ /*! export AbstractMessageType [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ErrorCodes [provided] [no usage info] [missing usage info prevents renaming] */ /*! export NotificationType [provided] [no usage info] [missing usage info prevents renaming] */ /*! export NotificationType0 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export NotificationType1 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export NotificationType2 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export NotificationType3 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export NotificationType4 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export NotificationType5 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export NotificationType6 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export NotificationType7 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export NotificationType8 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export NotificationType9 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RequestType [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RequestType0 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RequestType1 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RequestType2 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RequestType3 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RequestType4 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RequestType5 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RequestType6 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RequestType7 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RequestType8 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RequestType9 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ResponseError [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export isNotificationMessage [provided] [no usage info] [missing usage info prevents renaming] */ /*! export isRequestMessage [provided] [no usage info] [missing usage info prevents renaming] */ /*! export isResponseMessage [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const is = __webpack_require__(/*! ./is */ "../node_modules/vscode-jsonrpc/lib/is.js"); /** * Predefined error codes. */ var ErrorCodes; (function (ErrorCodes) { // Defined by JSON RPC ErrorCodes.ParseError = -32700; ErrorCodes.InvalidRequest = -32600; ErrorCodes.MethodNotFound = -32601; ErrorCodes.InvalidParams = -32602; ErrorCodes.InternalError = -32603; ErrorCodes.serverErrorStart = -32099; ErrorCodes.serverErrorEnd = -32000; ErrorCodes.ServerNotInitialized = -32002; ErrorCodes.UnknownErrorCode = -32001; // Defined by the protocol. ErrorCodes.RequestCancelled = -32800; ErrorCodes.ContentModified = -32801; // Defined by VSCode library. ErrorCodes.MessageWriteError = 1; ErrorCodes.MessageReadError = 2; })(ErrorCodes = exports.ErrorCodes || (exports.ErrorCodes = {})); /** * An error object return in a response in case a request * has failed. */ class ResponseError extends Error { constructor(code, message, data) { super(message); this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode; this.data = data; Object.setPrototypeOf(this, ResponseError.prototype); } toJson() { return { code: this.code, message: this.message, data: this.data, }; } } exports.ResponseError = ResponseError; /** * An abstract implementation of a MessageType. */ class AbstractMessageType { constructor(_method, _numberOfParams) { this._method = _method; this._numberOfParams = _numberOfParams; } get method() { return this._method; } get numberOfParams() { return this._numberOfParams; } } exports.AbstractMessageType = AbstractMessageType; /** * Classes to type request response pairs * * The type parameter RO will be removed in the next major version * of the JSON RPC library since it is a LSP concept and doesn't * belong here. For now it is tagged as default never. */ class RequestType0 extends AbstractMessageType { constructor(method) { super(method, 0); } } exports.RequestType0 = RequestType0; class RequestType extends AbstractMessageType { constructor(method) { super(method, 1); } } exports.RequestType = RequestType; class RequestType1 extends AbstractMessageType { constructor(method) { super(method, 1); } } exports.RequestType1 = RequestType1; class RequestType2 extends AbstractMessageType { constructor(method) { super(method, 2); } } exports.RequestType2 = RequestType2; class RequestType3 extends AbstractMessageType { constructor(method) { super(method, 3); } } exports.RequestType3 = RequestType3; class RequestType4 extends AbstractMessageType { constructor(method) { super(method, 4); } } exports.RequestType4 = RequestType4; class RequestType5 extends AbstractMessageType { constructor(method) { super(method, 5); } } exports.RequestType5 = RequestType5; class RequestType6 extends AbstractMessageType { constructor(method) { super(method, 6); } } exports.RequestType6 = RequestType6; class RequestType7 extends AbstractMessageType { constructor(method) { super(method, 7); } } exports.RequestType7 = RequestType7; class RequestType8 extends AbstractMessageType { constructor(method) { super(method, 8); } } exports.RequestType8 = RequestType8; class RequestType9 extends AbstractMessageType { constructor(method) { super(method, 9); } } exports.RequestType9 = RequestType9; /** * The type parameter RO will be removed in the next major version * of the JSON RPC library since it is a LSP concept and doesn't * belong here. For now it is tagged as default never. */ class NotificationType extends AbstractMessageType { constructor(method) { super(method, 1); this._ = undefined; } } exports.NotificationType = NotificationType; class NotificationType0 extends AbstractMessageType { constructor(method) { super(method, 0); } } exports.NotificationType0 = NotificationType0; class NotificationType1 extends AbstractMessageType { constructor(method) { super(method, 1); } } exports.NotificationType1 = NotificationType1; class NotificationType2 extends AbstractMessageType { constructor(method) { super(method, 2); } } exports.NotificationType2 = NotificationType2; class NotificationType3 extends AbstractMessageType { constructor(method) { super(method, 3); } } exports.NotificationType3 = NotificationType3; class NotificationType4 extends AbstractMessageType { constructor(method) { super(method, 4); } } exports.NotificationType4 = NotificationType4; class NotificationType5 extends AbstractMessageType { constructor(method) { super(method, 5); } } exports.NotificationType5 = NotificationType5; class NotificationType6 extends AbstractMessageType { constructor(method) { super(method, 6); } } exports.NotificationType6 = NotificationType6; class NotificationType7 extends AbstractMessageType { constructor(method) { super(method, 7); } } exports.NotificationType7 = NotificationType7; class NotificationType8 extends AbstractMessageType { constructor(method) { super(method, 8); } } exports.NotificationType8 = NotificationType8; class NotificationType9 extends AbstractMessageType { constructor(method) { super(method, 9); } } exports.NotificationType9 = NotificationType9; /** * Tests if the given message is a request message */ function isRequestMessage(message) { let candidate = message; return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id)); } exports.isRequestMessage = isRequestMessage; /** * Tests if the given message is a notification message */ function isNotificationMessage(message) { let candidate = message; return candidate && is.string(candidate.method) && message.id === void 0; } exports.isNotificationMessage = isNotificationMessage; /** * Tests if the given message is a response message */ function isResponseMessage(message) { let candidate = message; return candidate && (candidate.result !== void 0 || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null); } exports.isResponseMessage = isResponseMessage; /***/ }), /***/ "../node_modules/vscode-jsonrpc/lib/pipeSupport.js": /*!*********************************************************!*\ !*** ../node_modules/vscode-jsonrpc/lib/pipeSupport.js ***! \*********************************************************/ /*! flagged exports */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export createClientPipeTransport [provided] [no usage info] [missing usage info prevents renaming] */ /*! export createServerPipeTransport [provided] [no usage info] [missing usage info prevents renaming] */ /*! export generateRandomPipeName [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const path_1 = __webpack_require__(/*! path */ "path"); const os_1 = __webpack_require__(/*! os */ "os"); const crypto_1 = __webpack_require__(/*! crypto */ "crypto"); const net_1 = __webpack_require__(/*! net */ "net"); const messageReader_1 = __webpack_require__(/*! ./messageReader */ "../node_modules/vscode-jsonrpc/lib/messageReader.js"); const messageWriter_1 = __webpack_require__(/*! ./messageWriter */ "../node_modules/vscode-jsonrpc/lib/messageWriter.js"); function generateRandomPipeName() { const randomSuffix = crypto_1.randomBytes(21).toString('hex'); if (process.platform === 'win32') { return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`; } else { // Mac/Unix: use socket file return path_1.join(os_1.tmpdir(), `vscode-${randomSuffix}.sock`); } } exports.generateRandomPipeName = generateRandomPipeName; function createClientPipeTransport(pipeName, encoding = 'utf-8') { let connectResolve; let connected = new Promise((resolve, _reject) => { connectResolve = resolve; }); return new Promise((resolve, reject) => { let server = net_1.createServer((socket) => { server.close(); connectResolve([ new messageReader_1.SocketMessageReader(socket, encoding), new messageWriter_1.SocketMessageWriter(socket, encoding) ]); }); server.on('error', reject); server.listen(pipeName, () => { server.removeListener('error', reject); resolve({ onConnected: () => { return connected; } }); }); }); } exports.createClientPipeTransport = createClientPipeTransport; function createServerPipeTransport(pipeName, encoding = 'utf-8') { const socket = net_1.createConnection(pipeName); return [ new messageReader_1.SocketMessageReader(socket, encoding), new messageWriter_1.SocketMessageWriter(socket, encoding) ]; } exports.createServerPipeTransport = createServerPipeTransport; /***/ }), /***/ "../node_modules/vscode-jsonrpc/lib/socketSupport.js": /*!***********************************************************!*\ !*** ../node_modules/vscode-jsonrpc/lib/socketSupport.js ***! \***********************************************************/ /*! flagged exports */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export createClientSocketTransport [provided] [no usage info] [missing usage info prevents renaming] */ /*! export createServerSocketTransport [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const net_1 = __webpack_require__(/*! net */ "net"); const messageReader_1 = __webpack_require__(/*! ./messageReader */ "../node_modules/vscode-jsonrpc/lib/messageReader.js"); const messageWriter_1 = __webpack_require__(/*! ./messageWriter */ "../node_modules/vscode-jsonrpc/lib/messageWriter.js"); function createClientSocketTransport(port, encoding = 'utf-8') { let connectResolve; let connected = new Promise((resolve, _reject) => { connectResolve = resolve; }); return new Promise((resolve, reject) => { let server = net_1.createServer((socket) => { server.close(); connectResolve([ new messageReader_1.SocketMessageReader(socket, encoding), new messageWriter_1.SocketMessageWriter(socket, encoding) ]); }); server.on('error', reject); server.listen(port, '127.0.0.1', () => { server.removeListener('error', reject); resolve({ onConnected: () => { return connected; } }); }); }); } exports.createClientSocketTransport = createClientSocketTransport; function createServerSocketTransport(port, encoding = 'utf-8') { const socket = net_1.createConnection(port, '127.0.0.1'); return [ new messageReader_1.SocketMessageReader(socket, encoding), new messageWriter_1.SocketMessageWriter(socket, encoding) ]; } exports.createServerSocketTransport = createServerSocketTransport; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/callHierarchy.proposed.js": /*!***************************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/callHierarchy.proposed.js ***! \***************************************************************************/ /*! flagged exports */ /*! export CallHierarchyFeature [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_1 = __webpack_require__(/*! vscode */ "vscode"); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); const client_1 = __webpack_require__(/*! ./client */ "../node_modules/vscode-languageclient/lib/client.js"); function ensure(target, key) { if (target[key] === void 0) { target[key] = {}; } return target[key]; } var protocol2code; (function (protocol2code) { function asCallHierarchyItem(converter, item) { if (item === null) { return undefined; } let result = new vscode_1.CallHierarchyItem(converter.asSymbolKind(item.kind), item.name, item.detail || '', converter.asUri(item.uri), converter.asRange(item.range), converter.asRange(item.selectionRange)); if (item.tags !== undefined) { result.tags = converter.asSymbolTags(item.tags); } return result; } protocol2code.asCallHierarchyItem = asCallHierarchyItem; function asCallHierarchyItems(converter, items) { if (items === null) { return undefined; } let result = items.map(item => asCallHierarchyItem(converter, item)); return result[0]; } protocol2code.asCallHierarchyItems = asCallHierarchyItems; function asCallHierarchyIncomingCall(converter, item) { return new vscode_1.CallHierarchyIncomingCall(asCallHierarchyItem(converter, item.from), converter.asRanges(item.fromRanges)); } protocol2code.asCallHierarchyIncomingCall = asCallHierarchyIncomingCall; function asCallHierarchyIncomingCalls(converter, items) { if (items === null) { return undefined; } return items.map(item => asCallHierarchyIncomingCall(converter, item)); } protocol2code.asCallHierarchyIncomingCalls = asCallHierarchyIncomingCalls; function asCallHierarchyOutgoingCall(converter, item) { return new vscode_1.CallHierarchyOutgoingCall(asCallHierarchyItem(converter, item.to), converter.asRanges(item.fromRanges)); } protocol2code.asCallHierarchyOutgoingCall = asCallHierarchyOutgoingCall; function asCallHierarchyOutgoingCalls(converter, items) { if (items === null) { return undefined; } return items.map(item => asCallHierarchyOutgoingCall(converter, item)); } protocol2code.asCallHierarchyOutgoingCalls = asCallHierarchyOutgoingCalls; })(protocol2code || (protocol2code = {})); var code2protocol; (function (code2protocol) { function asCallHierarchyItem(converter, value) { const result = { name: value.name, kind: converter.asSymbolKind(value.kind), uri: converter.asUri(value.uri), range: converter.asRange(value.range), selectionRange: converter.asRange(value.selectionRange) }; if (value.detail !== undefined && value.detail.length > 0) { result.detail = value.detail; } if (value.tags !== undefined) { result.tags = converter.asSymbolTags(value.tags); } return result; } code2protocol.asCallHierarchyItem = asCallHierarchyItem; })(code2protocol || (code2protocol = {})); class CallHierarchyProvider { constructor(client) { this.client = client; this.middleware = client.clientOptions.middleware; } prepareCallHierarchy(document, position, token) { const client = this.client; const middleware = this.middleware; const prepareCallHierarchy = (document, position, token) => { const params = client.code2ProtocolConverter.asTextDocumentPositionParams(document, position); return client.sendRequest(vscode_languageserver_protocol_1.Proposed.CallHierarchyPrepareRequest.type, params, token).then((result) => { return protocol2code.asCallHierarchyItems(this.client.protocol2CodeConverter, result); }, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.Proposed.CallHierarchyPrepareRequest.type, error); return Promise.resolve(null); }); }; return middleware.prepareCallHierarchy ? middleware.prepareCallHierarchy(document, position, token, prepareCallHierarchy) : prepareCallHierarchy(document, position, token); } provideCallHierarchyIncomingCalls(item, token) { const client = this.client; const middleware = this.middleware; const provideCallHierarchyIncomingCalls = (item, token) => { const params = { item: code2protocol.asCallHierarchyItem(client.code2ProtocolConverter, item) }; return client.sendRequest(vscode_languageserver_protocol_1.Proposed.CallHierarchyIncomingCallsRequest.type, params, token).then((result) => { return protocol2code.asCallHierarchyIncomingCalls(client.protocol2CodeConverter, result); }, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.Proposed.CallHierarchyIncomingCallsRequest.type, error); return Promise.resolve(null); }); }; return middleware.provideCallHierarchyIncomingCalls ? middleware.provideCallHierarchyIncomingCalls(item, token, provideCallHierarchyIncomingCalls) : provideCallHierarchyIncomingCalls(item, token); } provideCallHierarchyOutgoingCalls(item, token) { const client = this.client; const middleware = this.middleware; const provideCallHierarchyOutgoingCalls = (item, token) => { const params = { item: code2protocol.asCallHierarchyItem(client.code2ProtocolConverter, item) }; return client.sendRequest(vscode_languageserver_protocol_1.Proposed.CallHierarchyOutgoingCallsRequest.type, params, token).then((result) => { return protocol2code.asCallHierarchyOutgoingCalls(client.protocol2CodeConverter, result); }, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.Proposed.CallHierarchyOutgoingCallsRequest.type, error); return Promise.resolve(null); }); }; return middleware.provideCallHierarchyOutgingCalls ? middleware.provideCallHierarchyOutgingCalls(item, token, provideCallHierarchyOutgoingCalls) : provideCallHierarchyOutgoingCalls(item, token); } } class CallHierarchyFeature extends client_1.TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.Proposed.CallHierarchyPrepareRequest.type); } fillClientCapabilities(cap) { const capabilites = cap; const capability = ensure(ensure(capabilites, 'textDocument'), 'callHierarchy'); capability.dynamicRegistration = true; } initialize(cap, documentSelector) { const capabilities = cap; const [id, options] = this.getRegistration(documentSelector, capabilities.callHierarchyProvider); if (!id || !options) { return; } this.register(this.messages, { id: id, registerOptions: options }); } registerLanguageProvider(options) { const client = this._client; const provider = new CallHierarchyProvider(client); return [vscode_1.languages.registerCallHierarchyProvider(options.documentSelector, provider), provider]; } } exports.CallHierarchyFeature = CallHierarchyFeature; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/client.js": /*!***********************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/client.js ***! \***********************************************************/ /*! unknown exports (runtime-defined) */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /*! CommonJS bailout: exports.hasOwnProperty(...) prevents optimization as exports is passed as call context at 7:26-48 */ /*! CommonJS bailout: exports is used directly at 7:53-60 */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ function __export(m) { for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; } Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_1 = __webpack_require__(/*! vscode */ "vscode"); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); const c2p = __webpack_require__(/*! ./codeConverter */ "../node_modules/vscode-languageclient/lib/codeConverter.js"); const p2c = __webpack_require__(/*! ./protocolConverter */ "../node_modules/vscode-languageclient/lib/protocolConverter.js"); const Is = __webpack_require__(/*! ./utils/is */ "../node_modules/vscode-languageclient/lib/utils/is.js"); const async_1 = __webpack_require__(/*! ./utils/async */ "../node_modules/vscode-languageclient/lib/utils/async.js"); const UUID = __webpack_require__(/*! ./utils/uuid */ "../node_modules/vscode-languageclient/lib/utils/uuid.js"); const progressPart_1 = __webpack_require__(/*! ./progressPart */ "../node_modules/vscode-languageclient/lib/progressPart.js"); __export(__webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js")); class ConsoleLogger { error(message) { console.error(message); } warn(message) { console.warn(message); } info(message) { console.info(message); } log(message) { console.log(message); } } function createConnection(input, output, errorHandler, closeHandler) { let logger = new ConsoleLogger(); let connection = vscode_languageserver_protocol_1.createProtocolConnection(input, output, logger); connection.onError((data) => { errorHandler(data[0], data[1], data[2]); }); connection.onClose(closeHandler); let result = { listen: () => connection.listen(), sendRequest: (type, ...params) => connection.sendRequest(Is.string(type) ? type : type.method, ...params), onRequest: (type, handler) => connection.onRequest(Is.string(type) ? type : type.method, handler), sendNotification: (type, params) => connection.sendNotification(Is.string(type) ? type : type.method, params), onNotification: (type, handler) => connection.onNotification(Is.string(type) ? type : type.method, handler), onProgress: connection.onProgress, sendProgress: connection.sendProgress, trace: (value, tracer, sendNotificationOrTraceOptions) => { const defaultTraceOptions = { sendNotification: false, traceFormat: vscode_languageserver_protocol_1.TraceFormat.Text }; if (sendNotificationOrTraceOptions === void 0) { connection.trace(value, tracer, defaultTraceOptions); } else if (Is.boolean(sendNotificationOrTraceOptions)) { connection.trace(value, tracer, sendNotificationOrTraceOptions); } else { connection.trace(value, tracer, sendNotificationOrTraceOptions); } }, initialize: (params) => connection.sendRequest(vscode_languageserver_protocol_1.InitializeRequest.type, params), shutdown: () => connection.sendRequest(vscode_languageserver_protocol_1.ShutdownRequest.type, undefined), exit: () => connection.sendNotification(vscode_languageserver_protocol_1.ExitNotification.type), onLogMessage: (handler) => connection.onNotification(vscode_languageserver_protocol_1.LogMessageNotification.type, handler), onShowMessage: (handler) => connection.onNotification(vscode_languageserver_protocol_1.ShowMessageNotification.type, handler), onTelemetry: (handler) => connection.onNotification(vscode_languageserver_protocol_1.TelemetryEventNotification.type, handler), didChangeConfiguration: (params) => connection.sendNotification(vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type, params), didChangeWatchedFiles: (params) => connection.sendNotification(vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification.type, params), didOpenTextDocument: (params) => connection.sendNotification(vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.type, params), didChangeTextDocument: (params) => connection.sendNotification(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, params), didCloseTextDocument: (params) => connection.sendNotification(vscode_languageserver_protocol_1.DidCloseTextDocumentNotification.type, params), didSaveTextDocument: (params) => connection.sendNotification(vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.type, params), onDiagnostics: (handler) => connection.onNotification(vscode_languageserver_protocol_1.PublishDiagnosticsNotification.type, handler), dispose: () => connection.dispose() }; return result; } /** * An action to be performed when the connection is producing errors. */ var ErrorAction; (function (ErrorAction) { /** * Continue running the server. */ ErrorAction[ErrorAction["Continue"] = 1] = "Continue"; /** * Shutdown the server. */ ErrorAction[ErrorAction["Shutdown"] = 2] = "Shutdown"; })(ErrorAction = exports.ErrorAction || (exports.ErrorAction = {})); /** * An action to be performed when the connection to a server got closed. */ var CloseAction; (function (CloseAction) { /** * Don't restart the server. The connection stays closed. */ CloseAction[CloseAction["DoNotRestart"] = 1] = "DoNotRestart"; /** * Restart the server. */ CloseAction[CloseAction["Restart"] = 2] = "Restart"; })(CloseAction = exports.CloseAction || (exports.CloseAction = {})); class DefaultErrorHandler { constructor(name) { this.name = name; this.restarts = []; } error(_error, _message, count) { if (count && count <= 3) { return ErrorAction.Continue; } return ErrorAction.Shutdown; } closed() { this.restarts.push(Date.now()); if (this.restarts.length < 5) { return CloseAction.Restart; } else { let diff = this.restarts[this.restarts.length - 1] - this.restarts[0]; if (diff <= 3 * 60 * 1000) { vscode_1.window.showErrorMessage(`The ${this.name} server crashed 5 times in the last 3 minutes. The server will not be restarted.`); return CloseAction.DoNotRestart; } else { this.restarts.shift(); return CloseAction.Restart; } } } } var RevealOutputChannelOn; (function (RevealOutputChannelOn) { RevealOutputChannelOn[RevealOutputChannelOn["Info"] = 1] = "Info"; RevealOutputChannelOn[RevealOutputChannelOn["Warn"] = 2] = "Warn"; RevealOutputChannelOn[RevealOutputChannelOn["Error"] = 3] = "Error"; RevealOutputChannelOn[RevealOutputChannelOn["Never"] = 4] = "Never"; })(RevealOutputChannelOn = exports.RevealOutputChannelOn || (exports.RevealOutputChannelOn = {})); var State; (function (State) { State[State["Stopped"] = 1] = "Stopped"; State[State["Starting"] = 3] = "Starting"; State[State["Running"] = 2] = "Running"; })(State = exports.State || (exports.State = {})); var ClientState; (function (ClientState) { ClientState[ClientState["Initial"] = 0] = "Initial"; ClientState[ClientState["Starting"] = 1] = "Starting"; ClientState[ClientState["StartFailed"] = 2] = "StartFailed"; ClientState[ClientState["Running"] = 3] = "Running"; ClientState[ClientState["Stopping"] = 4] = "Stopping"; ClientState[ClientState["Stopped"] = 5] = "Stopped"; })(ClientState || (ClientState = {})); const SupportedSymbolKinds = [ vscode_languageserver_protocol_1.SymbolKind.File, vscode_languageserver_protocol_1.SymbolKind.Module, vscode_languageserver_protocol_1.SymbolKind.Namespace, vscode_languageserver_protocol_1.SymbolKind.Package, vscode_languageserver_protocol_1.SymbolKind.Class, vscode_languageserver_protocol_1.SymbolKind.Method, vscode_languageserver_protocol_1.SymbolKind.Property, vscode_languageserver_protocol_1.SymbolKind.Field, vscode_languageserver_protocol_1.SymbolKind.Constructor, vscode_languageserver_protocol_1.SymbolKind.Enum, vscode_languageserver_protocol_1.SymbolKind.Interface, vscode_languageserver_protocol_1.SymbolKind.Function, vscode_languageserver_protocol_1.SymbolKind.Variable, vscode_languageserver_protocol_1.SymbolKind.Constant, vscode_languageserver_protocol_1.SymbolKind.String, vscode_languageserver_protocol_1.SymbolKind.Number, vscode_languageserver_protocol_1.SymbolKind.Boolean, vscode_languageserver_protocol_1.SymbolKind.Array, vscode_languageserver_protocol_1.SymbolKind.Object, vscode_languageserver_protocol_1.SymbolKind.Key, vscode_languageserver_protocol_1.SymbolKind.Null, vscode_languageserver_protocol_1.SymbolKind.EnumMember, vscode_languageserver_protocol_1.SymbolKind.Struct, vscode_languageserver_protocol_1.SymbolKind.Event, vscode_languageserver_protocol_1.SymbolKind.Operator, vscode_languageserver_protocol_1.SymbolKind.TypeParameter ]; const SupportedCompletionItemKinds = [ vscode_languageserver_protocol_1.CompletionItemKind.Text, vscode_languageserver_protocol_1.CompletionItemKind.Method, vscode_languageserver_protocol_1.CompletionItemKind.Function, vscode_languageserver_protocol_1.CompletionItemKind.Constructor, vscode_languageserver_protocol_1.CompletionItemKind.Field, vscode_languageserver_protocol_1.CompletionItemKind.Variable, vscode_languageserver_protocol_1.CompletionItemKind.Class, vscode_languageserver_protocol_1.CompletionItemKind.Interface, vscode_languageserver_protocol_1.CompletionItemKind.Module, vscode_languageserver_protocol_1.CompletionItemKind.Property, vscode_languageserver_protocol_1.CompletionItemKind.Unit, vscode_languageserver_protocol_1.CompletionItemKind.Value, vscode_languageserver_protocol_1.CompletionItemKind.Enum, vscode_languageserver_protocol_1.CompletionItemKind.Keyword, vscode_languageserver_protocol_1.CompletionItemKind.Snippet, vscode_languageserver_protocol_1.CompletionItemKind.Color, vscode_languageserver_protocol_1.CompletionItemKind.File, vscode_languageserver_protocol_1.CompletionItemKind.Reference, vscode_languageserver_protocol_1.CompletionItemKind.Folder, vscode_languageserver_protocol_1.CompletionItemKind.EnumMember, vscode_languageserver_protocol_1.CompletionItemKind.Constant, vscode_languageserver_protocol_1.CompletionItemKind.Struct, vscode_languageserver_protocol_1.CompletionItemKind.Event, vscode_languageserver_protocol_1.CompletionItemKind.Operator, vscode_languageserver_protocol_1.CompletionItemKind.TypeParameter ]; function ensure(target, key) { if (target[key] === void 0) { target[key] = {}; } return target[key]; } var DynamicFeature; (function (DynamicFeature) { function is(value) { let candidate = value; return candidate && Is.func(candidate.register) && Is.func(candidate.unregister) && Is.func(candidate.dispose) && candidate.messages !== void 0; } DynamicFeature.is = is; })(DynamicFeature || (DynamicFeature = {})); class DocumentNotifiactions { constructor(_client, _event, _type, _middleware, _createParams, _selectorFilter) { this._client = _client; this._event = _event; this._type = _type; this._middleware = _middleware; this._createParams = _createParams; this._selectorFilter = _selectorFilter; this._selectors = new Map(); } static textDocumentFilter(selectors, textDocument) { for (const selector of selectors) { if (vscode_1.languages.match(selector, textDocument)) { return true; } } return false; } register(_message, data) { if (!data.registerOptions.documentSelector) { return; } if (!this._listener) { this._listener = this._event(this.callback, this); } this._selectors.set(data.id, data.registerOptions.documentSelector); } callback(data) { if (!this._selectorFilter || this._selectorFilter(this._selectors.values(), data)) { if (this._middleware) { this._middleware(data, (data) => this._client.sendNotification(this._type, this._createParams(data))); } else { this._client.sendNotification(this._type, this._createParams(data)); } this.notificationSent(data); } } notificationSent(_data) { } unregister(id) { this._selectors.delete(id); if (this._selectors.size === 0 && this._listener) { this._listener.dispose(); this._listener = undefined; } } dispose() { this._selectors.clear(); if (this._listener) { this._listener.dispose(); this._listener = undefined; } } getProvider(document) { for (const selector of this._selectors.values()) { if (vscode_1.languages.match(selector, document)) { return { send: (data) => { this.callback(data); } }; } } throw new Error(`No provider available for the given text document`); } } class DidOpenTextDocumentFeature extends DocumentNotifiactions { constructor(client, _syncedDocuments) { super(client, vscode_1.workspace.onDidOpenTextDocument, vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.type, client.clientOptions.middleware.didOpen, (textDocument) => client.code2ProtocolConverter.asOpenTextDocumentParams(textDocument), DocumentNotifiactions.textDocumentFilter); this._syncedDocuments = _syncedDocuments; } get messages() { return vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.type; } fillClientCapabilities(capabilities) { ensure(ensure(capabilities, 'textDocument'), 'synchronization').dynamicRegistration = true; } initialize(capabilities, documentSelector) { let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync; if (documentSelector && textDocumentSyncOptions && textDocumentSyncOptions.openClose) { this.register(this.messages, { id: UUID.generateUuid(), registerOptions: { documentSelector: documentSelector } }); } } register(message, data) { super.register(message, data); if (!data.registerOptions.documentSelector) { return; } let documentSelector = data.registerOptions.documentSelector; vscode_1.workspace.textDocuments.forEach((textDocument) => { let uri = textDocument.uri.toString(); if (this._syncedDocuments.has(uri)) { return; } if (vscode_1.languages.match(documentSelector, textDocument)) { let middleware = this._client.clientOptions.middleware; let didOpen = (textDocument) => { this._client.sendNotification(this._type, this._createParams(textDocument)); }; if (middleware.didOpen) { middleware.didOpen(textDocument, didOpen); } else { didOpen(textDocument); } this._syncedDocuments.set(uri, textDocument); } }); } notificationSent(textDocument) { super.notificationSent(textDocument); this._syncedDocuments.set(textDocument.uri.toString(), textDocument); } } class DidCloseTextDocumentFeature extends DocumentNotifiactions { constructor(client, _syncedDocuments) { super(client, vscode_1.workspace.onDidCloseTextDocument, vscode_languageserver_protocol_1.DidCloseTextDocumentNotification.type, client.clientOptions.middleware.didClose, (textDocument) => client.code2ProtocolConverter.asCloseTextDocumentParams(textDocument), DocumentNotifiactions.textDocumentFilter); this._syncedDocuments = _syncedDocuments; } get messages() { return vscode_languageserver_protocol_1.DidCloseTextDocumentNotification.type; } fillClientCapabilities(capabilities) { ensure(ensure(capabilities, 'textDocument'), 'synchronization').dynamicRegistration = true; } initialize(capabilities, documentSelector) { let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync; if (documentSelector && textDocumentSyncOptions && textDocumentSyncOptions.openClose) { this.register(this.messages, { id: UUID.generateUuid(), registerOptions: { documentSelector: documentSelector } }); } } notificationSent(textDocument) { super.notificationSent(textDocument); this._syncedDocuments.delete(textDocument.uri.toString()); } unregister(id) { let selector = this._selectors.get(id); // The super call removed the selector from the map // of selectors. super.unregister(id); let selectors = this._selectors.values(); this._syncedDocuments.forEach((textDocument) => { if (vscode_1.languages.match(selector, textDocument) && !this._selectorFilter(selectors, textDocument)) { let middleware = this._client.clientOptions.middleware; let didClose = (textDocument) => { this._client.sendNotification(this._type, this._createParams(textDocument)); }; this._syncedDocuments.delete(textDocument.uri.toString()); if (middleware.didClose) { middleware.didClose(textDocument, didClose); } else { didClose(textDocument); } } }); } } class DidChangeTextDocumentFeature { constructor(_client) { this._client = _client; this._changeData = new Map(); this._forcingDelivery = false; } get messages() { return vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type; } fillClientCapabilities(capabilities) { ensure(ensure(capabilities, 'textDocument'), 'synchronization').dynamicRegistration = true; } initialize(capabilities, documentSelector) { let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync; if (documentSelector && textDocumentSyncOptions && textDocumentSyncOptions.change !== void 0 && textDocumentSyncOptions.change !== vscode_languageserver_protocol_1.TextDocumentSyncKind.None) { this.register(this.messages, { id: UUID.generateUuid(), registerOptions: Object.assign({}, { documentSelector: documentSelector }, { syncKind: textDocumentSyncOptions.change }) }); } } register(_message, data) { if (!data.registerOptions.documentSelector) { return; } if (!this._listener) { this._listener = vscode_1.workspace.onDidChangeTextDocument(this.callback, this); } this._changeData.set(data.id, { documentSelector: data.registerOptions.documentSelector, syncKind: data.registerOptions.syncKind }); } callback(event) { // Text document changes are send for dirty changes as well. We don't // have dirty / undirty events in the LSP so we ignore content changes // with length zero. if (event.contentChanges.length === 0) { return; } for (const changeData of this._changeData.values()) { if (vscode_1.languages.match(changeData.documentSelector, event.document)) { let middleware = this._client.clientOptions.middleware; if (changeData.syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.Incremental) { let params = this._client.code2ProtocolConverter.asChangeTextDocumentParams(event); if (middleware.didChange) { middleware.didChange(event, () => this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, params)); } else { this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, params); } } else if (changeData.syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.Full) { let didChange = (event) => { if (this._changeDelayer) { if (this._changeDelayer.uri !== event.document.uri.toString()) { // Use this force delivery to track boolean state. Otherwise we might call two times. this.forceDelivery(); this._changeDelayer.uri = event.document.uri.toString(); } this._changeDelayer.delayer.trigger(() => { this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, this._client.code2ProtocolConverter.asChangeTextDocumentParams(event.document)); }); } else { this._changeDelayer = { uri: event.document.uri.toString(), delayer: new async_1.Delayer(200) }; this._changeDelayer.delayer.trigger(() => { this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, this._client.code2ProtocolConverter.asChangeTextDocumentParams(event.document)); }, -1); } }; if (middleware.didChange) { middleware.didChange(event, didChange); } else { didChange(event); } } } } } unregister(id) { this._changeData.delete(id); if (this._changeData.size === 0 && this._listener) { this._listener.dispose(); this._listener = undefined; } } dispose() { this._changeDelayer = undefined; this._forcingDelivery = false; this._changeData.clear(); if (this._listener) { this._listener.dispose(); this._listener = undefined; } } forceDelivery() { if (this._forcingDelivery || !this._changeDelayer) { return; } try { this._forcingDelivery = true; this._changeDelayer.delayer.forceDelivery(); } finally { this._forcingDelivery = false; } } getProvider(document) { for (const changeData of this._changeData.values()) { if (vscode_1.languages.match(changeData.documentSelector, document)) { return { send: (event) => { this.callback(event); } }; } } throw new Error(`No provider available for the given text document`); } } class WillSaveFeature extends DocumentNotifiactions { constructor(client) { super(client, vscode_1.workspace.onWillSaveTextDocument, vscode_languageserver_protocol_1.WillSaveTextDocumentNotification.type, client.clientOptions.middleware.willSave, (willSaveEvent) => client.code2ProtocolConverter.asWillSaveTextDocumentParams(willSaveEvent), (selectors, willSaveEvent) => DocumentNotifiactions.textDocumentFilter(selectors, willSaveEvent.document)); } get messages() { return vscode_languageserver_protocol_1.WillSaveTextDocumentNotification.type; } fillClientCapabilities(capabilities) { let value = ensure(ensure(capabilities, 'textDocument'), 'synchronization'); value.willSave = true; } initialize(capabilities, documentSelector) { let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync; if (documentSelector && textDocumentSyncOptions && textDocumentSyncOptions.willSave) { this.register(this.messages, { id: UUID.generateUuid(), registerOptions: { documentSelector: documentSelector } }); } } } class WillSaveWaitUntilFeature { constructor(_client) { this._client = _client; this._selectors = new Map(); } get messages() { return vscode_languageserver_protocol_1.WillSaveTextDocumentWaitUntilRequest.type; } fillClientCapabilities(capabilities) { let value = ensure(ensure(capabilities, 'textDocument'), 'synchronization'); value.willSaveWaitUntil = true; } initialize(capabilities, documentSelector) { let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync; if (documentSelector && textDocumentSyncOptions && textDocumentSyncOptions.willSaveWaitUntil) { this.register(this.messages, { id: UUID.generateUuid(), registerOptions: { documentSelector: documentSelector } }); } } register(_message, data) { if (!data.registerOptions.documentSelector) { return; } if (!this._listener) { this._listener = vscode_1.workspace.onWillSaveTextDocument(this.callback, this); } this._selectors.set(data.id, data.registerOptions.documentSelector); } callback(event) { if (DocumentNotifiactions.textDocumentFilter(this._selectors.values(), event.document)) { let middleware = this._client.clientOptions.middleware; let willSaveWaitUntil = (event) => { return this._client.sendRequest(vscode_languageserver_protocol_1.WillSaveTextDocumentWaitUntilRequest.type, this._client.code2ProtocolConverter.asWillSaveTextDocumentParams(event)).then((edits) => { let vEdits = this._client.protocol2CodeConverter.asTextEdits(edits); return vEdits === void 0 ? [] : vEdits; }); }; event.waitUntil(middleware.willSaveWaitUntil ? middleware.willSaveWaitUntil(event, willSaveWaitUntil) : willSaveWaitUntil(event)); } } unregister(id) { this._selectors.delete(id); if (this._selectors.size === 0 && this._listener) { this._listener.dispose(); this._listener = undefined; } } dispose() { this._selectors.clear(); if (this._listener) { this._listener.dispose(); this._listener = undefined; } } } class DidSaveTextDocumentFeature extends DocumentNotifiactions { constructor(client) { super(client, vscode_1.workspace.onDidSaveTextDocument, vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.type, client.clientOptions.middleware.didSave, (textDocument) => client.code2ProtocolConverter.asSaveTextDocumentParams(textDocument, this._includeText), DocumentNotifiactions.textDocumentFilter); } get messages() { return vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.type; } fillClientCapabilities(capabilities) { ensure(ensure(capabilities, 'textDocument'), 'synchronization').didSave = true; } initialize(capabilities, documentSelector) { let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync; if (documentSelector && textDocumentSyncOptions && textDocumentSyncOptions.save) { this.register(this.messages, { id: UUID.generateUuid(), registerOptions: Object.assign({}, { documentSelector: documentSelector }, { includeText: !!textDocumentSyncOptions.save.includeText }) }); } } register(method, data) { this._includeText = !!data.registerOptions.includeText; super.register(method, data); } } class FileSystemWatcherFeature { constructor(_client, _notifyFileEvent) { this._client = _client; this._notifyFileEvent = _notifyFileEvent; this._watchers = new Map(); } get messages() { return vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification.type; } fillClientCapabilities(capabilities) { ensure(ensure(capabilities, 'workspace'), 'didChangeWatchedFiles').dynamicRegistration = true; } initialize(_capabilities, _documentSelector) { } register(_method, data) { if (!Array.isArray(data.registerOptions.watchers)) { return; } let disposeables = []; for (let watcher of data.registerOptions.watchers) { if (!Is.string(watcher.globPattern)) { continue; } let watchCreate = true, watchChange = true, watchDelete = true; if (watcher.kind !== void 0 && watcher.kind !== null) { watchCreate = (watcher.kind & vscode_languageserver_protocol_1.WatchKind.Create) !== 0; watchChange = (watcher.kind & vscode_languageserver_protocol_1.WatchKind.Change) !== 0; watchDelete = (watcher.kind & vscode_languageserver_protocol_1.WatchKind.Delete) !== 0; } let fileSystemWatcher = vscode_1.workspace.createFileSystemWatcher(watcher.globPattern, !watchCreate, !watchChange, !watchDelete); this.hookListeners(fileSystemWatcher, watchCreate, watchChange, watchDelete); disposeables.push(fileSystemWatcher); } this._watchers.set(data.id, disposeables); } registerRaw(id, fileSystemWatchers) { let disposeables = []; for (let fileSystemWatcher of fileSystemWatchers) { this.hookListeners(fileSystemWatcher, true, true, true, disposeables); } this._watchers.set(id, disposeables); } hookListeners(fileSystemWatcher, watchCreate, watchChange, watchDelete, listeners) { if (watchCreate) { fileSystemWatcher.onDidCreate((resource) => this._notifyFileEvent({ uri: this._client.code2ProtocolConverter.asUri(resource), type: vscode_languageserver_protocol_1.FileChangeType.Created }), null, listeners); } if (watchChange) { fileSystemWatcher.onDidChange((resource) => this._notifyFileEvent({ uri: this._client.code2ProtocolConverter.asUri(resource), type: vscode_languageserver_protocol_1.FileChangeType.Changed }), null, listeners); } if (watchDelete) { fileSystemWatcher.onDidDelete((resource) => this._notifyFileEvent({ uri: this._client.code2ProtocolConverter.asUri(resource), type: vscode_languageserver_protocol_1.FileChangeType.Deleted }), null, listeners); } } unregister(id) { let disposeables = this._watchers.get(id); if (disposeables) { for (let disposable of disposeables) { disposable.dispose(); } } } dispose() { this._watchers.forEach((disposeables) => { for (let disposable of disposeables) { disposable.dispose(); } }); this._watchers.clear(); } } class TextDocumentFeature { constructor(_client, _message) { this._client = _client; this._message = _message; this._registrations = new Map(); } get messages() { return this._message; } register(message, data) { if (message.method !== this.messages.method) { throw new Error(`Register called on wrong feature. Requested ${message.method} but reached feature ${this.messages.method}`); } if (!data.registerOptions.documentSelector) { return; } let registration = this.registerLanguageProvider(data.registerOptions); this._registrations.set(data.id, { disposable: registration[0], data, provider: registration[1] }); } unregister(id) { let registration = this._registrations.get(id); if (registration !== undefined) { registration.disposable.dispose(); } } dispose() { this._registrations.forEach((value) => { value.disposable.dispose(); }); this._registrations.clear(); } getRegistration(documentSelector, capability) { if (!capability) { return [undefined, undefined]; } else if (vscode_languageserver_protocol_1.TextDocumentRegistrationOptions.is(capability)) { const id = vscode_languageserver_protocol_1.StaticRegistrationOptions.hasId(capability) ? capability.id : UUID.generateUuid(); const selector = capability.documentSelector || documentSelector; if (selector) { return [id, Object.assign({}, capability, { documentSelector: selector })]; } } else if (Is.boolean(capability) && capability === true || vscode_languageserver_protocol_1.WorkDoneProgressOptions.is(capability)) { if (!documentSelector) { return [undefined, undefined]; } let options = (Is.boolean(capability) && capability === true ? { documentSelector } : Object.assign({}, capability, { documentSelector })); return [UUID.generateUuid(), options]; } return [undefined, undefined]; } getRegistrationOptions(documentSelector, capability) { if (!documentSelector || !capability) { return undefined; } return (Is.boolean(capability) && capability === true ? { documentSelector } : Object.assign({}, capability, { documentSelector })); } getProvider(textDocument) { for (const registration of this._registrations.values()) { let selector = registration.data.registerOptions.documentSelector; if (selector !== null && vscode_1.languages.match(selector, textDocument)) { return registration.provider; } } throw new Error(`The feature has no registration for the provided text document ${textDocument.uri.toString()}`); } } exports.TextDocumentFeature = TextDocumentFeature; class WorkspaceFeature { constructor(_client, _message) { this._client = _client; this._message = _message; this._registrations = new Map(); } get messages() { return this._message; } register(message, data) { if (message.method !== this.messages.method) { throw new Error(`Register called on wron feature. Requested ${message.method} but reached feature ${this.messages.method}`); } const registration = this.registerLanguageProvider(data.registerOptions); this._registrations.set(data.id, { disposable: registration[0], provider: registration[1] }); } unregister(id) { let registration = this._registrations.get(id); if (registration !== undefined) { registration.disposable.dispose(); } } dispose() { this._registrations.forEach((registration) => { registration.disposable.dispose(); }); this._registrations.clear(); } getProviders() { const result = []; for (const registration of this._registrations.values()) { result.push(registration.provider); } return result; } } class CompletionItemFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.CompletionRequest.type); } fillClientCapabilities(capabilites) { let completion = ensure(ensure(capabilites, 'textDocument'), 'completion'); completion.dynamicRegistration = true; completion.contextSupport = true; completion.completionItem = { snippetSupport: true, commitCharactersSupport: true, documentationFormat: [vscode_languageserver_protocol_1.MarkupKind.Markdown, vscode_languageserver_protocol_1.MarkupKind.PlainText], deprecatedSupport: true, preselectSupport: true, tagSupport: { valueSet: [vscode_languageserver_protocol_1.CompletionItemTag.Deprecated] } }; completion.completionItemKind = { valueSet: SupportedCompletionItemKinds }; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.completionProvider); if (!options) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const triggerCharacters = options.triggerCharacters || []; const provider = { provideCompletionItems: (document, position, token, context) => { const client = this._client; const middleware = this._client.clientOptions.middleware; const provideCompletionItems = (document, position, context, token) => { return client.sendRequest(vscode_languageserver_protocol_1.CompletionRequest.type, client.code2ProtocolConverter.asCompletionParams(document, position, context), token).then(client.protocol2CodeConverter.asCompletionResult, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.CompletionRequest.type, error); return Promise.resolve([]); }); }; return middleware.provideCompletionItem ? middleware.provideCompletionItem(document, position, context, token, provideCompletionItems) : provideCompletionItems(document, position, context, token); }, resolveCompletionItem: options.resolveProvider ? (item, token) => { const client = this._client; const middleware = this._client.clientOptions.middleware; const resolveCompletionItem = (item, token) => { return client.sendRequest(vscode_languageserver_protocol_1.CompletionResolveRequest.type, client.code2ProtocolConverter.asCompletionItem(item), token).then(client.protocol2CodeConverter.asCompletionItem, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.CompletionResolveRequest.type, error); return Promise.resolve(item); }); }; return middleware.resolveCompletionItem ? middleware.resolveCompletionItem(item, token, resolveCompletionItem) : resolveCompletionItem(item, token); } : undefined }; return [vscode_1.languages.registerCompletionItemProvider(options.documentSelector, provider, ...triggerCharacters), provider]; } } class HoverFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.HoverRequest.type); } fillClientCapabilities(capabilites) { const hoverCapability = (ensure(ensure(capabilites, 'textDocument'), 'hover')); hoverCapability.dynamicRegistration = true; hoverCapability.contentFormat = [vscode_languageserver_protocol_1.MarkupKind.Markdown, vscode_languageserver_protocol_1.MarkupKind.PlainText]; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.hoverProvider); if (!options) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideHover: (document, position, token) => { const client = this._client; const provideHover = (document, position, token) => { return client.sendRequest(vscode_languageserver_protocol_1.HoverRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then(client.protocol2CodeConverter.asHover, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.HoverRequest.type, error); return Promise.resolve(null); }); }; const middleware = client.clientOptions.middleware; return middleware.provideHover ? middleware.provideHover(document, position, token, provideHover) : provideHover(document, position, token); } }; return [vscode_1.languages.registerHoverProvider(options.documentSelector, provider), provider]; } } class SignatureHelpFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.SignatureHelpRequest.type); } fillClientCapabilities(capabilites) { let config = ensure(ensure(capabilites, 'textDocument'), 'signatureHelp'); config.dynamicRegistration = true; config.signatureInformation = { documentationFormat: [vscode_languageserver_protocol_1.MarkupKind.Markdown, vscode_languageserver_protocol_1.MarkupKind.PlainText] }; config.signatureInformation.parameterInformation = { labelOffsetSupport: true }; config.contextSupport = true; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.signatureHelpProvider); if (!options) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideSignatureHelp: (document, position, token, context) => { const client = this._client; const providerSignatureHelp = (document, position, context, token) => { return client.sendRequest(vscode_languageserver_protocol_1.SignatureHelpRequest.type, client.code2ProtocolConverter.asSignatureHelpParams(document, position, context), token).then(client.protocol2CodeConverter.asSignatureHelp, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.SignatureHelpRequest.type, error); return Promise.resolve(null); }); }; const middleware = client.clientOptions.middleware; return middleware.provideSignatureHelp ? middleware.provideSignatureHelp(document, position, context, token, providerSignatureHelp) : providerSignatureHelp(document, position, context, token); } }; let disposable; if (options.retriggerCharacters === undefined) { const triggerCharacters = options.triggerCharacters || []; disposable = vscode_1.languages.registerSignatureHelpProvider(options.documentSelector, provider, ...triggerCharacters); } else { const metaData = { triggerCharacters: options.triggerCharacters || [], retriggerCharacters: options.retriggerCharacters || [] }; disposable = vscode_1.languages.registerSignatureHelpProvider(options.documentSelector, provider, metaData); } return [disposable, provider]; } } class DefinitionFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.DefinitionRequest.type); } fillClientCapabilities(capabilites) { let definitionSupport = ensure(ensure(capabilites, 'textDocument'), 'definition'); definitionSupport.dynamicRegistration = true; definitionSupport.linkSupport = true; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.definitionProvider); if (!options) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideDefinition: (document, position, token) => { const client = this._client; const provideDefinition = (document, position, token) => { return client.sendRequest(vscode_languageserver_protocol_1.DefinitionRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then(client.protocol2CodeConverter.asDefinitionResult, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.DefinitionRequest.type, error); return Promise.resolve(null); }); }; const middleware = client.clientOptions.middleware; return middleware.provideDefinition ? middleware.provideDefinition(document, position, token, provideDefinition) : provideDefinition(document, position, token); } }; return [vscode_1.languages.registerDefinitionProvider(options.documentSelector, provider), provider]; } } class ReferencesFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.ReferencesRequest.type); } fillClientCapabilities(capabilites) { ensure(ensure(capabilites, 'textDocument'), 'references').dynamicRegistration = true; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.referencesProvider); if (!options) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideReferences: (document, position, options, token) => { const client = this._client; const _providerReferences = (document, position, options, token) => { return client.sendRequest(vscode_languageserver_protocol_1.ReferencesRequest.type, client.code2ProtocolConverter.asReferenceParams(document, position, options), token).then(client.protocol2CodeConverter.asReferences, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.ReferencesRequest.type, error); return Promise.resolve([]); }); }; const middleware = client.clientOptions.middleware; return middleware.provideReferences ? middleware.provideReferences(document, position, options, token, _providerReferences) : _providerReferences(document, position, options, token); } }; return [vscode_1.languages.registerReferenceProvider(options.documentSelector, provider), provider]; } } class DocumentHighlightFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.DocumentHighlightRequest.type); } fillClientCapabilities(capabilites) { ensure(ensure(capabilites, 'textDocument'), 'documentHighlight').dynamicRegistration = true; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.documentHighlightProvider); if (!options) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideDocumentHighlights: (document, position, token) => { const client = this._client; const _provideDocumentHighlights = (document, position, token) => { return client.sendRequest(vscode_languageserver_protocol_1.DocumentHighlightRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then(client.protocol2CodeConverter.asDocumentHighlights, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.DocumentHighlightRequest.type, error); return Promise.resolve([]); }); }; const middleware = client.clientOptions.middleware; return middleware.provideDocumentHighlights ? middleware.provideDocumentHighlights(document, position, token, _provideDocumentHighlights) : _provideDocumentHighlights(document, position, token); } }; return [vscode_1.languages.registerDocumentHighlightProvider(options.documentSelector, provider), provider]; } } class DocumentSymbolFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.DocumentSymbolRequest.type); } fillClientCapabilities(capabilites) { let symbolCapabilities = ensure(ensure(capabilites, 'textDocument'), 'documentSymbol'); symbolCapabilities.dynamicRegistration = true; symbolCapabilities.symbolKind = { valueSet: SupportedSymbolKinds }; symbolCapabilities.hierarchicalDocumentSymbolSupport = true; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.documentSymbolProvider); if (!options) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideDocumentSymbols: (document, token) => { const client = this._client; const _provideDocumentSymbols = (document, token) => { return client.sendRequest(vscode_languageserver_protocol_1.DocumentSymbolRequest.type, client.code2ProtocolConverter.asDocumentSymbolParams(document), token).then((data) => { if (data === null) { return undefined; } if (data.length === 0) { return []; } else { let element = data[0]; if (vscode_languageserver_protocol_1.DocumentSymbol.is(element)) { return client.protocol2CodeConverter.asDocumentSymbols(data); } else { return client.protocol2CodeConverter.asSymbolInformations(data); } } }, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.DocumentSymbolRequest.type, error); return Promise.resolve([]); }); }; const middleware = client.clientOptions.middleware; return middleware.provideDocumentSymbols ? middleware.provideDocumentSymbols(document, token, _provideDocumentSymbols) : _provideDocumentSymbols(document, token); } }; return [vscode_1.languages.registerDocumentSymbolProvider(options.documentSelector, provider), provider]; } } class WorkspaceSymbolFeature extends WorkspaceFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type); } fillClientCapabilities(capabilites) { let symbolCapabilities = ensure(ensure(capabilites, 'workspace'), 'symbol'); symbolCapabilities.dynamicRegistration = true; symbolCapabilities.symbolKind = { valueSet: SupportedSymbolKinds }; } initialize(capabilities) { if (!capabilities.workspaceSymbolProvider) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: capabilities.workspaceSymbolProvider === true ? { workDoneProgress: false } : capabilities.workspaceSymbolProvider }); } registerLanguageProvider(_options) { const provider = { provideWorkspaceSymbols: (query, token) => { const client = this._client; const provideWorkspaceSymbols = (query, token) => { return client.sendRequest(vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type, { query }, token).then(client.protocol2CodeConverter.asSymbolInformations, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type, error); return Promise.resolve([]); }); }; const middleware = client.clientOptions.middleware; return middleware.provideWorkspaceSymbols ? middleware.provideWorkspaceSymbols(query, token, provideWorkspaceSymbols) : provideWorkspaceSymbols(query, token); } }; return [vscode_1.languages.registerWorkspaceSymbolProvider(provider), provider]; } } class CodeActionFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.CodeActionRequest.type); } fillClientCapabilities(capabilites) { const cap = ensure(ensure(capabilites, 'textDocument'), 'codeAction'); cap.dynamicRegistration = true; cap.isPreferredSupport = true; cap.codeActionLiteralSupport = { codeActionKind: { valueSet: [ vscode_languageserver_protocol_1.CodeActionKind.Empty, vscode_languageserver_protocol_1.CodeActionKind.QuickFix, vscode_languageserver_protocol_1.CodeActionKind.Refactor, vscode_languageserver_protocol_1.CodeActionKind.RefactorExtract, vscode_languageserver_protocol_1.CodeActionKind.RefactorInline, vscode_languageserver_protocol_1.CodeActionKind.RefactorRewrite, vscode_languageserver_protocol_1.CodeActionKind.Source, vscode_languageserver_protocol_1.CodeActionKind.SourceOrganizeImports ] } }; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.codeActionProvider); if (!options) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideCodeActions: (document, range, context, token) => { const client = this._client; const _provideCodeActions = (document, range, context, token) => { const params = { textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document), range: client.code2ProtocolConverter.asRange(range), context: client.code2ProtocolConverter.asCodeActionContext(context) }; return client.sendRequest(vscode_languageserver_protocol_1.CodeActionRequest.type, params, token).then((values) => { if (values === null) { return undefined; } const result = []; for (let item of values) { if (vscode_languageserver_protocol_1.Command.is(item)) { result.push(client.protocol2CodeConverter.asCommand(item)); } else { result.push(client.protocol2CodeConverter.asCodeAction(item)); } } return result; }, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.CodeActionRequest.type, error); return Promise.resolve([]); }); }; const middleware = client.clientOptions.middleware; return middleware.provideCodeActions ? middleware.provideCodeActions(document, range, context, token, _provideCodeActions) : _provideCodeActions(document, range, context, token); } }; return [vscode_1.languages.registerCodeActionsProvider(options.documentSelector, provider, (options.codeActionKinds ? { providedCodeActionKinds: this._client.protocol2CodeConverter.asCodeActionKinds(options.codeActionKinds) } : undefined)), provider]; } } class CodeLensFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.CodeLensRequest.type); } fillClientCapabilities(capabilites) { ensure(ensure(capabilites, 'textDocument'), 'codeLens').dynamicRegistration = true; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.codeLensProvider); if (!options) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideCodeLenses: (document, token) => { const client = this._client; const provideCodeLenses = (document, token) => { return client.sendRequest(vscode_languageserver_protocol_1.CodeLensRequest.type, client.code2ProtocolConverter.asCodeLensParams(document), token).then(client.protocol2CodeConverter.asCodeLenses, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.CodeLensRequest.type, error); return Promise.resolve([]); }); }; const middleware = client.clientOptions.middleware; return middleware.provideCodeLenses ? middleware.provideCodeLenses(document, token, provideCodeLenses) : provideCodeLenses(document, token); }, resolveCodeLens: (options.resolveProvider) ? (codeLens, token) => { const client = this._client; const resolveCodeLens = (codeLens, token) => { return client.sendRequest(vscode_languageserver_protocol_1.CodeLensResolveRequest.type, client.code2ProtocolConverter.asCodeLens(codeLens), token).then(client.protocol2CodeConverter.asCodeLens, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.CodeLensResolveRequest.type, error); return codeLens; }); }; const middleware = client.clientOptions.middleware; return middleware.resolveCodeLens ? middleware.resolveCodeLens(codeLens, token, resolveCodeLens) : resolveCodeLens(codeLens, token); } : undefined }; return [vscode_1.languages.registerCodeLensProvider(options.documentSelector, provider), provider]; } } class DocumentFormattingFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.DocumentFormattingRequest.type); } fillClientCapabilities(capabilites) { ensure(ensure(capabilites, 'textDocument'), 'formatting').dynamicRegistration = true; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.documentFormattingProvider); if (!options) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideDocumentFormattingEdits: (document, options, token) => { const client = this._client; const provideDocumentFormattingEdits = (document, options, token) => { const params = { textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document), options: client.code2ProtocolConverter.asFormattingOptions(options) }; return client.sendRequest(vscode_languageserver_protocol_1.DocumentFormattingRequest.type, params, token).then(client.protocol2CodeConverter.asTextEdits, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.DocumentFormattingRequest.type, error); return Promise.resolve([]); }); }; const middleware = client.clientOptions.middleware; return middleware.provideDocumentFormattingEdits ? middleware.provideDocumentFormattingEdits(document, options, token, provideDocumentFormattingEdits) : provideDocumentFormattingEdits(document, options, token); } }; return [vscode_1.languages.registerDocumentFormattingEditProvider(options.documentSelector, provider), provider]; } } class DocumentRangeFormattingFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type); } fillClientCapabilities(capabilites) { ensure(ensure(capabilites, 'textDocument'), 'rangeFormatting').dynamicRegistration = true; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.documentRangeFormattingProvider); if (!options) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideDocumentRangeFormattingEdits: (document, range, options, token) => { const client = this._client; const provideDocumentRangeFormattingEdits = (document, range, options, token) => { let params = { textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document), range: client.code2ProtocolConverter.asRange(range), options: client.code2ProtocolConverter.asFormattingOptions(options) }; return client.sendRequest(vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type, params, token).then(client.protocol2CodeConverter.asTextEdits, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type, error); return Promise.resolve([]); }); }; let middleware = client.clientOptions.middleware; return middleware.provideDocumentRangeFormattingEdits ? middleware.provideDocumentRangeFormattingEdits(document, range, options, token, provideDocumentRangeFormattingEdits) : provideDocumentRangeFormattingEdits(document, range, options, token); } }; return [vscode_1.languages.registerDocumentRangeFormattingEditProvider(options.documentSelector, provider), provider]; } } class DocumentOnTypeFormattingFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type); } fillClientCapabilities(capabilites) { ensure(ensure(capabilites, 'textDocument'), 'onTypeFormatting').dynamicRegistration = true; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.documentOnTypeFormattingProvider); if (!options) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideOnTypeFormattingEdits: (document, position, ch, options, token) => { const client = this._client; const provideOnTypeFormattingEdits = (document, position, ch, options, token) => { let params = { textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document), position: client.code2ProtocolConverter.asPosition(position), ch: ch, options: client.code2ProtocolConverter.asFormattingOptions(options) }; return client.sendRequest(vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type, params, token).then(client.protocol2CodeConverter.asTextEdits, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type, error); return Promise.resolve([]); }); }; const middleware = client.clientOptions.middleware; return middleware.provideOnTypeFormattingEdits ? middleware.provideOnTypeFormattingEdits(document, position, ch, options, token, provideOnTypeFormattingEdits) : provideOnTypeFormattingEdits(document, position, ch, options, token); } }; const moreTriggerCharacter = options.moreTriggerCharacter || []; return [vscode_1.languages.registerOnTypeFormattingEditProvider(options.documentSelector, provider, options.firstTriggerCharacter, ...moreTriggerCharacter), provider]; } } class RenameFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.RenameRequest.type); } fillClientCapabilities(capabilites) { let rename = ensure(ensure(capabilites, 'textDocument'), 'rename'); rename.dynamicRegistration = true; rename.prepareSupport = true; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.renameProvider); if (!options) { return; } if (Is.boolean(capabilities.renameProvider)) { options.prepareProvider = false; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideRenameEdits: (document, position, newName, token) => { const client = this._client; const provideRenameEdits = (document, position, newName, token) => { let params = { textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document), position: client.code2ProtocolConverter.asPosition(position), newName: newName }; return client.sendRequest(vscode_languageserver_protocol_1.RenameRequest.type, params, token).then(client.protocol2CodeConverter.asWorkspaceEdit, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.RenameRequest.type, error); return Promise.reject(new Error(error.message)); }); }; const middleware = client.clientOptions.middleware; return middleware.provideRenameEdits ? middleware.provideRenameEdits(document, position, newName, token, provideRenameEdits) : provideRenameEdits(document, position, newName, token); }, prepareRename: options.prepareProvider ? (document, position, token) => { const client = this._client; const prepareRename = (document, position, token) => { let params = { textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document), position: client.code2ProtocolConverter.asPosition(position), }; return client.sendRequest(vscode_languageserver_protocol_1.PrepareRenameRequest.type, params, token).then((result) => { if (vscode_languageserver_protocol_1.Range.is(result)) { return client.protocol2CodeConverter.asRange(result); } else if (result && vscode_languageserver_protocol_1.Range.is(result.range)) { return { range: client.protocol2CodeConverter.asRange(result.range), placeholder: result.placeholder }; } // To cancel the rename vscode API expects a rejected promise. return Promise.reject(new Error(`The element can't be renamed.`)); }, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.PrepareRenameRequest.type, error); return Promise.reject(new Error(error.message)); }); }; const middleware = client.clientOptions.middleware; return middleware.prepareRename ? middleware.prepareRename(document, position, token, prepareRename) : prepareRename(document, position, token); } : undefined }; return [vscode_1.languages.registerRenameProvider(options.documentSelector, provider), provider]; } } class DocumentLinkFeature extends TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.DocumentLinkRequest.type); } fillClientCapabilities(capabilites) { const documentLinkCapabilities = ensure(ensure(capabilites, 'textDocument'), 'documentLink'); documentLinkCapabilities.dynamicRegistration = true; documentLinkCapabilities.tooltipSupport = true; } initialize(capabilities, documentSelector) { const options = this.getRegistrationOptions(documentSelector, capabilities.documentLinkProvider); if (!options) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideDocumentLinks: (document, token) => { const client = this._client; const provideDocumentLinks = (document, token) => { return client.sendRequest(vscode_languageserver_protocol_1.DocumentLinkRequest.type, client.code2ProtocolConverter.asDocumentLinkParams(document), token).then(client.protocol2CodeConverter.asDocumentLinks, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.DocumentLinkRequest.type, error); return Promise.resolve([]); }); }; const middleware = client.clientOptions.middleware; return middleware.provideDocumentLinks ? middleware.provideDocumentLinks(document, token, provideDocumentLinks) : provideDocumentLinks(document, token); }, resolveDocumentLink: options.resolveProvider ? (link, token) => { const client = this._client; let resolveDocumentLink = (link, token) => { return client.sendRequest(vscode_languageserver_protocol_1.DocumentLinkResolveRequest.type, client.code2ProtocolConverter.asDocumentLink(link), token).then(client.protocol2CodeConverter.asDocumentLink, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.DocumentLinkResolveRequest.type, error); return Promise.resolve(link); }); }; const middleware = client.clientOptions.middleware; return middleware.resolveDocumentLink ? middleware.resolveDocumentLink(link, token, resolveDocumentLink) : resolveDocumentLink(link, token); } : undefined }; return [vscode_1.languages.registerDocumentLinkProvider(options.documentSelector, provider), provider]; } } class ConfigurationFeature { constructor(_client) { this._client = _client; this._listeners = new Map(); } get messages() { return vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type; } fillClientCapabilities(capabilities) { ensure(ensure(capabilities, 'workspace'), 'didChangeConfiguration').dynamicRegistration = true; } initialize() { let section = this._client.clientOptions.synchronize.configurationSection; if (section !== void 0) { this.register(this.messages, { id: UUID.generateUuid(), registerOptions: { section: section } }); } } register(_message, data) { let disposable = vscode_1.workspace.onDidChangeConfiguration((event) => { this.onDidChangeConfiguration(data.registerOptions.section, event); }); this._listeners.set(data.id, disposable); if (data.registerOptions.section !== void 0) { this.onDidChangeConfiguration(data.registerOptions.section, undefined); } } unregister(id) { let disposable = this._listeners.get(id); if (disposable) { this._listeners.delete(id); disposable.dispose(); } } dispose() { for (let disposable of this._listeners.values()) { disposable.dispose(); } this._listeners.clear(); } onDidChangeConfiguration(configurationSection, event) { let sections; if (Is.string(configurationSection)) { sections = [configurationSection]; } else { sections = configurationSection; } if (sections !== void 0 && event !== void 0) { let affected = sections.some((section) => event.affectsConfiguration(section)); if (!affected) { return; } } let didChangeConfiguration = (sections) => { if (sections === void 0) { this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type, { settings: null }); return; } this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type, { settings: this.extractSettingsInformation(sections) }); }; let middleware = this.getMiddleware(); middleware ? middleware(sections, didChangeConfiguration) : didChangeConfiguration(sections); } extractSettingsInformation(keys) { function ensurePath(config, path) { let current = config; for (let i = 0; i < path.length - 1; i++) { let obj = current[path[i]]; if (!obj) { obj = Object.create(null); current[path[i]] = obj; } current = obj; } return current; } let resource = this._client.clientOptions.workspaceFolder ? this._client.clientOptions.workspaceFolder.uri : undefined; let result = Object.create(null); for (let i = 0; i < keys.length; i++) { let key = keys[i]; let index = key.indexOf('.'); let config = null; if (index >= 0) { config = vscode_1.workspace.getConfiguration(key.substr(0, index), resource).get(key.substr(index + 1)); } else { config = vscode_1.workspace.getConfiguration(key, resource); } if (config) { let path = keys[i].split('.'); ensurePath(result, path)[path[path.length - 1]] = config; } } return result; } getMiddleware() { let middleware = this._client.clientOptions.middleware; if (middleware.workspace && middleware.workspace.didChangeConfiguration) { return middleware.workspace.didChangeConfiguration; } else { return undefined; } } } class ExecuteCommandFeature { constructor(_client) { this._client = _client; this._commands = new Map(); } get messages() { return vscode_languageserver_protocol_1.ExecuteCommandRequest.type; } fillClientCapabilities(capabilities) { ensure(ensure(capabilities, 'workspace'), 'executeCommand').dynamicRegistration = true; } initialize(capabilities) { if (!capabilities.executeCommandProvider) { return; } this.register(this.messages, { id: UUID.generateUuid(), registerOptions: Object.assign({}, capabilities.executeCommandProvider) }); } register(_message, data) { const client = this._client; const middleware = client.clientOptions.middleware; const executeCommand = (command, args) => { let params = { command, arguments: args }; return client.sendRequest(vscode_languageserver_protocol_1.ExecuteCommandRequest.type, params).then(undefined, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.ExecuteCommandRequest.type, error); }); }; if (data.registerOptions.commands) { const disposeables = []; for (const command of data.registerOptions.commands) { disposeables.push(vscode_1.commands.registerCommand(command, (...args) => { return middleware.executeCommand ? middleware.executeCommand(command, args, executeCommand) : executeCommand(command, args); })); } this._commands.set(data.id, disposeables); } } unregister(id) { let disposeables = this._commands.get(id); if (disposeables) { disposeables.forEach(disposable => disposable.dispose()); } } dispose() { this._commands.forEach((value) => { value.forEach(disposable => disposable.dispose()); }); this._commands.clear(); } } var MessageTransports; (function (MessageTransports) { function is(value) { let candidate = value; return candidate && vscode_languageserver_protocol_1.MessageReader.is(value.reader) && vscode_languageserver_protocol_1.MessageWriter.is(value.writer); } MessageTransports.is = is; })(MessageTransports = exports.MessageTransports || (exports.MessageTransports = {})); class OnReady { constructor(_resolve, _reject) { this._resolve = _resolve; this._reject = _reject; this._used = false; } get isUsed() { return this._used; } resolve() { this._used = true; this._resolve(); } reject(error) { this._used = true; this._reject(error); } } class BaseLanguageClient { constructor(id, name, clientOptions) { this._traceFormat = vscode_languageserver_protocol_1.TraceFormat.Text; this._features = []; this._method2Message = new Map(); this._dynamicFeatures = new Map(); this._id = id; this._name = name; clientOptions = clientOptions || {}; this._clientOptions = { documentSelector: clientOptions.documentSelector || [], synchronize: clientOptions.synchronize || {}, diagnosticCollectionName: clientOptions.diagnosticCollectionName, outputChannelName: clientOptions.outputChannelName || this._name, revealOutputChannelOn: clientOptions.revealOutputChannelOn || RevealOutputChannelOn.Error, stdioEncoding: clientOptions.stdioEncoding || 'utf8', initializationOptions: clientOptions.initializationOptions, initializationFailedHandler: clientOptions.initializationFailedHandler, progressOnInitialization: !!clientOptions.progressOnInitialization, errorHandler: clientOptions.errorHandler || new DefaultErrorHandler(this._name), middleware: clientOptions.middleware || {}, uriConverters: clientOptions.uriConverters, workspaceFolder: clientOptions.workspaceFolder }; this._clientOptions.synchronize = this._clientOptions.synchronize || {}; this.state = ClientState.Initial; this._connectionPromise = undefined; this._resolvedConnection = undefined; this._initializeResult = undefined; if (clientOptions.outputChannel) { this._outputChannel = clientOptions.outputChannel; this._disposeOutputChannel = false; } else { this._outputChannel = undefined; this._disposeOutputChannel = true; } this._traceOutputChannel = clientOptions.traceOutputChannel; this._listeners = undefined; this._providers = undefined; this._diagnostics = undefined; this._fileEvents = []; this._fileEventDelayer = new async_1.Delayer(250); this._onReady = new Promise((resolve, reject) => { this._onReadyCallbacks = new OnReady(resolve, reject); }); this._onStop = undefined; this._telemetryEmitter = new vscode_languageserver_protocol_1.Emitter(); this._stateChangeEmitter = new vscode_languageserver_protocol_1.Emitter(); this._tracer = { log: (messageOrDataObject, data) => { if (Is.string(messageOrDataObject)) { this.logTrace(messageOrDataObject, data); } else { this.logObjectTrace(messageOrDataObject); } }, }; this._c2p = c2p.createConverter(clientOptions.uriConverters ? clientOptions.uriConverters.code2Protocol : undefined); this._p2c = p2c.createConverter(clientOptions.uriConverters ? clientOptions.uriConverters.protocol2Code : undefined); this._syncedDocuments = new Map(); this.registerBuiltinFeatures(); } get state() { return this._state; } set state(value) { let oldState = this.getPublicState(); this._state = value; let newState = this.getPublicState(); if (newState !== oldState) { this._stateChangeEmitter.fire({ oldState, newState }); } } getPublicState() { if (this.state === ClientState.Running) { return State.Running; } else if (this.state === ClientState.Starting) { return State.Starting; } else { return State.Stopped; } } get initializeResult() { return this._initializeResult; } sendRequest(type, ...params) { if (!this.isConnectionActive()) { throw new Error('Language client is not ready yet'); } this.forceDocumentSync(); try { return this._resolvedConnection.sendRequest(type, ...params); } catch (error) { this.error(`Sending request ${Is.string(type) ? type : type.method} failed.`, error); throw error; } } onRequest(type, handler) { if (!this.isConnectionActive()) { throw new Error('Language client is not ready yet'); } try { this._resolvedConnection.onRequest(type, handler); } catch (error) { this.error(`Registering request handler ${Is.string(type) ? type : type.method} failed.`, error); throw error; } } sendNotification(type, params) { if (!this.isConnectionActive()) { throw new Error('Language client is not ready yet'); } this.forceDocumentSync(); try { this._resolvedConnection.sendNotification(type, params); } catch (error) { this.error(`Sending notification ${Is.string(type) ? type : type.method} failed.`, error); throw error; } } onNotification(type, handler) { if (!this.isConnectionActive()) { throw new Error('Language client is not ready yet'); } try { this._resolvedConnection.onNotification(type, handler); } catch (error) { this.error(`Registering notification handler ${Is.string(type) ? type : type.method} failed.`, error); throw error; } } onProgress(type, token, handler) { if (!this.isConnectionActive()) { throw new Error('Language client is not ready yet'); } try { return this._resolvedConnection.onProgress(type, token, handler); } catch (error) { this.error(`Registering progress handler for token ${token} failed.`, error); throw error; } } sendProgress(type, token, value) { if (!this.isConnectionActive()) { throw new Error('Language client is not ready yet'); } this.forceDocumentSync(); try { this._resolvedConnection.sendProgress(type, token, value); } catch (error) { this.error(`Sending progress for token ${token} failed.`, error); throw error; } } get clientOptions() { return this._clientOptions; } get protocol2CodeConverter() { return this._p2c; } get code2ProtocolConverter() { return this._c2p; } get onTelemetry() { return this._telemetryEmitter.event; } get onDidChangeState() { return this._stateChangeEmitter.event; } get outputChannel() { if (!this._outputChannel) { this._outputChannel = vscode_1.window.createOutputChannel(this._clientOptions.outputChannelName ? this._clientOptions.outputChannelName : this._name); } return this._outputChannel; } get traceOutputChannel() { if (this._traceOutputChannel) { return this._traceOutputChannel; } return this.outputChannel; } get diagnostics() { return this._diagnostics; } createDefaultErrorHandler() { return new DefaultErrorHandler(this._name); } set trace(value) { this._trace = value; this.onReady().then(() => { this.resolveConnection().then((connection) => { connection.trace(this._trace, this._tracer, { sendNotification: false, traceFormat: this._traceFormat }); }); }, () => { }); } data2String(data) { if (data instanceof vscode_languageserver_protocol_1.ResponseError) { const responseError = data; return ` Message: ${responseError.message}\n Code: ${responseError.code} ${responseError.data ? '\n' + responseError.data.toString() : ''}`; } if (data instanceof Error) { if (Is.string(data.stack)) { return data.stack; } return data.message; } if (Is.string(data)) { return data; } return data.toString(); } info(message, data, showNotification = true) { this.outputChannel.appendLine(`[Info - ${(new Date().toLocaleTimeString())}] ${message}`); if (data) { this.outputChannel.appendLine(this.data2String(data)); } if (showNotification && this._clientOptions.revealOutputChannelOn <= RevealOutputChannelOn.Info) { this.showNotificationMessage(); } } warn(message, data, showNotification = true) { this.outputChannel.appendLine(`[Warn - ${(new Date().toLocaleTimeString())}] ${message}`); if (data) { this.outputChannel.appendLine(this.data2String(data)); } if (showNotification && this._clientOptions.revealOutputChannelOn <= RevealOutputChannelOn.Warn) { this.showNotificationMessage(); } } error(message, data, showNotification = true) { this.outputChannel.appendLine(`[Error - ${(new Date().toLocaleTimeString())}] ${message}`); if (data) { this.outputChannel.appendLine(this.data2String(data)); } if (showNotification && this._clientOptions.revealOutputChannelOn <= RevealOutputChannelOn.Error) { this.showNotificationMessage(); } } showNotificationMessage() { vscode_1.window.showInformationMessage('A request has failed. See the output for more information.', 'Go to output').then(() => { this.outputChannel.show(true); }); } logTrace(message, data) { this.traceOutputChannel.appendLine(`[Trace - ${(new Date().toLocaleTimeString())}] ${message}`); if (data) { this.traceOutputChannel.appendLine(this.data2String(data)); } } logObjectTrace(data) { if (data.isLSPMessage && data.type) { this.traceOutputChannel.append(`[LSP - ${(new Date().toLocaleTimeString())}] `); } else { this.traceOutputChannel.append(`[Trace - ${(new Date().toLocaleTimeString())}] `); } if (data) { this.traceOutputChannel.appendLine(`${JSON.stringify(data)}`); } } needsStart() { return this.state === ClientState.Initial || this.state === ClientState.Stopping || this.state === ClientState.Stopped; } needsStop() { return this.state === ClientState.Starting || this.state === ClientState.Running; } onReady() { return this._onReady; } isConnectionActive() { return this.state === ClientState.Running && !!this._resolvedConnection; } start() { if (this._onReadyCallbacks.isUsed) { this._onReady = new Promise((resolve, reject) => { this._onReadyCallbacks = new OnReady(resolve, reject); }); } this._listeners = []; this._providers = []; // If we restart then the diagnostics collection is reused. if (!this._diagnostics) { this._diagnostics = this._clientOptions.diagnosticCollectionName ? vscode_1.languages.createDiagnosticCollection(this._clientOptions.diagnosticCollectionName) : vscode_1.languages.createDiagnosticCollection(); } this.state = ClientState.Starting; this.resolveConnection().then((connection) => { connection.onLogMessage((message) => { switch (message.type) { case vscode_languageserver_protocol_1.MessageType.Error: this.error(message.message, undefined, false); break; case vscode_languageserver_protocol_1.MessageType.Warning: this.warn(message.message, undefined, false); break; case vscode_languageserver_protocol_1.MessageType.Info: this.info(message.message, undefined, false); break; default: this.outputChannel.appendLine(message.message); } }); connection.onShowMessage((message) => { switch (message.type) { case vscode_languageserver_protocol_1.MessageType.Error: vscode_1.window.showErrorMessage(message.message); break; case vscode_languageserver_protocol_1.MessageType.Warning: vscode_1.window.showWarningMessage(message.message); break; case vscode_languageserver_protocol_1.MessageType.Info: vscode_1.window.showInformationMessage(message.message); break; default: vscode_1.window.showInformationMessage(message.message); } }); connection.onRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, (params) => { let messageFunc; switch (params.type) { case vscode_languageserver_protocol_1.MessageType.Error: messageFunc = vscode_1.window.showErrorMessage; break; case vscode_languageserver_protocol_1.MessageType.Warning: messageFunc = vscode_1.window.showWarningMessage; break; case vscode_languageserver_protocol_1.MessageType.Info: messageFunc = vscode_1.window.showInformationMessage; break; default: messageFunc = vscode_1.window.showInformationMessage; } let actions = params.actions || []; return messageFunc(params.message, ...actions); }); connection.onTelemetry((data) => { this._telemetryEmitter.fire(data); }); connection.listen(); // Error is handled in the initialize call. return this.initialize(connection); }).then(undefined, (error) => { this.state = ClientState.StartFailed; this._onReadyCallbacks.reject(error); this.error('Starting client failed', error); vscode_1.window.showErrorMessage(`Couldn't start client ${this._name}`); }); return new vscode_1.Disposable(() => { if (this.needsStop()) { this.stop(); } }); } resolveConnection() { if (!this._connectionPromise) { this._connectionPromise = this.createConnection(); } return this._connectionPromise; } initialize(connection) { this.refreshTrace(connection, false); let initOption = this._clientOptions.initializationOptions; let rootPath = this._clientOptions.workspaceFolder ? this._clientOptions.workspaceFolder.uri.fsPath : this._clientGetRootPath(); let initParams = { processId: process.pid, clientInfo: { name: 'vscode', version: vscode_1.version }, rootPath: rootPath ? rootPath : null, rootUri: rootPath ? this._c2p.asUri(vscode_1.Uri.file(rootPath)) : null, capabilities: this.computeClientCapabilities(), initializationOptions: Is.func(initOption) ? initOption() : initOption, trace: vscode_languageserver_protocol_1.Trace.toString(this._trace), workspaceFolders: null }; this.fillInitializeParams(initParams); if (this._clientOptions.progressOnInitialization) { const token = UUID.generateUuid(); const part = new progressPart_1.ProgressPart(connection, token); initParams.workDoneToken = token; return this.doInitialize(connection, initParams).then((result) => { part.done(); return result; }, (error) => { part.cancel(); throw error; }); } else { return this.doInitialize(connection, initParams); } } doInitialize(connection, initParams) { return connection.initialize(initParams).then((result) => { this._resolvedConnection = connection; this._initializeResult = result; this.state = ClientState.Running; let textDocumentSyncOptions = undefined; if (Is.number(result.capabilities.textDocumentSync)) { if (result.capabilities.textDocumentSync === vscode_languageserver_protocol_1.TextDocumentSyncKind.None) { textDocumentSyncOptions = { openClose: false, change: vscode_languageserver_protocol_1.TextDocumentSyncKind.None, save: undefined }; } else { textDocumentSyncOptions = { openClose: true, change: result.capabilities.textDocumentSync, save: { includeText: false } }; } } else if (result.capabilities.textDocumentSync !== void 0 && result.capabilities.textDocumentSync !== null) { textDocumentSyncOptions = result.capabilities.textDocumentSync; } this._capabilities = Object.assign({}, result.capabilities, { resolvedTextDocumentSync: textDocumentSyncOptions }); connection.onDiagnostics(params => this.handleDiagnostics(params)); connection.onRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, params => this.handleRegistrationRequest(params)); // See https://github.com/Microsoft/vscode-languageserver-node/issues/199 connection.onRequest('client/registerFeature', params => this.handleRegistrationRequest(params)); connection.onRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, params => this.handleUnregistrationRequest(params)); // See https://github.com/Microsoft/vscode-languageserver-node/issues/199 connection.onRequest('client/unregisterFeature', params => this.handleUnregistrationRequest(params)); connection.onRequest(vscode_languageserver_protocol_1.ApplyWorkspaceEditRequest.type, params => this.handleApplyWorkspaceEdit(params)); connection.sendNotification(vscode_languageserver_protocol_1.InitializedNotification.type, {}); this.hookFileEvents(connection); this.hookConfigurationChanged(connection); this.initializeFeatures(connection); this._onReadyCallbacks.resolve(); return result; }).then(undefined, (error) => { if (this._clientOptions.initializationFailedHandler) { if (this._clientOptions.initializationFailedHandler(error)) { this.initialize(connection); } else { this.stop(); this._onReadyCallbacks.reject(error); } } else if (error instanceof vscode_languageserver_protocol_1.ResponseError && error.data && error.data.retry) { vscode_1.window.showErrorMessage(error.message, { title: 'Retry', id: 'retry' }).then(item => { if (item && item.id === 'retry') { this.initialize(connection); } else { this.stop(); this._onReadyCallbacks.reject(error); } }); } else { if (error && error.message) { vscode_1.window.showErrorMessage(error.message); } this.error('Server initialization failed.', error); this.stop(); this._onReadyCallbacks.reject(error); } throw error; }); } _clientGetRootPath() { let folders = vscode_1.workspace.workspaceFolders; if (!folders || folders.length === 0) { return undefined; } let folder = folders[0]; if (folder.uri.scheme === 'file') { return folder.uri.fsPath; } return undefined; } stop() { this._initializeResult = undefined; if (!this._connectionPromise) { this.state = ClientState.Stopped; return Promise.resolve(); } if (this.state === ClientState.Stopping && this._onStop) { return this._onStop; } this.state = ClientState.Stopping; this.cleanUp(false); // unhook listeners return this._onStop = this.resolveConnection().then(connection => { return connection.shutdown().then(() => { connection.exit(); connection.dispose(); this.state = ClientState.Stopped; this.cleanUpChannel(); this._onStop = undefined; this._connectionPromise = undefined; this._resolvedConnection = undefined; }); }); } cleanUp(channel = true, diagnostics = true) { if (this._listeners) { this._listeners.forEach(listener => listener.dispose()); this._listeners = undefined; } if (this._providers) { this._providers.forEach(provider => provider.dispose()); this._providers = undefined; } if (this._syncedDocuments) { this._syncedDocuments.clear(); } for (let handler of this._dynamicFeatures.values()) { handler.dispose(); } if (channel) { this.cleanUpChannel(); } if (diagnostics && this._diagnostics) { this._diagnostics.dispose(); this._diagnostics = undefined; } } cleanUpChannel() { if (this._outputChannel && this._disposeOutputChannel) { this._outputChannel.dispose(); this._outputChannel = undefined; } } notifyFileEvent(event) { var _a, _b; const client = this; function didChangeWatchedFile(event) { client._fileEvents.push(event); client._fileEventDelayer.trigger(() => { client.onReady().then(() => { client.resolveConnection().then(connection => { if (client.isConnectionActive()) { client.forceDocumentSync(); connection.didChangeWatchedFiles({ changes: client._fileEvents }); } client._fileEvents = []; }); }, (error) => { client.error(`Notify file events failed.`, error); }); }); } const workSpaceMiddleware = (_a = this.clientOptions.middleware) === null || _a === void 0 ? void 0 : _a.workspace; ((_b = workSpaceMiddleware) === null || _b === void 0 ? void 0 : _b.didChangeWatchedFile) ? workSpaceMiddleware.didChangeWatchedFile(event, didChangeWatchedFile) : didChangeWatchedFile(event); } forceDocumentSync() { this._dynamicFeatures.get(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type.method).forceDelivery(); } handleDiagnostics(params) { if (!this._diagnostics) { return; } let uri = this._p2c.asUri(params.uri); let diagnostics = this._p2c.asDiagnostics(params.diagnostics); let middleware = this.clientOptions.middleware; if (middleware.handleDiagnostics) { middleware.handleDiagnostics(uri, diagnostics, (uri, diagnostics) => this.setDiagnostics(uri, diagnostics)); } else { this.setDiagnostics(uri, diagnostics); } } setDiagnostics(uri, diagnostics) { if (!this._diagnostics) { return; } this._diagnostics.set(uri, diagnostics); } createConnection() { let errorHandler = (error, message, count) => { this.handleConnectionError(error, message, count); }; let closeHandler = () => { this.handleConnectionClosed(); }; return this.createMessageTransports(this._clientOptions.stdioEncoding || 'utf8').then((transports) => { return createConnection(transports.reader, transports.writer, errorHandler, closeHandler); }); } handleConnectionClosed() { // Check whether this is a normal shutdown in progress or the client stopped normally. if (this.state === ClientState.Stopping || this.state === ClientState.Stopped) { return; } try { if (this._resolvedConnection) { this._resolvedConnection.dispose(); } } catch (error) { // Disposing a connection could fail if error cases. } let action = CloseAction.DoNotRestart; try { action = this._clientOptions.errorHandler.closed(); } catch (error) { // Ignore errors coming from the error handler. } this._connectionPromise = undefined; this._resolvedConnection = undefined; if (action === CloseAction.DoNotRestart) { this.error('Connection to server got closed. Server will not be restarted.'); this.state = ClientState.Stopped; this.cleanUp(false, true); } else if (action === CloseAction.Restart) { this.info('Connection to server got closed. Server will restart.'); this.cleanUp(false, false); this.state = ClientState.Initial; this.start(); } } handleConnectionError(error, message, count) { let action = this._clientOptions.errorHandler.error(error, message, count); if (action === ErrorAction.Shutdown) { this.error('Connection to server is erroring. Shutting down server.'); this.stop(); } } hookConfigurationChanged(connection) { vscode_1.workspace.onDidChangeConfiguration(() => { this.refreshTrace(connection, true); }); } refreshTrace(connection, sendNotification = false) { let config = vscode_1.workspace.getConfiguration(this._id); let trace = vscode_languageserver_protocol_1.Trace.Off; let traceFormat = vscode_languageserver_protocol_1.TraceFormat.Text; if (config) { const traceConfig = config.get('trace.server', 'off'); if (typeof traceConfig === 'string') { trace = vscode_languageserver_protocol_1.Trace.fromString(traceConfig); } else { trace = vscode_languageserver_protocol_1.Trace.fromString(config.get('trace.server.verbosity', 'off')); traceFormat = vscode_languageserver_protocol_1.TraceFormat.fromString(config.get('trace.server.format', 'text')); } } this._trace = trace; this._traceFormat = traceFormat; connection.trace(this._trace, this._tracer, { sendNotification, traceFormat: this._traceFormat }); } hookFileEvents(_connection) { let fileEvents = this._clientOptions.synchronize.fileEvents; if (!fileEvents) { return; } let watchers; if (Is.array(fileEvents)) { watchers = fileEvents; } else { watchers = [fileEvents]; } if (!watchers) { return; } this._dynamicFeatures.get(vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification.type.method).registerRaw(UUID.generateUuid(), watchers); } registerFeatures(features) { for (let feature of features) { this.registerFeature(feature); } } registerFeature(feature) { this._features.push(feature); if (DynamicFeature.is(feature)) { let messages = feature.messages; if (Array.isArray(messages)) { for (let message of messages) { this._method2Message.set(message.method, message); this._dynamicFeatures.set(message.method, feature); } } else { this._method2Message.set(messages.method, messages); this._dynamicFeatures.set(messages.method, feature); } } } getFeature(request) { return this._dynamicFeatures.get(request); } registerBuiltinFeatures() { this.registerFeature(new ConfigurationFeature(this)); this.registerFeature(new DidOpenTextDocumentFeature(this, this._syncedDocuments)); this.registerFeature(new DidChangeTextDocumentFeature(this)); this.registerFeature(new WillSaveFeature(this)); this.registerFeature(new WillSaveWaitUntilFeature(this)); this.registerFeature(new DidSaveTextDocumentFeature(this)); this.registerFeature(new DidCloseTextDocumentFeature(this, this._syncedDocuments)); this.registerFeature(new FileSystemWatcherFeature(this, (event) => this.notifyFileEvent(event))); this.registerFeature(new CompletionItemFeature(this)); this.registerFeature(new HoverFeature(this)); this.registerFeature(new SignatureHelpFeature(this)); this.registerFeature(new DefinitionFeature(this)); this.registerFeature(new ReferencesFeature(this)); this.registerFeature(new DocumentHighlightFeature(this)); this.registerFeature(new DocumentSymbolFeature(this)); this.registerFeature(new WorkspaceSymbolFeature(this)); this.registerFeature(new CodeActionFeature(this)); this.registerFeature(new CodeLensFeature(this)); this.registerFeature(new DocumentFormattingFeature(this)); this.registerFeature(new DocumentRangeFormattingFeature(this)); this.registerFeature(new DocumentOnTypeFormattingFeature(this)); this.registerFeature(new RenameFeature(this)); this.registerFeature(new DocumentLinkFeature(this)); this.registerFeature(new ExecuteCommandFeature(this)); } fillInitializeParams(params) { for (let feature of this._features) { if (Is.func(feature.fillInitializeParams)) { feature.fillInitializeParams(params); } } } computeClientCapabilities() { let result = {}; ensure(result, 'workspace').applyEdit = true; let workspaceEdit = ensure(ensure(result, 'workspace'), 'workspaceEdit'); workspaceEdit.documentChanges = true; workspaceEdit.resourceOperations = [vscode_languageserver_protocol_1.ResourceOperationKind.Create, vscode_languageserver_protocol_1.ResourceOperationKind.Rename, vscode_languageserver_protocol_1.ResourceOperationKind.Delete]; workspaceEdit.failureHandling = vscode_languageserver_protocol_1.FailureHandlingKind.TextOnlyTransactional; let diagnostics = ensure(ensure(result, 'textDocument'), 'publishDiagnostics'); diagnostics.relatedInformation = true; diagnostics.versionSupport = false; diagnostics.tagSupport = { valueSet: [vscode_languageserver_protocol_1.DiagnosticTag.Unnecessary, vscode_languageserver_protocol_1.DiagnosticTag.Deprecated] }; for (let feature of this._features) { feature.fillClientCapabilities(result); } return result; } initializeFeatures(_connection) { let documentSelector = this._clientOptions.documentSelector; for (let feature of this._features) { feature.initialize(this._capabilities, documentSelector); } } handleRegistrationRequest(params) { return new Promise((resolve, reject) => { for (let registration of params.registrations) { const feature = this._dynamicFeatures.get(registration.method); if (!feature) { reject(new Error(`No feature implementation for ${registration.method} found. Registration failed.`)); return; } const options = registration.registerOptions || {}; options.documentSelector = options.documentSelector || this._clientOptions.documentSelector; const data = { id: registration.id, registerOptions: options }; feature.register(this._method2Message.get(registration.method), data); } resolve(); }); } handleUnregistrationRequest(params) { return new Promise((resolve, reject) => { for (let unregistration of params.unregisterations) { const feature = this._dynamicFeatures.get(unregistration.method); if (!feature) { reject(new Error(`No feature implementation for ${unregistration.method} found. Unregistration failed.`)); return; } feature.unregister(unregistration.id); } resolve(); }); } handleApplyWorkspaceEdit(params) { // This is some sort of workaround since the version check should be done by VS Code in the Workspace.applyEdit. // However doing it here adds some safety since the server can lag more behind then an extension. let workspaceEdit = params.edit; let openTextDocuments = new Map(); vscode_1.workspace.textDocuments.forEach((document) => openTextDocuments.set(document.uri.toString(), document)); let versionMismatch = false; if (workspaceEdit.documentChanges) { for (const change of workspaceEdit.documentChanges) { if (vscode_languageserver_protocol_1.TextDocumentEdit.is(change) && change.textDocument.version && change.textDocument.version >= 0) { let textDocument = openTextDocuments.get(change.textDocument.uri); if (textDocument && textDocument.version !== change.textDocument.version) { versionMismatch = true; break; } } } } if (versionMismatch) { return Promise.resolve({ applied: false }); } return Is.asPromise(vscode_1.workspace.applyEdit(this._p2c.asWorkspaceEdit(params.edit)).then((value) => { return { applied: value }; })); } logFailedRequest(type, error) { // If we get a request cancel or a content modified don't log anything. if (error instanceof vscode_languageserver_protocol_1.ResponseError && (error.code === vscode_languageserver_protocol_1.ErrorCodes.RequestCancelled || error.code === vscode_languageserver_protocol_1.ErrorCodes.ContentModified)) { return; } this.error(`Request ${type.method} failed.`, error); } } exports.BaseLanguageClient = BaseLanguageClient; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/codeConverter.js": /*!******************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/codeConverter.js ***! \******************************************************************/ /*! flagged exports */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export createConverter [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const code = __webpack_require__(/*! vscode */ "vscode"); const proto = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); const Is = __webpack_require__(/*! ./utils/is */ "../node_modules/vscode-languageclient/lib/utils/is.js"); const protocolCompletionItem_1 = __webpack_require__(/*! ./protocolCompletionItem */ "../node_modules/vscode-languageclient/lib/protocolCompletionItem.js"); const protocolCodeLens_1 = __webpack_require__(/*! ./protocolCodeLens */ "../node_modules/vscode-languageclient/lib/protocolCodeLens.js"); const protocolDocumentLink_1 = __webpack_require__(/*! ./protocolDocumentLink */ "../node_modules/vscode-languageclient/lib/protocolDocumentLink.js"); function createConverter(uriConverter) { const nullConverter = (value) => value.toString(); const _uriConverter = uriConverter || nullConverter; function asUri(value) { return _uriConverter(value); } function asTextDocumentIdentifier(textDocument) { return { uri: _uriConverter(textDocument.uri) }; } function asVersionedTextDocumentIdentifier(textDocument) { return { uri: _uriConverter(textDocument.uri), version: textDocument.version }; } function asOpenTextDocumentParams(textDocument) { return { textDocument: { uri: _uriConverter(textDocument.uri), languageId: textDocument.languageId, version: textDocument.version, text: textDocument.getText() } }; } function isTextDocumentChangeEvent(value) { let candidate = value; return !!candidate.document && !!candidate.contentChanges; } function isTextDocument(value) { let candidate = value; return !!candidate.uri && !!candidate.version; } function asChangeTextDocumentParams(arg) { if (isTextDocument(arg)) { let result = { textDocument: { uri: _uriConverter(arg.uri), version: arg.version }, contentChanges: [{ text: arg.getText() }] }; return result; } else if (isTextDocumentChangeEvent(arg)) { let document = arg.document; let result = { textDocument: { uri: _uriConverter(document.uri), version: document.version }, contentChanges: arg.contentChanges.map((change) => { let range = change.range; return { range: { start: { line: range.start.line, character: range.start.character }, end: { line: range.end.line, character: range.end.character } }, rangeLength: change.rangeLength, text: change.text }; }) }; return result; } else { throw Error('Unsupported text document change parameter'); } } function asCloseTextDocumentParams(textDocument) { return { textDocument: asTextDocumentIdentifier(textDocument) }; } function asSaveTextDocumentParams(textDocument, includeContent = false) { let result = { textDocument: asVersionedTextDocumentIdentifier(textDocument) }; if (includeContent) { result.text = textDocument.getText(); } return result; } function asTextDocumentSaveReason(reason) { switch (reason) { case code.TextDocumentSaveReason.Manual: return proto.TextDocumentSaveReason.Manual; case code.TextDocumentSaveReason.AfterDelay: return proto.TextDocumentSaveReason.AfterDelay; case code.TextDocumentSaveReason.FocusOut: return proto.TextDocumentSaveReason.FocusOut; } return proto.TextDocumentSaveReason.Manual; } function asWillSaveTextDocumentParams(event) { return { textDocument: asTextDocumentIdentifier(event.document), reason: asTextDocumentSaveReason(event.reason) }; } function asTextDocumentPositionParams(textDocument, position) { return { textDocument: asTextDocumentIdentifier(textDocument), position: asWorkerPosition(position) }; } function asCompletionTriggerKind(triggerKind) { switch (triggerKind) { case code.CompletionTriggerKind.TriggerCharacter: return proto.CompletionTriggerKind.TriggerCharacter; case code.CompletionTriggerKind.TriggerForIncompleteCompletions: return proto.CompletionTriggerKind.TriggerForIncompleteCompletions; default: return proto.CompletionTriggerKind.Invoked; } } function asCompletionParams(textDocument, position, context) { return { textDocument: asTextDocumentIdentifier(textDocument), position: asWorkerPosition(position), context: { triggerKind: asCompletionTriggerKind(context.triggerKind), triggerCharacter: context.triggerCharacter } }; } function asSignatureHelpTriggerKind(triggerKind) { switch (triggerKind) { case code.SignatureHelpTriggerKind.Invoke: return proto.SignatureHelpTriggerKind.Invoked; case code.SignatureHelpTriggerKind.TriggerCharacter: return proto.SignatureHelpTriggerKind.TriggerCharacter; case code.SignatureHelpTriggerKind.ContentChange: return proto.SignatureHelpTriggerKind.ContentChange; } } function asParameterInformation(value) { // We leave the documentation out on purpose since it usually adds no // value for the server. return { label: value.label }; } function asParameterInformations(values) { return values.map(asParameterInformation); } function asSignatureInformation(value) { // We leave the documentation out on purpose since it usually adds no // value for the server. return { label: value.label, parameters: asParameterInformations(value.parameters) }; } function asSignatureInformations(values) { return values.map(asSignatureInformation); } function asSignatureHelp(value) { if (value === undefined) { return value; } return { signatures: asSignatureInformations(value.signatures), activeSignature: value.activeSignature, activeParameter: value.activeParameter }; } function asSignatureHelpParams(textDocument, position, context) { return { textDocument: asTextDocumentIdentifier(textDocument), position: asWorkerPosition(position), context: { isRetrigger: context.isRetrigger, triggerCharacter: context.triggerCharacter, triggerKind: asSignatureHelpTriggerKind(context.triggerKind), activeSignatureHelp: asSignatureHelp(context.activeSignatureHelp) } }; } function asWorkerPosition(position) { return { line: position.line, character: position.character }; } function asPosition(value) { if (value === undefined || value === null) { return value; } return { line: value.line, character: value.character }; } function asPositions(value) { let result = []; for (let elem of value) { result.push(asPosition(elem)); } return result; } function isInsertReplace(value) { const candidate = value; return candidate && !!candidate.inserting && !!candidate.replacing; } function asRange(value) { if (value === undefined || value === null) { return value; } // The LSP has no support yet for insert replace. So this can never happen. if (isInsertReplace(value)) { throw new Error(`Receving unknown insert replace range.`); } return { start: asPosition(value.start), end: asPosition(value.end) }; } function asLocation(value) { if (value === undefined || value === null) { return value; } return proto.Location.create(asUri(value.uri), asRange(value.range)); } function asDiagnosticSeverity(value) { switch (value) { case code.DiagnosticSeverity.Error: return proto.DiagnosticSeverity.Error; case code.DiagnosticSeverity.Warning: return proto.DiagnosticSeverity.Warning; case code.DiagnosticSeverity.Information: return proto.DiagnosticSeverity.Information; case code.DiagnosticSeverity.Hint: return proto.DiagnosticSeverity.Hint; } } function asDiagnosticTags(tags) { if (!tags) { return undefined; } let result = []; for (let tag of tags) { let converted = asDiagnosticTag(tag); if (converted !== undefined) { result.push(converted); } } return result.length > 0 ? result : undefined; } function asDiagnosticTag(tag) { switch (tag) { case code.DiagnosticTag.Unnecessary: return proto.DiagnosticTag.Unnecessary; case code.DiagnosticTag.Deprecated: return proto.DiagnosticTag.Deprecated; default: return undefined; } } function asRelatedInformation(item) { return { message: item.message, location: asLocation(item.location) }; } function asRelatedInformations(items) { return items.map(asRelatedInformation); } function asDiagnostic(item) { let result = proto.Diagnostic.create(asRange(item.range), item.message); if (Is.number(item.severity)) { result.severity = asDiagnosticSeverity(item.severity); } if (Is.number(item.code) || Is.string(item.code)) { result.code = item.code; } if (Array.isArray(item.tags)) { result.tags = asDiagnosticTags(item.tags); } if (item.relatedInformation) { result.relatedInformation = asRelatedInformations(item.relatedInformation); } if (item.source) { result.source = item.source; } return result; } function asDiagnostics(items) { if (items === undefined || items === null) { return items; } return items.map(asDiagnostic); } function asDocumentation(format, documentation) { switch (format) { case '$string': return documentation; case proto.MarkupKind.PlainText: return { kind: format, value: documentation }; case proto.MarkupKind.Markdown: return { kind: format, value: documentation.value }; default: return `Unsupported Markup content received. Kind is: ${format}`; } } function asCompletionItemTag(tag) { switch (tag) { case code.CompletionItemTag.Deprecated: return proto.CompletionItemTag.Deprecated; } return undefined; } function asCompletionItemTags(tags) { if (tags === undefined) { return tags; } const result = []; for (let tag of tags) { const converted = asCompletionItemTag(tag); if (converted !== undefined) { result.push(converted); } } return result; } function asCompletionItemKind(value, original) { if (original !== undefined) { return original; } return value + 1; } function asCompletionItem(item) { let result = { label: item.label }; let protocolItem = item instanceof protocolCompletionItem_1.default ? item : undefined; if (item.detail) { result.detail = item.detail; } // We only send items back we created. So this can't be something else than // a string right now. if (item.documentation) { if (!protocolItem || protocolItem.documentationFormat === '$string') { result.documentation = item.documentation; } else { result.documentation = asDocumentation(protocolItem.documentationFormat, item.documentation); } } if (item.filterText) { result.filterText = item.filterText; } fillPrimaryInsertText(result, item); if (Is.number(item.kind)) { result.kind = asCompletionItemKind(item.kind, protocolItem && protocolItem.originalItemKind); } if (item.sortText) { result.sortText = item.sortText; } if (item.additionalTextEdits) { result.additionalTextEdits = asTextEdits(item.additionalTextEdits); } if (item.commitCharacters) { result.commitCharacters = item.commitCharacters.slice(); } if (item.command) { result.command = asCommand(item.command); } if (item.preselect === true || item.preselect === false) { result.preselect = item.preselect; } const tags = asCompletionItemTags(item.tags); if (protocolItem) { if (protocolItem.data !== undefined) { result.data = protocolItem.data; } if (protocolItem.deprecated === true || protocolItem.deprecated === false) { if (protocolItem.deprecated === true && tags !== undefined && tags.length > 0) { const index = tags.indexOf(code.CompletionItemTag.Deprecated); if (index !== -1) { tags.splice(index, 1); } } result.deprecated = protocolItem.deprecated; } } if (tags !== undefined && tags.length > 0) { result.tags = tags; } return result; } function fillPrimaryInsertText(target, source) { let format = proto.InsertTextFormat.PlainText; let text = undefined; let range = undefined; if (source.textEdit) { text = source.textEdit.newText; range = asRange(source.textEdit.range); } else if (source.insertText instanceof code.SnippetString) { format = proto.InsertTextFormat.Snippet; text = source.insertText.value; } else { text = source.insertText; } if (source.range) { range = asRange(source.range); } target.insertTextFormat = format; if (source.fromEdit && text !== undefined && range !== undefined) { target.textEdit = { newText: text, range: range }; } else { target.insertText = text; } } function asTextEdit(edit) { return { range: asRange(edit.range), newText: edit.newText }; } function asTextEdits(edits) { if (edits === undefined || edits === null) { return edits; } return edits.map(asTextEdit); } function asSymbolKind(item) { if (item <= code.SymbolKind.TypeParameter) { // Symbol kind is one based in the protocol and zero based in code. return (item + 1); } return proto.SymbolKind.Property; } function asSymbolTag(item) { return item; } function asSymbolTags(items) { return items.map(asSymbolTag); } function asReferenceParams(textDocument, position, options) { return { textDocument: asTextDocumentIdentifier(textDocument), position: asWorkerPosition(position), context: { includeDeclaration: options.includeDeclaration } }; } function asCodeActionContext(context) { if (context === undefined || context === null) { return context; } let only; if (context.only && Is.string(context.only.value)) { only = [context.only.value]; } return proto.CodeActionContext.create(asDiagnostics(context.diagnostics), only); } function asCommand(item) { let result = proto.Command.create(item.title, item.command); if (item.arguments) { result.arguments = item.arguments; } return result; } function asCodeLens(item) { let result = proto.CodeLens.create(asRange(item.range)); if (item.command) { result.command = asCommand(item.command); } if (item instanceof protocolCodeLens_1.default) { if (item.data) { result.data = item.data; } } return result; } function asFormattingOptions(item) { return { tabSize: item.tabSize, insertSpaces: item.insertSpaces }; } function asDocumentSymbolParams(textDocument) { return { textDocument: asTextDocumentIdentifier(textDocument) }; } function asCodeLensParams(textDocument) { return { textDocument: asTextDocumentIdentifier(textDocument) }; } function asDocumentLink(item) { let result = proto.DocumentLink.create(asRange(item.range)); if (item.target) { result.target = asUri(item.target); } if (item.tooltip !== undefined) { result.tooltip = item.tooltip; } let protocolItem = item instanceof protocolDocumentLink_1.default ? item : undefined; if (protocolItem && protocolItem.data) { result.data = protocolItem.data; } return result; } function asDocumentLinkParams(textDocument) { return { textDocument: asTextDocumentIdentifier(textDocument) }; } return { asUri, asTextDocumentIdentifier, asVersionedTextDocumentIdentifier, asOpenTextDocumentParams, asChangeTextDocumentParams, asCloseTextDocumentParams, asSaveTextDocumentParams, asWillSaveTextDocumentParams, asTextDocumentPositionParams, asCompletionParams, asSignatureHelpParams, asWorkerPosition, asRange, asPosition, asPositions, asLocation, asDiagnosticSeverity, asDiagnosticTag, asDiagnostic, asDiagnostics, asCompletionItem, asTextEdit, asSymbolKind, asSymbolTag, asSymbolTags, asReferenceParams, asCodeActionContext, asCommand, asCodeLens, asFormattingOptions, asDocumentSymbolParams, asCodeLensParams, asDocumentLink, asDocumentLinkParams }; } exports.createConverter = createConverter; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/colorProvider.js": /*!******************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/colorProvider.js ***! \******************************************************************/ /*! flagged exports */ /*! export ColorProviderFeature [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_1 = __webpack_require__(/*! vscode */ "vscode"); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); const client_1 = __webpack_require__(/*! ./client */ "../node_modules/vscode-languageclient/lib/client.js"); function ensure(target, key) { if (target[key] === void 0) { target[key] = {}; } return target[key]; } class ColorProviderFeature extends client_1.TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.DocumentColorRequest.type); } fillClientCapabilities(capabilites) { ensure(ensure(capabilites, 'textDocument'), 'colorProvider').dynamicRegistration = true; } initialize(capabilities, documentSelector) { let [id, options] = this.getRegistration(documentSelector, capabilities.colorProvider); if (!id || !options) { return; } this.register(this.messages, { id: id, registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideColorPresentations: (color, context, token) => { const client = this._client; const provideColorPresentations = (color, context, token) => { const requestParams = { color, textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(context.document), range: client.code2ProtocolConverter.asRange(context.range) }; return client.sendRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, requestParams, token).then(this.asColorPresentations.bind(this), (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, error); return Promise.resolve(null); }); }; const middleware = client.clientOptions.middleware; return middleware.provideColorPresentations ? middleware.provideColorPresentations(color, context, token, provideColorPresentations) : provideColorPresentations(color, context, token); }, provideDocumentColors: (document, token) => { const client = this._client; const provideDocumentColors = (document, token) => { const requestParams = { textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document) }; return client.sendRequest(vscode_languageserver_protocol_1.DocumentColorRequest.type, requestParams, token).then(this.asColorInformations.bind(this), (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, error); return Promise.resolve(null); }); }; const middleware = client.clientOptions.middleware; return middleware.provideDocumentColors ? middleware.provideDocumentColors(document, token, provideDocumentColors) : provideDocumentColors(document, token); } }; return [vscode_1.languages.registerColorProvider(options.documentSelector, provider), provider]; } asColor(color) { return new vscode_1.Color(color.red, color.green, color.blue, color.alpha); } asColorInformations(colorInformation) { if (Array.isArray(colorInformation)) { return colorInformation.map(ci => { return new vscode_1.ColorInformation(this._client.protocol2CodeConverter.asRange(ci.range), this.asColor(ci.color)); }); } return []; } asColorPresentations(colorPresentations) { if (Array.isArray(colorPresentations)) { return colorPresentations.map(cp => { let presentation = new vscode_1.ColorPresentation(cp.label); presentation.additionalTextEdits = this._client.protocol2CodeConverter.asTextEdits(cp.additionalTextEdits); presentation.textEdit = this._client.protocol2CodeConverter.asTextEdit(cp.textEdit); return presentation; }); } return []; } } exports.ColorProviderFeature = ColorProviderFeature; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/configuration.js": /*!******************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/configuration.js ***! \******************************************************************/ /*! flagged exports */ /*! export ConfigurationFeature [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_1 = __webpack_require__(/*! vscode */ "vscode"); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); class ConfigurationFeature { constructor(_client) { this._client = _client; } fillClientCapabilities(capabilities) { capabilities.workspace = capabilities.workspace || {}; capabilities.workspace.configuration = true; } initialize() { let client = this._client; client.onRequest(vscode_languageserver_protocol_1.ConfigurationRequest.type, (params, token) => { let configuration = (params) => { let result = []; for (let item of params.items) { let resource = item.scopeUri !== void 0 && item.scopeUri !== null ? this._client.protocol2CodeConverter.asUri(item.scopeUri) : undefined; result.push(this.getConfiguration(resource, item.section !== null ? item.section : undefined)); } return result; }; let middleware = client.clientOptions.middleware.workspace; return middleware && middleware.configuration ? middleware.configuration(params, token, configuration) : configuration(params, token); }); } getConfiguration(resource, section) { let result = null; if (section) { let index = section.lastIndexOf('.'); if (index === -1) { result = vscode_1.workspace.getConfiguration(undefined, resource).get(section); } else { let config = vscode_1.workspace.getConfiguration(section.substr(0, index), resource); if (config) { result = config.get(section.substr(index + 1)); } } } else { let config = vscode_1.workspace.getConfiguration(undefined, resource); result = {}; for (let key of Object.keys(config)) { if (config.has(key)) { result[key] = config.get(key); } } } if (!result) { return null; } return result; } } exports.ConfigurationFeature = ConfigurationFeature; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/declaration.js": /*!****************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/declaration.js ***! \****************************************************************/ /*! flagged exports */ /*! export DeclarationFeature [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_1 = __webpack_require__(/*! vscode */ "vscode"); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); const client_1 = __webpack_require__(/*! ./client */ "../node_modules/vscode-languageclient/lib/client.js"); function ensure(target, key) { if (target[key] === void 0) { target[key] = {}; } return target[key]; } class DeclarationFeature extends client_1.TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.DeclarationRequest.type); } fillClientCapabilities(capabilites) { const declarationSupport = ensure(ensure(capabilites, 'textDocument'), 'declaration'); declarationSupport.dynamicRegistration = true; declarationSupport.linkSupport = true; } initialize(capabilities, documentSelector) { const [id, options] = this.getRegistration(documentSelector, capabilities.declarationProvider); if (!id || !options) { return; } this.register(this.messages, { id: id, registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideDeclaration: (document, position, token) => { const client = this._client; const provideDeclaration = (document, position, token) => { return client.sendRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then(client.protocol2CodeConverter.asDeclarationResult, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, error); return Promise.resolve(null); }); }; const middleware = client.clientOptions.middleware; return middleware.provideDeclaration ? middleware.provideDeclaration(document, position, token, provideDeclaration) : provideDeclaration(document, position, token); } }; return [vscode_1.languages.registerDeclarationProvider(options.documentSelector, provider), provider]; } } exports.DeclarationFeature = DeclarationFeature; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/foldingRange.js": /*!*****************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/foldingRange.js ***! \*****************************************************************/ /*! flagged exports */ /*! export FoldingRangeFeature [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_1 = __webpack_require__(/*! vscode */ "vscode"); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); const client_1 = __webpack_require__(/*! ./client */ "../node_modules/vscode-languageclient/lib/client.js"); function ensure(target, key) { if (target[key] === void 0) { target[key] = {}; } return target[key]; } class FoldingRangeFeature extends client_1.TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.FoldingRangeRequest.type); } fillClientCapabilities(capabilites) { let capability = ensure(ensure(capabilites, 'textDocument'), 'foldingRange'); capability.dynamicRegistration = true; capability.rangeLimit = 5000; capability.lineFoldingOnly = true; } initialize(capabilities, documentSelector) { let [id, options] = this.getRegistration(documentSelector, capabilities.foldingRangeProvider); if (!id || !options) { return; } this.register(this.messages, { id: id, registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideFoldingRanges: (document, context, token) => { const client = this._client; const provideFoldingRanges = (document, _, token) => { const requestParams = { textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document) }; return client.sendRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, requestParams, token).then(this.asFoldingRanges.bind(this), (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, error); return Promise.resolve(null); }); }; const middleware = client.clientOptions.middleware; return middleware.provideFoldingRanges ? middleware.provideFoldingRanges(document, context, token, provideFoldingRanges) : provideFoldingRanges(document, context, token); } }; return [vscode_1.languages.registerFoldingRangeProvider(options.documentSelector, provider), provider]; } asFoldingRangeKind(kind) { if (kind) { switch (kind) { case vscode_languageserver_protocol_1.FoldingRangeKind.Comment: return vscode_1.FoldingRangeKind.Comment; case vscode_languageserver_protocol_1.FoldingRangeKind.Imports: return vscode_1.FoldingRangeKind.Imports; case vscode_languageserver_protocol_1.FoldingRangeKind.Region: return vscode_1.FoldingRangeKind.Region; } } return void 0; } asFoldingRanges(foldingRanges) { if (Array.isArray(foldingRanges)) { return foldingRanges.map(r => { return new vscode_1.FoldingRange(r.startLine, r.endLine, this.asFoldingRangeKind(r.kind)); }); } return []; } } exports.FoldingRangeFeature = FoldingRangeFeature; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/implementation.js": /*!*******************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/implementation.js ***! \*******************************************************************/ /*! flagged exports */ /*! export ImplementationFeature [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_1 = __webpack_require__(/*! vscode */ "vscode"); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); const client_1 = __webpack_require__(/*! ./client */ "../node_modules/vscode-languageclient/lib/client.js"); function ensure(target, key) { if (target[key] === void 0) { target[key] = {}; } return target[key]; } class ImplementationFeature extends client_1.TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.ImplementationRequest.type); } fillClientCapabilities(capabilites) { let implementationSupport = ensure(ensure(capabilites, 'textDocument'), 'implementation'); implementationSupport.dynamicRegistration = true; implementationSupport.linkSupport = true; } initialize(capabilities, documentSelector) { let [id, options] = this.getRegistration(documentSelector, capabilities.implementationProvider); if (!id || !options) { return; } this.register(this.messages, { id: id, registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideImplementation: (document, position, token) => { const client = this._client; const provideImplementation = (document, position, token) => { return client.sendRequest(vscode_languageserver_protocol_1.ImplementationRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then(client.protocol2CodeConverter.asDefinitionResult, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.ImplementationRequest.type, error); return Promise.resolve(null); }); }; const middleware = client.clientOptions.middleware; return middleware.provideImplementation ? middleware.provideImplementation(document, position, token, provideImplementation) : provideImplementation(document, position, token); } }; return [vscode_1.languages.registerImplementationProvider(options.documentSelector, provider), provider]; } } exports.ImplementationFeature = ImplementationFeature; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/main.js": /*!*********************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/main.js ***! \*********************************************************/ /*! unknown exports (runtime-defined) */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /*! CommonJS bailout: exports.hasOwnProperty(...) prevents optimization as exports is passed as call context at 7:26-48 */ /*! CommonJS bailout: exports is used directly at 7:53-60 */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ function __export(m) { for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; } Object.defineProperty(exports, "__esModule", ({ value: true })); const cp = __webpack_require__(/*! child_process */ "child_process"); const fs = __webpack_require__(/*! fs */ "fs"); const SemVer = __webpack_require__(/*! semver */ "../node_modules/vscode-languageclient/node_modules/semver/semver.js"); const client_1 = __webpack_require__(/*! ./client */ "../node_modules/vscode-languageclient/lib/client.js"); const vscode_1 = __webpack_require__(/*! vscode */ "vscode"); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); const colorProvider_1 = __webpack_require__(/*! ./colorProvider */ "../node_modules/vscode-languageclient/lib/colorProvider.js"); const configuration_1 = __webpack_require__(/*! ./configuration */ "../node_modules/vscode-languageclient/lib/configuration.js"); const implementation_1 = __webpack_require__(/*! ./implementation */ "../node_modules/vscode-languageclient/lib/implementation.js"); const typeDefinition_1 = __webpack_require__(/*! ./typeDefinition */ "../node_modules/vscode-languageclient/lib/typeDefinition.js"); const workspaceFolders_1 = __webpack_require__(/*! ./workspaceFolders */ "../node_modules/vscode-languageclient/lib/workspaceFolders.js"); const foldingRange_1 = __webpack_require__(/*! ./foldingRange */ "../node_modules/vscode-languageclient/lib/foldingRange.js"); const declaration_1 = __webpack_require__(/*! ./declaration */ "../node_modules/vscode-languageclient/lib/declaration.js"); const selectionRange_1 = __webpack_require__(/*! ./selectionRange */ "../node_modules/vscode-languageclient/lib/selectionRange.js"); const progress_1 = __webpack_require__(/*! ./progress */ "../node_modules/vscode-languageclient/lib/progress.js"); const callHierarchy_proposed_1 = __webpack_require__(/*! ./callHierarchy.proposed */ "../node_modules/vscode-languageclient/lib/callHierarchy.proposed.js"); const semanticTokens_proposed_1 = __webpack_require__(/*! ./semanticTokens.proposed */ "../node_modules/vscode-languageclient/lib/semanticTokens.proposed.js"); const Is = __webpack_require__(/*! ./utils/is */ "../node_modules/vscode-languageclient/lib/utils/is.js"); const processes_1 = __webpack_require__(/*! ./utils/processes */ "../node_modules/vscode-languageclient/lib/utils/processes.js"); __export(__webpack_require__(/*! ./client */ "../node_modules/vscode-languageclient/lib/client.js")); const REQUIRED_VSCODE_VERSION = '^1.41.0'; // do not change format, updated by `updateVSCode` script var Executable; (function (Executable) { function is(value) { return Is.string(value.command); } Executable.is = is; })(Executable || (Executable = {})); var TransportKind; (function (TransportKind) { TransportKind[TransportKind["stdio"] = 0] = "stdio"; TransportKind[TransportKind["ipc"] = 1] = "ipc"; TransportKind[TransportKind["pipe"] = 2] = "pipe"; TransportKind[TransportKind["socket"] = 3] = "socket"; })(TransportKind = exports.TransportKind || (exports.TransportKind = {})); var Transport; (function (Transport) { function isSocket(value) { let candidate = value; return candidate && candidate.kind === TransportKind.socket && Is.number(candidate.port); } Transport.isSocket = isSocket; })(Transport || (Transport = {})); var NodeModule; (function (NodeModule) { function is(value) { return Is.string(value.module); } NodeModule.is = is; })(NodeModule || (NodeModule = {})); var StreamInfo; (function (StreamInfo) { function is(value) { let candidate = value; return candidate && candidate.writer !== void 0 && candidate.reader !== void 0; } StreamInfo.is = is; })(StreamInfo || (StreamInfo = {})); var ChildProcessInfo; (function (ChildProcessInfo) { function is(value) { let candidate = value; return candidate && candidate.process !== void 0 && typeof candidate.detached === 'boolean'; } ChildProcessInfo.is = is; })(ChildProcessInfo || (ChildProcessInfo = {})); class LanguageClient extends client_1.BaseLanguageClient { constructor(arg1, arg2, arg3, arg4, arg5) { let id; let name; let serverOptions; let clientOptions; let forceDebug; if (Is.string(arg2)) { id = arg1; name = arg2; serverOptions = arg3; clientOptions = arg4; forceDebug = !!arg5; } else { id = arg1.toLowerCase(); name = arg1; serverOptions = arg2; clientOptions = arg3; forceDebug = arg4; } if (forceDebug === void 0) { forceDebug = false; } super(id, name, clientOptions); this._serverOptions = serverOptions; this._forceDebug = forceDebug; try { this.checkVersion(); } catch (error) { if (Is.string(error.message)) { this.outputChannel.appendLine(error.message); } throw error; } } checkVersion() { let codeVersion = SemVer.parse(vscode_1.version); if (!codeVersion) { throw new Error(`No valid VS Code version detected. Version string is: ${vscode_1.version}`); } // Remove the insider pre-release since we stay API compatible. if (codeVersion.prerelease && codeVersion.prerelease.length > 0) { codeVersion.prerelease = []; } if (!SemVer.satisfies(codeVersion, REQUIRED_VSCODE_VERSION)) { throw new Error(`The language client requires VS Code version ${REQUIRED_VSCODE_VERSION} but received version ${vscode_1.version}`); } } stop() { return super.stop().then(() => { if (this._serverProcess) { let toCheck = this._serverProcess; this._serverProcess = undefined; if (this._isDetached === void 0 || !this._isDetached) { this.checkProcessDied(toCheck); } this._isDetached = undefined; } }); } checkProcessDied(childProcess) { if (!childProcess) { return; } setTimeout(() => { // Test if the process is still alive. Throws an exception if not try { process.kill(childProcess.pid, 0); processes_1.terminate(childProcess); } catch (error) { // All is fine. } }, 2000); } handleConnectionClosed() { this._serverProcess = undefined; super.handleConnectionClosed(); } createMessageTransports(encoding) { function getEnvironment(env, fork) { if (!env && !fork) { return undefined; } let result = Object.create(null); Object.keys(process.env).forEach(key => result[key] = process.env[key]); if (fork) { result['ELECTRON_RUN_AS_NODE'] = '1'; result['ELECTRON_NO_ASAR'] = '1'; } if (env) { Object.keys(env).forEach(key => result[key] = env[key]); } return result; } const debugStartWith = ['--debug=', '--debug-brk=', '--inspect=', '--inspect-brk=']; const debugEquals = ['--debug', '--debug-brk', '--inspect', '--inspect-brk']; function startedInDebugMode() { let args = process.execArgv; if (args) { return args.some((arg) => { return debugStartWith.some(value => arg.startsWith(value)) || debugEquals.some(value => arg === value); }); } return false; } function assertStdio(process) { if (process.stdin === null || process.stdout === null || process.stderr === null) { throw new Error('Process created without stdio streams'); } } let server = this._serverOptions; // We got a function. if (Is.func(server)) { return server().then((result) => { if (client_1.MessageTransports.is(result)) { this._isDetached = !!result.detached; return result; } else if (StreamInfo.is(result)) { this._isDetached = !!result.detached; return { reader: new vscode_languageserver_protocol_1.StreamMessageReader(result.reader), writer: new vscode_languageserver_protocol_1.StreamMessageWriter(result.writer) }; } else { let cp; if (ChildProcessInfo.is(result)) { cp = result.process; this._isDetached = result.detached; } else { cp = result; this._isDetached = false; } cp.stderr.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); return { reader: new vscode_languageserver_protocol_1.StreamMessageReader(cp.stdout), writer: new vscode_languageserver_protocol_1.StreamMessageWriter(cp.stdin) }; } }); } let json; let runDebug = server; if (runDebug.run || runDebug.debug) { if (this._forceDebug || startedInDebugMode()) { json = runDebug.debug; } else { json = runDebug.run; } } else { json = server; } return this._getServerWorkingDir(json.options).then(serverWorkingDir => { if (NodeModule.is(json) && json.module) { let node = json; let transport = node.transport || TransportKind.stdio; if (node.runtime) { let args = []; let options = node.options || Object.create(null); if (options.execArgv) { options.execArgv.forEach(element => args.push(element)); } args.push(node.module); if (node.args) { node.args.forEach(element => args.push(element)); } let execOptions = Object.create(null); execOptions.cwd = serverWorkingDir; execOptions.env = getEnvironment(options.env, false); let pipeName = undefined; if (transport === TransportKind.ipc) { // exec options not correctly typed in lib execOptions.stdio = [null, null, null, 'ipc']; args.push('--node-ipc'); } else if (transport === TransportKind.stdio) { args.push('--stdio'); } else if (transport === TransportKind.pipe) { pipeName = vscode_languageserver_protocol_1.generateRandomPipeName(); args.push(`--pipe=${pipeName}`); } else if (Transport.isSocket(transport)) { args.push(`--socket=${transport.port}`); } args.push(`--clientProcessId=${process.pid.toString()}`); if (transport === TransportKind.ipc || transport === TransportKind.stdio) { let serverProcess = cp.spawn(node.runtime, args, execOptions); if (!serverProcess || !serverProcess.pid) { return Promise.reject(`Launching server using runtime ${node.runtime} failed.`); } this._serverProcess = serverProcess; serverProcess.stderr.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); if (transport === TransportKind.ipc) { serverProcess.stdout.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); return Promise.resolve({ reader: new vscode_languageserver_protocol_1.IPCMessageReader(serverProcess), writer: new vscode_languageserver_protocol_1.IPCMessageWriter(serverProcess) }); } else { return Promise.resolve({ reader: new vscode_languageserver_protocol_1.StreamMessageReader(serverProcess.stdout), writer: new vscode_languageserver_protocol_1.StreamMessageWriter(serverProcess.stdin) }); } } else if (transport === TransportKind.pipe) { return vscode_languageserver_protocol_1.createClientPipeTransport(pipeName).then((transport) => { let process = cp.spawn(node.runtime, args, execOptions); if (!process || !process.pid) { return Promise.reject(`Launching server using runtime ${node.runtime} failed.`); } this._serverProcess = process; process.stderr.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); process.stdout.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); return transport.onConnected().then((protocol) => { return { reader: protocol[0], writer: protocol[1] }; }); }); } else if (Transport.isSocket(transport)) { return vscode_languageserver_protocol_1.createClientSocketTransport(transport.port).then((transport) => { let process = cp.spawn(node.runtime, args, execOptions); if (!process || !process.pid) { return Promise.reject(`Launching server using runtime ${node.runtime} failed.`); } this._serverProcess = process; process.stderr.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); process.stdout.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); return transport.onConnected().then((protocol) => { return { reader: protocol[0], writer: protocol[1] }; }); }); } } else { let pipeName = undefined; return new Promise((resolve, _reject) => { let args = node.args && node.args.slice() || []; if (transport === TransportKind.ipc) { args.push('--node-ipc'); } else if (transport === TransportKind.stdio) { args.push('--stdio'); } else if (transport === TransportKind.pipe) { pipeName = vscode_languageserver_protocol_1.generateRandomPipeName(); args.push(`--pipe=${pipeName}`); } else if (Transport.isSocket(transport)) { args.push(`--socket=${transport.port}`); } args.push(`--clientProcessId=${process.pid.toString()}`); let options = node.options || Object.create(null); options.env = getEnvironment(options.env, true); options.execArgv = options.execArgv || []; options.cwd = serverWorkingDir; options.silent = true; if (transport === TransportKind.ipc || transport === TransportKind.stdio) { let sp = cp.fork(node.module, args || [], options); assertStdio(sp); this._serverProcess = sp; sp.stderr.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); if (transport === TransportKind.ipc) { sp.stdout.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); resolve({ reader: new vscode_languageserver_protocol_1.IPCMessageReader(this._serverProcess), writer: new vscode_languageserver_protocol_1.IPCMessageWriter(this._serverProcess) }); } else { resolve({ reader: new vscode_languageserver_protocol_1.StreamMessageReader(sp.stdout), writer: new vscode_languageserver_protocol_1.StreamMessageWriter(sp.stdin) }); } } else if (transport === TransportKind.pipe) { vscode_languageserver_protocol_1.createClientPipeTransport(pipeName).then((transport) => { let sp = cp.fork(node.module, args || [], options); assertStdio(sp); this._serverProcess = sp; sp.stderr.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); sp.stdout.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); transport.onConnected().then((protocol) => { resolve({ reader: protocol[0], writer: protocol[1] }); }); }); } else if (Transport.isSocket(transport)) { vscode_languageserver_protocol_1.createClientSocketTransport(transport.port).then((transport) => { let sp = cp.fork(node.module, args || [], options); assertStdio(sp); this._serverProcess = sp; sp.stderr.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); sp.stdout.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); transport.onConnected().then((protocol) => { resolve({ reader: protocol[0], writer: protocol[1] }); }); }); } }); } } else if (Executable.is(json) && json.command) { let command = json; let args = command.args || []; let options = Object.assign({}, command.options); options.cwd = options.cwd || serverWorkingDir; let serverProcess = cp.spawn(command.command, args, options); if (!serverProcess || !serverProcess.pid) { return Promise.reject(`Launching server using command ${command.command} failed.`); } serverProcess.stderr.on('data', data => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding))); this._serverProcess = serverProcess; this._isDetached = !!options.detached; return Promise.resolve({ reader: new vscode_languageserver_protocol_1.StreamMessageReader(serverProcess.stdout), writer: new vscode_languageserver_protocol_1.StreamMessageWriter(serverProcess.stdin) }); } return Promise.reject(new Error(`Unsupported server configuration ` + JSON.stringify(server, null, 4))); }); } registerProposedFeatures() { this.registerFeatures(ProposedFeatures.createAll(this)); } registerBuiltinFeatures() { super.registerBuiltinFeatures(); this.registerFeature(new configuration_1.ConfigurationFeature(this)); this.registerFeature(new typeDefinition_1.TypeDefinitionFeature(this)); this.registerFeature(new implementation_1.ImplementationFeature(this)); this.registerFeature(new colorProvider_1.ColorProviderFeature(this)); this.registerFeature(new workspaceFolders_1.WorkspaceFoldersFeature(this)); this.registerFeature(new foldingRange_1.FoldingRangeFeature(this)); this.registerFeature(new declaration_1.DeclarationFeature(this)); this.registerFeature(new selectionRange_1.SelectionRangeFeature(this)); this.registerFeature(new progress_1.ProgressFeature(this)); } _mainGetRootPath() { let folders = vscode_1.workspace.workspaceFolders; if (!folders || folders.length === 0) { return undefined; } let folder = folders[0]; if (folder.uri.scheme === 'file') { return folder.uri.fsPath; } return undefined; } _getServerWorkingDir(options) { let cwd = options && options.cwd; if (!cwd) { cwd = this.clientOptions.workspaceFolder ? this.clientOptions.workspaceFolder.uri.fsPath : this._mainGetRootPath(); } if (cwd) { // make sure the folder exists otherwise creating the process will fail return new Promise(s => { fs.lstat(cwd, (err, stats) => { s(!err && stats.isDirectory() ? cwd : undefined); }); }); } return Promise.resolve(undefined); } } exports.LanguageClient = LanguageClient; class SettingMonitor { constructor(_client, _setting) { this._client = _client; this._setting = _setting; this._listeners = []; } start() { vscode_1.workspace.onDidChangeConfiguration(this.onDidChangeConfiguration, this, this._listeners); this.onDidChangeConfiguration(); return new vscode_1.Disposable(() => { if (this._client.needsStop()) { this._client.stop(); } }); } onDidChangeConfiguration() { let index = this._setting.indexOf('.'); let primary = index >= 0 ? this._setting.substr(0, index) : this._setting; let rest = index >= 0 ? this._setting.substr(index + 1) : undefined; let enabled = rest ? vscode_1.workspace.getConfiguration(primary).get(rest, false) : vscode_1.workspace.getConfiguration(primary); if (enabled && this._client.needsStart()) { this._client.start(); } else if (!enabled && this._client.needsStop()) { this._client.stop(); } } } exports.SettingMonitor = SettingMonitor; // Exporting proposed protocol. var ProposedFeatures; (function (ProposedFeatures) { function createAll(client) { let result = [ new callHierarchy_proposed_1.CallHierarchyFeature(client), new semanticTokens_proposed_1.SemanticTokensFeature(client) ]; return result; } ProposedFeatures.createAll = createAll; })(ProposedFeatures = exports.ProposedFeatures || (exports.ProposedFeatures = {})); /***/ }), /***/ "../node_modules/vscode-languageclient/lib/progress.js": /*!*************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/progress.js ***! \*************************************************************/ /*! flagged exports */ /*! export ProgressFeature [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); const progressPart_1 = __webpack_require__(/*! ./progressPart */ "../node_modules/vscode-languageclient/lib/progressPart.js"); function ensure(target, key) { if (target[key] === void 0) { target[key] = Object.create(null); } return target[key]; } class ProgressFeature { constructor(_client) { this._client = _client; } fillClientCapabilities(capabilities) { ensure(capabilities, 'window').workDoneProgress = true; } initialize() { let client = this._client; let createHandler = (params) => { new progressPart_1.ProgressPart(this._client, params.token); }; client.onRequest(vscode_languageserver_protocol_1.WorkDoneProgressCreateRequest.type, createHandler); } } exports.ProgressFeature = ProgressFeature; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/progressPart.js": /*!*****************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/progressPart.js ***! \*****************************************************************/ /*! flagged exports */ /*! export ProgressPart [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_1 = __webpack_require__(/*! vscode */ "vscode"); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); const Is = __webpack_require__(/*! ./utils/is */ "../node_modules/vscode-languageclient/lib/utils/is.js"); class ProgressPart { constructor(_client, _token) { this._client = _client; this._token = _token; this._reported = 0; this._disposable = this._client.onProgress(vscode_languageserver_protocol_1.WorkDoneProgress.type, this._token, (value) => { switch (value.kind) { case 'begin': this.begin(value); break; case 'report': this.report(value); break; case 'end': this.done(); break; } }); } begin(params) { let location = params.cancellable ? vscode_1.ProgressLocation.Notification : vscode_1.ProgressLocation.Window; vscode_1.window.withProgress({ location, cancellable: params.cancellable, title: params.title }, async (progress, cancellationToken) => { this._progress = progress; this._infinite = params.percentage === undefined; this._cancellationToken = cancellationToken; this._cancellationToken.onCancellationRequested(() => { this._client.sendNotification(vscode_languageserver_protocol_1.WorkDoneProgressCancelNotification.type, { token: this._token }); }); this.report(params); return new Promise((resolve, reject) => { this._resolve = resolve; this._reject = reject; }); }); } report(params) { if (this._infinite && Is.string(params.message)) { this._progress.report({ message: params.message }); } else if (Is.number(params.percentage)) { let percentage = Math.max(0, Math.min(params.percentage, 100)); let delta = Math.max(0, percentage - this._reported); this._progress.report({ message: params.message, increment: delta }); this._reported += delta; } } cancel() { if (this._disposable) { this._disposable.dispose(); this._disposable = undefined; } if (this._reject) { this._reject(); this._resolve = undefined; this._reject = undefined; } } done() { if (this._disposable) { this._disposable.dispose(); this._disposable = undefined; } if (this._resolve) { this._resolve(); this._resolve = undefined; this._reject = undefined; } } } exports.ProgressPart = ProgressPart; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/protocolCodeLens.js": /*!*********************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/protocolCodeLens.js ***! \*********************************************************************/ /*! flagged exports */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export default [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const code = __webpack_require__(/*! vscode */ "vscode"); class ProtocolCodeLens extends code.CodeLens { constructor(range) { super(range); } } exports.default = ProtocolCodeLens; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/protocolCompletionItem.js": /*!***************************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/protocolCompletionItem.js ***! \***************************************************************************/ /*! flagged exports */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export default [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const code = __webpack_require__(/*! vscode */ "vscode"); class ProtocolCompletionItem extends code.CompletionItem { constructor(label) { super(label); } } exports.default = ProtocolCompletionItem; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/protocolConverter.js": /*!**********************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/protocolConverter.js ***! \**********************************************************************/ /*! flagged exports */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export createConverter [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const code = __webpack_require__(/*! vscode */ "vscode"); const ls = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); const Is = __webpack_require__(/*! ./utils/is */ "../node_modules/vscode-languageclient/lib/utils/is.js"); const protocolCompletionItem_1 = __webpack_require__(/*! ./protocolCompletionItem */ "../node_modules/vscode-languageclient/lib/protocolCompletionItem.js"); const protocolCodeLens_1 = __webpack_require__(/*! ./protocolCodeLens */ "../node_modules/vscode-languageclient/lib/protocolCodeLens.js"); const protocolDocumentLink_1 = __webpack_require__(/*! ./protocolDocumentLink */ "../node_modules/vscode-languageclient/lib/protocolDocumentLink.js"); var CodeBlock; (function (CodeBlock) { function is(value) { let candidate = value; return candidate && Is.string(candidate.language) && Is.string(candidate.value); } CodeBlock.is = is; })(CodeBlock || (CodeBlock = {})); function createConverter(uriConverter) { const nullConverter = (value) => code.Uri.parse(value); const _uriConverter = uriConverter || nullConverter; function asUri(value) { return _uriConverter(value); } function asDiagnostics(diagnostics) { return diagnostics.map(asDiagnostic); } function asDiagnostic(diagnostic) { let result = new code.Diagnostic(asRange(diagnostic.range), diagnostic.message, asDiagnosticSeverity(diagnostic.severity)); if (Is.number(diagnostic.code) || Is.string(diagnostic.code)) { result.code = diagnostic.code; } if (diagnostic.source) { result.source = diagnostic.source; } if (diagnostic.relatedInformation) { result.relatedInformation = asRelatedInformation(diagnostic.relatedInformation); } if (Array.isArray(diagnostic.tags)) { result.tags = asDiagnosticTags(diagnostic.tags); } return result; } function asRelatedInformation(relatedInformation) { return relatedInformation.map(asDiagnosticRelatedInformation); } function asDiagnosticRelatedInformation(information) { return new code.DiagnosticRelatedInformation(asLocation(information.location), information.message); } function asDiagnosticTags(tags) { if (!tags) { return undefined; } let result = []; for (let tag of tags) { let converted = asDiagnosticTag(tag); if (converted !== undefined) { result.push(converted); } } return result.length > 0 ? result : undefined; } function asDiagnosticTag(tag) { switch (tag) { case ls.DiagnosticTag.Unnecessary: return code.DiagnosticTag.Unnecessary; case ls.DiagnosticTag.Deprecated: return code.DiagnosticTag.Deprecated; default: return undefined; } } function asPosition(value) { if (!value) { return undefined; } return new code.Position(value.line, value.character); } function asRange(value) { if (!value) { return undefined; } return new code.Range(asPosition(value.start), asPosition(value.end)); } function asRanges(value) { return value.map(value => asRange(value)); } function asDiagnosticSeverity(value) { if (value === undefined || value === null) { return code.DiagnosticSeverity.Error; } switch (value) { case ls.DiagnosticSeverity.Error: return code.DiagnosticSeverity.Error; case ls.DiagnosticSeverity.Warning: return code.DiagnosticSeverity.Warning; case ls.DiagnosticSeverity.Information: return code.DiagnosticSeverity.Information; case ls.DiagnosticSeverity.Hint: return code.DiagnosticSeverity.Hint; } return code.DiagnosticSeverity.Error; } function asHoverContent(value) { if (Is.string(value)) { return new code.MarkdownString(value); } else if (CodeBlock.is(value)) { let result = new code.MarkdownString(); return result.appendCodeblock(value.value, value.language); } else if (Array.isArray(value)) { let result = []; for (let element of value) { let item = new code.MarkdownString(); if (CodeBlock.is(element)) { item.appendCodeblock(element.value, element.language); } else { item.appendMarkdown(element); } result.push(item); } return result; } else { let result; switch (value.kind) { case ls.MarkupKind.Markdown: return new code.MarkdownString(value.value); case ls.MarkupKind.PlainText: result = new code.MarkdownString(); result.appendText(value.value); return result; default: result = new code.MarkdownString(); result.appendText(`Unsupported Markup content received. Kind is: ${value.kind}`); return result; } } } function asDocumentation(value) { if (Is.string(value)) { return value; } else { switch (value.kind) { case ls.MarkupKind.Markdown: return new code.MarkdownString(value.value); case ls.MarkupKind.PlainText: return value.value; default: return `Unsupported Markup content received. Kind is: ${value.kind}`; } } } function asHover(hover) { if (!hover) { return undefined; } return new code.Hover(asHoverContent(hover.contents), asRange(hover.range)); } function asCompletionResult(result) { if (!result) { return undefined; } if (Array.isArray(result)) { let items = result; return items.map(asCompletionItem); } let list = result; return new code.CompletionList(list.items.map(asCompletionItem), list.isIncomplete); } function asCompletionItemKind(value) { // Protocol item kind is 1 based, codes item kind is zero based. if (ls.CompletionItemKind.Text <= value && value <= ls.CompletionItemKind.TypeParameter) { return [value - 1, undefined]; } return [code.CompletionItemKind.Text, value]; } function asCompletionItemTag(tag) { switch (tag) { case ls.CompletionItemTag.Deprecated: return code.CompletionItemTag.Deprecated; } return undefined; } function asCompletionItemTags(tags) { if (tags === undefined || tags === null) { return []; } const result = []; for (let tag of tags) { const converted = asCompletionItemTag(tag); if (converted !== undefined) { result.push(converted); } } return result; } function asCompletionItem(item) { let tags = asCompletionItemTags(item.tags); let result = new protocolCompletionItem_1.default(item.label); if (item.detail) { result.detail = item.detail; } if (item.documentation) { result.documentation = asDocumentation(item.documentation); result.documentationFormat = Is.string(item.documentation) ? '$string' : item.documentation.kind; } if (item.filterText) { result.filterText = item.filterText; } let insertText = asCompletionInsertText(item); if (insertText) { result.insertText = insertText.text; result.range = insertText.range; result.fromEdit = insertText.fromEdit; } if (Is.number(item.kind)) { let [itemKind, original] = asCompletionItemKind(item.kind); result.kind = itemKind; if (original) { result.originalItemKind = original; } } if (item.sortText) { result.sortText = item.sortText; } if (item.additionalTextEdits) { result.additionalTextEdits = asTextEdits(item.additionalTextEdits); } if (Is.stringArray(item.commitCharacters)) { result.commitCharacters = item.commitCharacters.slice(); } if (item.command) { result.command = asCommand(item.command); } if (item.deprecated === true || item.deprecated === false) { result.deprecated = item.deprecated; if (item.deprecated === true) { tags.push(code.CompletionItemTag.Deprecated); } } if (item.preselect === true || item.preselect === false) { result.preselect = item.preselect; } if (item.data !== undefined) { result.data = item.data; } if (tags.length > 0) { result.tags = tags; } return result; } function asCompletionInsertText(item) { if (item.textEdit) { if (item.insertTextFormat === ls.InsertTextFormat.Snippet) { return { text: new code.SnippetString(item.textEdit.newText), range: asRange(item.textEdit.range), fromEdit: true }; } else { return { text: item.textEdit.newText, range: asRange(item.textEdit.range), fromEdit: true }; } } else if (item.insertText) { if (item.insertTextFormat === ls.InsertTextFormat.Snippet) { return { text: new code.SnippetString(item.insertText), fromEdit: false }; } else { return { text: item.insertText, fromEdit: false }; } } else { return undefined; } } function asTextEdit(edit) { if (!edit) { return undefined; } return new code.TextEdit(asRange(edit.range), edit.newText); } function asTextEdits(items) { if (!items) { return undefined; } return items.map(asTextEdit); } function asSignatureHelp(item) { if (!item) { return undefined; } let result = new code.SignatureHelp(); if (Is.number(item.activeSignature)) { result.activeSignature = item.activeSignature; } else { // activeSignature was optional in the past result.activeSignature = 0; } if (Is.number(item.activeParameter)) { result.activeParameter = item.activeParameter; } else { // activeParameter was optional in the past result.activeParameter = 0; } if (item.signatures) { result.signatures = asSignatureInformations(item.signatures); } return result; } function asSignatureInformations(items) { return items.map(asSignatureInformation); } function asSignatureInformation(item) { let result = new code.SignatureInformation(item.label); if (item.documentation) { result.documentation = asDocumentation(item.documentation); } if (item.parameters) { result.parameters = asParameterInformations(item.parameters); } return result; } function asParameterInformations(item) { return item.map(asParameterInformation); } function asParameterInformation(item) { let result = new code.ParameterInformation(item.label); if (item.documentation) { result.documentation = asDocumentation(item.documentation); } return result; } function asLocation(item) { if (!item) { return undefined; } return new code.Location(_uriConverter(item.uri), asRange(item.range)); } function asDeclarationResult(item) { if (!item) { return undefined; } return asLocationResult(item); } function asDefinitionResult(item) { if (!item) { return undefined; } return asLocationResult(item); } function asLocationLink(item) { if (!item) { return undefined; } let result = { targetUri: _uriConverter(item.targetUri), targetRange: asRange(item.targetSelectionRange), originSelectionRange: asRange(item.originSelectionRange), targetSelectionRange: asRange(item.targetSelectionRange) }; if (!result.targetSelectionRange) { throw new Error(`targetSelectionRange must not be undefined or null`); } return result; } function asLocationResult(item) { if (!item) { return undefined; } if (Is.array(item)) { if (item.length === 0) { return []; } else if (ls.LocationLink.is(item[0])) { let links = item; return links.map((link) => asLocationLink(link)); } else { let locations = item; return locations.map((location) => asLocation(location)); } } else if (ls.LocationLink.is(item)) { return [asLocationLink(item)]; } else { return asLocation(item); } } function asReferences(values) { if (!values) { return undefined; } return values.map(location => asLocation(location)); } function asDocumentHighlights(values) { if (!values) { return undefined; } return values.map(asDocumentHighlight); } function asDocumentHighlight(item) { let result = new code.DocumentHighlight(asRange(item.range)); if (Is.number(item.kind)) { result.kind = asDocumentHighlightKind(item.kind); } return result; } function asDocumentHighlightKind(item) { switch (item) { case ls.DocumentHighlightKind.Text: return code.DocumentHighlightKind.Text; case ls.DocumentHighlightKind.Read: return code.DocumentHighlightKind.Read; case ls.DocumentHighlightKind.Write: return code.DocumentHighlightKind.Write; } return code.DocumentHighlightKind.Text; } function asSymbolInformations(values, uri) { if (!values) { return undefined; } return values.map(information => asSymbolInformation(information, uri)); } function asSymbolKind(item) { if (item <= ls.SymbolKind.TypeParameter) { // Symbol kind is one based in the protocol and zero based in code. return item - 1; } return code.SymbolKind.Property; } function asSymbolTag(value) { return value; } function asSymbolTags(items) { if (items === undefined || items === null) { return undefined; } return items.map(asSymbolTag); } function asSymbolInformation(item, uri) { // Symbol kind is one based in the protocol and zero based in code. let result = new code.SymbolInformation(item.name, asSymbolKind(item.kind), asRange(item.location.range), item.location.uri ? _uriConverter(item.location.uri) : uri); if (item.containerName) { result.containerName = item.containerName; } return result; } function asDocumentSymbols(values) { if (values === undefined || values === null) { return undefined; } return values.map(asDocumentSymbol); } function asDocumentSymbol(value) { let result = new code.DocumentSymbol(value.name, value.detail || '', asSymbolKind(value.kind), asRange(value.range), asRange(value.selectionRange)); if (value.children !== undefined && value.children.length > 0) { let children = []; for (let child of value.children) { children.push(asDocumentSymbol(child)); } result.children = children; } return result; } function asCommand(item) { let result = { title: item.title, command: item.command }; if (item.arguments) { result.arguments = item.arguments; } return result; } function asCommands(items) { if (!items) { return undefined; } return items.map(asCommand); } const kindMapping = new Map(); kindMapping.set(ls.CodeActionKind.Empty, code.CodeActionKind.Empty); kindMapping.set(ls.CodeActionKind.QuickFix, code.CodeActionKind.QuickFix); kindMapping.set(ls.CodeActionKind.Refactor, code.CodeActionKind.Refactor); kindMapping.set(ls.CodeActionKind.RefactorExtract, code.CodeActionKind.RefactorExtract); kindMapping.set(ls.CodeActionKind.RefactorInline, code.CodeActionKind.RefactorInline); kindMapping.set(ls.CodeActionKind.RefactorRewrite, code.CodeActionKind.RefactorRewrite); kindMapping.set(ls.CodeActionKind.Source, code.CodeActionKind.Source); kindMapping.set(ls.CodeActionKind.SourceOrganizeImports, code.CodeActionKind.SourceOrganizeImports); function asCodeActionKind(item) { if (item === undefined || item === null) { return undefined; } let result = kindMapping.get(item); if (result) { return result; } let parts = item.split('.'); result = code.CodeActionKind.Empty; for (let part of parts) { result = result.append(part); } return result; } function asCodeActionKinds(items) { if (items === undefined || items === null) { return undefined; } return items.map(kind => asCodeActionKind(kind)); } function asCodeAction(item) { if (item === undefined || item === null) { return undefined; } let result = new code.CodeAction(item.title); if (item.kind !== undefined) { result.kind = asCodeActionKind(item.kind); } if (item.diagnostics) { result.diagnostics = asDiagnostics(item.diagnostics); } if (item.edit) { result.edit = asWorkspaceEdit(item.edit); } if (item.command) { result.command = asCommand(item.command); } if (item.isPreferred !== undefined) { result.isPreferred = item.isPreferred; } return result; } function asCodeLens(item) { if (!item) { return undefined; } let result = new protocolCodeLens_1.default(asRange(item.range)); if (item.command) { result.command = asCommand(item.command); } if (item.data !== undefined && item.data !== null) { result.data = item.data; } return result; } function asCodeLenses(items) { if (!items) { return undefined; } return items.map((codeLens) => asCodeLens(codeLens)); } function asWorkspaceEdit(item) { if (!item) { return undefined; } let result = new code.WorkspaceEdit(); if (item.documentChanges) { item.documentChanges.forEach(change => { if (ls.CreateFile.is(change)) { result.createFile(_uriConverter(change.uri), change.options); } else if (ls.RenameFile.is(change)) { result.renameFile(_uriConverter(change.oldUri), _uriConverter(change.newUri), change.options); } else if (ls.DeleteFile.is(change)) { result.deleteFile(_uriConverter(change.uri), change.options); } else if (ls.TextDocumentEdit.is(change)) { result.set(_uriConverter(change.textDocument.uri), asTextEdits(change.edits)); } else { console.error(`Unknown workspace edit change received:\n${JSON.stringify(change, undefined, 4)}`); } }); } else if (item.changes) { Object.keys(item.changes).forEach(key => { result.set(_uriConverter(key), asTextEdits(item.changes[key])); }); } return result; } function asDocumentLink(item) { let range = asRange(item.range); let target = item.target ? asUri(item.target) : undefined; // target must be optional in DocumentLink let link = new protocolDocumentLink_1.default(range, target); if (item.tooltip !== undefined) { link.tooltip = item.tooltip; } if (item.data !== undefined && item.data !== null) { link.data = item.data; } return link; } function asDocumentLinks(items) { if (!items) { return undefined; } return items.map(asDocumentLink); } function asColor(color) { return new code.Color(color.red, color.green, color.blue, color.alpha); } function asColorInformation(ci) { return new code.ColorInformation(asRange(ci.range), asColor(ci.color)); } function asColorInformations(colorInformation) { if (Array.isArray(colorInformation)) { return colorInformation.map(asColorInformation); } return undefined; } function asColorPresentation(cp) { let presentation = new code.ColorPresentation(cp.label); presentation.additionalTextEdits = asTextEdits(cp.additionalTextEdits); if (cp.textEdit) { presentation.textEdit = asTextEdit(cp.textEdit); } return presentation; } function asColorPresentations(colorPresentations) { if (Array.isArray(colorPresentations)) { return colorPresentations.map(asColorPresentation); } return undefined; } function asFoldingRangeKind(kind) { if (kind) { switch (kind) { case ls.FoldingRangeKind.Comment: return code.FoldingRangeKind.Comment; case ls.FoldingRangeKind.Imports: return code.FoldingRangeKind.Imports; case ls.FoldingRangeKind.Region: return code.FoldingRangeKind.Region; } } return undefined; } function asFoldingRange(r) { return new code.FoldingRange(r.startLine, r.endLine, asFoldingRangeKind(r.kind)); } function asFoldingRanges(foldingRanges) { if (Array.isArray(foldingRanges)) { return foldingRanges.map(asFoldingRange); } return undefined; } function asSelectionRange(selectionRange) { return new code.SelectionRange(asRange(selectionRange.range), selectionRange.parent ? asSelectionRange(selectionRange.parent) : undefined); } function asSelectionRanges(selectionRanges) { if (!Array.isArray(selectionRanges)) { return []; } let result = []; for (let range of selectionRanges) { result.push(asSelectionRange(range)); } return result; } return { asUri, asDiagnostics, asDiagnostic, asRange, asRanges, asPosition, asDiagnosticSeverity, asDiagnosticTag, asHover, asCompletionResult, asCompletionItem, asTextEdit, asTextEdits, asSignatureHelp, asSignatureInformations, asSignatureInformation, asParameterInformations, asParameterInformation, asDeclarationResult, asDefinitionResult, asLocation, asReferences, asDocumentHighlights, asDocumentHighlight, asDocumentHighlightKind, asSymbolKind, asSymbolTag, asSymbolTags, asSymbolInformations, asSymbolInformation, asDocumentSymbols, asDocumentSymbol, asCommand, asCommands, asCodeAction, asCodeActionKind, asCodeActionKinds, asCodeLens, asCodeLenses, asWorkspaceEdit, asDocumentLink, asDocumentLinks, asFoldingRangeKind, asFoldingRange, asFoldingRanges, asColor, asColorInformation, asColorInformations, asColorPresentation, asColorPresentations, asSelectionRange, asSelectionRanges }; } exports.createConverter = createConverter; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/protocolDocumentLink.js": /*!*************************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/protocolDocumentLink.js ***! \*************************************************************************/ /*! flagged exports */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export default [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const code = __webpack_require__(/*! vscode */ "vscode"); class ProtocolDocumentLink extends code.DocumentLink { constructor(range, target) { super(range, target); } } exports.default = ProtocolDocumentLink; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/selectionRange.js": /*!*******************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/selectionRange.js ***! \*******************************************************************/ /*! flagged exports */ /*! export SelectionRangeFeature [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_1 = __webpack_require__(/*! vscode */ "vscode"); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); const client_1 = __webpack_require__(/*! ./client */ "../node_modules/vscode-languageclient/lib/client.js"); function ensure(target, key) { if (target[key] === void 0) { target[key] = Object.create(null); } return target[key]; } class SelectionRangeFeature extends client_1.TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.SelectionRangeRequest.type); } fillClientCapabilities(capabilites) { let capability = ensure(ensure(capabilites, 'textDocument'), 'selectionRange'); capability.dynamicRegistration = true; } initialize(capabilities, documentSelector) { let [id, options] = this.getRegistration(documentSelector, capabilities.selectionRangeProvider); if (!id || !options) { return; } this.register(this.messages, { id: id, registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideSelectionRanges: (document, positions, token) => { const client = this._client; const provideSelectionRanges = (document, positions, token) => { const requestParams = { textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document), positions: client.code2ProtocolConverter.asPositions(positions) }; return client.sendRequest(vscode_languageserver_protocol_1.SelectionRangeRequest.type, requestParams, token).then((ranges) => client.protocol2CodeConverter.asSelectionRanges(ranges), (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.SelectionRangeRequest.type, error); return Promise.resolve(null); }); }; const middleware = client.clientOptions.middleware; return middleware.provideSelectionRanges ? middleware.provideSelectionRanges(document, positions, token, provideSelectionRanges) : provideSelectionRanges(document, positions, token); } }; return [vscode_1.languages.registerSelectionRangeProvider(options.documentSelector, provider), provider]; } } exports.SelectionRangeFeature = SelectionRangeFeature; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/semanticTokens.proposed.js": /*!****************************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/semanticTokens.proposed.js ***! \****************************************************************************/ /*! flagged exports */ /*! export SemanticTokensFeature [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode = __webpack_require__(/*! vscode */ "vscode"); const client_1 = __webpack_require__(/*! ./client */ "../node_modules/vscode-languageclient/lib/client.js"); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); function ensure(target, key) { if (target[key] === void 0) { target[key] = {}; } return target[key]; } var protocol2code; (function (protocol2code) { function asSemanticTokens(value) { if (value === undefined || value === null) { return undefined; } return new vscode.SemanticTokens(new Uint32Array(value.data), value.resultId); } protocol2code.asSemanticTokens = asSemanticTokens; function asSemanticTokensEdit(value) { return new vscode.SemanticTokensEdit(value.start, value.deleteCount, value.data !== undefined ? new Uint32Array(value.data) : undefined); } protocol2code.asSemanticTokensEdit = asSemanticTokensEdit; function asSemanticTokensEdits(value) { if (value === undefined || value === null) { return undefined; } return new vscode.SemanticTokensEdits(value.edits.map(asSemanticTokensEdit), value.resultId); } protocol2code.asSemanticTokensEdits = asSemanticTokensEdits; function asLegend(value) { return value; } protocol2code.asLegend = asLegend; })(protocol2code || (protocol2code = {})); class SemanticTokensFeature extends client_1.TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.Proposed.SemanticTokensRequest.type); } fillClientCapabilities(cap) { const capabilites = cap; let capability = ensure(ensure(capabilites, 'textDocument'), 'semanticTokens'); capability.dynamicRegistration = true; capability.tokenTypes = [ vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.comment, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.keyword, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.number, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.regexp, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.operator, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.namespace, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.type, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.struct, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.class, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.interface, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.enum, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.typeParameter, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.function, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.member, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.macro, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.variable, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.parameter, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.property, vscode_languageserver_protocol_1.Proposed.SemanticTokenTypes.label ]; capability.tokenModifiers = [ vscode_languageserver_protocol_1.Proposed.SemanticTokenModifiers.declaration, vscode_languageserver_protocol_1.Proposed.SemanticTokenModifiers.documentation, vscode_languageserver_protocol_1.Proposed.SemanticTokenModifiers.static, vscode_languageserver_protocol_1.Proposed.SemanticTokenModifiers.abstract, vscode_languageserver_protocol_1.Proposed.SemanticTokenModifiers.deprecated, vscode_languageserver_protocol_1.Proposed.SemanticTokenModifiers.async, vscode_languageserver_protocol_1.Proposed.SemanticTokenModifiers.readonly ]; } initialize(cap, documentSelector) { const capabilities = cap; let [id, options] = this.getRegistration(documentSelector, capabilities.semanticTokensProvider); if (!id || !options) { return; } this.register(this.messages, { id: id, registerOptions: options }); } registerLanguageProvider(options) { const hasEditProvider = options.documentProvider !== undefined && typeof options.documentProvider !== 'boolean' && options.documentProvider.edits === true; const documentProvider = { provideDocumentSemanticTokens: (document, token) => { const client = this._client; const middleware = client.clientOptions.middleware; const provideDocumentSemanticTokens = (document, token) => { const params = { textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document) }; return client.sendRequest(vscode_languageserver_protocol_1.Proposed.SemanticTokensRequest.type, params, token).then((result) => { return protocol2code.asSemanticTokens(result); }, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.Proposed.SemanticTokensRequest.type, error); return undefined; }); }; return middleware.provideDocumentSemanticTokens ? middleware.provideDocumentSemanticTokens(document, token, provideDocumentSemanticTokens) : provideDocumentSemanticTokens(document, token); }, provideDocumentSemanticTokensEdits: hasEditProvider ? (document, previousResultId, token) => { const client = this._client; const middleware = client.clientOptions.middleware; const provideDocumentSemanticTokensEdits = (document, previousResultId, token) => { const params = { textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document), previousResultId }; return client.sendRequest(vscode_languageserver_protocol_1.Proposed.SemanticTokensEditsRequest.type, params, token).then((result) => { if (vscode_languageserver_protocol_1.Proposed.SemanticTokens.is(result)) { return protocol2code.asSemanticTokens(result); } else { return protocol2code.asSemanticTokensEdits(result); } }, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.Proposed.SemanticTokensEditsRequest.type, error); return undefined; }); }; return middleware.provideDocumentSemanticTokensEdits ? middleware.provideDocumentSemanticTokensEdits(document, previousResultId, token, provideDocumentSemanticTokensEdits) : provideDocumentSemanticTokensEdits(document, previousResultId, token); } : undefined }; const hasRangeProvider = options.rangeProvider === true; const rangeProvider = hasRangeProvider ? { provideDocumentRangeSemanticTokens: (document, range, token) => { const client = this._client; const middleware = client.clientOptions.middleware; const provideDocumentRangeSemanticTokens = (document, range, token) => { const params = { textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document), range: client.code2ProtocolConverter.asRange(range) }; return client.sendRequest(vscode_languageserver_protocol_1.Proposed.SemanticTokensRangeRequest.type, params, token).then((result) => { return protocol2code.asSemanticTokens(result); }, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.Proposed.SemanticTokensRangeRequest.type, error); return undefined; }); }; return middleware.provideDocumentRangeSemanticTokens ? middleware.provideDocumentRangeSemanticTokens(document, range, token, provideDocumentRangeSemanticTokens) : provideDocumentRangeSemanticTokens(document, range, token); } } : undefined; const disposables = []; const legend = protocol2code.asLegend(options.legend); disposables.push(vscode.languages.registerDocumentSemanticTokensProvider(options.documentSelector, documentProvider, legend)); if (rangeProvider !== undefined) { disposables.push(vscode.languages.registerDocumentRangeSemanticTokensProvider(options.documentSelector, rangeProvider, legend)); } return [new vscode.Disposable(() => disposables.forEach(item => item.dispose())), { document: documentProvider, range: rangeProvider }]; } } exports.SemanticTokensFeature = SemanticTokensFeature; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/typeDefinition.js": /*!*******************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/typeDefinition.js ***! \*******************************************************************/ /*! flagged exports */ /*! export TypeDefinitionFeature [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_1 = __webpack_require__(/*! vscode */ "vscode"); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); const client_1 = __webpack_require__(/*! ./client */ "../node_modules/vscode-languageclient/lib/client.js"); function ensure(target, key) { if (target[key] === void 0) { target[key] = {}; } return target[key]; } class TypeDefinitionFeature extends client_1.TextDocumentFeature { constructor(client) { super(client, vscode_languageserver_protocol_1.TypeDefinitionRequest.type); } fillClientCapabilities(capabilites) { ensure(ensure(capabilites, 'textDocument'), 'typeDefinition').dynamicRegistration = true; let typeDefinitionSupport = ensure(ensure(capabilites, 'textDocument'), 'typeDefinition'); typeDefinitionSupport.dynamicRegistration = true; typeDefinitionSupport.linkSupport = true; } initialize(capabilities, documentSelector) { let [id, options] = this.getRegistration(documentSelector, capabilities.typeDefinitionProvider); if (!id || !options) { return; } this.register(this.messages, { id: id, registerOptions: options }); } registerLanguageProvider(options) { const provider = { provideTypeDefinition: (document, position, token) => { const client = this._client; const provideTypeDefinition = (document, position, token) => { return client.sendRequest(vscode_languageserver_protocol_1.TypeDefinitionRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then(client.protocol2CodeConverter.asDefinitionResult, (error) => { client.logFailedRequest(vscode_languageserver_protocol_1.TypeDefinitionRequest.type, error); return Promise.resolve(null); }); }; const middleware = client.clientOptions.middleware; return middleware.provideTypeDefinition ? middleware.provideTypeDefinition(document, position, token, provideTypeDefinition) : provideTypeDefinition(document, position, token); } }; return [vscode_1.languages.registerTypeDefinitionProvider(options.documentSelector, provider), provider]; } } exports.TypeDefinitionFeature = TypeDefinitionFeature; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/utils/async.js": /*!****************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/utils/async.js ***! \****************************************************************/ /*! flagged exports */ /*! export Delayer [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__ */ /***/ ((__unused_webpack_module, exports) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); class Delayer { constructor(defaultDelay) { this.defaultDelay = defaultDelay; this.timeout = undefined; this.completionPromise = undefined; this.onSuccess = undefined; this.task = undefined; } trigger(task, delay = this.defaultDelay) { this.task = task; if (delay >= 0) { this.cancelTimeout(); } if (!this.completionPromise) { this.completionPromise = new Promise((resolve) => { this.onSuccess = resolve; }).then(() => { this.completionPromise = undefined; this.onSuccess = undefined; var result = this.task(); this.task = undefined; return result; }); } if (delay >= 0 || this.timeout === void 0) { this.timeout = setTimeout(() => { this.timeout = undefined; this.onSuccess(undefined); }, delay >= 0 ? delay : this.defaultDelay); } return this.completionPromise; } forceDelivery() { if (!this.completionPromise) { return undefined; } this.cancelTimeout(); let result = this.task(); this.completionPromise = undefined; this.onSuccess = undefined; this.task = undefined; return result; } isTriggered() { return this.timeout !== void 0; } cancel() { this.cancelTimeout(); this.completionPromise = undefined; } cancelTimeout() { if (this.timeout !== void 0) { clearTimeout(this.timeout); this.timeout = undefined; } } } exports.Delayer = Delayer; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/utils/is.js": /*!*************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/utils/is.js ***! \*************************************************************/ /*! flagged exports */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export array [provided] [no usage info] [missing usage info prevents renaming] */ /*! export asPromise [provided] [no usage info] [missing usage info prevents renaming] */ /*! export boolean [provided] [no usage info] [missing usage info prevents renaming] */ /*! export error [provided] [no usage info] [missing usage info prevents renaming] */ /*! export func [provided] [no usage info] [missing usage info prevents renaming] */ /*! export number [provided] [no usage info] [missing usage info prevents renaming] */ /*! export string [provided] [no usage info] [missing usage info prevents renaming] */ /*! export stringArray [provided] [no usage info] [missing usage info prevents renaming] */ /*! export thenable [provided] [no usage info] [missing usage info prevents renaming] */ /*! export typedArray [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__ */ /***/ ((__unused_webpack_module, exports) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); function boolean(value) { return value === true || value === false; } exports.boolean = boolean; function string(value) { return typeof value === 'string' || value instanceof String; } exports.string = string; function number(value) { return typeof value === 'number' || value instanceof Number; } exports.number = number; function error(value) { return value instanceof Error; } exports.error = error; function func(value) { return typeof value === 'function'; } exports.func = func; function array(value) { return Array.isArray(value); } exports.array = array; function stringArray(value) { return array(value) && value.every(elem => string(elem)); } exports.stringArray = stringArray; function typedArray(value, check) { return Array.isArray(value) && value.every(check); } exports.typedArray = typedArray; function thenable(value) { return value && func(value.then); } exports.thenable = thenable; function asPromise(value) { if (value instanceof Promise) { return value; } else if (thenable(value)) { return new Promise((resolve, reject) => { value.then((resolved) => resolve(resolved), (error) => reject(error)); }); } else { return Promise.resolve(value); } } exports.asPromise = asPromise; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/utils/processes.js": /*!********************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/utils/processes.js ***! \********************************************************************/ /*! flagged exports */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export terminate [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const cp = __webpack_require__(/*! child_process */ "child_process"); const path_1 = __webpack_require__(/*! path */ "path"); const isWindows = (process.platform === 'win32'); const isMacintosh = (process.platform === 'darwin'); const isLinux = (process.platform === 'linux'); function terminate(process, cwd) { if (isWindows) { try { // This we run in Atom execFileSync is available. // Ignore stderr since this is otherwise piped to parent.stderr // which might be already closed. let options = { stdio: ['pipe', 'pipe', 'ignore'] }; if (cwd) { options.cwd = cwd; } cp.execFileSync('taskkill', ['/T', '/F', '/PID', process.pid.toString()], options); return true; } catch (err) { return false; } } else if (isLinux || isMacintosh) { try { var cmd = path_1.join(__dirname, 'terminateProcess.sh'); var result = cp.spawnSync(cmd, [process.pid.toString()]); return result.error ? false : true; } catch (err) { return false; } } else { process.kill('SIGKILL'); return true; } } exports.terminate = terminate; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/utils/uuid.js": /*!***************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/utils/uuid.js ***! \***************************************************************/ /*! flagged exports */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export empty [provided] [no usage info] [missing usage info prevents renaming] */ /*! export generateUuid [provided] [no usage info] [missing usage info prevents renaming] */ /*! export isUUID [provided] [no usage info] [missing usage info prevents renaming] */ /*! export parse [provided] [no usage info] [missing usage info prevents renaming] */ /*! export v4 [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__ */ /***/ ((__unused_webpack_module, exports) => { "use strict"; /*--------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ Object.defineProperty(exports, "__esModule", ({ value: true })); class ValueUUID { constructor(_value) { this._value = _value; // empty } asHex() { return this._value; } equals(other) { return this.asHex() === other.asHex(); } } class V4UUID extends ValueUUID { constructor() { super([ V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), '-', V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), '-', '4', V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), '-', V4UUID._oneOf(V4UUID._timeHighBits), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), '-', V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), V4UUID._randomHex(), ].join('')); } static _oneOf(array) { return array[Math.floor(array.length * Math.random())]; } static _randomHex() { return V4UUID._oneOf(V4UUID._chars); } } V4UUID._chars = ['0', '1', '2', '3', '4', '5', '6', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']; V4UUID._timeHighBits = ['8', '9', 'a', 'b']; /** * An empty UUID that contains only zeros. */ exports.empty = new ValueUUID('00000000-0000-0000-0000-000000000000'); function v4() { return new V4UUID(); } exports.v4 = v4; const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i; function isUUID(value) { return _UUIDPattern.test(value); } exports.isUUID = isUUID; /** * Parses a UUID that is of the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx. * @param value A uuid string. */ function parse(value) { if (!isUUID(value)) { throw new Error('invalid uuid'); } return new ValueUUID(value); } exports.parse = parse; function generateUuid() { return v4().asHex(); } exports.generateUuid = generateUuid; /***/ }), /***/ "../node_modules/vscode-languageclient/lib/workspaceFolders.js": /*!*********************************************************************!*\ !*** ../node_modules/vscode-languageclient/lib/workspaceFolders.js ***! \*********************************************************************/ /*! flagged exports */ /*! export WorkspaceFoldersFeature [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export arrayDiff [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const UUID = __webpack_require__(/*! ./utils/uuid */ "../node_modules/vscode-languageclient/lib/utils/uuid.js"); const vscode_1 = __webpack_require__(/*! vscode */ "vscode"); const vscode_languageserver_protocol_1 = __webpack_require__(/*! vscode-languageserver-protocol */ "../node_modules/vscode-languageserver-protocol/lib/main.js"); function access(target, key) { if (target === void 0) { return undefined; } return target[key]; } function arrayDiff(left, right) { return left.filter(element => right.indexOf(element) < 0); } exports.arrayDiff = arrayDiff; class WorkspaceFoldersFeature { constructor(_client) { this._client = _client; this._listeners = new Map(); } get messages() { return vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type; } fillInitializeParams(params) { let folders = vscode_1.workspace.workspaceFolders; this.initializeWithFolders(folders); if (folders === void 0) { params.workspaceFolders = null; } else { params.workspaceFolders = folders.map(folder => this.asProtocol(folder)); } } initializeWithFolders(currentWorkspaceFolders) { this._initialFolders = currentWorkspaceFolders; } fillClientCapabilities(capabilities) { capabilities.workspace = capabilities.workspace || {}; capabilities.workspace.workspaceFolders = true; } initialize(capabilities) { let client = this._client; client.onRequest(vscode_languageserver_protocol_1.WorkspaceFoldersRequest.type, (token) => { let workspaceFolders = () => { let folders = vscode_1.workspace.workspaceFolders; if (folders === void 0) { return null; } let result = folders.map((folder) => { return this.asProtocol(folder); }); return result; }; let middleware = client.clientOptions.middleware.workspace; return middleware && middleware.workspaceFolders ? middleware.workspaceFolders(token, workspaceFolders) : workspaceFolders(token); }); let value = access(access(access(capabilities, 'workspace'), 'workspaceFolders'), 'changeNotifications'); let id; if (typeof value === 'string') { id = value; } else if (value === true) { id = UUID.generateUuid(); } if (id) { this.register(this.messages, { id: id, registerOptions: undefined }); } } sendInitialEvent(currentWorkspaceFolders) { if (this._initialFolders && currentWorkspaceFolders) { const removed = arrayDiff(this._initialFolders, currentWorkspaceFolders); const added = arrayDiff(currentWorkspaceFolders, this._initialFolders); if (added.length > 0 || removed.length > 0) { this.doSendEvent(added, removed); } } else if (this._initialFolders) { this.doSendEvent([], this._initialFolders); } else if (currentWorkspaceFolders) { this.doSendEvent(currentWorkspaceFolders, []); } } doSendEvent(addedFolders, removedFolders) { let params = { event: { added: addedFolders.map(folder => this.asProtocol(folder)), removed: removedFolders.map(folder => this.asProtocol(folder)) } }; this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type, params); } register(_message, data) { let id = data.id; let client = this._client; let disposable = vscode_1.workspace.onDidChangeWorkspaceFolders((event) => { let didChangeWorkspaceFolders = (event) => { this.doSendEvent(event.added, event.removed); }; let middleware = client.clientOptions.middleware.workspace; middleware && middleware.didChangeWorkspaceFolders ? middleware.didChangeWorkspaceFolders(event, didChangeWorkspaceFolders) : didChangeWorkspaceFolders(event); }); this._listeners.set(id, disposable); this.sendInitialEvent(vscode_1.workspace.workspaceFolders); } unregister(id) { let disposable = this._listeners.get(id); if (disposable === void 0) { return; } this._listeners.delete(id); disposable.dispose(); } dispose() { for (let disposable of this._listeners.values()) { disposable.dispose(); } this._listeners.clear(); } asProtocol(workspaceFolder) { if (workspaceFolder === void 0) { return null; } return { uri: this._client.code2ProtocolConverter.asUri(workspaceFolder.uri), name: workspaceFolder.name }; } } exports.WorkspaceFoldersFeature = WorkspaceFoldersFeature; /***/ }), /***/ "../node_modules/vscode-languageclient/node_modules/semver/semver.js": /*!***************************************************************************!*\ !*** ../node_modules/vscode-languageclient/node_modules/semver/semver.js ***! \***************************************************************************/ /*! unknown exports (runtime-defined) */ /*! runtime requirements: __webpack_exports__, module */ /*! CommonJS bailout: module.exports is used directly at 1:10-24 */ /*! CommonJS bailout: exports is used directly at 1:0-7 */ /*! CommonJS bailout: exports.compareBuild(...) prevents optimization as exports is passed as call context at 670:11-31 */ /*! CommonJS bailout: exports.compareBuild(...) prevents optimization as exports is passed as call context at 677:11-31 */ /***/ ((module, exports) => { exports = module.exports = SemVer var debug /* istanbul ignore next */ if (typeof process === 'object' && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) { debug = function () { var args = Array.prototype.slice.call(arguments, 0) args.unshift('SEMVER') console.log.apply(console, args) } } else { debug = function () {} } // Note: this is the semver.org version of the spec that it implements // Not necessarily the package version of this code. exports.SEMVER_SPEC_VERSION = '2.0.0' var MAX_LENGTH = 256 var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */ 9007199254740991 // Max safe segment length for coercion. var MAX_SAFE_COMPONENT_LENGTH = 16 // The actual regexps go on exports.re var re = exports.re = [] var src = exports.src = [] var t = exports.tokens = {} var R = 0 function tok (n) { t[n] = R++ } // The following Regular Expressions can be used for tokenizing, // validating, and parsing SemVer version strings. // ## Numeric Identifier // A single `0`, or a non-zero digit followed by zero or more digits. tok('NUMERICIDENTIFIER') src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*' tok('NUMERICIDENTIFIERLOOSE') src[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+' // ## Non-numeric Identifier // Zero or more digits, followed by a letter or hyphen, and then zero or // more letters, digits, or hyphens. tok('NONNUMERICIDENTIFIER') src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*' // ## Main Version // Three dot-separated numeric identifiers. tok('MAINVERSION') src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')' tok('MAINVERSIONLOOSE') src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')' // ## Pre-release Version Identifier // A numeric identifier, or a non-numeric identifier. tok('PRERELEASEIDENTIFIER') src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] + '|' + src[t.NONNUMERICIDENTIFIER] + ')' tok('PRERELEASEIDENTIFIERLOOSE') src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] + '|' + src[t.NONNUMERICIDENTIFIER] + ')' // ## Pre-release Version // Hyphen, followed by one or more dot-separated pre-release version // identifiers. tok('PRERELEASE') src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] + '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))' tok('PRERELEASELOOSE') src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] + '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))' // ## Build Metadata Identifier // Any combination of digits, letters, or hyphens. tok('BUILDIDENTIFIER') src[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+' // ## Build Metadata // Plus sign, followed by one or more period-separated build metadata // identifiers. tok('BUILD') src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] + '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))' // ## Full Version String // A main version, followed optionally by a pre-release version and // build metadata. // Note that the only major, minor, patch, and pre-release sections of // the version string are capturing groups. The build metadata is not a // capturing group, because it should not ever be used in version // comparison. tok('FULL') tok('FULLPLAIN') src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] + src[t.PRERELEASE] + '?' + src[t.BUILD] + '?' src[t.FULL] = '^' + src[t.FULLPLAIN] + '$' // like full, but allows v1.2.3 and =1.2.3, which people do sometimes. // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty // common in the npm registry. tok('LOOSEPLAIN') src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] + src[t.PRERELEASELOOSE] + '?' + src[t.BUILD] + '?' tok('LOOSE') src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$' tok('GTLT') src[t.GTLT] = '((?:<|>)?=?)' // Something like "2.*" or "1.2.x". // Note that "x.x" is a valid xRange identifer, meaning "any version" // Only the first item is strictly required. tok('XRANGEIDENTIFIERLOOSE') src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*' tok('XRANGEIDENTIFIER') src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*' tok('XRANGEPLAIN') src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:' + src[t.PRERELEASE] + ')?' + src[t.BUILD] + '?' + ')?)?' tok('XRANGEPLAINLOOSE') src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:' + src[t.PRERELEASELOOSE] + ')?' + src[t.BUILD] + '?' + ')?)?' tok('XRANGE') src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$' tok('XRANGELOOSE') src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$' // Coercion. // Extract anything that could conceivably be a part of a valid semver tok('COERCE') src[t.COERCE] = '(^|[^\\d])' + '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:$|[^\\d])' tok('COERCERTL') re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g') // Tilde ranges. // Meaning is "reasonably at or greater than" tok('LONETILDE') src[t.LONETILDE] = '(?:~>?)' tok('TILDETRIM') src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+' re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g') var tildeTrimReplace = '$1~' tok('TILDE') src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$' tok('TILDELOOSE') src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$' // Caret ranges. // Meaning is "at least and backwards compatible with" tok('LONECARET') src[t.LONECARET] = '(?:\\^)' tok('CARETTRIM') src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+' re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g') var caretTrimReplace = '$1^' tok('CARET') src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$' tok('CARETLOOSE') src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$' // A simple gt/lt/eq thing, or just "" to indicate "any version" tok('COMPARATORLOOSE') src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$' tok('COMPARATOR') src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$' // An expression to strip any whitespace between the gtlt and the thing // it modifies, so that `> 1.2.3` ==> `>1.2.3` tok('COMPARATORTRIM') src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')' // this one has to use the /g flag re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g') var comparatorTrimReplace = '$1$2$3' // Something like `1.2.3 - 1.2.4` // Note that these all use the loose form, because they'll be // checked against either the strict or loose comparator form // later. tok('HYPHENRANGE') src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' + '\\s+-\\s+' + '(' + src[t.XRANGEPLAIN] + ')' + '\\s*$' tok('HYPHENRANGELOOSE') src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\s+-\\s+' + '(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\s*$' // Star ranges basically just allow anything at all. tok('STAR') src[t.STAR] = '(<|>)?=?\\s*\\*' // Compile to actual regexp objects. // All are flag-free, unless they were created above with a flag. for (var i = 0; i < R; i++) { debug(i, src[i]) if (!re[i]) { re[i] = new RegExp(src[i]) } } exports.parse = parse function parse (version, options) { if (!options || typeof options !== 'object') { options = { loose: !!options, includePrerelease: false } } if (version instanceof SemVer) { return version } if (typeof version !== 'string') { return null } if (version.length > MAX_LENGTH) { return null } var r = options.loose ? re[t.LOOSE] : re[t.FULL] if (!r.test(version)) { return null } try { return new SemVer(version, options) } catch (er) { return null } } exports.valid = valid function valid (version, options) { var v = parse(version, options) return v ? v.version : null } exports.clean = clean function clean (version, options) { var s = parse(version.trim().replace(/^[=v]+/, ''), options) return s ? s.version : null } exports.SemVer = SemVer function SemVer (version, options) { if (!options || typeof options !== 'object') { options = { loose: !!options, includePrerelease: false } } if (version instanceof SemVer) { if (version.loose === options.loose) { return version } else { version = version.version } } else if (typeof version !== 'string') { throw new TypeError('Invalid Version: ' + version) } if (version.length > MAX_LENGTH) { throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters') } if (!(this instanceof SemVer)) { return new SemVer(version, options) } debug('SemVer', version, options) this.options = options this.loose = !!options.loose var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]) if (!m) { throw new TypeError('Invalid Version: ' + version) } this.raw = version // these are actually numbers this.major = +m[1] this.minor = +m[2] this.patch = +m[3] if (this.major > MAX_SAFE_INTEGER || this.major < 0) { throw new TypeError('Invalid major version') } if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { throw new TypeError('Invalid minor version') } if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { throw new TypeError('Invalid patch version') } // numberify any prerelease numeric ids if (!m[4]) { this.prerelease = [] } else { this.prerelease = m[4].split('.').map(function (id) { if (/^[0-9]+$/.test(id)) { var num = +id if (num >= 0 && num < MAX_SAFE_INTEGER) { return num } } return id }) } this.build = m[5] ? m[5].split('.') : [] this.format() } SemVer.prototype.format = function () { this.version = this.major + '.' + this.minor + '.' + this.patch if (this.prerelease.length) { this.version += '-' + this.prerelease.join('.') } return this.version } SemVer.prototype.toString = function () { return this.version } SemVer.prototype.compare = function (other) { debug('SemVer.compare', this.version, this.options, other) if (!(other instanceof SemVer)) { other = new SemVer(other, this.options) } return this.compareMain(other) || this.comparePre(other) } SemVer.prototype.compareMain = function (other) { if (!(other instanceof SemVer)) { other = new SemVer(other, this.options) } return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch) } SemVer.prototype.comparePre = function (other) { if (!(other instanceof SemVer)) { other = new SemVer(other, this.options) } // NOT having a prerelease is > having one if (this.prerelease.length && !other.prerelease.length) { return -1 } else if (!this.prerelease.length && other.prerelease.length) { return 1 } else if (!this.prerelease.length && !other.prerelease.length) { return 0 } var i = 0 do { var a = this.prerelease[i] var b = other.prerelease[i] debug('prerelease compare', i, a, b) if (a === undefined && b === undefined) { return 0 } else if (b === undefined) { return 1 } else if (a === undefined) { return -1 } else if (a === b) { continue } else { return compareIdentifiers(a, b) } } while (++i) } SemVer.prototype.compareBuild = function (other) { if (!(other instanceof SemVer)) { other = new SemVer(other, this.options) } var i = 0 do { var a = this.build[i] var b = other.build[i] debug('prerelease compare', i, a, b) if (a === undefined && b === undefined) { return 0 } else if (b === undefined) { return 1 } else if (a === undefined) { return -1 } else if (a === b) { continue } else { return compareIdentifiers(a, b) } } while (++i) } // preminor will bump the version up to the next minor release, and immediately // down to pre-release. premajor and prepatch work the same way. SemVer.prototype.inc = function (release, identifier) { switch (release) { case 'premajor': this.prerelease.length = 0 this.patch = 0 this.minor = 0 this.major++ this.inc('pre', identifier) break case 'preminor': this.prerelease.length = 0 this.patch = 0 this.minor++ this.inc('pre', identifier) break case 'prepatch': // If this is already a prerelease, it will bump to the next version // drop any prereleases that might already exist, since they are not // relevant at this point. this.prerelease.length = 0 this.inc('patch', identifier) this.inc('pre', identifier) break // If the input is a non-prerelease version, this acts the same as // prepatch. case 'prerelease': if (this.prerelease.length === 0) { this.inc('patch', identifier) } this.inc('pre', identifier) break case 'major': // If this is a pre-major version, bump up to the same major version. // Otherwise increment major. // 1.0.0-5 bumps to 1.0.0 // 1.1.0 bumps to 2.0.0 if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) { this.major++ } this.minor = 0 this.patch = 0 this.prerelease = [] break case 'minor': // If this is a pre-minor version, bump up to the same minor version. // Otherwise increment minor. // 1.2.0-5 bumps to 1.2.0 // 1.2.1 bumps to 1.3.0 if (this.patch !== 0 || this.prerelease.length === 0) { this.minor++ } this.patch = 0 this.prerelease = [] break case 'patch': // If this is not a pre-release version, it will increment the patch. // If it is a pre-release it will bump up to the same patch version. // 1.2.0-5 patches to 1.2.0 // 1.2.0 patches to 1.2.1 if (this.prerelease.length === 0) { this.patch++ } this.prerelease = [] break // This probably shouldn't be used publicly. // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction. case 'pre': if (this.prerelease.length === 0) { this.prerelease = [0] } else { var i = this.prerelease.length while (--i >= 0) { if (typeof this.prerelease[i] === 'number') { this.prerelease[i]++ i = -2 } } if (i === -1) { // didn't increment anything this.prerelease.push(0) } } if (identifier) { // 1.2.0-beta.1 bumps to 1.2.0-beta.2, // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 if (this.prerelease[0] === identifier) { if (isNaN(this.prerelease[1])) { this.prerelease = [identifier, 0] } } else { this.prerelease = [identifier, 0] } } break default: throw new Error('invalid increment argument: ' + release) } this.format() this.raw = this.version return this } exports.inc = inc function inc (version, release, loose, identifier) { if (typeof (loose) === 'string') { identifier = loose loose = undefined } try { return new SemVer(version, loose).inc(release, identifier).version } catch (er) { return null } } exports.diff = diff function diff (version1, version2) { if (eq(version1, version2)) { return null } else { var v1 = parse(version1) var v2 = parse(version2) var prefix = '' if (v1.prerelease.length || v2.prerelease.length) { prefix = 'pre' var defaultResult = 'prerelease' } for (var key in v1) { if (key === 'major' || key === 'minor' || key === 'patch') { if (v1[key] !== v2[key]) { return prefix + key } } } return defaultResult // may be undefined } } exports.compareIdentifiers = compareIdentifiers var numeric = /^[0-9]+$/ function compareIdentifiers (a, b) { var anum = numeric.test(a) var bnum = numeric.test(b) if (anum && bnum) { a = +a b = +b } return a === b ? 0 : (anum && !bnum) ? -1 : (bnum && !anum) ? 1 : a < b ? -1 : 1 } exports.rcompareIdentifiers = rcompareIdentifiers function rcompareIdentifiers (a, b) { return compareIdentifiers(b, a) } exports.major = major function major (a, loose) { return new SemVer(a, loose).major } exports.minor = minor function minor (a, loose) { return new SemVer(a, loose).minor } exports.patch = patch function patch (a, loose) { return new SemVer(a, loose).patch } exports.compare = compare function compare (a, b, loose) { return new SemVer(a, loose).compare(new SemVer(b, loose)) } exports.compareLoose = compareLoose function compareLoose (a, b) { return compare(a, b, true) } exports.compareBuild = compareBuild function compareBuild (a, b, loose) { var versionA = new SemVer(a, loose) var versionB = new SemVer(b, loose) return versionA.compare(versionB) || versionA.compareBuild(versionB) } exports.rcompare = rcompare function rcompare (a, b, loose) { return compare(b, a, loose) } exports.sort = sort function sort (list, loose) { return list.sort(function (a, b) { return exports.compareBuild(a, b, loose) }) } exports.rsort = rsort function rsort (list, loose) { return list.sort(function (a, b) { return exports.compareBuild(b, a, loose) }) } exports.gt = gt function gt (a, b, loose) { return compare(a, b, loose) > 0 } exports.lt = lt function lt (a, b, loose) { return compare(a, b, loose) < 0 } exports.eq = eq function eq (a, b, loose) { return compare(a, b, loose) === 0 } exports.neq = neq function neq (a, b, loose) { return compare(a, b, loose) !== 0 } exports.gte = gte function gte (a, b, loose) { return compare(a, b, loose) >= 0 } exports.lte = lte function lte (a, b, loose) { return compare(a, b, loose) <= 0 } exports.cmp = cmp function cmp (a, op, b, loose) { switch (op) { case '===': if (typeof a === 'object') a = a.version if (typeof b === 'object') b = b.version return a === b case '!==': if (typeof a === 'object') a = a.version if (typeof b === 'object') b = b.version return a !== b case '': case '=': case '==': return eq(a, b, loose) case '!=': return neq(a, b, loose) case '>': return gt(a, b, loose) case '>=': return gte(a, b, loose) case '<': return lt(a, b, loose) case '<=': return lte(a, b, loose) default: throw new TypeError('Invalid operator: ' + op) } } exports.Comparator = Comparator function Comparator (comp, options) { if (!options || typeof options !== 'object') { options = { loose: !!options, includePrerelease: false } } if (comp instanceof Comparator) { if (comp.loose === !!options.loose) { return comp } else { comp = comp.value } } if (!(this instanceof Comparator)) { return new Comparator(comp, options) } debug('comparator', comp, options) this.options = options this.loose = !!options.loose this.parse(comp) if (this.semver === ANY) { this.value = '' } else { this.value = this.operator + this.semver.version } debug('comp', this) } var ANY = {} Comparator.prototype.parse = function (comp) { var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] var m = comp.match(r) if (!m) { throw new TypeError('Invalid comparator: ' + comp) } this.operator = m[1] !== undefined ? m[1] : '' if (this.operator === '=') { this.operator = '' } // if it literally is just '>' or '' then allow anything. if (!m[2]) { this.semver = ANY } else { this.semver = new SemVer(m[2], this.options.loose) } } Comparator.prototype.toString = function () { return this.value } Comparator.prototype.test = function (version) { debug('Comparator.test', version, this.options.loose) if (this.semver === ANY || version === ANY) { return true } if (typeof version === 'string') { try { version = new SemVer(version, this.options) } catch (er) { return false } } return cmp(version, this.operator, this.semver, this.options) } Comparator.prototype.intersects = function (comp, options) { if (!(comp instanceof Comparator)) { throw new TypeError('a Comparator is required') } if (!options || typeof options !== 'object') { options = { loose: !!options, includePrerelease: false } } var rangeTmp if (this.operator === '') { if (this.value === '') { return true } rangeTmp = new Range(comp.value, options) return satisfies(this.value, rangeTmp, options) } else if (comp.operator === '') { if (comp.value === '') { return true } rangeTmp = new Range(this.value, options) return satisfies(comp.semver, rangeTmp, options) } var sameDirectionIncreasing = (this.operator === '>=' || this.operator === '>') && (comp.operator === '>=' || comp.operator === '>') var sameDirectionDecreasing = (this.operator === '<=' || this.operator === '<') && (comp.operator === '<=' || comp.operator === '<') var sameSemVer = this.semver.version === comp.semver.version var differentDirectionsInclusive = (this.operator === '>=' || this.operator === '<=') && (comp.operator === '>=' || comp.operator === '<=') var oppositeDirectionsLessThan = cmp(this.semver, '<', comp.semver, options) && ((this.operator === '>=' || this.operator === '>') && (comp.operator === '<=' || comp.operator === '<')) var oppositeDirectionsGreaterThan = cmp(this.semver, '>', comp.semver, options) && ((this.operator === '<=' || this.operator === '<') && (comp.operator === '>=' || comp.operator === '>')) return sameDirectionIncreasing || sameDirectionDecreasing || (sameSemVer && differentDirectionsInclusive) || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan } exports.Range = Range function Range (range, options) { if (!options || typeof options !== 'object') { options = { loose: !!options, includePrerelease: false } } if (range instanceof Range) { if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) { return range } else { return new Range(range.raw, options) } } if (range instanceof Comparator) { return new Range(range.value, options) } if (!(this instanceof Range)) { return new Range(range, options) } this.options = options this.loose = !!options.loose this.includePrerelease = !!options.includePrerelease // First, split based on boolean or || this.raw = range this.set = range.split(/\s*\|\|\s*/).map(function (range) { return this.parseRange(range.trim()) }, this).filter(function (c) { // throw out any that are not relevant for whatever reason return c.length }) if (!this.set.length) { throw new TypeError('Invalid SemVer Range: ' + range) } this.format() } Range.prototype.format = function () { this.range = this.set.map(function (comps) { return comps.join(' ').trim() }).join('||').trim() return this.range } Range.prototype.toString = function () { return this.range } Range.prototype.parseRange = function (range) { var loose = this.options.loose range = range.trim() // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE] range = range.replace(hr, hyphenReplace) debug('hyphen replace', range) // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace) debug('comparator trim', range, re[t.COMPARATORTRIM]) // `~ 1.2.3` => `~1.2.3` range = range.replace(re[t.TILDETRIM], tildeTrimReplace) // `^ 1.2.3` => `^1.2.3` range = range.replace(re[t.CARETTRIM], caretTrimReplace) // normalize spaces range = range.split(/\s+/).join(' ') // At this point, the range is completely trimmed and // ready to be split into comparators. var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] var set = range.split(' ').map(function (comp) { return parseComparator(comp, this.options) }, this).join(' ').split(/\s+/) if (this.options.loose) { // in loose mode, throw out any that are not valid comparators set = set.filter(function (comp) { return !!comp.match(compRe) }) } set = set.map(function (comp) { return new Comparator(comp, this.options) }, this) return set } Range.prototype.intersects = function (range, options) { if (!(range instanceof Range)) { throw new TypeError('a Range is required') } return this.set.some(function (thisComparators) { return ( isSatisfiable(thisComparators, options) && range.set.some(function (rangeComparators) { return ( isSatisfiable(rangeComparators, options) && thisComparators.every(function (thisComparator) { return rangeComparators.every(function (rangeComparator) { return thisComparator.intersects(rangeComparator, options) }) }) ) }) ) }) } // take a set of comparators and determine whether there // exists a version which can satisfy it function isSatisfiable (comparators, options) { var result = true var remainingComparators = comparators.slice() var testComparator = remainingComparators.pop() while (result && remainingComparators.length) { result = remainingComparators.every(function (otherComparator) { return testComparator.intersects(otherComparator, options) }) testComparator = remainingComparators.pop() } return result } // Mostly just for testing and legacy API reasons exports.toComparators = toComparators function toComparators (range, options) { return new Range(range, options).set.map(function (comp) { return comp.map(function (c) { return c.value }).join(' ').trim().split(' ') }) } // comprised of xranges, tildes, stars, and gtlt's at this point. // already replaced the hyphen ranges // turn into a set of JUST comparators. function parseComparator (comp, options) { debug('comp', comp, options) comp = replaceCarets(comp, options) debug('caret', comp) comp = replaceTildes(comp, options) debug('tildes', comp) comp = replaceXRanges(comp, options) debug('xrange', comp) comp = replaceStars(comp, options) debug('stars', comp) return comp } function isX (id) { return !id || id.toLowerCase() === 'x' || id === '*' } // ~, ~> --> * (any, kinda silly) // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0 // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0 // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0 // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0 // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0 function replaceTildes (comp, options) { return comp.trim().split(/\s+/).map(function (comp) { return replaceTilde(comp, options) }).join(' ') } function replaceTilde (comp, options) { var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE] return comp.replace(r, function (_, M, m, p, pr) { debug('tilde', comp, _, M, m, p, pr) var ret if (isX(M)) { ret = '' } else if (isX(m)) { ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' } else if (isX(p)) { // ~1.2 == >=1.2.0 <1.3.0 ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' } else if (pr) { debug('replaceTilde pr', pr) ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + (+m + 1) + '.0' } else { // ~1.2.3 == >=1.2.3 <1.3.0 ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0' } debug('tilde return', ret) return ret }) } // ^ --> * (any, kinda silly) // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0 // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0 // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0 // ^1.2.3 --> >=1.2.3 <2.0.0 // ^1.2.0 --> >=1.2.0 <2.0.0 function replaceCarets (comp, options) { return comp.trim().split(/\s+/).map(function (comp) { return replaceCaret(comp, options) }).join(' ') } function replaceCaret (comp, options) { debug('caret', comp, options) var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET] return comp.replace(r, function (_, M, m, p, pr) { debug('caret', comp, _, M, m, p, pr) var ret if (isX(M)) { ret = '' } else if (isX(m)) { ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' } else if (isX(p)) { if (M === '0') { ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' } else { ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0' } } else if (pr) { debug('replaceCaret pr', pr) if (M === '0') { if (m === '0') { ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + m + '.' + (+p + 1) } else { ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + (+m + 1) + '.0' } } else { ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + (+M + 1) + '.0.0' } } else { debug('no pr') if (M === '0') { if (m === '0') { ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + m + '.' + (+p + 1) } else { ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0' } } else { ret = '>=' + M + '.' + m + '.' + p + ' <' + (+M + 1) + '.0.0' } } debug('caret return', ret) return ret }) } function replaceXRanges (comp, options) { debug('replaceXRanges', comp, options) return comp.split(/\s+/).map(function (comp) { return replaceXRange(comp, options) }).join(' ') } function replaceXRange (comp, options) { comp = comp.trim() var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE] return comp.replace(r, function (ret, gtlt, M, m, p, pr) { debug('xRange', comp, ret, gtlt, M, m, p, pr) var xM = isX(M) var xm = xM || isX(m) var xp = xm || isX(p) var anyX = xp if (gtlt === '=' && anyX) { gtlt = '' } // if we're including prereleases in the match, then we need // to fix this to -0, the lowest possible prerelease value pr = options.includePrerelease ? '-0' : '' if (xM) { if (gtlt === '>' || gtlt === '<') { // nothing is allowed ret = '<0.0.0-0' } else { // nothing is forbidden ret = '*' } } else if (gtlt && anyX) { // we know patch is an x, because we have any x at all. // replace X with 0 if (xm) { m = 0 } p = 0 if (gtlt === '>') { // >1 => >=2.0.0 // >1.2 => >=1.3.0 // >1.2.3 => >= 1.2.4 gtlt = '>=' if (xm) { M = +M + 1 m = 0 p = 0 } else { m = +m + 1 p = 0 } } else if (gtlt === '<=') { // <=0.7.x is actually <0.8.0, since any 0.7.x should // pass. Similarly, <=7.x is actually <8.0.0, etc. gtlt = '<' if (xm) { M = +M + 1 } else { m = +m + 1 } } ret = gtlt + M + '.' + m + '.' + p + pr } else if (xm) { ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr } else if (xp) { ret = '>=' + M + '.' + m + '.0' + pr + ' <' + M + '.' + (+m + 1) + '.0' + pr } debug('xRange return', ret) return ret }) } // Because * is AND-ed with everything else in the comparator, // and '' means "any version", just remove the *s entirely. function replaceStars (comp, options) { debug('replaceStars', comp, options) // Looseness is ignored here. star is always as loose as it gets! return comp.trim().replace(re[t.STAR], '') } // This function is passed to string.replace(re[t.HYPHENRANGE]) // M, m, patch, prerelease, build // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 // 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do // 1.2 - 3.4 => >=1.2.0 <3.5.0 function hyphenReplace ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) { if (isX(fM)) { from = '' } else if (isX(fm)) { from = '>=' + fM + '.0.0' } else if (isX(fp)) { from = '>=' + fM + '.' + fm + '.0' } else { from = '>=' + from } if (isX(tM)) { to = '' } else if (isX(tm)) { to = '<' + (+tM + 1) + '.0.0' } else if (isX(tp)) { to = '<' + tM + '.' + (+tm + 1) + '.0' } else if (tpr) { to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr } else { to = '<=' + to } return (from + ' ' + to).trim() } // if ANY of the sets match ALL of its comparators, then pass Range.prototype.test = function (version) { if (!version) { return false } if (typeof version === 'string') { try { version = new SemVer(version, this.options) } catch (er) { return false } } for (var i = 0; i < this.set.length; i++) { if (testSet(this.set[i], version, this.options)) { return true } } return false } function testSet (set, version, options) { for (var i = 0; i < set.length; i++) { if (!set[i].test(version)) { return false } } if (version.prerelease.length && !options.includePrerelease) { // Find the set of versions that are allowed to have prereleases // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 // That should allow `1.2.3-pr.2` to pass. // However, `1.2.4-alpha.notready` should NOT be allowed, // even though it's within the range set by the comparators. for (i = 0; i < set.length; i++) { debug(set[i].semver) if (set[i].semver === ANY) { continue } if (set[i].semver.prerelease.length > 0) { var allowed = set[i].semver if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) { return true } } } // Version has a -pre, but it's not one of the ones we like. return false } return true } exports.satisfies = satisfies function satisfies (version, range, options) { try { range = new Range(range, options) } catch (er) { return false } return range.test(version) } exports.maxSatisfying = maxSatisfying function maxSatisfying (versions, range, options) { var max = null var maxSV = null try { var rangeObj = new Range(range, options) } catch (er) { return null } versions.forEach(function (v) { if (rangeObj.test(v)) { // satisfies(v, range, options) if (!max || maxSV.compare(v) === -1) { // compare(max, v, true) max = v maxSV = new SemVer(max, options) } } }) return max } exports.minSatisfying = minSatisfying function minSatisfying (versions, range, options) { var min = null var minSV = null try { var rangeObj = new Range(range, options) } catch (er) { return null } versions.forEach(function (v) { if (rangeObj.test(v)) { // satisfies(v, range, options) if (!min || minSV.compare(v) === 1) { // compare(min, v, true) min = v minSV = new SemVer(min, options) } } }) return min } exports.minVersion = minVersion function minVersion (range, loose) { range = new Range(range, loose) var minver = new SemVer('0.0.0') if (range.test(minver)) { return minver } minver = new SemVer('0.0.0-0') if (range.test(minver)) { return minver } minver = null for (var i = 0; i < range.set.length; ++i) { var comparators = range.set[i] comparators.forEach(function (comparator) { // Clone to avoid manipulating the comparator's semver object. var compver = new SemVer(comparator.semver.version) switch (comparator.operator) { case '>': if (compver.prerelease.length === 0) { compver.patch++ } else { compver.prerelease.push(0) } compver.raw = compver.format() /* fallthrough */ case '': case '>=': if (!minver || gt(minver, compver)) { minver = compver } break case '<': case '<=': /* Ignore maximum versions */ break /* istanbul ignore next */ default: throw new Error('Unexpected operation: ' + comparator.operator) } }) } if (minver && range.test(minver)) { return minver } return null } exports.validRange = validRange function validRange (range, options) { try { // Return '*' instead of '' so that truthiness works. // This will throw if it's invalid anyway return new Range(range, options).range || '*' } catch (er) { return null } } // Determine if version is less than all the versions possible in the range exports.ltr = ltr function ltr (version, range, options) { return outside(version, range, '<', options) } // Determine if version is greater than all the versions possible in the range. exports.gtr = gtr function gtr (version, range, options) { return outside(version, range, '>', options) } exports.outside = outside function outside (version, range, hilo, options) { version = new SemVer(version, options) range = new Range(range, options) var gtfn, ltefn, ltfn, comp, ecomp switch (hilo) { case '>': gtfn = gt ltefn = lte ltfn = lt comp = '>' ecomp = '>=' break case '<': gtfn = lt ltefn = gte ltfn = gt comp = '<' ecomp = '<=' break default: throw new TypeError('Must provide a hilo val of "<" or ">"') } // If it satisifes the range it is not outside if (satisfies(version, range, options)) { return false } // From now on, variable terms are as if we're in "gtr" mode. // but note that everything is flipped for the "ltr" function. for (var i = 0; i < range.set.length; ++i) { var comparators = range.set[i] var high = null var low = null comparators.forEach(function (comparator) { if (comparator.semver === ANY) { comparator = new Comparator('>=0.0.0') } high = high || comparator low = low || comparator if (gtfn(comparator.semver, high.semver, options)) { high = comparator } else if (ltfn(comparator.semver, low.semver, options)) { low = comparator } }) // If the edge version comparator has a operator then our version // isn't outside it if (high.operator === comp || high.operator === ecomp) { return false } // If the lowest version comparator has an operator and our version // is less than it then it isn't higher than the range if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) { return false } else if (low.operator === ecomp && ltfn(version, low.semver)) { return false } } return true } exports.prerelease = prerelease function prerelease (version, options) { var parsed = parse(version, options) return (parsed && parsed.prerelease.length) ? parsed.prerelease : null } exports.intersects = intersects function intersects (r1, r2, options) { r1 = new Range(r1, options) r2 = new Range(r2, options) return r1.intersects(r2) } exports.coerce = coerce function coerce (version, options) { if (version instanceof SemVer) { return version } if (typeof version === 'number') { version = String(version) } if (typeof version !== 'string') { return null } options = options || {} var match = null if (!options.rtl) { match = version.match(re[t.COERCE]) } else { // Find the right-most coercible string that does not share // a terminus with a more left-ward coercible string. // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4' // // Walk through the string checking with a /g regexp // Manually set the index so as to pick up overlapping matches. // Stop when we get a match that ends at the string end, since no // coercible string can be more right-ward without the same terminus. var next while ((next = re[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length) ) { if (!match || next.index + next[0].length !== match.index + match[0].length) { match = next } re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length } // leave it in a clean state re[t.COERCERTL].lastIndex = -1 } if (match === null) { return null } return parse(match[2] + '.' + (match[3] || '0') + '.' + (match[4] || '0'), options) } /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/main.js": /*!******************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/main.js ***! \******************************************************************/ /*! unknown exports (runtime-defined) */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /*! CommonJS bailout: exports.hasOwnProperty(...) prevents optimization as exports is passed as call context at 7:26-48 */ /*! CommonJS bailout: exports is used directly at 7:53-60 */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ function __export(m) { for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; } Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_jsonrpc_1 = __webpack_require__(/*! vscode-jsonrpc */ "../node_modules/vscode-jsonrpc/lib/main.js"); exports.ErrorCodes = vscode_jsonrpc_1.ErrorCodes; exports.ResponseError = vscode_jsonrpc_1.ResponseError; exports.CancellationToken = vscode_jsonrpc_1.CancellationToken; exports.CancellationTokenSource = vscode_jsonrpc_1.CancellationTokenSource; exports.Disposable = vscode_jsonrpc_1.Disposable; exports.Event = vscode_jsonrpc_1.Event; exports.Emitter = vscode_jsonrpc_1.Emitter; exports.Trace = vscode_jsonrpc_1.Trace; exports.TraceFormat = vscode_jsonrpc_1.TraceFormat; exports.SetTraceNotification = vscode_jsonrpc_1.SetTraceNotification; exports.LogTraceNotification = vscode_jsonrpc_1.LogTraceNotification; exports.RequestType = vscode_jsonrpc_1.RequestType; exports.RequestType0 = vscode_jsonrpc_1.RequestType0; exports.NotificationType = vscode_jsonrpc_1.NotificationType; exports.NotificationType0 = vscode_jsonrpc_1.NotificationType0; exports.MessageReader = vscode_jsonrpc_1.MessageReader; exports.MessageWriter = vscode_jsonrpc_1.MessageWriter; exports.ConnectionStrategy = vscode_jsonrpc_1.ConnectionStrategy; exports.StreamMessageReader = vscode_jsonrpc_1.StreamMessageReader; exports.StreamMessageWriter = vscode_jsonrpc_1.StreamMessageWriter; exports.IPCMessageReader = vscode_jsonrpc_1.IPCMessageReader; exports.IPCMessageWriter = vscode_jsonrpc_1.IPCMessageWriter; exports.createClientPipeTransport = vscode_jsonrpc_1.createClientPipeTransport; exports.createServerPipeTransport = vscode_jsonrpc_1.createServerPipeTransport; exports.generateRandomPipeName = vscode_jsonrpc_1.generateRandomPipeName; exports.createClientSocketTransport = vscode_jsonrpc_1.createClientSocketTransport; exports.createServerSocketTransport = vscode_jsonrpc_1.createServerSocketTransport; exports.ProgressType = vscode_jsonrpc_1.ProgressType; __export(__webpack_require__(/*! vscode-languageserver-types */ "../node_modules/vscode-languageserver-types/lib/esm/main.js")); __export(__webpack_require__(/*! ./protocol */ "../node_modules/vscode-languageserver-protocol/lib/protocol.js")); const callHierarchy = __webpack_require__(/*! ./protocol.callHierarchy.proposed */ "../node_modules/vscode-languageserver-protocol/lib/protocol.callHierarchy.proposed.js"); const st = __webpack_require__(/*! ./protocol.sematicTokens.proposed */ "../node_modules/vscode-languageserver-protocol/lib/protocol.sematicTokens.proposed.js"); var Proposed; (function (Proposed) { let CallHierarchyPrepareRequest; (function (CallHierarchyPrepareRequest) { CallHierarchyPrepareRequest.method = callHierarchy.CallHierarchyPrepareRequest.method; CallHierarchyPrepareRequest.type = callHierarchy.CallHierarchyPrepareRequest.type; })(CallHierarchyPrepareRequest = Proposed.CallHierarchyPrepareRequest || (Proposed.CallHierarchyPrepareRequest = {})); let CallHierarchyIncomingCallsRequest; (function (CallHierarchyIncomingCallsRequest) { CallHierarchyIncomingCallsRequest.method = callHierarchy.CallHierarchyIncomingCallsRequest.method; CallHierarchyIncomingCallsRequest.type = callHierarchy.CallHierarchyIncomingCallsRequest.type; })(CallHierarchyIncomingCallsRequest = Proposed.CallHierarchyIncomingCallsRequest || (Proposed.CallHierarchyIncomingCallsRequest = {})); let CallHierarchyOutgoingCallsRequest; (function (CallHierarchyOutgoingCallsRequest) { CallHierarchyOutgoingCallsRequest.method = callHierarchy.CallHierarchyOutgoingCallsRequest.method; CallHierarchyOutgoingCallsRequest.type = callHierarchy.CallHierarchyOutgoingCallsRequest.type; })(CallHierarchyOutgoingCallsRequest = Proposed.CallHierarchyOutgoingCallsRequest || (Proposed.CallHierarchyOutgoingCallsRequest = {})); Proposed.SemanticTokenTypes = st.SemanticTokenTypes; Proposed.SemanticTokenModifiers = st.SemanticTokenModifiers; Proposed.SemanticTokens = st.SemanticTokens; let SemanticTokensRequest; (function (SemanticTokensRequest) { SemanticTokensRequest.method = st.SemanticTokensRequest.method; SemanticTokensRequest.type = st.SemanticTokensRequest.type; })(SemanticTokensRequest = Proposed.SemanticTokensRequest || (Proposed.SemanticTokensRequest = {})); let SemanticTokensEditsRequest; (function (SemanticTokensEditsRequest) { SemanticTokensEditsRequest.method = st.SemanticTokensEditsRequest.method; SemanticTokensEditsRequest.type = st.SemanticTokensEditsRequest.type; })(SemanticTokensEditsRequest = Proposed.SemanticTokensEditsRequest || (Proposed.SemanticTokensEditsRequest = {})); let SemanticTokensRangeRequest; (function (SemanticTokensRangeRequest) { SemanticTokensRangeRequest.method = st.SemanticTokensRangeRequest.method; SemanticTokensRangeRequest.type = st.SemanticTokensRangeRequest.type; })(SemanticTokensRangeRequest = Proposed.SemanticTokensRangeRequest || (Proposed.SemanticTokensRangeRequest = {})); })(Proposed = exports.Proposed || (exports.Proposed = {})); function createProtocolConnection(reader, writer, logger, strategy) { return vscode_jsonrpc_1.createMessageConnection(reader, writer, logger, strategy); } exports.createProtocolConnection = createProtocolConnection; /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/messages.js": /*!**********************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/messages.js ***! \**********************************************************************/ /*! flagged exports */ /*! export ProtocolNotificationType [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ProtocolNotificationType0 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ProtocolRequestType [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ProtocolRequestType0 [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_jsonrpc_1 = __webpack_require__(/*! vscode-jsonrpc */ "../node_modules/vscode-jsonrpc/lib/main.js"); class ProtocolRequestType0 extends vscode_jsonrpc_1.RequestType0 { constructor(method) { super(method); } } exports.ProtocolRequestType0 = ProtocolRequestType0; class ProtocolRequestType extends vscode_jsonrpc_1.RequestType { constructor(method) { super(method); } } exports.ProtocolRequestType = ProtocolRequestType; class ProtocolNotificationType extends vscode_jsonrpc_1.NotificationType { constructor(method) { super(method); } } exports.ProtocolNotificationType = ProtocolNotificationType; class ProtocolNotificationType0 extends vscode_jsonrpc_1.NotificationType0 { constructor(method) { super(method); } } exports.ProtocolNotificationType0 = ProtocolNotificationType0; /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/protocol.callHierarchy.proposed.js": /*!*********************************************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/protocol.callHierarchy.proposed.js ***! \*********************************************************************************************/ /*! flagged exports */ /*! export CallHierarchyIncomingCallsRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CallHierarchyOutgoingCallsRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CallHierarchyPrepareRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) TypeFox and others. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const messages_1 = __webpack_require__(/*! ./messages */ "../node_modules/vscode-languageserver-protocol/lib/messages.js"); /** * A request to result a `CallHierarchyItem` in a document at a given position. * Can be used as an input to a incoming or outgoing call hierarchy. * * @since 3.16.0 - Proposed state */ var CallHierarchyPrepareRequest; (function (CallHierarchyPrepareRequest) { CallHierarchyPrepareRequest.method = 'textDocument/prepareCallHierarchy'; CallHierarchyPrepareRequest.type = new messages_1.ProtocolRequestType(CallHierarchyPrepareRequest.method); })(CallHierarchyPrepareRequest = exports.CallHierarchyPrepareRequest || (exports.CallHierarchyPrepareRequest = {})); /** * A request to resolve the incoming calls for a given `CallHierarchyItem`. * * @since 3.16.0 - Proposed state */ var CallHierarchyIncomingCallsRequest; (function (CallHierarchyIncomingCallsRequest) { CallHierarchyIncomingCallsRequest.method = 'callHierarchy/incomingCalls'; CallHierarchyIncomingCallsRequest.type = new messages_1.ProtocolRequestType(CallHierarchyIncomingCallsRequest.method); })(CallHierarchyIncomingCallsRequest = exports.CallHierarchyIncomingCallsRequest || (exports.CallHierarchyIncomingCallsRequest = {})); /** * A request to resolve the outgoing calls for a given `CallHierarchyItem`. * * @since 3.16.0 - Proposed state */ var CallHierarchyOutgoingCallsRequest; (function (CallHierarchyOutgoingCallsRequest) { CallHierarchyOutgoingCallsRequest.method = 'callHierarchy/outgoingCalls'; CallHierarchyOutgoingCallsRequest.type = new messages_1.ProtocolRequestType(CallHierarchyOutgoingCallsRequest.method); })(CallHierarchyOutgoingCallsRequest = exports.CallHierarchyOutgoingCallsRequest || (exports.CallHierarchyOutgoingCallsRequest = {})); /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/protocol.colorProvider.js": /*!************************************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/protocol.colorProvider.js ***! \************************************************************************************/ /*! flagged exports */ /*! export ColorPresentationRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentColorRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_jsonrpc_1 = __webpack_require__(/*! vscode-jsonrpc */ "../node_modules/vscode-jsonrpc/lib/main.js"); const messages_1 = __webpack_require__(/*! ./messages */ "../node_modules/vscode-languageserver-protocol/lib/messages.js"); /** * A request to list all color symbols found in a given text document. The request's * parameter is of type [DocumentColorParams](#DocumentColorParams) the * response is of type [ColorInformation[]](#ColorInformation) or a Thenable * that resolves to such. */ var DocumentColorRequest; (function (DocumentColorRequest) { DocumentColorRequest.method = 'textDocument/documentColor'; DocumentColorRequest.type = new messages_1.ProtocolRequestType(DocumentColorRequest.method); /** @deprecated Use DocumentColorRequest.type */ DocumentColorRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(DocumentColorRequest = exports.DocumentColorRequest || (exports.DocumentColorRequest = {})); /** * A request to list all presentation for a color. The request's * parameter is of type [ColorPresentationParams](#ColorPresentationParams) the * response is of type [ColorInformation[]](#ColorInformation) or a Thenable * that resolves to such. */ var ColorPresentationRequest; (function (ColorPresentationRequest) { ColorPresentationRequest.type = new messages_1.ProtocolRequestType('textDocument/colorPresentation'); })(ColorPresentationRequest = exports.ColorPresentationRequest || (exports.ColorPresentationRequest = {})); /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/protocol.configuration.js": /*!************************************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/protocol.configuration.js ***! \************************************************************************************/ /*! flagged exports */ /*! export ConfigurationRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const messages_1 = __webpack_require__(/*! ./messages */ "../node_modules/vscode-languageserver-protocol/lib/messages.js"); /** * The 'workspace/configuration' request is sent from the server to the client to fetch a certain * configuration setting. * * This pull model replaces the old push model were the client signaled configuration change via an * event. If the server still needs to react to configuration changes (since the server caches the * result of `workspace/configuration` requests) the server should register for an empty configuration * change event and empty the cache if such an event is received. */ var ConfigurationRequest; (function (ConfigurationRequest) { ConfigurationRequest.type = new messages_1.ProtocolRequestType('workspace/configuration'); })(ConfigurationRequest = exports.ConfigurationRequest || (exports.ConfigurationRequest = {})); /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/protocol.declaration.js": /*!**********************************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/protocol.declaration.js ***! \**********************************************************************************/ /*! flagged exports */ /*! export DeclarationRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_jsonrpc_1 = __webpack_require__(/*! vscode-jsonrpc */ "../node_modules/vscode-jsonrpc/lib/main.js"); const messages_1 = __webpack_require__(/*! ./messages */ "../node_modules/vscode-languageserver-protocol/lib/messages.js"); // @ts-ignore: to avoid inlining LocatioLink as dynamic import let __noDynamicImport; /** * A request to resolve the type definition locations of a symbol at a given text * document position. The request's parameter is of type [TextDocumentPositioParams] * (#TextDocumentPositionParams) the response is of type [Declaration](#Declaration) * or a typed array of [DeclarationLink](#DeclarationLink) or a Thenable that resolves * to such. */ var DeclarationRequest; (function (DeclarationRequest) { DeclarationRequest.method = 'textDocument/declaration'; DeclarationRequest.type = new messages_1.ProtocolRequestType(DeclarationRequest.method); /** @deprecated Use DeclarationRequest.type */ DeclarationRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(DeclarationRequest = exports.DeclarationRequest || (exports.DeclarationRequest = {})); /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/protocol.foldingRange.js": /*!***********************************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/protocol.foldingRange.js ***! \***********************************************************************************/ /*! flagged exports */ /*! export FoldingRangeKind [provided] [no usage info] [missing usage info prevents renaming] */ /*! export FoldingRangeRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /*--------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_jsonrpc_1 = __webpack_require__(/*! vscode-jsonrpc */ "../node_modules/vscode-jsonrpc/lib/main.js"); const messages_1 = __webpack_require__(/*! ./messages */ "../node_modules/vscode-languageserver-protocol/lib/messages.js"); /** * Enum of known range kinds */ var FoldingRangeKind; (function (FoldingRangeKind) { /** * Folding range for a comment */ FoldingRangeKind["Comment"] = "comment"; /** * Folding range for a imports or includes */ FoldingRangeKind["Imports"] = "imports"; /** * Folding range for a region (e.g. `#region`) */ FoldingRangeKind["Region"] = "region"; })(FoldingRangeKind = exports.FoldingRangeKind || (exports.FoldingRangeKind = {})); /** * A request to provide folding ranges in a document. The request's * parameter is of type [FoldingRangeParams](#FoldingRangeParams), the * response is of type [FoldingRangeList](#FoldingRangeList) or a Thenable * that resolves to such. */ var FoldingRangeRequest; (function (FoldingRangeRequest) { FoldingRangeRequest.method = 'textDocument/foldingRange'; FoldingRangeRequest.type = new messages_1.ProtocolRequestType(FoldingRangeRequest.method); /** @deprecated Use FoldingRangeRequest.type */ FoldingRangeRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(FoldingRangeRequest = exports.FoldingRangeRequest || (exports.FoldingRangeRequest = {})); /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/protocol.implementation.js": /*!*************************************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/protocol.implementation.js ***! \*************************************************************************************/ /*! flagged exports */ /*! export ImplementationRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_jsonrpc_1 = __webpack_require__(/*! vscode-jsonrpc */ "../node_modules/vscode-jsonrpc/lib/main.js"); const messages_1 = __webpack_require__(/*! ./messages */ "../node_modules/vscode-languageserver-protocol/lib/messages.js"); // @ts-ignore: to avoid inlining LocatioLink as dynamic import let __noDynamicImport; /** * A request to resolve the implementation locations of a symbol at a given text * document position. The request's parameter is of type [TextDocumentPositioParams] * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a * Thenable that resolves to such. */ var ImplementationRequest; (function (ImplementationRequest) { ImplementationRequest.method = 'textDocument/implementation'; ImplementationRequest.type = new messages_1.ProtocolRequestType(ImplementationRequest.method); /** @deprecated Use ImplementationRequest.type */ ImplementationRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(ImplementationRequest = exports.ImplementationRequest || (exports.ImplementationRequest = {})); /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/protocol.js": /*!**********************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/protocol.js ***! \**********************************************************************/ /*! flagged exports */ /*! export ApplyWorkspaceEditRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CodeActionRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CodeLensRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CodeLensResolveRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ColorPresentationRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CompletionRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CompletionResolveRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CompletionTriggerKind [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ConfigurationRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DeclarationRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DefinitionRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DidChangeConfigurationNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DidChangeTextDocumentNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DidChangeWatchedFilesNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DidChangeWorkspaceFoldersNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DidCloseTextDocumentNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DidOpenTextDocumentNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DidSaveTextDocumentNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentColorRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentFilter [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentFormattingRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentHighlightRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentLinkRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentLinkResolveRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentOnTypeFormattingRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentRangeFormattingRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentSelector [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentSymbolRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ExecuteCommandRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ExitNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export FailureHandlingKind [provided] [no usage info] [missing usage info prevents renaming] */ /*! export FileChangeType [provided] [no usage info] [missing usage info prevents renaming] */ /*! export FoldingRangeRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export HoverRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ImplementationRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export InitializeError [provided] [no usage info] [missing usage info prevents renaming] */ /*! export InitializeRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export InitializedNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export LogMessageNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export MessageType [provided] [no usage info] [missing usage info prevents renaming] */ /*! export PrepareRenameRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export PublishDiagnosticsNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ReferencesRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RegistrationRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RenameRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ResourceOperationKind [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SelectionRangeRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ShowMessageNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ShowMessageRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ShutdownRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SignatureHelpRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SignatureHelpTriggerKind [provided] [no usage info] [missing usage info prevents renaming] */ /*! export StaticRegistrationOptions [provided] [no usage info] [missing usage info prevents renaming] */ /*! export TelemetryEventNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export TextDocumentRegistrationOptions [provided] [no usage info] [missing usage info prevents renaming] */ /*! export TextDocumentSaveReason [provided] [no usage info] [missing usage info prevents renaming] */ /*! export TextDocumentSyncKind [provided] [no usage info] [missing usage info prevents renaming] */ /*! export TypeDefinitionRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export UnregistrationRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WatchKind [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WillSaveTextDocumentNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WillSaveTextDocumentWaitUntilRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WorkDoneProgress [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WorkDoneProgressCancelNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WorkDoneProgressCreateRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WorkDoneProgressOptions [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WorkspaceFoldersRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WorkspaceSymbolRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const Is = __webpack_require__(/*! ./utils/is */ "../node_modules/vscode-languageserver-protocol/lib/utils/is.js"); const vscode_jsonrpc_1 = __webpack_require__(/*! vscode-jsonrpc */ "../node_modules/vscode-jsonrpc/lib/main.js"); const messages_1 = __webpack_require__(/*! ./messages */ "../node_modules/vscode-languageserver-protocol/lib/messages.js"); const protocol_implementation_1 = __webpack_require__(/*! ./protocol.implementation */ "../node_modules/vscode-languageserver-protocol/lib/protocol.implementation.js"); exports.ImplementationRequest = protocol_implementation_1.ImplementationRequest; const protocol_typeDefinition_1 = __webpack_require__(/*! ./protocol.typeDefinition */ "../node_modules/vscode-languageserver-protocol/lib/protocol.typeDefinition.js"); exports.TypeDefinitionRequest = protocol_typeDefinition_1.TypeDefinitionRequest; const protocol_workspaceFolders_1 = __webpack_require__(/*! ./protocol.workspaceFolders */ "../node_modules/vscode-languageserver-protocol/lib/protocol.workspaceFolders.js"); exports.WorkspaceFoldersRequest = protocol_workspaceFolders_1.WorkspaceFoldersRequest; exports.DidChangeWorkspaceFoldersNotification = protocol_workspaceFolders_1.DidChangeWorkspaceFoldersNotification; const protocol_configuration_1 = __webpack_require__(/*! ./protocol.configuration */ "../node_modules/vscode-languageserver-protocol/lib/protocol.configuration.js"); exports.ConfigurationRequest = protocol_configuration_1.ConfigurationRequest; const protocol_colorProvider_1 = __webpack_require__(/*! ./protocol.colorProvider */ "../node_modules/vscode-languageserver-protocol/lib/protocol.colorProvider.js"); exports.DocumentColorRequest = protocol_colorProvider_1.DocumentColorRequest; exports.ColorPresentationRequest = protocol_colorProvider_1.ColorPresentationRequest; const protocol_foldingRange_1 = __webpack_require__(/*! ./protocol.foldingRange */ "../node_modules/vscode-languageserver-protocol/lib/protocol.foldingRange.js"); exports.FoldingRangeRequest = protocol_foldingRange_1.FoldingRangeRequest; const protocol_declaration_1 = __webpack_require__(/*! ./protocol.declaration */ "../node_modules/vscode-languageserver-protocol/lib/protocol.declaration.js"); exports.DeclarationRequest = protocol_declaration_1.DeclarationRequest; const protocol_selectionRange_1 = __webpack_require__(/*! ./protocol.selectionRange */ "../node_modules/vscode-languageserver-protocol/lib/protocol.selectionRange.js"); exports.SelectionRangeRequest = protocol_selectionRange_1.SelectionRangeRequest; const protocol_progress_1 = __webpack_require__(/*! ./protocol.progress */ "../node_modules/vscode-languageserver-protocol/lib/protocol.progress.js"); exports.WorkDoneProgress = protocol_progress_1.WorkDoneProgress; exports.WorkDoneProgressCreateRequest = protocol_progress_1.WorkDoneProgressCreateRequest; exports.WorkDoneProgressCancelNotification = protocol_progress_1.WorkDoneProgressCancelNotification; // @ts-ignore: to avoid inlining LocatioLink as dynamic import let __noDynamicImport; /** * The DocumentFilter namespace provides helper functions to work with * [DocumentFilter](#DocumentFilter) literals. */ var DocumentFilter; (function (DocumentFilter) { function is(value) { const candidate = value; return Is.string(candidate.language) || Is.string(candidate.scheme) || Is.string(candidate.pattern); } DocumentFilter.is = is; })(DocumentFilter = exports.DocumentFilter || (exports.DocumentFilter = {})); /** * The DocumentSelector namespace provides helper functions to work with * [DocumentSelector](#DocumentSelector)s. */ var DocumentSelector; (function (DocumentSelector) { function is(value) { if (!Array.isArray(value)) { return false; } for (let elem of value) { if (!Is.string(elem) && !DocumentFilter.is(elem)) { return false; } } return true; } DocumentSelector.is = is; })(DocumentSelector = exports.DocumentSelector || (exports.DocumentSelector = {})); /** * The `client/registerCapability` request is sent from the server to the client to register a new capability * handler on the client side. */ var RegistrationRequest; (function (RegistrationRequest) { RegistrationRequest.type = new messages_1.ProtocolRequestType('client/registerCapability'); })(RegistrationRequest = exports.RegistrationRequest || (exports.RegistrationRequest = {})); /** * The `client/unregisterCapability` request is sent from the server to the client to unregister a previously registered capability * handler on the client side. */ var UnregistrationRequest; (function (UnregistrationRequest) { UnregistrationRequest.type = new messages_1.ProtocolRequestType('client/unregisterCapability'); })(UnregistrationRequest = exports.UnregistrationRequest || (exports.UnregistrationRequest = {})); var ResourceOperationKind; (function (ResourceOperationKind) { /** * Supports creating new files and folders. */ ResourceOperationKind.Create = 'create'; /** * Supports renaming existing files and folders. */ ResourceOperationKind.Rename = 'rename'; /** * Supports deleting existing files and folders. */ ResourceOperationKind.Delete = 'delete'; })(ResourceOperationKind = exports.ResourceOperationKind || (exports.ResourceOperationKind = {})); var FailureHandlingKind; (function (FailureHandlingKind) { /** * Applying the workspace change is simply aborted if one of the changes provided * fails. All operations executed before the failing operation stay executed. */ FailureHandlingKind.Abort = 'abort'; /** * All operations are executed transactional. That means they either all * succeed or no changes at all are applied to the workspace. */ FailureHandlingKind.Transactional = 'transactional'; /** * If the workspace edit contains only textual file changes they are executed transactional. * If resource changes (create, rename or delete file) are part of the change the failure * handling startegy is abort. */ FailureHandlingKind.TextOnlyTransactional = 'textOnlyTransactional'; /** * The client tries to undo the operations already executed. But there is no * guarantee that this is succeeding. */ FailureHandlingKind.Undo = 'undo'; })(FailureHandlingKind = exports.FailureHandlingKind || (exports.FailureHandlingKind = {})); /** * The StaticRegistrationOptions namespace provides helper functions to work with * [StaticRegistrationOptions](#StaticRegistrationOptions) literals. */ var StaticRegistrationOptions; (function (StaticRegistrationOptions) { function hasId(value) { const candidate = value; return candidate && Is.string(candidate.id) && candidate.id.length > 0; } StaticRegistrationOptions.hasId = hasId; })(StaticRegistrationOptions = exports.StaticRegistrationOptions || (exports.StaticRegistrationOptions = {})); /** * The TextDocumentRegistrationOptions namespace provides helper functions to work with * [TextDocumentRegistrationOptions](#TextDocumentRegistrationOptions) literals. */ var TextDocumentRegistrationOptions; (function (TextDocumentRegistrationOptions) { function is(value) { const candidate = value; return candidate && (candidate.documentSelector === null || DocumentSelector.is(candidate.documentSelector)); } TextDocumentRegistrationOptions.is = is; })(TextDocumentRegistrationOptions = exports.TextDocumentRegistrationOptions || (exports.TextDocumentRegistrationOptions = {})); /** * The WorkDoneProgressOptions namespace provides helper functions to work with * [WorkDoneProgressOptions](#WorkDoneProgressOptions) literals. */ var WorkDoneProgressOptions; (function (WorkDoneProgressOptions) { function is(value) { const candidate = value; return Is.objectLiteral(candidate) && (candidate.workDoneProgress === undefined || Is.boolean(candidate.workDoneProgress)); } WorkDoneProgressOptions.is = is; function hasWorkDoneProgress(value) { const candidate = value; return candidate && Is.boolean(candidate.workDoneProgress); } WorkDoneProgressOptions.hasWorkDoneProgress = hasWorkDoneProgress; })(WorkDoneProgressOptions = exports.WorkDoneProgressOptions || (exports.WorkDoneProgressOptions = {})); /** * The initialize request is sent from the client to the server. * It is sent once as the request after starting up the server. * The requests parameter is of type [InitializeParams](#InitializeParams) * the response if of type [InitializeResult](#InitializeResult) of a Thenable that * resolves to such. */ var InitializeRequest; (function (InitializeRequest) { InitializeRequest.type = new messages_1.ProtocolRequestType('initialize'); })(InitializeRequest = exports.InitializeRequest || (exports.InitializeRequest = {})); /** * Known error codes for an `InitializeError`; */ var InitializeError; (function (InitializeError) { /** * If the protocol version provided by the client can't be handled by the server. * @deprecated This initialize error got replaced by client capabilities. There is * no version handshake in version 3.0x */ InitializeError.unknownProtocolVersion = 1; })(InitializeError = exports.InitializeError || (exports.InitializeError = {})); /** * The intialized notification is sent from the client to the * server after the client is fully initialized and the server * is allowed to send requests from the server to the client. */ var InitializedNotification; (function (InitializedNotification) { InitializedNotification.type = new messages_1.ProtocolNotificationType('initialized'); })(InitializedNotification = exports.InitializedNotification || (exports.InitializedNotification = {})); //---- Shutdown Method ---- /** * A shutdown request is sent from the client to the server. * It is sent once when the client decides to shutdown the * server. The only notification that is sent after a shutdown request * is the exit event. */ var ShutdownRequest; (function (ShutdownRequest) { ShutdownRequest.type = new messages_1.ProtocolRequestType0('shutdown'); })(ShutdownRequest = exports.ShutdownRequest || (exports.ShutdownRequest = {})); //---- Exit Notification ---- /** * The exit event is sent from the client to the server to * ask the server to exit its process. */ var ExitNotification; (function (ExitNotification) { ExitNotification.type = new messages_1.ProtocolNotificationType0('exit'); })(ExitNotification = exports.ExitNotification || (exports.ExitNotification = {})); /** * The configuration change notification is sent from the client to the server * when the client's configuration has changed. The notification contains * the changed configuration as defined by the language client. */ var DidChangeConfigurationNotification; (function (DidChangeConfigurationNotification) { DidChangeConfigurationNotification.type = new messages_1.ProtocolNotificationType('workspace/didChangeConfiguration'); })(DidChangeConfigurationNotification = exports.DidChangeConfigurationNotification || (exports.DidChangeConfigurationNotification = {})); //---- Message show and log notifications ---- /** * The message type */ var MessageType; (function (MessageType) { /** * An error message. */ MessageType.Error = 1; /** * A warning message. */ MessageType.Warning = 2; /** * An information message. */ MessageType.Info = 3; /** * A log message. */ MessageType.Log = 4; })(MessageType = exports.MessageType || (exports.MessageType = {})); /** * The show message notification is sent from a server to a client to ask * the client to display a particular message in the user interface. */ var ShowMessageNotification; (function (ShowMessageNotification) { ShowMessageNotification.type = new messages_1.ProtocolNotificationType('window/showMessage'); })(ShowMessageNotification = exports.ShowMessageNotification || (exports.ShowMessageNotification = {})); /** * The show message request is sent from the server to the client to show a message * and a set of options actions to the user. */ var ShowMessageRequest; (function (ShowMessageRequest) { ShowMessageRequest.type = new messages_1.ProtocolRequestType('window/showMessageRequest'); })(ShowMessageRequest = exports.ShowMessageRequest || (exports.ShowMessageRequest = {})); /** * The log message notification is sent from the server to the client to ask * the client to log a particular message. */ var LogMessageNotification; (function (LogMessageNotification) { LogMessageNotification.type = new messages_1.ProtocolNotificationType('window/logMessage'); })(LogMessageNotification = exports.LogMessageNotification || (exports.LogMessageNotification = {})); //---- Telemetry notification /** * The telemetry event notification is sent from the server to the client to ask * the client to log telemetry data. */ var TelemetryEventNotification; (function (TelemetryEventNotification) { TelemetryEventNotification.type = new messages_1.ProtocolNotificationType('telemetry/event'); })(TelemetryEventNotification = exports.TelemetryEventNotification || (exports.TelemetryEventNotification = {})); /** * Defines how the host (editor) should sync * document changes to the language server. */ var TextDocumentSyncKind; (function (TextDocumentSyncKind) { /** * Documents should not be synced at all. */ TextDocumentSyncKind.None = 0; /** * Documents are synced by always sending the full content * of the document. */ TextDocumentSyncKind.Full = 1; /** * Documents are synced by sending the full content on open. * After that only incremental updates to the document are * send. */ TextDocumentSyncKind.Incremental = 2; })(TextDocumentSyncKind = exports.TextDocumentSyncKind || (exports.TextDocumentSyncKind = {})); /** * The document open notification is sent from the client to the server to signal * newly opened text documents. The document's truth is now managed by the client * and the server must not try to read the document's truth using the document's * uri. Open in this sense means it is managed by the client. It doesn't necessarily * mean that its content is presented in an editor. An open notification must not * be sent more than once without a corresponding close notification send before. * This means open and close notification must be balanced and the max open count * is one. */ var DidOpenTextDocumentNotification; (function (DidOpenTextDocumentNotification) { DidOpenTextDocumentNotification.method = 'textDocument/didOpen'; DidOpenTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidOpenTextDocumentNotification.method); })(DidOpenTextDocumentNotification = exports.DidOpenTextDocumentNotification || (exports.DidOpenTextDocumentNotification = {})); /** * The document change notification is sent from the client to the server to signal * changes to a text document. */ var DidChangeTextDocumentNotification; (function (DidChangeTextDocumentNotification) { DidChangeTextDocumentNotification.method = 'textDocument/didChange'; DidChangeTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidChangeTextDocumentNotification.method); })(DidChangeTextDocumentNotification = exports.DidChangeTextDocumentNotification || (exports.DidChangeTextDocumentNotification = {})); /** * The document close notification is sent from the client to the server when * the document got closed in the client. The document's truth now exists where * the document's uri points to (e.g. if the document's uri is a file uri the * truth now exists on disk). As with the open notification the close notification * is about managing the document's content. Receiving a close notification * doesn't mean that the document was open in an editor before. A close * notification requires a previous open notification to be sent. */ var DidCloseTextDocumentNotification; (function (DidCloseTextDocumentNotification) { DidCloseTextDocumentNotification.method = 'textDocument/didClose'; DidCloseTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidCloseTextDocumentNotification.method); })(DidCloseTextDocumentNotification = exports.DidCloseTextDocumentNotification || (exports.DidCloseTextDocumentNotification = {})); /** * The document save notification is sent from the client to the server when * the document got saved in the client. */ var DidSaveTextDocumentNotification; (function (DidSaveTextDocumentNotification) { DidSaveTextDocumentNotification.method = 'textDocument/didSave'; DidSaveTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidSaveTextDocumentNotification.method); })(DidSaveTextDocumentNotification = exports.DidSaveTextDocumentNotification || (exports.DidSaveTextDocumentNotification = {})); /** * Represents reasons why a text document is saved. */ var TextDocumentSaveReason; (function (TextDocumentSaveReason) { /** * Manually triggered, e.g. by the user pressing save, by starting debugging, * or by an API call. */ TextDocumentSaveReason.Manual = 1; /** * Automatic after a delay. */ TextDocumentSaveReason.AfterDelay = 2; /** * When the editor lost focus. */ TextDocumentSaveReason.FocusOut = 3; })(TextDocumentSaveReason = exports.TextDocumentSaveReason || (exports.TextDocumentSaveReason = {})); /** * A document will save notification is sent from the client to the server before * the document is actually saved. */ var WillSaveTextDocumentNotification; (function (WillSaveTextDocumentNotification) { WillSaveTextDocumentNotification.method = 'textDocument/willSave'; WillSaveTextDocumentNotification.type = new messages_1.ProtocolNotificationType(WillSaveTextDocumentNotification.method); })(WillSaveTextDocumentNotification = exports.WillSaveTextDocumentNotification || (exports.WillSaveTextDocumentNotification = {})); /** * A document will save request is sent from the client to the server before * the document is actually saved. The request can return an array of TextEdits * which will be applied to the text document before it is saved. Please note that * clients might drop results if computing the text edits took too long or if a * server constantly fails on this request. This is done to keep the save fast and * reliable. */ var WillSaveTextDocumentWaitUntilRequest; (function (WillSaveTextDocumentWaitUntilRequest) { WillSaveTextDocumentWaitUntilRequest.method = 'textDocument/willSaveWaitUntil'; WillSaveTextDocumentWaitUntilRequest.type = new messages_1.ProtocolRequestType(WillSaveTextDocumentWaitUntilRequest.method); })(WillSaveTextDocumentWaitUntilRequest = exports.WillSaveTextDocumentWaitUntilRequest || (exports.WillSaveTextDocumentWaitUntilRequest = {})); /** * The watched files notification is sent from the client to the server when * the client detects changes to file watched by the language client. */ var DidChangeWatchedFilesNotification; (function (DidChangeWatchedFilesNotification) { DidChangeWatchedFilesNotification.type = new messages_1.ProtocolNotificationType('workspace/didChangeWatchedFiles'); })(DidChangeWatchedFilesNotification = exports.DidChangeWatchedFilesNotification || (exports.DidChangeWatchedFilesNotification = {})); /** * The file event type */ var FileChangeType; (function (FileChangeType) { /** * The file got created. */ FileChangeType.Created = 1; /** * The file got changed. */ FileChangeType.Changed = 2; /** * The file got deleted. */ FileChangeType.Deleted = 3; })(FileChangeType = exports.FileChangeType || (exports.FileChangeType = {})); var WatchKind; (function (WatchKind) { /** * Interested in create events. */ WatchKind.Create = 1; /** * Interested in change events */ WatchKind.Change = 2; /** * Interested in delete events */ WatchKind.Delete = 4; })(WatchKind = exports.WatchKind || (exports.WatchKind = {})); /** * Diagnostics notification are sent from the server to the client to signal * results of validation runs. */ var PublishDiagnosticsNotification; (function (PublishDiagnosticsNotification) { PublishDiagnosticsNotification.type = new messages_1.ProtocolNotificationType('textDocument/publishDiagnostics'); })(PublishDiagnosticsNotification = exports.PublishDiagnosticsNotification || (exports.PublishDiagnosticsNotification = {})); /** * How a completion was triggered */ var CompletionTriggerKind; (function (CompletionTriggerKind) { /** * Completion was triggered by typing an identifier (24x7 code * complete), manual invocation (e.g Ctrl+Space) or via API. */ CompletionTriggerKind.Invoked = 1; /** * Completion was triggered by a trigger character specified by * the `triggerCharacters` properties of the `CompletionRegistrationOptions`. */ CompletionTriggerKind.TriggerCharacter = 2; /** * Completion was re-triggered as current completion list is incomplete */ CompletionTriggerKind.TriggerForIncompleteCompletions = 3; })(CompletionTriggerKind = exports.CompletionTriggerKind || (exports.CompletionTriggerKind = {})); /** * Request to request completion at a given text document position. The request's * parameter is of type [TextDocumentPosition](#TextDocumentPosition) the response * is of type [CompletionItem[]](#CompletionItem) or [CompletionList](#CompletionList) * or a Thenable that resolves to such. * * The request can delay the computation of the [`detail`](#CompletionItem.detail) * and [`documentation`](#CompletionItem.documentation) properties to the `completionItem/resolve` * request. However, properties that are needed for the initial sorting and filtering, like `sortText`, * `filterText`, `insertText`, and `textEdit`, must not be changed during resolve. */ var CompletionRequest; (function (CompletionRequest) { CompletionRequest.method = 'textDocument/completion'; CompletionRequest.type = new messages_1.ProtocolRequestType(CompletionRequest.method); /** @deprecated Use CompletionRequest.type */ CompletionRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(CompletionRequest = exports.CompletionRequest || (exports.CompletionRequest = {})); /** * Request to resolve additional information for a given completion item.The request's * parameter is of type [CompletionItem](#CompletionItem) the response * is of type [CompletionItem](#CompletionItem) or a Thenable that resolves to such. */ var CompletionResolveRequest; (function (CompletionResolveRequest) { CompletionResolveRequest.method = 'completionItem/resolve'; CompletionResolveRequest.type = new messages_1.ProtocolRequestType(CompletionResolveRequest.method); })(CompletionResolveRequest = exports.CompletionResolveRequest || (exports.CompletionResolveRequest = {})); /** * Request to request hover information at a given text document position. The request's * parameter is of type [TextDocumentPosition](#TextDocumentPosition) the response is of * type [Hover](#Hover) or a Thenable that resolves to such. */ var HoverRequest; (function (HoverRequest) { HoverRequest.method = 'textDocument/hover'; HoverRequest.type = new messages_1.ProtocolRequestType(HoverRequest.method); })(HoverRequest = exports.HoverRequest || (exports.HoverRequest = {})); /** * How a signature help was triggered. * * @since 3.15.0 */ var SignatureHelpTriggerKind; (function (SignatureHelpTriggerKind) { /** * Signature help was invoked manually by the user or by a command. */ SignatureHelpTriggerKind.Invoked = 1; /** * Signature help was triggered by a trigger character. */ SignatureHelpTriggerKind.TriggerCharacter = 2; /** * Signature help was triggered by the cursor moving or by the document content changing. */ SignatureHelpTriggerKind.ContentChange = 3; })(SignatureHelpTriggerKind = exports.SignatureHelpTriggerKind || (exports.SignatureHelpTriggerKind = {})); var SignatureHelpRequest; (function (SignatureHelpRequest) { SignatureHelpRequest.method = 'textDocument/signatureHelp'; SignatureHelpRequest.type = new messages_1.ProtocolRequestType(SignatureHelpRequest.method); })(SignatureHelpRequest = exports.SignatureHelpRequest || (exports.SignatureHelpRequest = {})); /** * A request to resolve the definition location of a symbol at a given text * document position. The request's parameter is of type [TextDocumentPosition] * (#TextDocumentPosition) the response is of either type [Definition](#Definition) * or a typed array of [DefinitionLink](#DefinitionLink) or a Thenable that resolves * to such. */ var DefinitionRequest; (function (DefinitionRequest) { DefinitionRequest.method = 'textDocument/definition'; DefinitionRequest.type = new messages_1.ProtocolRequestType(DefinitionRequest.method); /** @deprecated Use DefinitionRequest.type */ DefinitionRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(DefinitionRequest = exports.DefinitionRequest || (exports.DefinitionRequest = {})); /** * A request to resolve project-wide references for the symbol denoted * by the given text document position. The request's parameter is of * type [ReferenceParams](#ReferenceParams) the response is of type * [Location[]](#Location) or a Thenable that resolves to such. */ var ReferencesRequest; (function (ReferencesRequest) { ReferencesRequest.method = 'textDocument/references'; ReferencesRequest.type = new messages_1.ProtocolRequestType(ReferencesRequest.method); /** @deprecated Use ReferencesRequest.type */ ReferencesRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(ReferencesRequest = exports.ReferencesRequest || (exports.ReferencesRequest = {})); /** * Request to resolve a [DocumentHighlight](#DocumentHighlight) for a given * text document position. The request's parameter is of type [TextDocumentPosition] * (#TextDocumentPosition) the request response is of type [DocumentHighlight[]] * (#DocumentHighlight) or a Thenable that resolves to such. */ var DocumentHighlightRequest; (function (DocumentHighlightRequest) { DocumentHighlightRequest.method = 'textDocument/documentHighlight'; DocumentHighlightRequest.type = new messages_1.ProtocolRequestType(DocumentHighlightRequest.method); /** @deprecated Use DocumentHighlightRequest.type */ DocumentHighlightRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(DocumentHighlightRequest = exports.DocumentHighlightRequest || (exports.DocumentHighlightRequest = {})); /** * A request to list all symbols found in a given text document. The request's * parameter is of type [TextDocumentIdentifier](#TextDocumentIdentifier) the * response is of type [SymbolInformation[]](#SymbolInformation) or a Thenable * that resolves to such. */ var DocumentSymbolRequest; (function (DocumentSymbolRequest) { DocumentSymbolRequest.method = 'textDocument/documentSymbol'; DocumentSymbolRequest.type = new messages_1.ProtocolRequestType(DocumentSymbolRequest.method); /** @deprecated Use DocumentSymbolRequest.type */ DocumentSymbolRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(DocumentSymbolRequest = exports.DocumentSymbolRequest || (exports.DocumentSymbolRequest = {})); /** * A request to provide commands for the given text document and range. */ var CodeActionRequest; (function (CodeActionRequest) { CodeActionRequest.method = 'textDocument/codeAction'; CodeActionRequest.type = new messages_1.ProtocolRequestType(CodeActionRequest.method); /** @deprecated Use CodeActionRequest.type */ CodeActionRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(CodeActionRequest = exports.CodeActionRequest || (exports.CodeActionRequest = {})); /** * A request to list project-wide symbols matching the query string given * by the [WorkspaceSymbolParams](#WorkspaceSymbolParams). The response is * of type [SymbolInformation[]](#SymbolInformation) or a Thenable that * resolves to such. */ var WorkspaceSymbolRequest; (function (WorkspaceSymbolRequest) { WorkspaceSymbolRequest.method = 'workspace/symbol'; WorkspaceSymbolRequest.type = new messages_1.ProtocolRequestType(WorkspaceSymbolRequest.method); /** @deprecated Use WorkspaceSymbolRequest.type */ WorkspaceSymbolRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(WorkspaceSymbolRequest = exports.WorkspaceSymbolRequest || (exports.WorkspaceSymbolRequest = {})); /** * A request to provide code lens for the given text document. */ var CodeLensRequest; (function (CodeLensRequest) { CodeLensRequest.type = new messages_1.ProtocolRequestType('textDocument/codeLens'); /** @deprecated Use CodeLensRequest.type */ CodeLensRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(CodeLensRequest = exports.CodeLensRequest || (exports.CodeLensRequest = {})); /** * A request to resolve a command for a given code lens. */ var CodeLensResolveRequest; (function (CodeLensResolveRequest) { CodeLensResolveRequest.type = new messages_1.ProtocolRequestType('codeLens/resolve'); })(CodeLensResolveRequest = exports.CodeLensResolveRequest || (exports.CodeLensResolveRequest = {})); /** * A request to provide document links */ var DocumentLinkRequest; (function (DocumentLinkRequest) { DocumentLinkRequest.method = 'textDocument/documentLink'; DocumentLinkRequest.type = new messages_1.ProtocolRequestType(DocumentLinkRequest.method); /** @deprecated Use DocumentLinkRequest.type */ DocumentLinkRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(DocumentLinkRequest = exports.DocumentLinkRequest || (exports.DocumentLinkRequest = {})); /** * Request to resolve additional information for a given document link. The request's * parameter is of type [DocumentLink](#DocumentLink) the response * is of type [DocumentLink](#DocumentLink) or a Thenable that resolves to such. */ var DocumentLinkResolveRequest; (function (DocumentLinkResolveRequest) { DocumentLinkResolveRequest.type = new messages_1.ProtocolRequestType('documentLink/resolve'); })(DocumentLinkResolveRequest = exports.DocumentLinkResolveRequest || (exports.DocumentLinkResolveRequest = {})); /** * A request to to format a whole document. */ var DocumentFormattingRequest; (function (DocumentFormattingRequest) { DocumentFormattingRequest.method = 'textDocument/formatting'; DocumentFormattingRequest.type = new messages_1.ProtocolRequestType(DocumentFormattingRequest.method); })(DocumentFormattingRequest = exports.DocumentFormattingRequest || (exports.DocumentFormattingRequest = {})); /** * A request to to format a range in a document. */ var DocumentRangeFormattingRequest; (function (DocumentRangeFormattingRequest) { DocumentRangeFormattingRequest.method = 'textDocument/rangeFormatting'; DocumentRangeFormattingRequest.type = new messages_1.ProtocolRequestType(DocumentRangeFormattingRequest.method); })(DocumentRangeFormattingRequest = exports.DocumentRangeFormattingRequest || (exports.DocumentRangeFormattingRequest = {})); /** * A request to format a document on type. */ var DocumentOnTypeFormattingRequest; (function (DocumentOnTypeFormattingRequest) { DocumentOnTypeFormattingRequest.method = 'textDocument/onTypeFormatting'; DocumentOnTypeFormattingRequest.type = new messages_1.ProtocolRequestType(DocumentOnTypeFormattingRequest.method); })(DocumentOnTypeFormattingRequest = exports.DocumentOnTypeFormattingRequest || (exports.DocumentOnTypeFormattingRequest = {})); /** * A request to rename a symbol. */ var RenameRequest; (function (RenameRequest) { RenameRequest.method = 'textDocument/rename'; RenameRequest.type = new messages_1.ProtocolRequestType(RenameRequest.method); })(RenameRequest = exports.RenameRequest || (exports.RenameRequest = {})); /** * A request to test and perform the setup necessary for a rename. */ var PrepareRenameRequest; (function (PrepareRenameRequest) { PrepareRenameRequest.method = 'textDocument/prepareRename'; PrepareRenameRequest.type = new messages_1.ProtocolRequestType(PrepareRenameRequest.method); })(PrepareRenameRequest = exports.PrepareRenameRequest || (exports.PrepareRenameRequest = {})); /** * A request send from the client to the server to execute a command. The request might return * a workspace edit which the client will apply to the workspace. */ var ExecuteCommandRequest; (function (ExecuteCommandRequest) { ExecuteCommandRequest.type = new messages_1.ProtocolRequestType('workspace/executeCommand'); })(ExecuteCommandRequest = exports.ExecuteCommandRequest || (exports.ExecuteCommandRequest = {})); /** * A request sent from the server to the client to modified certain resources. */ var ApplyWorkspaceEditRequest; (function (ApplyWorkspaceEditRequest) { ApplyWorkspaceEditRequest.type = new messages_1.ProtocolRequestType('workspace/applyEdit'); })(ApplyWorkspaceEditRequest = exports.ApplyWorkspaceEditRequest || (exports.ApplyWorkspaceEditRequest = {})); /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/protocol.progress.js": /*!*******************************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/protocol.progress.js ***! \*******************************************************************************/ /*! flagged exports */ /*! export WorkDoneProgress [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WorkDoneProgressCancelNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WorkDoneProgressCreateRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_jsonrpc_1 = __webpack_require__(/*! vscode-jsonrpc */ "../node_modules/vscode-jsonrpc/lib/main.js"); const messages_1 = __webpack_require__(/*! ./messages */ "../node_modules/vscode-languageserver-protocol/lib/messages.js"); var WorkDoneProgress; (function (WorkDoneProgress) { WorkDoneProgress.type = new vscode_jsonrpc_1.ProgressType(); })(WorkDoneProgress = exports.WorkDoneProgress || (exports.WorkDoneProgress = {})); /** * The `window/workDoneProgress/create` request is sent from the server to the client to initiate progress * reporting from the server. */ var WorkDoneProgressCreateRequest; (function (WorkDoneProgressCreateRequest) { WorkDoneProgressCreateRequest.type = new messages_1.ProtocolRequestType('window/workDoneProgress/create'); })(WorkDoneProgressCreateRequest = exports.WorkDoneProgressCreateRequest || (exports.WorkDoneProgressCreateRequest = {})); /** * The `window/workDoneProgress/cancel` notification is sent from the client to the server to cancel a progress * initiated on the server side. */ var WorkDoneProgressCancelNotification; (function (WorkDoneProgressCancelNotification) { WorkDoneProgressCancelNotification.type = new messages_1.ProtocolNotificationType('window/workDoneProgress/cancel'); })(WorkDoneProgressCancelNotification = exports.WorkDoneProgressCancelNotification || (exports.WorkDoneProgressCancelNotification = {})); /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/protocol.selectionRange.js": /*!*************************************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/protocol.selectionRange.js ***! \*************************************************************************************/ /*! flagged exports */ /*! export SelectionRangeRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /*--------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_jsonrpc_1 = __webpack_require__(/*! vscode-jsonrpc */ "../node_modules/vscode-jsonrpc/lib/main.js"); const messages_1 = __webpack_require__(/*! ./messages */ "../node_modules/vscode-languageserver-protocol/lib/messages.js"); /** * A request to provide selection ranges in a document. The request's * parameter is of type [SelectionRangeParams](#SelectionRangeParams), the * response is of type [SelectionRange[]](#SelectionRange[]) or a Thenable * that resolves to such. */ var SelectionRangeRequest; (function (SelectionRangeRequest) { SelectionRangeRequest.method = 'textDocument/selectionRange'; SelectionRangeRequest.type = new messages_1.ProtocolRequestType(SelectionRangeRequest.method); /** @deprecated Use SelectionRangeRequest.type */ SelectionRangeRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(SelectionRangeRequest = exports.SelectionRangeRequest || (exports.SelectionRangeRequest = {})); /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/protocol.sematicTokens.proposed.js": /*!*********************************************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/protocol.sematicTokens.proposed.js ***! \*********************************************************************************************/ /*! flagged exports */ /*! export SemanticTokenModifiers [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SemanticTokenTypes [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SemanticTokens [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SemanticTokensEditsRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SemanticTokensRangeRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SemanticTokensRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const messages_1 = __webpack_require__(/*! ./messages */ "../node_modules/vscode-languageserver-protocol/lib/messages.js"); /** * A set of predefined token types. This set is not fixed * an clients can specify additional token types via the * corresponding client capabilities. * * @since 3.16.0 - Proposed state */ var SemanticTokenTypes; (function (SemanticTokenTypes) { SemanticTokenTypes["comment"] = "comment"; SemanticTokenTypes["keyword"] = "keyword"; SemanticTokenTypes["string"] = "string"; SemanticTokenTypes["number"] = "number"; SemanticTokenTypes["regexp"] = "regexp"; SemanticTokenTypes["operator"] = "operator"; SemanticTokenTypes["namespace"] = "namespace"; SemanticTokenTypes["type"] = "type"; SemanticTokenTypes["struct"] = "struct"; SemanticTokenTypes["class"] = "class"; SemanticTokenTypes["interface"] = "interface"; SemanticTokenTypes["enum"] = "enum"; SemanticTokenTypes["typeParameter"] = "typeParameter"; SemanticTokenTypes["function"] = "function"; SemanticTokenTypes["member"] = "member"; SemanticTokenTypes["property"] = "property"; SemanticTokenTypes["macro"] = "macro"; SemanticTokenTypes["variable"] = "variable"; SemanticTokenTypes["parameter"] = "parameter"; SemanticTokenTypes["label"] = "label"; })(SemanticTokenTypes = exports.SemanticTokenTypes || (exports.SemanticTokenTypes = {})); /** * A set of predefined token modifiers. This set is not fixed * an clients can specify additional token types via the * corresponding client capabilities. * * @since 3.16.0 - Proposed state */ var SemanticTokenModifiers; (function (SemanticTokenModifiers) { SemanticTokenModifiers["documentation"] = "documentation"; SemanticTokenModifiers["declaration"] = "declaration"; SemanticTokenModifiers["definition"] = "definition"; SemanticTokenModifiers["reference"] = "reference"; SemanticTokenModifiers["static"] = "static"; SemanticTokenModifiers["abstract"] = "abstract"; SemanticTokenModifiers["deprecated"] = "deprecated"; SemanticTokenModifiers["async"] = "async"; SemanticTokenModifiers["volatile"] = "volatile"; SemanticTokenModifiers["readonly"] = "readonly"; })(SemanticTokenModifiers = exports.SemanticTokenModifiers || (exports.SemanticTokenModifiers = {})); /** * @since 3.16.0 - Proposed state */ var SemanticTokens; (function (SemanticTokens) { function is(value) { const candidate = value; return candidate !== undefined && (candidate.resultId === undefined || typeof candidate.resultId === 'string') && Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === 'number'); } SemanticTokens.is = is; })(SemanticTokens = exports.SemanticTokens || (exports.SemanticTokens = {})); /** * @since 3.16.0 - Proposed state */ var SemanticTokensRequest; (function (SemanticTokensRequest) { SemanticTokensRequest.method = 'textDocument/semanticTokens'; SemanticTokensRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRequest.method); })(SemanticTokensRequest = exports.SemanticTokensRequest || (exports.SemanticTokensRequest = {})); /** * @since 3.16.0 - Proposed state */ var SemanticTokensEditsRequest; (function (SemanticTokensEditsRequest) { SemanticTokensEditsRequest.method = 'textDocument/semanticTokens/edits'; SemanticTokensEditsRequest.type = new messages_1.ProtocolRequestType(SemanticTokensEditsRequest.method); })(SemanticTokensEditsRequest = exports.SemanticTokensEditsRequest || (exports.SemanticTokensEditsRequest = {})); /** * @since 3.16.0 - Proposed state */ var SemanticTokensRangeRequest; (function (SemanticTokensRangeRequest) { SemanticTokensRangeRequest.method = 'textDocument/semanticTokens/range'; SemanticTokensRangeRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest.method); })(SemanticTokensRangeRequest = exports.SemanticTokensRangeRequest || (exports.SemanticTokensRangeRequest = {})); /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/protocol.typeDefinition.js": /*!*************************************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/protocol.typeDefinition.js ***! \*************************************************************************************/ /*! flagged exports */ /*! export TypeDefinitionRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const vscode_jsonrpc_1 = __webpack_require__(/*! vscode-jsonrpc */ "../node_modules/vscode-jsonrpc/lib/main.js"); const messages_1 = __webpack_require__(/*! ./messages */ "../node_modules/vscode-languageserver-protocol/lib/messages.js"); // @ts-ignore: to avoid inlining LocatioLink as dynamic import let __noDynamicImport; /** * A request to resolve the type definition locations of a symbol at a given text * document position. The request's parameter is of type [TextDocumentPositioParams] * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a * Thenable that resolves to such. */ var TypeDefinitionRequest; (function (TypeDefinitionRequest) { TypeDefinitionRequest.method = 'textDocument/typeDefinition'; TypeDefinitionRequest.type = new messages_1.ProtocolRequestType(TypeDefinitionRequest.method); /** @deprecated Use TypeDefinitionRequest.type */ TypeDefinitionRequest.resultType = new vscode_jsonrpc_1.ProgressType(); })(TypeDefinitionRequest = exports.TypeDefinitionRequest || (exports.TypeDefinitionRequest = {})); /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/protocol.workspaceFolders.js": /*!***************************************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/protocol.workspaceFolders.js ***! \***************************************************************************************/ /*! flagged exports */ /*! export DidChangeWorkspaceFoldersNotification [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WorkspaceFoldersRequest [provided] [no usage info] [missing usage info prevents renaming] */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__, __webpack_require__ */ /***/ ((__unused_webpack_module, exports, __webpack_require__) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); const messages_1 = __webpack_require__(/*! ./messages */ "../node_modules/vscode-languageserver-protocol/lib/messages.js"); /** * The `workspace/workspaceFolders` is sent from the server to the client to fetch the open workspace folders. */ var WorkspaceFoldersRequest; (function (WorkspaceFoldersRequest) { WorkspaceFoldersRequest.type = new messages_1.ProtocolRequestType0('workspace/workspaceFolders'); })(WorkspaceFoldersRequest = exports.WorkspaceFoldersRequest || (exports.WorkspaceFoldersRequest = {})); /** * The `workspace/didChangeWorkspaceFolders` notification is sent from the client to the server when the workspace * folder configuration changes. */ var DidChangeWorkspaceFoldersNotification; (function (DidChangeWorkspaceFoldersNotification) { DidChangeWorkspaceFoldersNotification.type = new messages_1.ProtocolNotificationType('workspace/didChangeWorkspaceFolders'); })(DidChangeWorkspaceFoldersNotification = exports.DidChangeWorkspaceFoldersNotification || (exports.DidChangeWorkspaceFoldersNotification = {})); /***/ }), /***/ "../node_modules/vscode-languageserver-protocol/lib/utils/is.js": /*!**********************************************************************!*\ !*** ../node_modules/vscode-languageserver-protocol/lib/utils/is.js ***! \**********************************************************************/ /*! flagged exports */ /*! export __esModule [provided] [no usage info] [missing usage info prevents renaming] */ /*! export array [provided] [no usage info] [missing usage info prevents renaming] */ /*! export boolean [provided] [no usage info] [missing usage info prevents renaming] */ /*! export error [provided] [no usage info] [missing usage info prevents renaming] */ /*! export func [provided] [no usage info] [missing usage info prevents renaming] */ /*! export number [provided] [no usage info] [missing usage info prevents renaming] */ /*! export objectLiteral [provided] [no usage info] [missing usage info prevents renaming] */ /*! export string [provided] [no usage info] [missing usage info prevents renaming] */ /*! export stringArray [provided] [no usage info] [missing usage info prevents renaming] */ /*! export typedArray [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_exports__ */ /***/ ((__unused_webpack_module, exports) => { "use strict"; /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ Object.defineProperty(exports, "__esModule", ({ value: true })); function boolean(value) { return value === true || value === false; } exports.boolean = boolean; function string(value) { return typeof value === 'string' || value instanceof String; } exports.string = string; function number(value) { return typeof value === 'number' || value instanceof Number; } exports.number = number; function error(value) { return value instanceof Error; } exports.error = error; function func(value) { return typeof value === 'function'; } exports.func = func; function array(value) { return Array.isArray(value); } exports.array = array; function stringArray(value) { return array(value) && value.every(elem => string(elem)); } exports.stringArray = stringArray; function typedArray(value, check) { return Array.isArray(value) && value.every(check); } exports.typedArray = typedArray; function objectLiteral(value) { // Strictly speaking class instances pass this check as well. Since the LSP // doesn't use classes we ignore this for now. If we do we need to add something // like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null` return value !== null && typeof value === 'object'; } exports.objectLiteral = objectLiteral; /***/ }), /***/ "../node_modules/vscode-languageserver-types/lib/esm/main.js": /*!*******************************************************************!*\ !*** ../node_modules/vscode-languageserver-types/lib/esm/main.js ***! \*******************************************************************/ /*! namespace exports */ /*! export CodeAction [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CodeActionContext [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CodeActionKind [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CodeLens [provided] [no usage info] [missing usage info prevents renaming] */ /*! export Color [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ColorInformation [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ColorPresentation [provided] [no usage info] [missing usage info prevents renaming] */ /*! export Command [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CompletionItem [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CompletionItemKind [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CompletionItemTag [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CompletionList [provided] [no usage info] [missing usage info prevents renaming] */ /*! export CreateFile [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DeleteFile [provided] [no usage info] [missing usage info prevents renaming] */ /*! export Diagnostic [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DiagnosticRelatedInformation [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DiagnosticSeverity [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DiagnosticTag [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentHighlight [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentHighlightKind [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentLink [provided] [no usage info] [missing usage info prevents renaming] */ /*! export DocumentSymbol [provided] [no usage info] [missing usage info prevents renaming] */ /*! export EOL [provided] [no usage info] [missing usage info prevents renaming] */ /*! export FoldingRange [provided] [no usage info] [missing usage info prevents renaming] */ /*! export FoldingRangeKind [provided] [no usage info] [missing usage info prevents renaming] */ /*! export FormattingOptions [provided] [no usage info] [missing usage info prevents renaming] */ /*! export Hover [provided] [no usage info] [missing usage info prevents renaming] */ /*! export InsertTextFormat [provided] [no usage info] [missing usage info prevents renaming] */ /*! export Location [provided] [no usage info] [missing usage info prevents renaming] */ /*! export LocationLink [provided] [no usage info] [missing usage info prevents renaming] */ /*! export MarkedString [provided] [no usage info] [missing usage info prevents renaming] */ /*! export MarkupContent [provided] [no usage info] [missing usage info prevents renaming] */ /*! export MarkupKind [provided] [no usage info] [missing usage info prevents renaming] */ /*! export ParameterInformation [provided] [no usage info] [missing usage info prevents renaming] */ /*! export Position [provided] [no usage info] [missing usage info prevents renaming] */ /*! export Range [provided] [no usage info] [missing usage info prevents renaming] */ /*! export RenameFile [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SelectionRange [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SignatureInformation [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SymbolInformation [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SymbolKind [provided] [no usage info] [missing usage info prevents renaming] */ /*! export SymbolTag [provided] [no usage info] [missing usage info prevents renaming] */ /*! export TextDocument [provided] [no usage info] [missing usage info prevents renaming] */ /*! export TextDocumentEdit [provided] [no usage info] [missing usage info prevents renaming] */ /*! export TextDocumentIdentifier [provided] [no usage info] [missing usage info prevents renaming] */ /*! export TextDocumentItem [provided] [no usage info] [missing usage info prevents renaming] */ /*! export TextEdit [provided] [no usage info] [missing usage info prevents renaming] */ /*! export VersionedTextDocumentIdentifier [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WorkspaceChange [provided] [no usage info] [missing usage info prevents renaming] */ /*! export WorkspaceEdit [provided] [no usage info] [missing usage info prevents renaming] */ /*! other exports [not provided] [no usage info] */ /*! runtime requirements: __webpack_require__.r, __webpack_exports__, __webpack_require__.d, __webpack_require__.* */ /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { "use strict"; __webpack_require__.r(__webpack_exports__); /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ "Position": () => /* binding */ Position, /* harmony export */ "Range": () => /* binding */ Range, /* harmony export */ "Location": () => /* binding */ Location, /* harmony export */ "LocationLink": () => /* binding */ LocationLink, /* harmony export */ "Color": () => /* binding */ Color, /* harmony export */ "ColorInformation": () => /* binding */ ColorInformation, /* harmony export */ "ColorPresentation": () => /* binding */ ColorPresentation, /* harmony export */ "FoldingRangeKind": () => /* binding */ FoldingRangeKind, /* harmony export */ "FoldingRange": () => /* binding */ FoldingRange, /* harmony export */ "DiagnosticRelatedInformation": () => /* binding */ DiagnosticRelatedInformation, /* harmony export */ "DiagnosticSeverity": () => /* binding */ DiagnosticSeverity, /* harmony export */ "DiagnosticTag": () => /* binding */ DiagnosticTag, /* harmony export */ "Diagnostic": () => /* binding */ Diagnostic, /* harmony export */ "Command": () => /* binding */ Command, /* harmony export */ "TextEdit": () => /* binding */ TextEdit, /* harmony export */ "TextDocumentEdit": () => /* binding */ TextDocumentEdit, /* harmony export */ "CreateFile": () => /* binding */ CreateFile, /* harmony export */ "RenameFile": () => /* binding */ RenameFile, /* harmony export */ "DeleteFile": () => /* binding */ DeleteFile, /* harmony export */ "WorkspaceEdit": () => /* binding */ WorkspaceEdit, /* harmony export */ "WorkspaceChange": () => /* binding */ WorkspaceChange, /* harmony export */ "TextDocumentIdentifier": () => /* binding */ TextDocumentIdentifier, /* harmony export */ "VersionedTextDocumentIdentifier": () => /* binding */ VersionedTextDocumentIdentifier, /* harmony export */ "TextDocumentItem": () => /* binding */ TextDocumentItem, /* harmony export */ "MarkupKind": () => /* binding */ MarkupKind, /* harmony export */ "MarkupContent": () => /* binding */ MarkupContent, /* harmony export */ "CompletionItemKind": () => /* binding */ CompletionItemKind, /* harmony export */ "InsertTextFormat": () => /* binding */ InsertTextFormat, /* harmony export */ "CompletionItemTag": () => /* binding */ CompletionItemTag, /* harmony export */ "CompletionItem": () => /* binding */ CompletionItem, /* harmony export */ "CompletionList": () => /* binding */ CompletionList, /* harmony export */ "MarkedString": () => /* binding */ MarkedString, /* harmony export */ "Hover": () => /* binding */ Hover, /* harmony export */ "ParameterInformation": () => /* binding */ ParameterInformation, /* harmony export */ "SignatureInformation": () => /* binding */ SignatureInformation, /* harmony export */ "DocumentHighlightKind": () => /* binding */ DocumentHighlightKind, /* harmony export */ "DocumentHighlight": () => /* binding */ DocumentHighlight, /* harmony export */ "SymbolKind": () => /* binding */ SymbolKind, /* harmony export */ "SymbolTag": () => /* binding */ SymbolTag, /* harmony export */ "SymbolInformation": () => /* binding */ SymbolInformation, /* harmony export */ "DocumentSymbol": () => /* binding */ DocumentSymbol, /* harmony export */ "CodeActionKind": () => /* binding */ CodeActionKind, /* harmony export */ "CodeActionContext": () => /* binding */ CodeActionContext, /* harmony export */ "CodeAction": () => /* binding */ CodeAction, /* harmony export */ "CodeLens": () => /* binding */ CodeLens, /* harmony export */ "FormattingOptions": () => /* binding */ FormattingOptions, /* harmony export */ "DocumentLink": () => /* binding */ DocumentLink, /* harmony export */ "SelectionRange": () => /* binding */ SelectionRange, /* harmony export */ "EOL": () => /* binding */ EOL, /* harmony export */ "TextDocument": () => /* binding */ TextDocument /* harmony export */ }); /* -------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. * ------------------------------------------------------------------------------------------ */ /** * The Position namespace provides helper functions to work with * [Position](#Position) literals. */ var Position; (function (Position) { /** * Creates a new Position literal from the given line and character. * @param line The position's line. * @param character The position's character. */ function create(line, character) { return { line: line, character: character }; } Position.create = create; /** * Checks whether the given liternal conforms to the [Position](#Position) interface. */ function is(value) { var candidate = value; return Is.objectLiteral(candidate) && Is.number(candidate.line) && Is.number(candidate.character); } Position.is = is; })(Position || (Position = {})); /** * The Range namespace provides helper functions to work with * [Range](#Range) literals. */ var Range; (function (Range) { function create(one, two, three, four) { if (Is.number(one) && Is.number(two) && Is.number(three) && Is.number(four)) { return { start: Position.create(one, two), end: Position.create(three, four) }; } else if (Position.is(one) && Position.is(two)) { return { start: one, end: two }; } else { throw new Error("Range#create called with invalid arguments[" + one + ", " + two + ", " + three + ", " + four + "]"); } } Range.create = create; /** * Checks whether the given literal conforms to the [Range](#Range) interface. */ function is(value) { var candidate = value; return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end); } Range.is = is; })(Range || (Range = {})); /** * The Location namespace provides helper functions to work with * [Location](#Location) literals. */ var Location; (function (Location) { /** * Creates a Location literal. * @param uri The location's uri. * @param range The location's range. */ function create(uri, range) { return { uri: uri, range: range }; } Location.create = create; /** * Checks whether the given literal conforms to the [Location](#Location) interface. */ function is(value) { var candidate = value; return Is.defined(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri)); } Location.is = is; })(Location || (Location = {})); /** * The LocationLink namespace provides helper functions to work with * [LocationLink](#LocationLink) literals. */ var LocationLink; (function (LocationLink) { /** * Creates a LocationLink literal. * @param targetUri The definition's uri. * @param targetRange The full range of the definition. * @param targetSelectionRange The span of the symbol definition at the target. * @param originSelectionRange The span of the symbol being defined in the originating source file. */ function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) { return { targetUri: targetUri, targetRange: targetRange, targetSelectionRange: targetSelectionRange, originSelectionRange: originSelectionRange }; } LocationLink.create = create; /** * Checks whether the given literal conforms to the [LocationLink](#LocationLink) interface. */ function is(value) { var candidate = value; return Is.defined(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri) && (Range.is(candidate.targetSelectionRange) || Is.undefined(candidate.targetSelectionRange)) && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange)); } LocationLink.is = is; })(LocationLink || (LocationLink = {})); /** * The Color namespace provides helper functions to work with * [Color](#Color) literals. */ var Color; (function (Color) { /** * Creates a new Color literal. */ function create(red, green, blue, alpha) { return { red: red, green: green, blue: blue, alpha: alpha, }; } Color.create = create; /** * Checks whether the given literal conforms to the [Color](#Color) interface. */ function is(value) { var candidate = value; return Is.number(candidate.red) && Is.number(candidate.green) && Is.number(candidate.blue) && Is.number(candidate.alpha); } Color.is = is; })(Color || (Color = {})); /** * The ColorInformation namespace provides helper functions to work with * [ColorInformation](#ColorInformation) literals. */ var ColorInformation; (function (ColorInformation) { /** * Creates a new ColorInformation literal. */ function create(range, color) { return { range: range, color: color, }; } ColorInformation.create = create; /** * Checks whether the given literal conforms to the [ColorInformation](#ColorInformation) interface. */ function is(value) { var candidate = value; return Range.is(candidate.range) && Color.is(candidate.color); } ColorInformation.is = is; })(ColorInformation || (ColorInformation = {})); /** * The Color namespace provides helper functions to work with * [ColorPresentation](#ColorPresentation) literals. */ var ColorPresentation; (function (ColorPresentation) { /** * Creates a new ColorInformation literal. */ function create(label, textEdit, additionalTextEdits) { return { label: label, textEdit: textEdit, additionalTextEdits: additionalTextEdits, }; } ColorPresentation.create = create; /** * Checks whether the given literal conforms to the [ColorInformation](#ColorInformation) interface. */ function is(value) { var candidate = value; return Is.string(candidate.label) && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate)) && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is)); } ColorPresentation.is = is; })(ColorPresentation || (ColorPresentation = {})); /** * Enum of known range kinds */ var FoldingRangeKind; (function (FoldingRangeKind) { /** * Folding range for a comment */ FoldingRangeKind["Comment"] = "comment"; /** * Folding range for a imports or includes */ FoldingRangeKind["Imports"] = "imports"; /** * Folding range for a region (e.g. `#region`) */ FoldingRangeKind["Region"] = "region"; })(FoldingRangeKind || (FoldingRangeKind = {})); /** * The folding range namespace provides helper functions to work with * [FoldingRange](#FoldingRange) literals. */ var FoldingRange; (function (FoldingRange) { /** * Creates a new FoldingRange literal. */ function create(startLine, endLine, startCharacter, endCharacter, kind) { var result = { startLine: startLine, endLine: endLine }; if (Is.defined(startCharacter)) { result.startCharacter = startCharacter; } if (Is.defined(endCharacter)) { result.endCharacter = endCharacter; } if (Is.defined(kind)) { result.kind = kind; } return result; } FoldingRange.create = create; /** * Checks whether the given literal conforms to the [FoldingRange](#FoldingRange) interface. */ function is(value) { var candidate = value; return Is.number(candidate.startLine) && Is.number(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.number(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.number(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind)); } FoldingRange.is = is; })(FoldingRange || (FoldingRange = {})); /** * The DiagnosticRelatedInformation namespace provides helper functions to work with * [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) literals. */ var DiagnosticRelatedInformation; (function (DiagnosticRelatedInformation) { /** * Creates a new DiagnosticRelatedInformation literal. */ function create(location, message) { return { location: location, message: message }; } DiagnosticRelatedInformation.create = create; /** * Checks whether the given literal conforms to the [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) interface. */ function is(value) { var candidate = value; return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message); } DiagnosticRelatedInformation.is = is; })(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {})); /** * The diagnostic's severity. */ var DiagnosticSeverity; (function (DiagnosticSeverity) { /** * Reports an error. */ DiagnosticSeverity.Error = 1; /** * Reports a warning. */ DiagnosticSeverity.Warning = 2; /** * Reports an information. */ DiagnosticSeverity.Information = 3; /** * Reports a hint. */ DiagnosticSeverity.Hint = 4; })(DiagnosticSeverity || (DiagnosticSeverity = {})); /** * The diagnostic tags. * * @since 3.15.0 */ var DiagnosticTag; (function (DiagnosticTag) { /** * Unused or unnecessary code. * * Clients are allowed to render diagnostics with this tag faded out instead of having * an error squiggle. */ DiagnosticTag.Unnecessary = 1; /** * Deprecated or obsolete code. * * Clients are allowed to rendered diagnostics with this tag strike through. */ DiagnosticTag.Deprecated = 2; })(DiagnosticTag || (DiagnosticTag = {})); /** * The Diagnostic namespace provides helper functions to work with * [Diagnostic](#Diagnostic) literals. */ var Diagnostic; (function (Diagnostic) { /** * Creates a new Diagnostic literal. */ function create(range, message, severity, code, source, relatedInformation) { var result = { range: range, message: message }; if (Is.defined(severity)) { result.severity = severity; } if (Is.defined(code)) { result.code = code; } if (Is.defined(source)) { result.source = source; } if (Is.defined(relatedInformation)) { result.relatedInformation = relatedInformation; } return result; } Diagnostic.create = create; /** * Checks whether the given literal conforms to the [Diagnostic](#Diagnostic) interface. */ function is(value) { var candidate = value; return Is.defined(candidate) && Range.is(candidate.range) && Is.string(candidate.message) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.number(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is)); } Diagnostic.is = is; })(Diagnostic || (Diagnostic = {})); /** * The Command namespace provides helper functions to work with * [Command](#Command) literals. */ var Command; (function (Command) { /** * Creates a new Command literal. */ function create(title, command) { var args = []; for (var _i = 2; _i < arguments.length; _i++) { args[_i - 2] = arguments[_i]; } var result = { title: title, command: command }; if (Is.defined(args) && args.length > 0) { result.arguments = args; } return result; } Command.create = create; /** * Checks whether the given literal conforms to the [Command](#Command) interface. */ function is(value) { var candidate = value; return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command); } Command.is = is; })(Command || (Command = {})); /** * The TextEdit namespace provides helper function to create replace, * insert and delete edits more easily. */ var TextEdit; (function (TextEdit) { /** * Creates a replace text edit. * @param range The range of text to be replaced. * @param newText The new text. */ function replace(range, newText) { return { range: range, newText: newText }; } TextEdit.replace = replace; /** * Creates a insert text edit. * @param position The position to insert the text at. * @param newText The text to be inserted. */ function insert(position, newText) { return { range: { start: position, end: position }, newText: newText }; } TextEdit.insert = insert; /** * Creates a delete text edit. * @param range The range of text to be deleted. */ function del(range) { return { range: range, newText: '' }; } TextEdit.del = del; function is(value) { var candidate = value; return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range.is(candidate.range); } TextEdit.is = is; })(TextEdit || (TextEdit = {})); /** * The TextDocumentEdit namespace provides helper function to create * an edit that manipulates a text document. */ var TextDocumentEdit; (function (TextDocumentEdit) { /** * Creates a new `TextDocumentEdit` */ function create(textDocument, edits) { return { textDocument: textDocument, edits: edits }; } TextDocumentEdit.create = create; function is(value) { var candidate = value; return Is.defined(candidate) && VersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits); } TextDocumentEdit.is = is; })(TextDocumentEdit || (TextDocumentEdit = {})); var CreateFile; (function (CreateFile) { function create(uri, options) { var result = { kind: 'create', uri: uri }; if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) { result.options = options; } return result; } CreateFile.create = create; function is(value) { var candidate = value; return candidate && candidate.kind === 'create' && Is.string(candidate.uri) && (candidate.options === void 0 || ((candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists)))); } CreateFile.is = is; })(CreateFile || (CreateFile = {})); var RenameFile; (function (RenameFile) { function create(oldUri, newUri, options) { var result = { kind: 'rename', oldUri: oldUri, newUri: newUri }; if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) { result.options = options; } return result; } RenameFile.create = create; function is(value) { var candidate = value; return candidate && candidate.kind === 'rename' && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === void 0 || ((candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists)))); } RenameFile.is = is; })(RenameFile || (RenameFile = {})); var DeleteFile; (function (DeleteFile) { function create(uri, options) { var result = { kind: 'delete', uri: uri }; if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) { result.options = options; } return result; } DeleteFile.create = create; function is(value) { var candidate = value; return candidate && candidate.kind === 'delete' && Is.string(candidate.uri) && (candidate.options === void 0 || ((candidate.options.recursive === void 0 || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is.boolean(candidate.options.ignoreIfNotExists)))); } DeleteFile.is = is; })(DeleteFile || (DeleteFile = {})); var WorkspaceEdit; (function (WorkspaceEdit) { function is(value) { var candidate = value; return candidate && (candidate.changes !== void 0 || candidate.documentChanges !== void 0) && (candidate.documentChanges === void 0 || candidate.documentChanges.every(function (change) { if (Is.string(change.kind)) { return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change); } else { return TextDocumentEdit.is(change); } })); } WorkspaceEdit.is = is; })(WorkspaceEdit || (WorkspaceEdit = {})); var TextEditChangeImpl = /** @class */ (function () { function TextEditChangeImpl(edits) { this.edits = edits; } TextEditChangeImpl.prototype.insert = function (position, newText) { this.edits.push(TextEdit.insert(position, newText)); }; TextEditChangeImpl.prototype.replace = function (range, newText) { this.edits.push(TextEdit.replace(range, newText)); }; TextEditChangeImpl.prototype.delete = function (range) { this.edits.push(TextEdit.del(range)); }; TextEditChangeImpl.prototype.add = function (edit) { this.edits.push(edit); }; TextEditChangeImpl.prototype.all = function () { return this.edits; }; TextEditChangeImpl.prototype.clear = function () { this.edits.splice(0, this.edits.length); }; return TextEditChangeImpl; }()); /** * A workspace change helps constructing changes to a workspace. */ var WorkspaceChange = /** @class */ (function () { function WorkspaceChange(workspaceEdit) { var _this = this; this._textEditChanges = Object.create(null); if (workspaceEdit) { this._workspaceEdit = workspaceEdit; if (workspaceEdit.documentChanges) { workspaceEdit.documentChanges.forEach(function (change) { if (TextDocumentEdit.is(change)) { var textEditChange = new TextEditChangeImpl(change.edits); _this._textEditChanges[change.textDocument.uri] = textEditChange; } }); } else if (workspaceEdit.changes) { Object.keys(workspaceEdit.changes).forEach(function (key) { var textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]); _this._textEditChanges[key] = textEditChange; }); } } } Object.defineProperty(WorkspaceChange.prototype, "edit", { /** * Returns the underlying [WorkspaceEdit](#WorkspaceEdit) literal * use to be returned from a workspace edit operation like rename. */ get: function () { return this._workspaceEdit; }, enumerable: true, configurable: true }); WorkspaceChange.prototype.getTextEditChange = function (key) { if (VersionedTextDocumentIdentifier.is(key)) { if (!this._workspaceEdit) { this._workspaceEdit = { documentChanges: [] }; } if (!this._workspaceEdit.documentChanges) { throw new Error('Workspace edit is not configured for document changes.'); } var textDocument = key; var result = this._textEditChanges[textDocument.uri]; if (!result) { var edits = []; var textDocumentEdit = { textDocument: textDocument, edits: edits }; this._workspaceEdit.documentChanges.push(textDocumentEdit); result = new TextEditChangeImpl(edits); this._textEditChanges[textDocument.uri] = result; } return result; } else { if (!this._workspaceEdit) { this._workspaceEdit = { changes: Object.create(null) }; } if (!this._workspaceEdit.changes) { throw new Error('Workspace edit is not configured for normal text edit changes.'); } var result = this._textEditChanges[key]; if (!result) { var edits = []; this._workspaceEdit.changes[key] = edits; result = new TextEditChangeImpl(edits); this._textEditChanges[key] = result; } return result; } }; WorkspaceChange.prototype.createFile = function (uri, options) { this.checkDocumentChanges(); this._workspaceEdit.documentChanges.push(CreateFile.create(uri, options)); }; WorkspaceChange.prototype.renameFile = function (oldUri, newUri, options) { this.checkDocumentChanges(); this._workspaceEdit.documentChanges.push(RenameFile.create(oldUri, newUri, options)); }; WorkspaceChange.prototype.deleteFile = function (uri, options) { this.checkDocumentChanges(); this._workspaceEdit.documentChanges.push(DeleteFile.create(uri, options)); }; WorkspaceChange.prototype.checkDocumentChanges = function () { if (!this._workspaceEdit || !this._workspaceEdit.documentChanges) { throw new Error('Workspace edit is not configured for document changes.'); } }; return WorkspaceChange; }()); /** * The TextDocumentIdentifier namespace provides helper functions to work with * [TextDocumentIdentifier](#TextDocumentIdentifier) literals. */ var TextDocumentIdentifier; (function (TextDocumentIdentifier) { /** * Creates a new TextDocumentIdentifier literal. * @param uri The document's uri. */ function create(uri) { return { uri: uri }; } TextDocumentIdentifier.create = create; /** * Checks whether the given literal conforms to the [TextDocumentIdentifier](#TextDocumentIdentifier) interface. */ function is(value) { var candidate = value; return Is.defined(candidate) && Is.string(candidate.uri); } TextDocumentIdentifier.is = is; })(TextDocumentIdentifier || (TextDocumentIdentifier = {})); /** * The VersionedTextDocumentIdentifier namespace provides helper functions to work with * [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) literals. */ var VersionedTextDocumentIdentifier; (function (VersionedTextDocumentIdentifier) { /** * Creates a new VersionedTextDocumentIdentifier literal. * @param uri The document's uri. * @param uri The document's text. */ function create(uri, version) { return { uri: uri, version: version }; } VersionedTextDocumentIdentifier.create = create; /** * Checks whether the given literal conforms to the [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) interface. */ function is(value) { var candidate = value; return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.number(candidate.version)); } VersionedTextDocumentIdentifier.is = is; })(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {})); /** * The TextDocumentItem namespace provides helper functions to work with * [TextDocumentItem](#TextDocumentItem) literals. */ var TextDocumentItem; (function (TextDocumentItem) { /** * Creates a new TextDocumentItem literal. * @param uri The document's uri. * @param languageId The document's language identifier. * @param version The document's version number. * @param text The document's text. */ function create(uri, languageId, version, text) { return { uri: uri, languageId: languageId, version: version, text: text }; } TextDocumentItem.create = create; /** * Checks whether the given literal conforms to the [TextDocumentItem](#TextDocumentItem) interface. */ function is(value) { var candidate = value; return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.number(candidate.version) && Is.string(candidate.text); } TextDocumentItem.is = is; })(TextDocumentItem || (TextDocumentItem = {})); /** * Describes the content type that a client supports in various * result literals like `Hover`, `ParameterInfo` or `CompletionItem`. * * Please note that `MarkupKinds` must not start with a `$`. This kinds * are reserved for internal usage. */ var MarkupKind; (function (MarkupKind) { /** * Plain text is supported as a content format */ MarkupKind.PlainText = 'plaintext'; /** * Markdown is supported as a content format */ MarkupKind.Markdown = 'markdown'; })(MarkupKind || (MarkupKind = {})); (function (MarkupKind) { /** * Checks whether the given value is a value of the [MarkupKind](#MarkupKind) type. */ function is(value) { var candidate = value; return candidate === MarkupKind.PlainText || candidate === MarkupKind.Markdown; } MarkupKind.is = is; })(MarkupKind || (MarkupKind = {})); var MarkupContent; (function (MarkupContent) { /** * Checks whether the given value conforms to the [MarkupContent](#MarkupContent) interface. */ function is(value) { var candidate = value; return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value); } MarkupContent.is = is; })(MarkupContent || (MarkupContent = {})); /** * The kind of a completion entry. */ var CompletionItemKind; (function (CompletionItemKind) { CompletionItemKind.Text = 1; CompletionItemKind.Method = 2; CompletionItemKind.Function = 3; CompletionItemKind.Constructor = 4; CompletionItemKind.Field = 5; CompletionItemKind.Variable = 6; CompletionItemKind.Class = 7; CompletionItemKind.Interface = 8; CompletionItemKind.Module = 9; CompletionItemKind.Property = 10; CompletionItemKind.Unit = 11; CompletionItemKind.Value = 12; CompletionItemKind.Enum = 13; CompletionItemKind.Keyword = 14; CompletionItemKind.Snippet = 15; CompletionItemKind.Color = 16; CompletionItemKind.File = 17; CompletionItemKind.Reference = 18; CompletionItemKind.Folder = 19; CompletionItemKind.EnumMember = 20; CompletionItemKind.Constant = 21; CompletionItemKind.Struct = 22; CompletionItemKind.Event = 23; CompletionItemKind.Operator = 24; CompletionItemKind.TypeParameter = 25; })(CompletionItemKind || (CompletionItemKind = {})); /** * Defines whether the insert text in a completion item should be interpreted as * plain text or a snippet. */ var InsertTextFormat; (function (InsertTextFormat) { /** * The primary text to be inserted is treated as a plain string. */ InsertTextFormat.PlainText = 1; /** * The primary text to be inserted is treated as a snippet. * * A snippet can define tab stops and placeholders with `$1`, `$2` * and `${3:foo}`. `$0` defines the final tab stop, it defaults to * the end of the snippet. Placeholders with equal identifiers are linked, * that is typing in one will update others too. * * See also: https://github.com/Microsoft/vscode/blob/master/src/vs/editor/contrib/snippet/common/snippet.md */ InsertTextFormat.Snippet = 2; })(InsertTextFormat || (InsertTextFormat = {})); /** * Completion item tags are extra annotations that tweak the rendering of a completion * item. * * @since 3.15.0 */ var CompletionItemTag; (function (CompletionItemTag) { /** * Render a completion as obsolete, usually using a strike-out. */ CompletionItemTag.Deprecated = 1; })(CompletionItemTag || (CompletionItemTag = {})); /** * The CompletionItem namespace provides functions to deal with * completion items. */ var CompletionItem; (function (CompletionItem) { /** * Create a completion item and seed it with a label. * @param label The completion item's label */ function create(label) { return { label: label }; } CompletionItem.create = create; })(CompletionItem || (CompletionItem = {})); /** * The CompletionList namespace provides functions to deal with * completion lists. */ var CompletionList; (function (CompletionList) { /** * Creates a new completion list. * * @param items The completion items. * @param isIncomplete The list is not complete. */ function create(items, isIncomplete) { return { items: items ? items : [], isIncomplete: !!isIncomplete }; } CompletionList.create = create; })(CompletionList || (CompletionList = {})); var MarkedString; (function (MarkedString) { /** * Creates a marked string from plain text. * * @param plainText The plain text. */ function fromPlainText(plainText) { return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&'); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash } MarkedString.fromPlainText = fromPlainText; /** * Checks whether the given value conforms to the [MarkedString](#MarkedString) type. */ function is(value) { var candidate = value; return Is.string(candidate) || (Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value)); } MarkedString.is = is; })(MarkedString || (MarkedString = {})); var Hover; (function (Hover) { /** * Checks whether the given value conforms to the [Hover](#Hover) interface. */ function is(value) { var candidate = value; return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range.is(value.range)); } Hover.is = is; })(Hover || (Hover = {})); /** * The ParameterInformation namespace provides helper functions to work with * [ParameterInformation](#ParameterInformation) literals. */ var ParameterInformation; (function (ParameterInformation) { /** * Creates a new parameter information literal. * * @param label A label string. * @param documentation A doc string. */ function create(label, documentation) { return documentation ? { label: label, documentation: documentation } : { label: label }; } ParameterInformation.create = create; })(ParameterInformation || (ParameterInformation = {})); /** * The SignatureInformation namespace provides helper functions to work with * [SignatureInformation](#SignatureInformation) literals. */ var SignatureInformation; (function (SignatureInformation) { function create(label, documentation) { var parameters = []; for (var _i = 2; _i < arguments.length; _i++) { parameters[_i - 2] = arguments[_i]; } var result = { label: label }; if (Is.defined(documentation)) { result.documentation = documentation; } if (Is.defined(parameters)) { result.parameters = parameters; } else { result.parameters = []; } return result; } SignatureInformation.create = create; })(SignatureInformation || (SignatureInformation = {})); /** * A document highlight kind. */ var DocumentHighlightKind; (function (DocumentHighlightKind) { /** * A textual occurrence. */ DocumentHighlightKind.Text = 1; /** * Read-access of a symbol, like reading a variable. */ DocumentHighlightKind.Read = 2; /** * Write-access of a symbol, like writing to a variable. */ DocumentHighlightKind.Write = 3; })(DocumentHighlightKind || (DocumentHighlightKind = {})); /** * DocumentHighlight namespace to provide helper functions to work with * [DocumentHighlight](#DocumentHighlight) literals. */ var DocumentHighlight; (function (DocumentHighlight) { /** * Create a DocumentHighlight object. * @param range The range the highlight applies to. */ function create(range, kind) { var result = { range: range }; if (Is.number(kind)) { result.kind = kind; } return result; } DocumentHighlight.create = create; })(DocumentHighlight || (DocumentHighlight = {})); /** * A symbol kind. */ var SymbolKind; (function (SymbolKind) { SymbolKind.File = 1; SymbolKind.Module = 2; SymbolKind.Namespace = 3; SymbolKind.Package = 4; SymbolKind.Class = 5; SymbolKind.Method = 6; SymbolKind.Property = 7; SymbolKind.Field = 8; SymbolKind.Constructor = 9; SymbolKind.Enum = 10; SymbolKind.Interface = 11; SymbolKind.Function = 12; SymbolKind.Variable = 13; SymbolKind.Constant = 14; SymbolKind.String = 15; SymbolKind.Number = 16; SymbolKind.Boolean = 17; SymbolKind.Array = 18; SymbolKind.Object = 19; SymbolKind.Key = 20; SymbolKind.Null = 21; SymbolKind.EnumMember = 22; SymbolKind.Struct = 23; SymbolKind.Event = 24; SymbolKind.Operator = 25; SymbolKind.TypeParameter = 26; })(SymbolKind || (SymbolKind = {})); /** * Symbol tags are extra annotations that tweak the rendering of a symbol. * @since 3.15 */ var SymbolTag; (function (SymbolTag) { /** * Render a symbol as obsolete, usually using a strike-out. */ SymbolTag.Deprecated = 1; })(SymbolTag || (SymbolTag = {})); var SymbolInformation; (function (SymbolInformation) { /** * Creates a new symbol information literal. * * @param name The name of the symbol. * @param kind The kind of the symbol. * @param range The range of the location of the symbol. * @param uri The resource of the location of symbol, defaults to the current document. * @param containerName The name of the symbol containing the symbol. */ function create(name, kind, range, uri, containerName) { var result = { name: name, kind: kind, location: { uri: uri, range: range } }; if (containerName) { result.containerName = containerName; } return result; } SymbolInformation.create = create; })(SymbolInformation || (SymbolInformation = {})); var DocumentSymbol; (function (DocumentSymbol) { /** * Creates a new symbol information literal. * * @param name The name of the symbol. * @param detail The detail of the symbol. * @param kind The kind of the symbol. * @param range The range of the symbol. * @param selectionRange The selectionRange of the symbol. * @param children Children of the symbol. */ function create(name, detail, kind, range, selectionRange, children) { var result = { name: name, detail: detail, kind: kind, range: range, selectionRange: selectionRange }; if (children !== void 0) { result.children = children; } return result; } DocumentSymbol.create = create; /** * Checks whether the given literal conforms to the [DocumentSymbol](#DocumentSymbol) interface. */ function is(value) { var candidate = value; return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range.is(candidate.range) && Range.is(candidate.selectionRange) && (candidate.detail === void 0 || Is.string(candidate.detail)) && (candidate.deprecated === void 0 || Is.boolean(candidate.deprecated)) && (candidate.children === void 0 || Array.isArray(candidate.children)); } DocumentSymbol.is = is; })(DocumentSymbol || (DocumentSymbol = {})); /** * A set of predefined code action kinds */ var CodeActionKind; (function (CodeActionKind) { /** * Empty kind. */ CodeActionKind.Empty = ''; /** * Base kind for quickfix actions: 'quickfix' */ CodeActionKind.QuickFix = 'quickfix'; /** * Base kind for refactoring actions: 'refactor' */ CodeActionKind.Refactor = 'refactor'; /** * Base kind for refactoring extraction actions: 'refactor.extract' * * Example extract actions: * * - Extract method * - Extract function * - Extract variable * - Extract interface from class * - ... */ CodeActionKind.RefactorExtract = 'refactor.extract'; /** * Base kind for refactoring inline actions: 'refactor.inline' * * Example inline actions: * * - Inline function * - Inline variable * - Inline constant * - ... */ CodeActionKind.RefactorInline = 'refactor.inline'; /** * Base kind for refactoring rewrite actions: 'refactor.rewrite' * * Example rewrite actions: * * - Convert JavaScript function to class * - Add or remove parameter * - Encapsulate field * - Make method static * - Move method to base class * - ... */ CodeActionKind.RefactorRewrite = 'refactor.rewrite'; /** * Base kind for source actions: `source` * * Source code actions apply to the entire file. */ CodeActionKind.Source = 'source'; /** * Base kind for an organize imports source action: `source.organizeImports` */ CodeActionKind.SourceOrganizeImports = 'source.organizeImports'; /** * Base kind for auto-fix source actions: `source.fixAll`. * * Fix all actions automatically fix errors that have a clear fix that do not require user input. * They should not suppress errors or perform unsafe fixes such as generating new types or classes. * * @since 3.15.0 */ CodeActionKind.SourceFixAll = 'source.fixAll'; })(CodeActionKind || (CodeActionKind = {})); /** * The CodeActionContext namespace provides helper functions to work with * [CodeActionContext](#CodeActionContext) literals. */ var CodeActionContext; (function (CodeActionContext) { /** * Creates a new CodeActionContext literal. */ function create(diagnostics, only) { var result = { diagnostics: diagnostics }; if (only !== void 0 && only !== null) { result.only = only; } return result; } CodeActionContext.create = create; /** * Checks whether the given literal conforms to the [CodeActionContext](#CodeActionContext) interface. */ function is(value) { var candidate = value; return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string)); } CodeActionContext.is = is; })(CodeActionContext || (CodeActionContext = {})); var CodeAction; (function (CodeAction) { function create(title, commandOrEdit, kind) { var result = { title: title }; if (Command.is(commandOrEdit)) { result.command = commandOrEdit; } else { result.edit = commandOrEdit; } if (kind !== void 0) { result.kind = kind; } return result; } CodeAction.create = create; function is(value) { var candidate = value; return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit.is(candidate.edit)); } CodeAction.is = is; })(CodeAction || (CodeAction = {})); /** * The CodeLens namespace provides helper functions to work with * [CodeLens](#CodeLens) literals. */ var CodeLens; (function (CodeLens) { /** * Creates a new CodeLens literal. */ function create(range, data) { var result = { range: range }; if (Is.defined(data)) { result.data = data; } return result; } CodeLens.create = create; /** * Checks whether the given literal conforms to the [CodeLens](#CodeLens) interface. */ function is(value) { var candidate = value; return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command)); } CodeLens.is = is; })(CodeLens || (CodeLens = {})); /** * The FormattingOptions namespace provides helper functions to work with * [FormattingOptions](#FormattingOptions) literals. */ var FormattingOptions; (function (FormattingOptions) { /** * Creates a new FormattingOptions literal. */ function create(tabSize, insertSpaces) { return { tabSize: tabSize, insertSpaces: insertSpaces }; } FormattingOptions.create = create; /** * Checks whether the given literal conforms to the [FormattingOptions](#FormattingOptions) interface. */ function is(value) { var candidate = value; return Is.defined(candidate) && Is.number(candidate.tabSize) && Is.boolean(candidate.insertSpaces); } FormattingOptions.is = is; })(FormattingOptions || (FormattingOptions = {})); /** * The DocumentLink namespace provides helper functions to work with * [DocumentLink](#DocumentLink) literals. */ var DocumentLink; (function (DocumentLink) { /** * Creates a new DocumentLink literal. */ function create(range, target, data) { return { range: range, target: target, data: data }; } DocumentLink.create = create; /** * Checks whether the given literal conforms to the [DocumentLink](#DocumentLink) interface. */ function is(value) { var candidate = value; return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target)); } DocumentLink.is = is; })(DocumentLink || (DocumentLink = {})); /** * The SelectionRange namespace provides helper function to work with * SelectionRange literals. */ var SelectionRange; (function (SelectionRange) { /** * Creates a new SelectionRange * @param range the range. * @param parent an optional parent. */ function create(range, parent) { return { range: range, parent: parent }; } SelectionRange.create = create; function is(value) { var candidate = value; return candidate !== undefined && Range.is(candidate.range) && (candidate.parent === undefined || SelectionRange.is(candidate.parent)); } SelectionRange.is = is; })(SelectionRange || (SelectionRange = {})); var EOL = ['\n', '\r\n', '\r']; /** * @deprecated Use the text document from the new vscode-languageserver-textdocument package. */ var TextDocument; (function (TextDocument) { /** * Creates a new ITextDocument literal from the given uri and content. * @param uri The document's uri. * @param languageId The document's language Id. * @param content The document's content. */ function create(uri, languageId, version, content) { return new FullTextDocument(uri, languageId, version, content); } TextDocument.create = create; /** * Checks whether the given literal conforms to the [ITextDocument](#ITextDocument) interface. */ function is(value) { var candidate = value; return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.number(candidate.lineCount) && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false; } TextDocument.is = is; function applyEdits(document, edits) { var text = document.getText(); var sortedEdits = mergeSort(edits, function (a, b) { var diff = a.range.start.line - b.range.start.line; if (diff === 0) { return a.range.start.character - b.range.start.character; } return diff; }); var lastModifiedOffset = text.length; for (var i = sortedEdits.length - 1; i >= 0; i--) { var e = sortedEdits[i]; var startOffset = document.offsetAt(e.range.start); var endOffset = document.offsetAt(e.range.end); if (endOffset <= lastModifiedOffset) { text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length); } else { throw new Error('Overlapping edit'); } lastModifiedOffset = startOffset; } return text; } TextDocument.applyEdits = applyEdits; function mergeSort(data, compare) { if (data.length <= 1) { // sorted return data; } var p = (data.length / 2) | 0; var left = data.slice(0, p); var right = data.slice(p); mergeSort(left, compare); mergeSort(right, compare); var leftIdx = 0; var rightIdx = 0; var i = 0; while (leftIdx < left.length && rightIdx < right.length) { var ret = compare(left[leftIdx], right[rightIdx]); if (ret <= 0) { // smaller_equal -> take left to preserve order data[i++] = left[leftIdx++]; } else { // greater -> take right data[i++] = right[rightIdx++]; } } while (leftIdx < left.length) { data[i++] = left[leftIdx++]; } while (rightIdx < right.length) { data[i++] = right[rightIdx++]; } return data; } })(TextDocument || (TextDocument = {})); var FullTextDocument = /** @class */ (function () { function FullTextDocument(uri, languageId, version, content) { this._uri = uri; this._languageId = languageId; this._version = version; this._content = content; this._lineOffsets = undefined; } Object.defineProperty(FullTextDocument.prototype, "uri", { get: function () { return this._uri; }, enumerable: true, configurable: true }); Object.defineProperty(FullTextDocument.prototype, "languageId", { get: function () { return this._languageId; }, enumerable: true, configurable: true }); Object.defineProperty(FullTextDocument.prototype, "version", { get: function () { return this._version; }, enumerable: true, configurable: true }); FullTextDocument.prototype.getText = function (range) { if (range) { var start = this.offsetAt(range.start); var end = this.offsetAt(range.end); return this._content.substring(start, end); } return this._content; }; FullTextDocument.prototype.update = function (event, version) { this._content = event.text; this._version = version; this._lineOffsets = undefined; }; FullTextDocument.prototype.getLineOffsets = function () { if (this._lineOffsets === undefined) { var lineOffsets = []; var text = this._content; var isLineStart = true; for (var i = 0; i < text.length; i++) { if (isLineStart) { lineOffsets.push(i); isLineStart = false; } var ch = text.charAt(i); isLineStart = (ch === '\r' || ch === '\n'); if (ch === '\r' && i + 1 < text.length && text.charAt(i + 1) === '\n') { i++; } } if (isLineStart && text.length > 0) { lineOffsets.push(text.length); } this._lineOffsets = lineOffsets; } return this._lineOffsets; }; FullTextDocument.prototype.positionAt = function (offset) { offset = Math.max(Math.min(offset, this._content.length), 0); var lineOffsets = this.getLineOffsets(); var low = 0, high = lineOffsets.length; if (high === 0) { return Position.create(0, offset); } while (low < high) { var mid = Math.floor((low + high) / 2); if (lineOffsets[mid] > offset) { high = mid; } else { low = mid + 1; } } // low is the least x for which the line offset is larger than the current offset // or array.length if no line offset is larger than the current offset var line = low - 1; return Position.create(line, offset - lineOffsets[line]); }; FullTextDocument.prototype.offsetAt = function (position) { var lineOffsets = this.getLineOffsets(); if (position.line >= lineOffsets.length) { return this._content.length; } else if (position.line < 0) { return 0; } var lineOffset = lineOffsets[position.line]; var nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length; return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset); }; Object.defineProperty(FullTextDocument.prototype, "lineCount", { get: function () { return this.getLineOffsets().length; }, enumerable: true, configurable: true }); return FullTextDocument; }()); var Is; (function (Is) { var toString = Object.prototype.toString; function defined(value) { return typeof value !== 'undefined'; } Is.defined = defined; function undefined(value) { return typeof value === 'undefined'; } Is.undefined = undefined; function boolean(value) { return value === true || value === false; } Is.boolean = boolean; function string(value) { return toString.call(value) === '[object String]'; } Is.string = string; function number(value) { return toString.call(value) === '[object Number]'; } Is.number = number; function func(value) { return toString.call(value) === '[object Function]'; } Is.func = func; function objectLiteral(value) { // Strictly speaking class instances pass this check as well. Since the LSP // doesn't use classes we ignore this for now. If we do we need to add something // like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null` return value !== null && typeof value === 'object'; } Is.objectLiteral = objectLiteral; function typedArray(value, check) { return Array.isArray(value) && value.every(check); } Is.typedArray = typedArray; })(Is || (Is = {})); /***/ }), /***/ "child_process": /*!********************************!*\ !*** external "child_process" ***! \********************************/ /*! dynamic exports */ /*! exports [maybe provided (runtime-defined)] [no usage info] */ /*! runtime requirements: module */ /***/ ((module) => { "use strict"; module.exports = require("child_process");; /***/ }), /***/ "crypto": /*!*************************!*\ !*** external "crypto" ***! \*************************/ /*! dynamic exports */ /*! exports [maybe provided (runtime-defined)] [no usage info] */ /*! runtime requirements: module */ /***/ ((module) => { "use strict"; module.exports = require("crypto");; /***/ }), /***/ "fs": /*!*********************!*\ !*** external "fs" ***! \*********************/ /*! dynamic exports */ /*! exports [maybe provided (runtime-defined)] [no usage info] */ /*! runtime requirements: module */ /***/ ((module) => { "use strict"; module.exports = require("fs");; /***/ }), /***/ "net": /*!**********************!*\ !*** external "net" ***! \**********************/ /*! dynamic exports */ /*! exports [maybe provided (runtime-defined)] [no usage info] */ /*! runtime requirements: module */ /***/ ((module) => { "use strict"; module.exports = require("net");; /***/ }), /***/ "os": /*!*********************!*\ !*** external "os" ***! \*********************/ /*! dynamic exports */ /*! exports [maybe provided (runtime-defined)] [no usage info] */ /*! runtime requirements: module */ /***/ ((module) => { "use strict"; module.exports = require("os");; /***/ }), /***/ "path": /*!***********************!*\ !*** external "path" ***! \***********************/ /*! dynamic exports */ /*! exports [maybe provided (runtime-defined)] [no usage info] */ /*! runtime requirements: module */ /***/ ((module) => { "use strict"; module.exports = require("path");; /***/ }), /***/ "vscode": /*!*************************!*\ !*** external "vscode" ***! \*************************/ /*! dynamic exports */ /*! exports [maybe provided (runtime-defined)] [no usage info] */ /*! runtime requirements: module */ /***/ ((module) => { "use strict"; module.exports = require("vscode");; /***/ }) /******/ }); /************************************************************************/ /******/ // The module cache /******/ var __webpack_module_cache__ = {}; /******/ /******/ // The require function /******/ function __webpack_require__(moduleId) { /******/ // Check if module is in cache /******/ if(__webpack_module_cache__[moduleId]) { /******/ return __webpack_module_cache__[moduleId].exports; /******/ } /******/ // Create a new module (and put it into the cache) /******/ var module = __webpack_module_cache__[moduleId] = { /******/ // no module.id needed /******/ // no module.loaded needed /******/ exports: {} /******/ }; /******/ /******/ // Execute the module function /******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); /******/ /******/ // Return the exports of the module /******/ return module.exports; /******/ } /******/ /************************************************************************/ /******/ /* webpack/runtime/define property getters */ /******/ (() => { /******/ // define getter functions for harmony exports /******/ __webpack_require__.d = (exports, definition) => { /******/ for(var key in definition) { /******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { /******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); /******/ } /******/ } /******/ }; /******/ })(); /******/ /******/ /* webpack/runtime/hasOwnProperty shorthand */ /******/ (() => { /******/ __webpack_require__.o = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop) /******/ })(); /******/ /******/ /* webpack/runtime/make namespace object */ /******/ (() => { /******/ // define __esModule on exports /******/ __webpack_require__.r = (exports) => { /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); /******/ } /******/ Object.defineProperty(exports, '__esModule', { value: true }); /******/ }; /******/ })(); /******/ /************************************************************************/ /******/ // module exports must be returned from runtime so entry inlining is disabled /******/ // startup /******/ // Load entry module and return exports /******/ return __webpack_require__("./src/extension.ts"); /******/ })() ; //# sourceMappingURL=extension.js.map