3955 lines
148 KiB
JavaScript
3955 lines
148 KiB
JavaScript
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
|
|
var __commonJS = (callback, module2) => () => {
|
|
if (!module2) {
|
|
module2 = {exports: {}};
|
|
callback(module2.exports, module2);
|
|
}
|
|
return module2.exports;
|
|
};
|
|
var __export = (target, all) => {
|
|
__markAsModule(target);
|
|
for (var name in all)
|
|
__defProp(target, name, {get: all[name], enumerable: true});
|
|
};
|
|
var __exportStar = (target, module2, desc) => {
|
|
__markAsModule(target);
|
|
if (module2 && typeof module2 === "object" || typeof module2 === "function") {
|
|
for (let key of __getOwnPropNames(module2))
|
|
if (!__hasOwnProp.call(target, key) && key !== "default")
|
|
__defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
|
|
}
|
|
return target;
|
|
};
|
|
var __toModule = (module2) => {
|
|
if (module2 && module2.__esModule)
|
|
return module2;
|
|
return __exportStar(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", {value: module2, enumerable: true}), module2);
|
|
};
|
|
|
|
// node_modules/vscode-jsonrpc/lib/is.js
|
|
var require_is = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
function boolean(value) {
|
|
return value === true || value === false;
|
|
}
|
|
exports2.boolean = boolean;
|
|
function string(value) {
|
|
return typeof value === "string" || value instanceof String;
|
|
}
|
|
exports2.string = string;
|
|
function number(value) {
|
|
return typeof value === "number" || value instanceof Number;
|
|
}
|
|
exports2.number = number;
|
|
function error(value) {
|
|
return value instanceof Error;
|
|
}
|
|
exports2.error = error;
|
|
function func(value) {
|
|
return typeof value === "function";
|
|
}
|
|
exports2.func = func;
|
|
function array(value) {
|
|
return Array.isArray(value);
|
|
}
|
|
exports2.array = array;
|
|
function stringArray(value) {
|
|
return array(value) && value.every((elem) => string(elem));
|
|
}
|
|
exports2.stringArray = stringArray;
|
|
});
|
|
|
|
// node_modules/vscode-jsonrpc/lib/messages.js
|
|
var require_messages = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var is = require_is();
|
|
var ErrorCodes;
|
|
(function(ErrorCodes2) {
|
|
ErrorCodes2.ParseError = -32700;
|
|
ErrorCodes2.InvalidRequest = -32600;
|
|
ErrorCodes2.MethodNotFound = -32601;
|
|
ErrorCodes2.InvalidParams = -32602;
|
|
ErrorCodes2.InternalError = -32603;
|
|
ErrorCodes2.serverErrorStart = -32099;
|
|
ErrorCodes2.serverErrorEnd = -32e3;
|
|
ErrorCodes2.ServerNotInitialized = -32002;
|
|
ErrorCodes2.UnknownErrorCode = -32001;
|
|
ErrorCodes2.RequestCancelled = -32800;
|
|
ErrorCodes2.ContentModified = -32801;
|
|
ErrorCodes2.MessageWriteError = 1;
|
|
ErrorCodes2.MessageReadError = 2;
|
|
})(ErrorCodes = exports2.ErrorCodes || (exports2.ErrorCodes = {}));
|
|
var ResponseError = class 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
|
|
};
|
|
}
|
|
};
|
|
exports2.ResponseError = ResponseError;
|
|
var AbstractMessageType = class {
|
|
constructor(_method, _numberOfParams) {
|
|
this._method = _method;
|
|
this._numberOfParams = _numberOfParams;
|
|
}
|
|
get method() {
|
|
return this._method;
|
|
}
|
|
get numberOfParams() {
|
|
return this._numberOfParams;
|
|
}
|
|
};
|
|
exports2.AbstractMessageType = AbstractMessageType;
|
|
var RequestType0 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 0);
|
|
}
|
|
};
|
|
exports2.RequestType0 = RequestType0;
|
|
var RequestType = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 1);
|
|
}
|
|
};
|
|
exports2.RequestType = RequestType;
|
|
var RequestType1 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 1);
|
|
}
|
|
};
|
|
exports2.RequestType1 = RequestType1;
|
|
var RequestType2 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 2);
|
|
}
|
|
};
|
|
exports2.RequestType2 = RequestType2;
|
|
var RequestType3 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 3);
|
|
}
|
|
};
|
|
exports2.RequestType3 = RequestType3;
|
|
var RequestType4 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 4);
|
|
}
|
|
};
|
|
exports2.RequestType4 = RequestType4;
|
|
var RequestType5 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 5);
|
|
}
|
|
};
|
|
exports2.RequestType5 = RequestType5;
|
|
var RequestType6 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 6);
|
|
}
|
|
};
|
|
exports2.RequestType6 = RequestType6;
|
|
var RequestType7 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 7);
|
|
}
|
|
};
|
|
exports2.RequestType7 = RequestType7;
|
|
var RequestType8 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 8);
|
|
}
|
|
};
|
|
exports2.RequestType8 = RequestType8;
|
|
var RequestType9 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 9);
|
|
}
|
|
};
|
|
exports2.RequestType9 = RequestType9;
|
|
var NotificationType = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 1);
|
|
this._ = void 0;
|
|
}
|
|
};
|
|
exports2.NotificationType = NotificationType;
|
|
var NotificationType0 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 0);
|
|
}
|
|
};
|
|
exports2.NotificationType0 = NotificationType0;
|
|
var NotificationType1 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 1);
|
|
}
|
|
};
|
|
exports2.NotificationType1 = NotificationType1;
|
|
var NotificationType2 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 2);
|
|
}
|
|
};
|
|
exports2.NotificationType2 = NotificationType2;
|
|
var NotificationType3 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 3);
|
|
}
|
|
};
|
|
exports2.NotificationType3 = NotificationType3;
|
|
var NotificationType4 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 4);
|
|
}
|
|
};
|
|
exports2.NotificationType4 = NotificationType4;
|
|
var NotificationType5 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 5);
|
|
}
|
|
};
|
|
exports2.NotificationType5 = NotificationType5;
|
|
var NotificationType6 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 6);
|
|
}
|
|
};
|
|
exports2.NotificationType6 = NotificationType6;
|
|
var NotificationType7 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 7);
|
|
}
|
|
};
|
|
exports2.NotificationType7 = NotificationType7;
|
|
var NotificationType8 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 8);
|
|
}
|
|
};
|
|
exports2.NotificationType8 = NotificationType8;
|
|
var NotificationType9 = class extends AbstractMessageType {
|
|
constructor(method) {
|
|
super(method, 9);
|
|
}
|
|
};
|
|
exports2.NotificationType9 = NotificationType9;
|
|
function isRequestMessage(message) {
|
|
let candidate = message;
|
|
return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));
|
|
}
|
|
exports2.isRequestMessage = isRequestMessage;
|
|
function isNotificationMessage(message) {
|
|
let candidate = message;
|
|
return candidate && is.string(candidate.method) && message.id === void 0;
|
|
}
|
|
exports2.isNotificationMessage = isNotificationMessage;
|
|
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);
|
|
}
|
|
exports2.isResponseMessage = isResponseMessage;
|
|
});
|
|
|
|
// node_modules/vscode-jsonrpc/lib/events.js
|
|
var require_events = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var Disposable;
|
|
(function(Disposable2) {
|
|
function create(func) {
|
|
return {
|
|
dispose: func
|
|
};
|
|
}
|
|
Disposable2.create = create;
|
|
})(Disposable = exports2.Disposable || (exports2.Disposable = {}));
|
|
var Event;
|
|
(function(Event2) {
|
|
const _disposable = {dispose() {
|
|
}};
|
|
Event2.None = function() {
|
|
return _disposable;
|
|
};
|
|
})(Event = exports2.Event || (exports2.Event = {}));
|
|
var CallbackList = class {
|
|
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) {
|
|
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) {
|
|
console.error(e);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
isEmpty() {
|
|
return !this._callbacks || this._callbacks.length === 0;
|
|
}
|
|
dispose() {
|
|
this._callbacks = void 0;
|
|
this._contexts = void 0;
|
|
}
|
|
};
|
|
var Emitter = class {
|
|
constructor(_options) {
|
|
this._options = _options;
|
|
}
|
|
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;
|
|
}
|
|
fire(event) {
|
|
if (this._callbacks) {
|
|
this._callbacks.invoke.call(this._callbacks, event);
|
|
}
|
|
}
|
|
dispose() {
|
|
if (this._callbacks) {
|
|
this._callbacks.dispose();
|
|
this._callbacks = void 0;
|
|
}
|
|
}
|
|
};
|
|
exports2.Emitter = Emitter;
|
|
Emitter._noop = function() {
|
|
};
|
|
});
|
|
|
|
// node_modules/vscode-jsonrpc/lib/messageReader.js
|
|
var require_messageReader = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var events_1 = require_events();
|
|
var Is = require_is();
|
|
var DefaultSize = 8192;
|
|
var CR = Buffer.from("\r", "ascii")[0];
|
|
var LF = Buffer.from("\n", "ascii")[0];
|
|
var CRLF = "\r\n";
|
|
var MessageBuffer = class {
|
|
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 = void 0;
|
|
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++;
|
|
}
|
|
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(MessageReader2) {
|
|
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);
|
|
}
|
|
MessageReader2.is = is;
|
|
})(MessageReader = exports2.MessageReader || (exports2.MessageReader = {}));
|
|
var AbstractMessageReader = class {
|
|
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(void 0);
|
|
}
|
|
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"}`);
|
|
}
|
|
}
|
|
};
|
|
exports2.AbstractMessageReader = AbstractMessageReader;
|
|
var StreamMessageReader = class extends AbstractMessageReader {
|
|
constructor(readable, encoding = "utf8") {
|
|
super();
|
|
this.readable = readable;
|
|
this.buffer = new MessageBuffer(encoding);
|
|
this._partialMessageTimeout = 1e4;
|
|
}
|
|
set partialMessageTimeout(timeout) {
|
|
this._partialMessageTimeout = timeout;
|
|
}
|
|
get partialMessageTimeout() {
|
|
return this._partialMessageTimeout;
|
|
}
|
|
listen(callback) {
|
|
this.nextMessageLength = -1;
|
|
this.messageToken = 0;
|
|
this.partialMessageTimer = void 0;
|
|
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;
|
|
}
|
|
var msg = this.buffer.tryReadContent(this.nextMessageLength);
|
|
if (msg === null) {
|
|
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 = void 0;
|
|
}
|
|
}
|
|
setPartialMessageTimer() {
|
|
this.clearPartialMessageTimer();
|
|
if (this._partialMessageTimeout <= 0) {
|
|
return;
|
|
}
|
|
this.partialMessageTimer = setTimeout((token, timeout) => {
|
|
this.partialMessageTimer = void 0;
|
|
if (token === this.messageToken) {
|
|
this.firePartialMessage({messageToken: token, waitingTime: timeout});
|
|
this.setPartialMessageTimer();
|
|
}
|
|
}, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
|
|
}
|
|
};
|
|
exports2.StreamMessageReader = StreamMessageReader;
|
|
var IPCMessageReader = class extends AbstractMessageReader {
|
|
constructor(process2) {
|
|
super();
|
|
this.process = process2;
|
|
let eventEmitter = this.process;
|
|
eventEmitter.on("error", (error) => this.fireError(error));
|
|
eventEmitter.on("close", () => this.fireClose());
|
|
}
|
|
listen(callback) {
|
|
this.process.on("message", callback);
|
|
}
|
|
};
|
|
exports2.IPCMessageReader = IPCMessageReader;
|
|
var SocketMessageReader = class extends StreamMessageReader {
|
|
constructor(socket, encoding = "utf-8") {
|
|
super(socket, encoding);
|
|
}
|
|
};
|
|
exports2.SocketMessageReader = SocketMessageReader;
|
|
});
|
|
|
|
// node_modules/vscode-jsonrpc/lib/messageWriter.js
|
|
var require_messageWriter = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var events_1 = require_events();
|
|
var Is = require_is();
|
|
var ContentLength = "Content-Length: ";
|
|
var CRLF = "\r\n";
|
|
var MessageWriter;
|
|
(function(MessageWriter2) {
|
|
function is(value) {
|
|
let candidate = value;
|
|
return candidate && Is.func(candidate.dispose) && Is.func(candidate.onClose) && Is.func(candidate.onError) && Is.func(candidate.write);
|
|
}
|
|
MessageWriter2.is = is;
|
|
})(MessageWriter = exports2.MessageWriter || (exports2.MessageWriter = {}));
|
|
var AbstractMessageWriter = class {
|
|
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(void 0);
|
|
}
|
|
asError(error) {
|
|
if (error instanceof Error) {
|
|
return error;
|
|
} else {
|
|
return new Error(`Writer received error. Reason: ${Is.string(error.message) ? error.message : "unknown"}`);
|
|
}
|
|
}
|
|
};
|
|
exports2.AbstractMessageWriter = AbstractMessageWriter;
|
|
var StreamMessageWriter = class 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 {
|
|
this.writable.write(headers.join(""), "ascii");
|
|
this.writable.write(json, this.encoding);
|
|
this.errorCount = 0;
|
|
} catch (error) {
|
|
this.errorCount++;
|
|
this.fireError(error, msg, this.errorCount);
|
|
}
|
|
}
|
|
};
|
|
exports2.StreamMessageWriter = StreamMessageWriter;
|
|
var IPCMessageWriter = class extends AbstractMessageWriter {
|
|
constructor(process2) {
|
|
super();
|
|
this.process = process2;
|
|
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) {
|
|
this.doWriteMessage(msg);
|
|
} else {
|
|
this.queue.push(msg);
|
|
}
|
|
}
|
|
doWriteMessage(msg) {
|
|
try {
|
|
if (this.process.send) {
|
|
this.sending = true;
|
|
this.process.send(msg, void 0, void 0, (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);
|
|
}
|
|
}
|
|
};
|
|
exports2.IPCMessageWriter = IPCMessageWriter;
|
|
var SocketMessageWriter = class 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) {
|
|
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 {
|
|
this.sending = true;
|
|
this.socket.write(headers.join(""), "ascii", (error) => {
|
|
if (error) {
|
|
this.handleError(error, msg);
|
|
}
|
|
try {
|
|
this.socket.write(json, this.encoding, (error2) => {
|
|
this.sending = false;
|
|
if (error2) {
|
|
this.handleError(error2, msg);
|
|
} else {
|
|
this.errorCount = 0;
|
|
}
|
|
if (this.queue.length > 0) {
|
|
this.doWriteMessage(this.queue.shift());
|
|
}
|
|
});
|
|
} catch (error2) {
|
|
this.handleError(error2, msg);
|
|
}
|
|
});
|
|
} catch (error) {
|
|
this.handleError(error, msg);
|
|
}
|
|
}
|
|
handleError(error, msg) {
|
|
this.errorCount++;
|
|
this.fireError(error, msg, this.errorCount);
|
|
}
|
|
};
|
|
exports2.SocketMessageWriter = SocketMessageWriter;
|
|
});
|
|
|
|
// node_modules/vscode-jsonrpc/lib/cancellation.js
|
|
var require_cancellation = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var events_1 = require_events();
|
|
var Is = require_is();
|
|
var CancellationToken2;
|
|
(function(CancellationToken3) {
|
|
CancellationToken3.None = Object.freeze({
|
|
isCancellationRequested: false,
|
|
onCancellationRequested: events_1.Event.None
|
|
});
|
|
CancellationToken3.Cancelled = Object.freeze({
|
|
isCancellationRequested: true,
|
|
onCancellationRequested: events_1.Event.None
|
|
});
|
|
function is(value) {
|
|
let candidate = value;
|
|
return candidate && (candidate === CancellationToken3.None || candidate === CancellationToken3.Cancelled || Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested);
|
|
}
|
|
CancellationToken3.is = is;
|
|
})(CancellationToken2 = exports2.CancellationToken || (exports2.CancellationToken = {}));
|
|
var shortcutEvent = Object.freeze(function(callback, context) {
|
|
let handle = setTimeout(callback.bind(context), 0);
|
|
return {dispose() {
|
|
clearTimeout(handle);
|
|
}};
|
|
});
|
|
var MutableToken = class {
|
|
constructor() {
|
|
this._isCancelled = false;
|
|
}
|
|
cancel() {
|
|
if (!this._isCancelled) {
|
|
this._isCancelled = true;
|
|
if (this._emitter) {
|
|
this._emitter.fire(void 0);
|
|
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 = void 0;
|
|
}
|
|
}
|
|
};
|
|
var CancellationTokenSource = class {
|
|
get token() {
|
|
if (!this._token) {
|
|
this._token = new MutableToken();
|
|
}
|
|
return this._token;
|
|
}
|
|
cancel() {
|
|
if (!this._token) {
|
|
this._token = CancellationToken2.Cancelled;
|
|
} else {
|
|
this._token.cancel();
|
|
}
|
|
}
|
|
dispose() {
|
|
if (!this._token) {
|
|
this._token = CancellationToken2.None;
|
|
} else if (this._token instanceof MutableToken) {
|
|
this._token.dispose();
|
|
}
|
|
}
|
|
};
|
|
exports2.CancellationTokenSource = CancellationTokenSource;
|
|
});
|
|
|
|
// node_modules/vscode-jsonrpc/lib/linkedMap.js
|
|
var require_linkedMap = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var Touch;
|
|
(function(Touch2) {
|
|
Touch2.None = 0;
|
|
Touch2.First = 1;
|
|
Touch2.Last = 2;
|
|
})(Touch = exports2.Touch || (exports2.Touch = {}));
|
|
var LinkedMap = class {
|
|
constructor() {
|
|
this._map = new Map();
|
|
this._head = void 0;
|
|
this._tail = void 0;
|
|
this._size = 0;
|
|
}
|
|
clear() {
|
|
this._map.clear();
|
|
this._head = void 0;
|
|
this._tail = void 0;
|
|
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 void 0;
|
|
}
|
|
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: void 0, previous: void 0};
|
|
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 void 0;
|
|
}
|
|
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;
|
|
}
|
|
addItemFirst(item) {
|
|
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) {
|
|
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 = void 0;
|
|
this._tail = void 0;
|
|
} 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;
|
|
if (item === this._tail) {
|
|
previous.next = void 0;
|
|
this._tail = previous;
|
|
} else {
|
|
next.previous = previous;
|
|
previous.next = next;
|
|
}
|
|
item.previous = void 0;
|
|
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;
|
|
if (item === this._head) {
|
|
next.previous = void 0;
|
|
this._head = next;
|
|
} else {
|
|
next.previous = previous;
|
|
previous.next = next;
|
|
}
|
|
item.next = void 0;
|
|
item.previous = this._tail;
|
|
this._tail.next = item;
|
|
this._tail = item;
|
|
}
|
|
}
|
|
};
|
|
exports2.LinkedMap = LinkedMap;
|
|
});
|
|
|
|
// node_modules/vscode-jsonrpc/lib/pipeSupport.js
|
|
var require_pipeSupport = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var path_1 = require("path");
|
|
var os_1 = require("os");
|
|
var crypto_1 = require("crypto");
|
|
var net_1 = require("net");
|
|
var messageReader_1 = require_messageReader();
|
|
var messageWriter_1 = require_messageWriter();
|
|
function generateRandomPipeName() {
|
|
const randomSuffix = crypto_1.randomBytes(21).toString("hex");
|
|
if (process.platform === "win32") {
|
|
return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`;
|
|
} else {
|
|
return path_1.join(os_1.tmpdir(), `vscode-${randomSuffix}.sock`);
|
|
}
|
|
}
|
|
exports2.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;
|
|
}
|
|
});
|
|
});
|
|
});
|
|
}
|
|
exports2.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)
|
|
];
|
|
}
|
|
exports2.createServerPipeTransport = createServerPipeTransport;
|
|
});
|
|
|
|
// node_modules/vscode-jsonrpc/lib/socketSupport.js
|
|
var require_socketSupport = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var net_1 = require("net");
|
|
var messageReader_1 = require_messageReader();
|
|
var messageWriter_1 = require_messageWriter();
|
|
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;
|
|
}
|
|
});
|
|
});
|
|
});
|
|
}
|
|
exports2.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)
|
|
];
|
|
}
|
|
exports2.createServerSocketTransport = createServerSocketTransport;
|
|
});
|
|
|
|
// node_modules/vscode-jsonrpc/lib/main.js
|
|
var require_main = __commonJS((exports2) => {
|
|
"use strict";
|
|
function __export2(m) {
|
|
for (var p in m)
|
|
if (!exports2.hasOwnProperty(p))
|
|
exports2[p] = m[p];
|
|
}
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var Is = require_is();
|
|
var messages_1 = require_messages();
|
|
exports2.RequestType = messages_1.RequestType;
|
|
exports2.RequestType0 = messages_1.RequestType0;
|
|
exports2.RequestType1 = messages_1.RequestType1;
|
|
exports2.RequestType2 = messages_1.RequestType2;
|
|
exports2.RequestType3 = messages_1.RequestType3;
|
|
exports2.RequestType4 = messages_1.RequestType4;
|
|
exports2.RequestType5 = messages_1.RequestType5;
|
|
exports2.RequestType6 = messages_1.RequestType6;
|
|
exports2.RequestType7 = messages_1.RequestType7;
|
|
exports2.RequestType8 = messages_1.RequestType8;
|
|
exports2.RequestType9 = messages_1.RequestType9;
|
|
exports2.ResponseError = messages_1.ResponseError;
|
|
exports2.ErrorCodes = messages_1.ErrorCodes;
|
|
exports2.NotificationType = messages_1.NotificationType;
|
|
exports2.NotificationType0 = messages_1.NotificationType0;
|
|
exports2.NotificationType1 = messages_1.NotificationType1;
|
|
exports2.NotificationType2 = messages_1.NotificationType2;
|
|
exports2.NotificationType3 = messages_1.NotificationType3;
|
|
exports2.NotificationType4 = messages_1.NotificationType4;
|
|
exports2.NotificationType5 = messages_1.NotificationType5;
|
|
exports2.NotificationType6 = messages_1.NotificationType6;
|
|
exports2.NotificationType7 = messages_1.NotificationType7;
|
|
exports2.NotificationType8 = messages_1.NotificationType8;
|
|
exports2.NotificationType9 = messages_1.NotificationType9;
|
|
var messageReader_1 = require_messageReader();
|
|
exports2.MessageReader = messageReader_1.MessageReader;
|
|
exports2.StreamMessageReader = messageReader_1.StreamMessageReader;
|
|
exports2.IPCMessageReader = messageReader_1.IPCMessageReader;
|
|
exports2.SocketMessageReader = messageReader_1.SocketMessageReader;
|
|
var messageWriter_1 = require_messageWriter();
|
|
exports2.MessageWriter = messageWriter_1.MessageWriter;
|
|
exports2.StreamMessageWriter = messageWriter_1.StreamMessageWriter;
|
|
exports2.IPCMessageWriter = messageWriter_1.IPCMessageWriter;
|
|
exports2.SocketMessageWriter = messageWriter_1.SocketMessageWriter;
|
|
var events_1 = require_events();
|
|
exports2.Disposable = events_1.Disposable;
|
|
exports2.Event = events_1.Event;
|
|
exports2.Emitter = events_1.Emitter;
|
|
var cancellation_1 = require_cancellation();
|
|
exports2.CancellationTokenSource = cancellation_1.CancellationTokenSource;
|
|
exports2.CancellationToken = cancellation_1.CancellationToken;
|
|
var linkedMap_1 = require_linkedMap();
|
|
__export2(require_pipeSupport());
|
|
__export2(require_socketSupport());
|
|
var CancelNotification;
|
|
(function(CancelNotification2) {
|
|
CancelNotification2.type = new messages_1.NotificationType("$/cancelRequest");
|
|
})(CancelNotification || (CancelNotification = {}));
|
|
var ProgressNotification;
|
|
(function(ProgressNotification2) {
|
|
ProgressNotification2.type = new messages_1.NotificationType("$/progress");
|
|
})(ProgressNotification || (ProgressNotification = {}));
|
|
var ProgressType = class {
|
|
constructor() {
|
|
}
|
|
};
|
|
exports2.ProgressType = ProgressType;
|
|
exports2.NullLogger = Object.freeze({
|
|
error: () => {
|
|
},
|
|
warn: () => {
|
|
},
|
|
info: () => {
|
|
},
|
|
log: () => {
|
|
}
|
|
});
|
|
var Trace;
|
|
(function(Trace2) {
|
|
Trace2[Trace2["Off"] = 0] = "Off";
|
|
Trace2[Trace2["Messages"] = 1] = "Messages";
|
|
Trace2[Trace2["Verbose"] = 2] = "Verbose";
|
|
})(Trace = exports2.Trace || (exports2.Trace = {}));
|
|
(function(Trace2) {
|
|
function fromString(value) {
|
|
if (!Is.string(value)) {
|
|
return Trace2.Off;
|
|
}
|
|
value = value.toLowerCase();
|
|
switch (value) {
|
|
case "off":
|
|
return Trace2.Off;
|
|
case "messages":
|
|
return Trace2.Messages;
|
|
case "verbose":
|
|
return Trace2.Verbose;
|
|
default:
|
|
return Trace2.Off;
|
|
}
|
|
}
|
|
Trace2.fromString = fromString;
|
|
function toString(value) {
|
|
switch (value) {
|
|
case Trace2.Off:
|
|
return "off";
|
|
case Trace2.Messages:
|
|
return "messages";
|
|
case Trace2.Verbose:
|
|
return "verbose";
|
|
default:
|
|
return "off";
|
|
}
|
|
}
|
|
Trace2.toString = toString;
|
|
})(Trace = exports2.Trace || (exports2.Trace = {}));
|
|
var TraceFormat;
|
|
(function(TraceFormat2) {
|
|
TraceFormat2["Text"] = "text";
|
|
TraceFormat2["JSON"] = "json";
|
|
})(TraceFormat = exports2.TraceFormat || (exports2.TraceFormat = {}));
|
|
(function(TraceFormat2) {
|
|
function fromString(value) {
|
|
value = value.toLowerCase();
|
|
if (value === "json") {
|
|
return TraceFormat2.JSON;
|
|
} else {
|
|
return TraceFormat2.Text;
|
|
}
|
|
}
|
|
TraceFormat2.fromString = fromString;
|
|
})(TraceFormat = exports2.TraceFormat || (exports2.TraceFormat = {}));
|
|
var SetTraceNotification;
|
|
(function(SetTraceNotification2) {
|
|
SetTraceNotification2.type = new messages_1.NotificationType("$/setTraceNotification");
|
|
})(SetTraceNotification = exports2.SetTraceNotification || (exports2.SetTraceNotification = {}));
|
|
var LogTraceNotification;
|
|
(function(LogTraceNotification2) {
|
|
LogTraceNotification2.type = new messages_1.NotificationType("$/logTraceNotification");
|
|
})(LogTraceNotification = exports2.LogTraceNotification || (exports2.LogTraceNotification = {}));
|
|
var ConnectionErrors;
|
|
(function(ConnectionErrors2) {
|
|
ConnectionErrors2[ConnectionErrors2["Closed"] = 1] = "Closed";
|
|
ConnectionErrors2[ConnectionErrors2["Disposed"] = 2] = "Disposed";
|
|
ConnectionErrors2[ConnectionErrors2["AlreadyListening"] = 3] = "AlreadyListening";
|
|
})(ConnectionErrors = exports2.ConnectionErrors || (exports2.ConnectionErrors = {}));
|
|
var ConnectionError = class extends Error {
|
|
constructor(code, message) {
|
|
super(message);
|
|
this.code = code;
|
|
Object.setPrototypeOf(this, ConnectionError.prototype);
|
|
}
|
|
};
|
|
exports2.ConnectionError = ConnectionError;
|
|
var ConnectionStrategy;
|
|
(function(ConnectionStrategy2) {
|
|
function is(value) {
|
|
let candidate = value;
|
|
return candidate && Is.func(candidate.cancelUndispatched);
|
|
}
|
|
ConnectionStrategy2.is = is;
|
|
})(ConnectionStrategy = exports2.ConnectionStrategy || (exports2.ConnectionStrategy = {}));
|
|
var ConnectionState;
|
|
(function(ConnectionState2) {
|
|
ConnectionState2[ConnectionState2["New"] = 1] = "New";
|
|
ConnectionState2[ConnectionState2["Listening"] = 2] = "Listening";
|
|
ConnectionState2[ConnectionState2["Closed"] = 3] = "Closed";
|
|
ConnectionState2[ConnectionState2["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 = void 0;
|
|
let requestHandlers = Object.create(null);
|
|
let starNotificationHandler = void 0;
|
|
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 void 0;
|
|
}
|
|
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(void 0);
|
|
}
|
|
}
|
|
function readErrorHandler(error) {
|
|
errorEmitter.fire([error, void 0, void 0]);
|
|
}
|
|
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 = void 0;
|
|
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 {
|
|
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()) {
|
|
return;
|
|
}
|
|
function reply(resultOrError, method, startTime2) {
|
|
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, startTime2);
|
|
messageWriter.write(message);
|
|
}
|
|
function replyError(error, method, startTime2) {
|
|
let message = {
|
|
jsonrpc: version,
|
|
id: requestMessage.id,
|
|
error: error.toJson()
|
|
};
|
|
traceSendingResponse(message, method, startTime2);
|
|
messageWriter.write(message);
|
|
}
|
|
function replySuccess(result, method, startTime2) {
|
|
if (result === void 0) {
|
|
result = null;
|
|
}
|
|
let message = {
|
|
jsonrpc: version,
|
|
id: requestMessage.id,
|
|
result
|
|
};
|
|
traceSendingResponse(message, method, startTime2);
|
|
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()) {
|
|
return;
|
|
}
|
|
if (responseMessage.id === null) {
|
|
if (responseMessage.error) {
|
|
logger.error(`Received response message without id: Error is:
|
|
${JSON.stringify(responseMessage.error, void 0, 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()) {
|
|
return;
|
|
}
|
|
let type = void 0;
|
|
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:
|
|
${JSON.stringify(message, null, 4)}`);
|
|
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 = void 0;
|
|
if (trace === Trace.Verbose && message.params) {
|
|
data = `Params: ${JSON.stringify(message.params, null, 4)}
|
|
|
|
`;
|
|
}
|
|
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 = void 0;
|
|
if (trace === Trace.Verbose) {
|
|
if (message.params) {
|
|
data = `Params: ${JSON.stringify(message.params, null, 4)}
|
|
|
|
`;
|
|
} 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 = void 0;
|
|
if (trace === Trace.Verbose) {
|
|
if (message.error && message.error.data) {
|
|
data = `Error data: ${JSON.stringify(message.error.data, null, 4)}
|
|
|
|
`;
|
|
} else {
|
|
if (message.result) {
|
|
data = `Result: ${JSON.stringify(message.result, null, 4)}
|
|
|
|
`;
|
|
} 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 = void 0;
|
|
if (trace === Trace.Verbose && message.params) {
|
|
data = `Params: ${JSON.stringify(message.params, null, 4)}
|
|
|
|
`;
|
|
}
|
|
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 = void 0;
|
|
if (trace === Trace.Verbose) {
|
|
if (message.params) {
|
|
data = `Params: ${JSON.stringify(message.params, null, 4)}
|
|
|
|
`;
|
|
} 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 = void 0;
|
|
if (trace === Trace.Verbose) {
|
|
if (message.error && message.error.data) {
|
|
data = `Error data: ${JSON.stringify(message.error.data, null, 4)}
|
|
|
|
`;
|
|
} else {
|
|
if (message.result) {
|
|
data = `Result: ${JSON.stringify(message.result, null, 4)}
|
|
|
|
`;
|
|
} 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,
|
|
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: void 0, 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 = void 0;
|
|
if (Is.string(type)) {
|
|
method = type;
|
|
switch (params.length) {
|
|
case 0:
|
|
messageParams = null;
|
|
break;
|
|
case 1:
|
|
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] : void 0;
|
|
}
|
|
let id = sequenceNumber++;
|
|
let result = new Promise((resolve, reject) => {
|
|
let requestMessage = {
|
|
jsonrpc: version,
|
|
id,
|
|
method,
|
|
params: messageParams
|
|
};
|
|
let responsePromise = {method, timerStart: Date.now(), resolve, reject};
|
|
traceSendingRequest(requestMessage);
|
|
try {
|
|
messageWriter.write(requestMessage);
|
|
} catch (e) {
|
|
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: void 0, 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 = void 0;
|
|
} 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(void 0);
|
|
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();
|
|
if (Is.func(messageWriter.dispose)) {
|
|
messageWriter.dispose();
|
|
}
|
|
if (Is.func(messageReader.dispose)) {
|
|
messageReader.dispose();
|
|
}
|
|
},
|
|
listen: () => {
|
|
throwIfClosedOrDisposed();
|
|
throwIfListening();
|
|
state = ConnectionState.Listening;
|
|
messageReader.listen(callback);
|
|
},
|
|
inspect: () => {
|
|
console.log("inspect");
|
|
}
|
|
};
|
|
connection.onNotification(LogTraceNotification.type, (params) => {
|
|
if (trace === Trace.Off || !tracer) {
|
|
return;
|
|
}
|
|
tracer.log(params.message, trace === Trace.Verbose ? params.verbose : void 0);
|
|
});
|
|
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 = exports2.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);
|
|
}
|
|
exports2.createMessageConnection = createMessageConnection;
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-types/lib/esm/main.js
|
|
var require_main2 = __commonJS((exports2) => {
|
|
__export(exports2, {
|
|
CodeAction: () => CodeAction,
|
|
CodeActionContext: () => CodeActionContext,
|
|
CodeActionKind: () => CodeActionKind,
|
|
CodeLens: () => CodeLens,
|
|
Color: () => Color,
|
|
ColorInformation: () => ColorInformation,
|
|
ColorPresentation: () => ColorPresentation,
|
|
Command: () => Command,
|
|
CompletionItem: () => CompletionItem2,
|
|
CompletionItemKind: () => CompletionItemKind,
|
|
CompletionItemTag: () => CompletionItemTag,
|
|
CompletionList: () => CompletionList2,
|
|
CreateFile: () => CreateFile,
|
|
DeleteFile: () => DeleteFile,
|
|
Diagnostic: () => Diagnostic,
|
|
DiagnosticRelatedInformation: () => DiagnosticRelatedInformation,
|
|
DiagnosticSeverity: () => DiagnosticSeverity,
|
|
DiagnosticTag: () => DiagnosticTag,
|
|
DocumentHighlight: () => DocumentHighlight,
|
|
DocumentHighlightKind: () => DocumentHighlightKind,
|
|
DocumentLink: () => DocumentLink,
|
|
DocumentSymbol: () => DocumentSymbol,
|
|
EOL: () => EOL,
|
|
FoldingRange: () => FoldingRange,
|
|
FoldingRangeKind: () => FoldingRangeKind,
|
|
FormattingOptions: () => FormattingOptions,
|
|
Hover: () => Hover,
|
|
InsertTextFormat: () => InsertTextFormat2,
|
|
Location: () => Location,
|
|
LocationLink: () => LocationLink,
|
|
MarkedString: () => MarkedString,
|
|
MarkupContent: () => MarkupContent,
|
|
MarkupKind: () => MarkupKind,
|
|
ParameterInformation: () => ParameterInformation,
|
|
Position: () => Position2,
|
|
Range: () => Range,
|
|
RenameFile: () => RenameFile,
|
|
SelectionRange: () => SelectionRange,
|
|
SignatureInformation: () => SignatureInformation,
|
|
SymbolInformation: () => SymbolInformation,
|
|
SymbolKind: () => SymbolKind,
|
|
SymbolTag: () => SymbolTag,
|
|
TextDocument: () => TextDocument,
|
|
TextDocumentEdit: () => TextDocumentEdit,
|
|
TextDocumentIdentifier: () => TextDocumentIdentifier,
|
|
TextDocumentItem: () => TextDocumentItem,
|
|
TextEdit: () => TextEdit,
|
|
VersionedTextDocumentIdentifier: () => VersionedTextDocumentIdentifier,
|
|
WorkspaceChange: () => WorkspaceChange,
|
|
WorkspaceEdit: () => WorkspaceEdit
|
|
});
|
|
"use strict";
|
|
var Position2;
|
|
(function(Position3) {
|
|
function create(line, character) {
|
|
return {line, character};
|
|
}
|
|
Position3.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Is.number(candidate.line) && Is.number(candidate.character);
|
|
}
|
|
Position3.is = is;
|
|
})(Position2 || (Position2 = {}));
|
|
var Range;
|
|
(function(Range2) {
|
|
function create(one, two, three, four) {
|
|
if (Is.number(one) && Is.number(two) && Is.number(three) && Is.number(four)) {
|
|
return {start: Position2.create(one, two), end: Position2.create(three, four)};
|
|
} else if (Position2.is(one) && Position2.is(two)) {
|
|
return {start: one, end: two};
|
|
} else {
|
|
throw new Error("Range#create called with invalid arguments[" + one + ", " + two + ", " + three + ", " + four + "]");
|
|
}
|
|
}
|
|
Range2.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Position2.is(candidate.start) && Position2.is(candidate.end);
|
|
}
|
|
Range2.is = is;
|
|
})(Range || (Range = {}));
|
|
var Location;
|
|
(function(Location2) {
|
|
function create(uri, range) {
|
|
return {uri, range};
|
|
}
|
|
Location2.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
|
|
}
|
|
Location2.is = is;
|
|
})(Location || (Location = {}));
|
|
var LocationLink;
|
|
(function(LocationLink2) {
|
|
function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
|
|
return {targetUri, targetRange, targetSelectionRange, originSelectionRange};
|
|
}
|
|
LocationLink2.create = create;
|
|
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));
|
|
}
|
|
LocationLink2.is = is;
|
|
})(LocationLink || (LocationLink = {}));
|
|
var Color;
|
|
(function(Color2) {
|
|
function create(red, green, blue, alpha) {
|
|
return {
|
|
red,
|
|
green,
|
|
blue,
|
|
alpha
|
|
};
|
|
}
|
|
Color2.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.number(candidate.red) && Is.number(candidate.green) && Is.number(candidate.blue) && Is.number(candidate.alpha);
|
|
}
|
|
Color2.is = is;
|
|
})(Color || (Color = {}));
|
|
var ColorInformation;
|
|
(function(ColorInformation2) {
|
|
function create(range, color) {
|
|
return {
|
|
range,
|
|
color
|
|
};
|
|
}
|
|
ColorInformation2.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Range.is(candidate.range) && Color.is(candidate.color);
|
|
}
|
|
ColorInformation2.is = is;
|
|
})(ColorInformation || (ColorInformation = {}));
|
|
var ColorPresentation;
|
|
(function(ColorPresentation2) {
|
|
function create(label, textEdit, additionalTextEdits) {
|
|
return {
|
|
label,
|
|
textEdit,
|
|
additionalTextEdits
|
|
};
|
|
}
|
|
ColorPresentation2.create = create;
|
|
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));
|
|
}
|
|
ColorPresentation2.is = is;
|
|
})(ColorPresentation || (ColorPresentation = {}));
|
|
var FoldingRangeKind;
|
|
(function(FoldingRangeKind2) {
|
|
FoldingRangeKind2["Comment"] = "comment";
|
|
FoldingRangeKind2["Imports"] = "imports";
|
|
FoldingRangeKind2["Region"] = "region";
|
|
})(FoldingRangeKind || (FoldingRangeKind = {}));
|
|
var FoldingRange;
|
|
(function(FoldingRange2) {
|
|
function create(startLine, endLine, startCharacter, endCharacter, kind) {
|
|
var result = {
|
|
startLine,
|
|
endLine
|
|
};
|
|
if (Is.defined(startCharacter)) {
|
|
result.startCharacter = startCharacter;
|
|
}
|
|
if (Is.defined(endCharacter)) {
|
|
result.endCharacter = endCharacter;
|
|
}
|
|
if (Is.defined(kind)) {
|
|
result.kind = kind;
|
|
}
|
|
return result;
|
|
}
|
|
FoldingRange2.create = create;
|
|
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));
|
|
}
|
|
FoldingRange2.is = is;
|
|
})(FoldingRange || (FoldingRange = {}));
|
|
var DiagnosticRelatedInformation;
|
|
(function(DiagnosticRelatedInformation2) {
|
|
function create(location, message) {
|
|
return {
|
|
location,
|
|
message
|
|
};
|
|
}
|
|
DiagnosticRelatedInformation2.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);
|
|
}
|
|
DiagnosticRelatedInformation2.is = is;
|
|
})(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));
|
|
var DiagnosticSeverity;
|
|
(function(DiagnosticSeverity2) {
|
|
DiagnosticSeverity2.Error = 1;
|
|
DiagnosticSeverity2.Warning = 2;
|
|
DiagnosticSeverity2.Information = 3;
|
|
DiagnosticSeverity2.Hint = 4;
|
|
})(DiagnosticSeverity || (DiagnosticSeverity = {}));
|
|
var DiagnosticTag;
|
|
(function(DiagnosticTag2) {
|
|
DiagnosticTag2.Unnecessary = 1;
|
|
DiagnosticTag2.Deprecated = 2;
|
|
})(DiagnosticTag || (DiagnosticTag = {}));
|
|
var Diagnostic;
|
|
(function(Diagnostic2) {
|
|
function create(range, message, severity, code, source, relatedInformation) {
|
|
var result = {range, 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;
|
|
}
|
|
Diagnostic2.create = create;
|
|
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));
|
|
}
|
|
Diagnostic2.is = is;
|
|
})(Diagnostic || (Diagnostic = {}));
|
|
var Command;
|
|
(function(Command2) {
|
|
function create(title, command) {
|
|
var args = [];
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
|
args[_i - 2] = arguments[_i];
|
|
}
|
|
var result = {title, command};
|
|
if (Is.defined(args) && args.length > 0) {
|
|
result.arguments = args;
|
|
}
|
|
return result;
|
|
}
|
|
Command2.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);
|
|
}
|
|
Command2.is = is;
|
|
})(Command || (Command = {}));
|
|
var TextEdit;
|
|
(function(TextEdit2) {
|
|
function replace(range, newText) {
|
|
return {range, newText};
|
|
}
|
|
TextEdit2.replace = replace;
|
|
function insert(position, newText) {
|
|
return {range: {start: position, end: position}, newText};
|
|
}
|
|
TextEdit2.insert = insert;
|
|
function del(range) {
|
|
return {range, newText: ""};
|
|
}
|
|
TextEdit2.del = del;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range.is(candidate.range);
|
|
}
|
|
TextEdit2.is = is;
|
|
})(TextEdit || (TextEdit = {}));
|
|
var TextDocumentEdit;
|
|
(function(TextDocumentEdit2) {
|
|
function create(textDocument, edits) {
|
|
return {textDocument, edits};
|
|
}
|
|
TextDocumentEdit2.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && VersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
|
|
}
|
|
TextDocumentEdit2.is = is;
|
|
})(TextDocumentEdit || (TextDocumentEdit = {}));
|
|
var CreateFile;
|
|
(function(CreateFile2) {
|
|
function create(uri, options) {
|
|
var result = {
|
|
kind: "create",
|
|
uri
|
|
};
|
|
if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
|
|
result.options = options;
|
|
}
|
|
return result;
|
|
}
|
|
CreateFile2.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)));
|
|
}
|
|
CreateFile2.is = is;
|
|
})(CreateFile || (CreateFile = {}));
|
|
var RenameFile;
|
|
(function(RenameFile2) {
|
|
function create(oldUri, newUri, options) {
|
|
var result = {
|
|
kind: "rename",
|
|
oldUri,
|
|
newUri
|
|
};
|
|
if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
|
|
result.options = options;
|
|
}
|
|
return result;
|
|
}
|
|
RenameFile2.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)));
|
|
}
|
|
RenameFile2.is = is;
|
|
})(RenameFile || (RenameFile = {}));
|
|
var DeleteFile;
|
|
(function(DeleteFile2) {
|
|
function create(uri, options) {
|
|
var result = {
|
|
kind: "delete",
|
|
uri
|
|
};
|
|
if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {
|
|
result.options = options;
|
|
}
|
|
return result;
|
|
}
|
|
DeleteFile2.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)));
|
|
}
|
|
DeleteFile2.is = is;
|
|
})(DeleteFile || (DeleteFile = {}));
|
|
var WorkspaceEdit;
|
|
(function(WorkspaceEdit2) {
|
|
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);
|
|
}
|
|
}));
|
|
}
|
|
WorkspaceEdit2.is = is;
|
|
})(WorkspaceEdit || (WorkspaceEdit = {}));
|
|
var TextEditChangeImpl = function() {
|
|
function TextEditChangeImpl2(edits) {
|
|
this.edits = edits;
|
|
}
|
|
TextEditChangeImpl2.prototype.insert = function(position, newText) {
|
|
this.edits.push(TextEdit.insert(position, newText));
|
|
};
|
|
TextEditChangeImpl2.prototype.replace = function(range, newText) {
|
|
this.edits.push(TextEdit.replace(range, newText));
|
|
};
|
|
TextEditChangeImpl2.prototype.delete = function(range) {
|
|
this.edits.push(TextEdit.del(range));
|
|
};
|
|
TextEditChangeImpl2.prototype.add = function(edit) {
|
|
this.edits.push(edit);
|
|
};
|
|
TextEditChangeImpl2.prototype.all = function() {
|
|
return this.edits;
|
|
};
|
|
TextEditChangeImpl2.prototype.clear = function() {
|
|
this.edits.splice(0, this.edits.length);
|
|
};
|
|
return TextEditChangeImpl2;
|
|
}();
|
|
var WorkspaceChange = function() {
|
|
function WorkspaceChange2(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(WorkspaceChange2.prototype, "edit", {
|
|
get: function() {
|
|
return this._workspaceEdit;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
WorkspaceChange2.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,
|
|
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;
|
|
}
|
|
};
|
|
WorkspaceChange2.prototype.createFile = function(uri, options) {
|
|
this.checkDocumentChanges();
|
|
this._workspaceEdit.documentChanges.push(CreateFile.create(uri, options));
|
|
};
|
|
WorkspaceChange2.prototype.renameFile = function(oldUri, newUri, options) {
|
|
this.checkDocumentChanges();
|
|
this._workspaceEdit.documentChanges.push(RenameFile.create(oldUri, newUri, options));
|
|
};
|
|
WorkspaceChange2.prototype.deleteFile = function(uri, options) {
|
|
this.checkDocumentChanges();
|
|
this._workspaceEdit.documentChanges.push(DeleteFile.create(uri, options));
|
|
};
|
|
WorkspaceChange2.prototype.checkDocumentChanges = function() {
|
|
if (!this._workspaceEdit || !this._workspaceEdit.documentChanges) {
|
|
throw new Error("Workspace edit is not configured for document changes.");
|
|
}
|
|
};
|
|
return WorkspaceChange2;
|
|
}();
|
|
var TextDocumentIdentifier;
|
|
(function(TextDocumentIdentifier2) {
|
|
function create(uri) {
|
|
return {uri};
|
|
}
|
|
TextDocumentIdentifier2.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Is.string(candidate.uri);
|
|
}
|
|
TextDocumentIdentifier2.is = is;
|
|
})(TextDocumentIdentifier || (TextDocumentIdentifier = {}));
|
|
var VersionedTextDocumentIdentifier;
|
|
(function(VersionedTextDocumentIdentifier2) {
|
|
function create(uri, version) {
|
|
return {uri, version};
|
|
}
|
|
VersionedTextDocumentIdentifier2.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.number(candidate.version));
|
|
}
|
|
VersionedTextDocumentIdentifier2.is = is;
|
|
})(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));
|
|
var TextDocumentItem;
|
|
(function(TextDocumentItem2) {
|
|
function create(uri, languageId, version, text) {
|
|
return {uri, languageId, version, text};
|
|
}
|
|
TextDocumentItem2.create = create;
|
|
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);
|
|
}
|
|
TextDocumentItem2.is = is;
|
|
})(TextDocumentItem || (TextDocumentItem = {}));
|
|
var MarkupKind;
|
|
(function(MarkupKind2) {
|
|
MarkupKind2.PlainText = "plaintext";
|
|
MarkupKind2.Markdown = "markdown";
|
|
})(MarkupKind || (MarkupKind = {}));
|
|
(function(MarkupKind2) {
|
|
function is(value) {
|
|
var candidate = value;
|
|
return candidate === MarkupKind2.PlainText || candidate === MarkupKind2.Markdown;
|
|
}
|
|
MarkupKind2.is = is;
|
|
})(MarkupKind || (MarkupKind = {}));
|
|
var MarkupContent;
|
|
(function(MarkupContent2) {
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);
|
|
}
|
|
MarkupContent2.is = is;
|
|
})(MarkupContent || (MarkupContent = {}));
|
|
var CompletionItemKind;
|
|
(function(CompletionItemKind2) {
|
|
CompletionItemKind2.Text = 1;
|
|
CompletionItemKind2.Method = 2;
|
|
CompletionItemKind2.Function = 3;
|
|
CompletionItemKind2.Constructor = 4;
|
|
CompletionItemKind2.Field = 5;
|
|
CompletionItemKind2.Variable = 6;
|
|
CompletionItemKind2.Class = 7;
|
|
CompletionItemKind2.Interface = 8;
|
|
CompletionItemKind2.Module = 9;
|
|
CompletionItemKind2.Property = 10;
|
|
CompletionItemKind2.Unit = 11;
|
|
CompletionItemKind2.Value = 12;
|
|
CompletionItemKind2.Enum = 13;
|
|
CompletionItemKind2.Keyword = 14;
|
|
CompletionItemKind2.Snippet = 15;
|
|
CompletionItemKind2.Color = 16;
|
|
CompletionItemKind2.File = 17;
|
|
CompletionItemKind2.Reference = 18;
|
|
CompletionItemKind2.Folder = 19;
|
|
CompletionItemKind2.EnumMember = 20;
|
|
CompletionItemKind2.Constant = 21;
|
|
CompletionItemKind2.Struct = 22;
|
|
CompletionItemKind2.Event = 23;
|
|
CompletionItemKind2.Operator = 24;
|
|
CompletionItemKind2.TypeParameter = 25;
|
|
})(CompletionItemKind || (CompletionItemKind = {}));
|
|
var InsertTextFormat2;
|
|
(function(InsertTextFormat3) {
|
|
InsertTextFormat3.PlainText = 1;
|
|
InsertTextFormat3.Snippet = 2;
|
|
})(InsertTextFormat2 || (InsertTextFormat2 = {}));
|
|
var CompletionItemTag;
|
|
(function(CompletionItemTag2) {
|
|
CompletionItemTag2.Deprecated = 1;
|
|
})(CompletionItemTag || (CompletionItemTag = {}));
|
|
var CompletionItem2;
|
|
(function(CompletionItem3) {
|
|
function create(label) {
|
|
return {label};
|
|
}
|
|
CompletionItem3.create = create;
|
|
})(CompletionItem2 || (CompletionItem2 = {}));
|
|
var CompletionList2;
|
|
(function(CompletionList3) {
|
|
function create(items, isIncomplete) {
|
|
return {items: items ? items : [], isIncomplete: !!isIncomplete};
|
|
}
|
|
CompletionList3.create = create;
|
|
})(CompletionList2 || (CompletionList2 = {}));
|
|
var MarkedString;
|
|
(function(MarkedString2) {
|
|
function fromPlainText(plainText) {
|
|
return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
|
|
}
|
|
MarkedString2.fromPlainText = fromPlainText;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.string(candidate) || Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value);
|
|
}
|
|
MarkedString2.is = is;
|
|
})(MarkedString || (MarkedString = {}));
|
|
var Hover;
|
|
(function(Hover2) {
|
|
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));
|
|
}
|
|
Hover2.is = is;
|
|
})(Hover || (Hover = {}));
|
|
var ParameterInformation;
|
|
(function(ParameterInformation2) {
|
|
function create(label, documentation) {
|
|
return documentation ? {label, documentation} : {label};
|
|
}
|
|
ParameterInformation2.create = create;
|
|
})(ParameterInformation || (ParameterInformation = {}));
|
|
var SignatureInformation;
|
|
(function(SignatureInformation2) {
|
|
function create(label, documentation) {
|
|
var parameters = [];
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
|
parameters[_i - 2] = arguments[_i];
|
|
}
|
|
var result = {label};
|
|
if (Is.defined(documentation)) {
|
|
result.documentation = documentation;
|
|
}
|
|
if (Is.defined(parameters)) {
|
|
result.parameters = parameters;
|
|
} else {
|
|
result.parameters = [];
|
|
}
|
|
return result;
|
|
}
|
|
SignatureInformation2.create = create;
|
|
})(SignatureInformation || (SignatureInformation = {}));
|
|
var DocumentHighlightKind;
|
|
(function(DocumentHighlightKind2) {
|
|
DocumentHighlightKind2.Text = 1;
|
|
DocumentHighlightKind2.Read = 2;
|
|
DocumentHighlightKind2.Write = 3;
|
|
})(DocumentHighlightKind || (DocumentHighlightKind = {}));
|
|
var DocumentHighlight;
|
|
(function(DocumentHighlight2) {
|
|
function create(range, kind) {
|
|
var result = {range};
|
|
if (Is.number(kind)) {
|
|
result.kind = kind;
|
|
}
|
|
return result;
|
|
}
|
|
DocumentHighlight2.create = create;
|
|
})(DocumentHighlight || (DocumentHighlight = {}));
|
|
var SymbolKind;
|
|
(function(SymbolKind2) {
|
|
SymbolKind2.File = 1;
|
|
SymbolKind2.Module = 2;
|
|
SymbolKind2.Namespace = 3;
|
|
SymbolKind2.Package = 4;
|
|
SymbolKind2.Class = 5;
|
|
SymbolKind2.Method = 6;
|
|
SymbolKind2.Property = 7;
|
|
SymbolKind2.Field = 8;
|
|
SymbolKind2.Constructor = 9;
|
|
SymbolKind2.Enum = 10;
|
|
SymbolKind2.Interface = 11;
|
|
SymbolKind2.Function = 12;
|
|
SymbolKind2.Variable = 13;
|
|
SymbolKind2.Constant = 14;
|
|
SymbolKind2.String = 15;
|
|
SymbolKind2.Number = 16;
|
|
SymbolKind2.Boolean = 17;
|
|
SymbolKind2.Array = 18;
|
|
SymbolKind2.Object = 19;
|
|
SymbolKind2.Key = 20;
|
|
SymbolKind2.Null = 21;
|
|
SymbolKind2.EnumMember = 22;
|
|
SymbolKind2.Struct = 23;
|
|
SymbolKind2.Event = 24;
|
|
SymbolKind2.Operator = 25;
|
|
SymbolKind2.TypeParameter = 26;
|
|
})(SymbolKind || (SymbolKind = {}));
|
|
var SymbolTag;
|
|
(function(SymbolTag2) {
|
|
SymbolTag2.Deprecated = 1;
|
|
})(SymbolTag || (SymbolTag = {}));
|
|
var SymbolInformation;
|
|
(function(SymbolInformation2) {
|
|
function create(name, kind, range, uri, containerName) {
|
|
var result = {
|
|
name,
|
|
kind,
|
|
location: {uri, range}
|
|
};
|
|
if (containerName) {
|
|
result.containerName = containerName;
|
|
}
|
|
return result;
|
|
}
|
|
SymbolInformation2.create = create;
|
|
})(SymbolInformation || (SymbolInformation = {}));
|
|
var DocumentSymbol;
|
|
(function(DocumentSymbol2) {
|
|
function create(name, detail, kind, range, selectionRange, children) {
|
|
var result = {
|
|
name,
|
|
detail,
|
|
kind,
|
|
range,
|
|
selectionRange
|
|
};
|
|
if (children !== void 0) {
|
|
result.children = children;
|
|
}
|
|
return result;
|
|
}
|
|
DocumentSymbol2.create = create;
|
|
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));
|
|
}
|
|
DocumentSymbol2.is = is;
|
|
})(DocumentSymbol || (DocumentSymbol = {}));
|
|
var CodeActionKind;
|
|
(function(CodeActionKind2) {
|
|
CodeActionKind2.Empty = "";
|
|
CodeActionKind2.QuickFix = "quickfix";
|
|
CodeActionKind2.Refactor = "refactor";
|
|
CodeActionKind2.RefactorExtract = "refactor.extract";
|
|
CodeActionKind2.RefactorInline = "refactor.inline";
|
|
CodeActionKind2.RefactorRewrite = "refactor.rewrite";
|
|
CodeActionKind2.Source = "source";
|
|
CodeActionKind2.SourceOrganizeImports = "source.organizeImports";
|
|
CodeActionKind2.SourceFixAll = "source.fixAll";
|
|
})(CodeActionKind || (CodeActionKind = {}));
|
|
var CodeActionContext;
|
|
(function(CodeActionContext2) {
|
|
function create(diagnostics, only) {
|
|
var result = {diagnostics};
|
|
if (only !== void 0 && only !== null) {
|
|
result.only = only;
|
|
}
|
|
return result;
|
|
}
|
|
CodeActionContext2.create = create;
|
|
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));
|
|
}
|
|
CodeActionContext2.is = is;
|
|
})(CodeActionContext || (CodeActionContext = {}));
|
|
var CodeAction;
|
|
(function(CodeAction2) {
|
|
function create(title, commandOrEdit, kind) {
|
|
var result = {title};
|
|
if (Command.is(commandOrEdit)) {
|
|
result.command = commandOrEdit;
|
|
} else {
|
|
result.edit = commandOrEdit;
|
|
}
|
|
if (kind !== void 0) {
|
|
result.kind = kind;
|
|
}
|
|
return result;
|
|
}
|
|
CodeAction2.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));
|
|
}
|
|
CodeAction2.is = is;
|
|
})(CodeAction || (CodeAction = {}));
|
|
var CodeLens;
|
|
(function(CodeLens2) {
|
|
function create(range, data) {
|
|
var result = {range};
|
|
if (Is.defined(data)) {
|
|
result.data = data;
|
|
}
|
|
return result;
|
|
}
|
|
CodeLens2.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));
|
|
}
|
|
CodeLens2.is = is;
|
|
})(CodeLens || (CodeLens = {}));
|
|
var FormattingOptions;
|
|
(function(FormattingOptions2) {
|
|
function create(tabSize, insertSpaces) {
|
|
return {tabSize, insertSpaces};
|
|
}
|
|
FormattingOptions2.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Is.number(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
|
|
}
|
|
FormattingOptions2.is = is;
|
|
})(FormattingOptions || (FormattingOptions = {}));
|
|
var DocumentLink;
|
|
(function(DocumentLink2) {
|
|
function create(range, target, data) {
|
|
return {range, target, data};
|
|
}
|
|
DocumentLink2.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
|
|
}
|
|
DocumentLink2.is = is;
|
|
})(DocumentLink || (DocumentLink = {}));
|
|
var SelectionRange;
|
|
(function(SelectionRange2) {
|
|
function create(range, parent) {
|
|
return {range, parent};
|
|
}
|
|
SelectionRange2.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return candidate !== void 0 && Range.is(candidate.range) && (candidate.parent === void 0 || SelectionRange2.is(candidate.parent));
|
|
}
|
|
SelectionRange2.is = is;
|
|
})(SelectionRange || (SelectionRange = {}));
|
|
var EOL = ["\n", "\r\n", "\r"];
|
|
var TextDocument;
|
|
(function(TextDocument2) {
|
|
function create(uri, languageId, version, content) {
|
|
return new FullTextDocument(uri, languageId, version, content);
|
|
}
|
|
TextDocument2.create = create;
|
|
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;
|
|
}
|
|
TextDocument2.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;
|
|
}
|
|
TextDocument2.applyEdits = applyEdits;
|
|
function mergeSort(data, compare) {
|
|
if (data.length <= 1) {
|
|
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) {
|
|
data[i++] = left[leftIdx++];
|
|
} else {
|
|
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 = function() {
|
|
function FullTextDocument2(uri, languageId, version, content) {
|
|
this._uri = uri;
|
|
this._languageId = languageId;
|
|
this._version = version;
|
|
this._content = content;
|
|
this._lineOffsets = void 0;
|
|
}
|
|
Object.defineProperty(FullTextDocument2.prototype, "uri", {
|
|
get: function() {
|
|
return this._uri;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(FullTextDocument2.prototype, "languageId", {
|
|
get: function() {
|
|
return this._languageId;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(FullTextDocument2.prototype, "version", {
|
|
get: function() {
|
|
return this._version;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
FullTextDocument2.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;
|
|
};
|
|
FullTextDocument2.prototype.update = function(event, version) {
|
|
this._content = event.text;
|
|
this._version = version;
|
|
this._lineOffsets = void 0;
|
|
};
|
|
FullTextDocument2.prototype.getLineOffsets = function() {
|
|
if (this._lineOffsets === void 0) {
|
|
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;
|
|
};
|
|
FullTextDocument2.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 Position2.create(0, offset);
|
|
}
|
|
while (low < high) {
|
|
var mid = Math.floor((low + high) / 2);
|
|
if (lineOffsets[mid] > offset) {
|
|
high = mid;
|
|
} else {
|
|
low = mid + 1;
|
|
}
|
|
}
|
|
var line = low - 1;
|
|
return Position2.create(line, offset - lineOffsets[line]);
|
|
};
|
|
FullTextDocument2.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(FullTextDocument2.prototype, "lineCount", {
|
|
get: function() {
|
|
return this.getLineOffsets().length;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
return FullTextDocument2;
|
|
}();
|
|
var Is;
|
|
(function(Is2) {
|
|
var toString = Object.prototype.toString;
|
|
function defined(value) {
|
|
return typeof value !== "undefined";
|
|
}
|
|
Is2.defined = defined;
|
|
function undefined2(value) {
|
|
return typeof value === "undefined";
|
|
}
|
|
Is2.undefined = undefined2;
|
|
function boolean(value) {
|
|
return value === true || value === false;
|
|
}
|
|
Is2.boolean = boolean;
|
|
function string(value) {
|
|
return toString.call(value) === "[object String]";
|
|
}
|
|
Is2.string = string;
|
|
function number(value) {
|
|
return toString.call(value) === "[object Number]";
|
|
}
|
|
Is2.number = number;
|
|
function func(value) {
|
|
return toString.call(value) === "[object Function]";
|
|
}
|
|
Is2.func = func;
|
|
function objectLiteral(value) {
|
|
return value !== null && typeof value === "object";
|
|
}
|
|
Is2.objectLiteral = objectLiteral;
|
|
function typedArray(value, check) {
|
|
return Array.isArray(value) && value.every(check);
|
|
}
|
|
Is2.typedArray = typedArray;
|
|
})(Is || (Is = {}));
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/utils/is.js
|
|
var require_is2 = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
function boolean(value) {
|
|
return value === true || value === false;
|
|
}
|
|
exports2.boolean = boolean;
|
|
function string(value) {
|
|
return typeof value === "string" || value instanceof String;
|
|
}
|
|
exports2.string = string;
|
|
function number(value) {
|
|
return typeof value === "number" || value instanceof Number;
|
|
}
|
|
exports2.number = number;
|
|
function error(value) {
|
|
return value instanceof Error;
|
|
}
|
|
exports2.error = error;
|
|
function func(value) {
|
|
return typeof value === "function";
|
|
}
|
|
exports2.func = func;
|
|
function array(value) {
|
|
return Array.isArray(value);
|
|
}
|
|
exports2.array = array;
|
|
function stringArray(value) {
|
|
return array(value) && value.every((elem) => string(elem));
|
|
}
|
|
exports2.stringArray = stringArray;
|
|
function typedArray(value, check) {
|
|
return Array.isArray(value) && value.every(check);
|
|
}
|
|
exports2.typedArray = typedArray;
|
|
function objectLiteral(value) {
|
|
return value !== null && typeof value === "object";
|
|
}
|
|
exports2.objectLiteral = objectLiteral;
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/messages.js
|
|
var require_messages2 = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var vscode_jsonrpc_1 = require_main();
|
|
var ProtocolRequestType0 = class extends vscode_jsonrpc_1.RequestType0 {
|
|
constructor(method) {
|
|
super(method);
|
|
}
|
|
};
|
|
exports2.ProtocolRequestType0 = ProtocolRequestType0;
|
|
var ProtocolRequestType = class extends vscode_jsonrpc_1.RequestType {
|
|
constructor(method) {
|
|
super(method);
|
|
}
|
|
};
|
|
exports2.ProtocolRequestType = ProtocolRequestType;
|
|
var ProtocolNotificationType = class extends vscode_jsonrpc_1.NotificationType {
|
|
constructor(method) {
|
|
super(method);
|
|
}
|
|
};
|
|
exports2.ProtocolNotificationType = ProtocolNotificationType;
|
|
var ProtocolNotificationType0 = class extends vscode_jsonrpc_1.NotificationType0 {
|
|
constructor(method) {
|
|
super(method);
|
|
}
|
|
};
|
|
exports2.ProtocolNotificationType0 = ProtocolNotificationType0;
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/protocol.implementation.js
|
|
var require_protocol_implementation = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var vscode_jsonrpc_1 = require_main();
|
|
var messages_1 = require_messages2();
|
|
var ImplementationRequest;
|
|
(function(ImplementationRequest2) {
|
|
ImplementationRequest2.method = "textDocument/implementation";
|
|
ImplementationRequest2.type = new messages_1.ProtocolRequestType(ImplementationRequest2.method);
|
|
ImplementationRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(ImplementationRequest = exports2.ImplementationRequest || (exports2.ImplementationRequest = {}));
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/protocol.typeDefinition.js
|
|
var require_protocol_typeDefinition = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var vscode_jsonrpc_1 = require_main();
|
|
var messages_1 = require_messages2();
|
|
var TypeDefinitionRequest;
|
|
(function(TypeDefinitionRequest2) {
|
|
TypeDefinitionRequest2.method = "textDocument/typeDefinition";
|
|
TypeDefinitionRequest2.type = new messages_1.ProtocolRequestType(TypeDefinitionRequest2.method);
|
|
TypeDefinitionRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(TypeDefinitionRequest = exports2.TypeDefinitionRequest || (exports2.TypeDefinitionRequest = {}));
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/protocol.workspaceFolders.js
|
|
var require_protocol_workspaceFolders = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var messages_1 = require_messages2();
|
|
var WorkspaceFoldersRequest;
|
|
(function(WorkspaceFoldersRequest2) {
|
|
WorkspaceFoldersRequest2.type = new messages_1.ProtocolRequestType0("workspace/workspaceFolders");
|
|
})(WorkspaceFoldersRequest = exports2.WorkspaceFoldersRequest || (exports2.WorkspaceFoldersRequest = {}));
|
|
var DidChangeWorkspaceFoldersNotification;
|
|
(function(DidChangeWorkspaceFoldersNotification2) {
|
|
DidChangeWorkspaceFoldersNotification2.type = new messages_1.ProtocolNotificationType("workspace/didChangeWorkspaceFolders");
|
|
})(DidChangeWorkspaceFoldersNotification = exports2.DidChangeWorkspaceFoldersNotification || (exports2.DidChangeWorkspaceFoldersNotification = {}));
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/protocol.configuration.js
|
|
var require_protocol_configuration = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var messages_1 = require_messages2();
|
|
var ConfigurationRequest;
|
|
(function(ConfigurationRequest2) {
|
|
ConfigurationRequest2.type = new messages_1.ProtocolRequestType("workspace/configuration");
|
|
})(ConfigurationRequest = exports2.ConfigurationRequest || (exports2.ConfigurationRequest = {}));
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/protocol.colorProvider.js
|
|
var require_protocol_colorProvider = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var vscode_jsonrpc_1 = require_main();
|
|
var messages_1 = require_messages2();
|
|
var DocumentColorRequest;
|
|
(function(DocumentColorRequest2) {
|
|
DocumentColorRequest2.method = "textDocument/documentColor";
|
|
DocumentColorRequest2.type = new messages_1.ProtocolRequestType(DocumentColorRequest2.method);
|
|
DocumentColorRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(DocumentColorRequest = exports2.DocumentColorRequest || (exports2.DocumentColorRequest = {}));
|
|
var ColorPresentationRequest;
|
|
(function(ColorPresentationRequest2) {
|
|
ColorPresentationRequest2.type = new messages_1.ProtocolRequestType("textDocument/colorPresentation");
|
|
})(ColorPresentationRequest = exports2.ColorPresentationRequest || (exports2.ColorPresentationRequest = {}));
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/protocol.foldingRange.js
|
|
var require_protocol_foldingRange = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var vscode_jsonrpc_1 = require_main();
|
|
var messages_1 = require_messages2();
|
|
var FoldingRangeKind;
|
|
(function(FoldingRangeKind2) {
|
|
FoldingRangeKind2["Comment"] = "comment";
|
|
FoldingRangeKind2["Imports"] = "imports";
|
|
FoldingRangeKind2["Region"] = "region";
|
|
})(FoldingRangeKind = exports2.FoldingRangeKind || (exports2.FoldingRangeKind = {}));
|
|
var FoldingRangeRequest;
|
|
(function(FoldingRangeRequest2) {
|
|
FoldingRangeRequest2.method = "textDocument/foldingRange";
|
|
FoldingRangeRequest2.type = new messages_1.ProtocolRequestType(FoldingRangeRequest2.method);
|
|
FoldingRangeRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(FoldingRangeRequest = exports2.FoldingRangeRequest || (exports2.FoldingRangeRequest = {}));
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/protocol.declaration.js
|
|
var require_protocol_declaration = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var vscode_jsonrpc_1 = require_main();
|
|
var messages_1 = require_messages2();
|
|
var DeclarationRequest;
|
|
(function(DeclarationRequest2) {
|
|
DeclarationRequest2.method = "textDocument/declaration";
|
|
DeclarationRequest2.type = new messages_1.ProtocolRequestType(DeclarationRequest2.method);
|
|
DeclarationRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(DeclarationRequest = exports2.DeclarationRequest || (exports2.DeclarationRequest = {}));
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/protocol.selectionRange.js
|
|
var require_protocol_selectionRange = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var vscode_jsonrpc_1 = require_main();
|
|
var messages_1 = require_messages2();
|
|
var SelectionRangeRequest;
|
|
(function(SelectionRangeRequest2) {
|
|
SelectionRangeRequest2.method = "textDocument/selectionRange";
|
|
SelectionRangeRequest2.type = new messages_1.ProtocolRequestType(SelectionRangeRequest2.method);
|
|
SelectionRangeRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(SelectionRangeRequest = exports2.SelectionRangeRequest || (exports2.SelectionRangeRequest = {}));
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/protocol.progress.js
|
|
var require_protocol_progress = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var vscode_jsonrpc_1 = require_main();
|
|
var messages_1 = require_messages2();
|
|
var WorkDoneProgress;
|
|
(function(WorkDoneProgress2) {
|
|
WorkDoneProgress2.type = new vscode_jsonrpc_1.ProgressType();
|
|
})(WorkDoneProgress = exports2.WorkDoneProgress || (exports2.WorkDoneProgress = {}));
|
|
var WorkDoneProgressCreateRequest;
|
|
(function(WorkDoneProgressCreateRequest2) {
|
|
WorkDoneProgressCreateRequest2.type = new messages_1.ProtocolRequestType("window/workDoneProgress/create");
|
|
})(WorkDoneProgressCreateRequest = exports2.WorkDoneProgressCreateRequest || (exports2.WorkDoneProgressCreateRequest = {}));
|
|
var WorkDoneProgressCancelNotification;
|
|
(function(WorkDoneProgressCancelNotification2) {
|
|
WorkDoneProgressCancelNotification2.type = new messages_1.ProtocolNotificationType("window/workDoneProgress/cancel");
|
|
})(WorkDoneProgressCancelNotification = exports2.WorkDoneProgressCancelNotification || (exports2.WorkDoneProgressCancelNotification = {}));
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/protocol.js
|
|
var require_protocol = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var Is = require_is2();
|
|
var vscode_jsonrpc_1 = require_main();
|
|
var messages_1 = require_messages2();
|
|
var protocol_implementation_1 = require_protocol_implementation();
|
|
exports2.ImplementationRequest = protocol_implementation_1.ImplementationRequest;
|
|
var protocol_typeDefinition_1 = require_protocol_typeDefinition();
|
|
exports2.TypeDefinitionRequest = protocol_typeDefinition_1.TypeDefinitionRequest;
|
|
var protocol_workspaceFolders_1 = require_protocol_workspaceFolders();
|
|
exports2.WorkspaceFoldersRequest = protocol_workspaceFolders_1.WorkspaceFoldersRequest;
|
|
exports2.DidChangeWorkspaceFoldersNotification = protocol_workspaceFolders_1.DidChangeWorkspaceFoldersNotification;
|
|
var protocol_configuration_1 = require_protocol_configuration();
|
|
exports2.ConfigurationRequest = protocol_configuration_1.ConfigurationRequest;
|
|
var protocol_colorProvider_1 = require_protocol_colorProvider();
|
|
exports2.DocumentColorRequest = protocol_colorProvider_1.DocumentColorRequest;
|
|
exports2.ColorPresentationRequest = protocol_colorProvider_1.ColorPresentationRequest;
|
|
var protocol_foldingRange_1 = require_protocol_foldingRange();
|
|
exports2.FoldingRangeRequest = protocol_foldingRange_1.FoldingRangeRequest;
|
|
var protocol_declaration_1 = require_protocol_declaration();
|
|
exports2.DeclarationRequest = protocol_declaration_1.DeclarationRequest;
|
|
var protocol_selectionRange_1 = require_protocol_selectionRange();
|
|
exports2.SelectionRangeRequest = protocol_selectionRange_1.SelectionRangeRequest;
|
|
var protocol_progress_1 = require_protocol_progress();
|
|
exports2.WorkDoneProgress = protocol_progress_1.WorkDoneProgress;
|
|
exports2.WorkDoneProgressCreateRequest = protocol_progress_1.WorkDoneProgressCreateRequest;
|
|
exports2.WorkDoneProgressCancelNotification = protocol_progress_1.WorkDoneProgressCancelNotification;
|
|
var DocumentFilter;
|
|
(function(DocumentFilter2) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return Is.string(candidate.language) || Is.string(candidate.scheme) || Is.string(candidate.pattern);
|
|
}
|
|
DocumentFilter2.is = is;
|
|
})(DocumentFilter = exports2.DocumentFilter || (exports2.DocumentFilter = {}));
|
|
var DocumentSelector2;
|
|
(function(DocumentSelector3) {
|
|
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;
|
|
}
|
|
DocumentSelector3.is = is;
|
|
})(DocumentSelector2 = exports2.DocumentSelector || (exports2.DocumentSelector = {}));
|
|
var RegistrationRequest;
|
|
(function(RegistrationRequest2) {
|
|
RegistrationRequest2.type = new messages_1.ProtocolRequestType("client/registerCapability");
|
|
})(RegistrationRequest = exports2.RegistrationRequest || (exports2.RegistrationRequest = {}));
|
|
var UnregistrationRequest;
|
|
(function(UnregistrationRequest2) {
|
|
UnregistrationRequest2.type = new messages_1.ProtocolRequestType("client/unregisterCapability");
|
|
})(UnregistrationRequest = exports2.UnregistrationRequest || (exports2.UnregistrationRequest = {}));
|
|
var ResourceOperationKind;
|
|
(function(ResourceOperationKind2) {
|
|
ResourceOperationKind2.Create = "create";
|
|
ResourceOperationKind2.Rename = "rename";
|
|
ResourceOperationKind2.Delete = "delete";
|
|
})(ResourceOperationKind = exports2.ResourceOperationKind || (exports2.ResourceOperationKind = {}));
|
|
var FailureHandlingKind;
|
|
(function(FailureHandlingKind2) {
|
|
FailureHandlingKind2.Abort = "abort";
|
|
FailureHandlingKind2.Transactional = "transactional";
|
|
FailureHandlingKind2.TextOnlyTransactional = "textOnlyTransactional";
|
|
FailureHandlingKind2.Undo = "undo";
|
|
})(FailureHandlingKind = exports2.FailureHandlingKind || (exports2.FailureHandlingKind = {}));
|
|
var StaticRegistrationOptions;
|
|
(function(StaticRegistrationOptions2) {
|
|
function hasId(value) {
|
|
const candidate = value;
|
|
return candidate && Is.string(candidate.id) && candidate.id.length > 0;
|
|
}
|
|
StaticRegistrationOptions2.hasId = hasId;
|
|
})(StaticRegistrationOptions = exports2.StaticRegistrationOptions || (exports2.StaticRegistrationOptions = {}));
|
|
var TextDocumentRegistrationOptions;
|
|
(function(TextDocumentRegistrationOptions2) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return candidate && (candidate.documentSelector === null || DocumentSelector2.is(candidate.documentSelector));
|
|
}
|
|
TextDocumentRegistrationOptions2.is = is;
|
|
})(TextDocumentRegistrationOptions = exports2.TextDocumentRegistrationOptions || (exports2.TextDocumentRegistrationOptions = {}));
|
|
var WorkDoneProgressOptions;
|
|
(function(WorkDoneProgressOptions2) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return Is.objectLiteral(candidate) && (candidate.workDoneProgress === void 0 || Is.boolean(candidate.workDoneProgress));
|
|
}
|
|
WorkDoneProgressOptions2.is = is;
|
|
function hasWorkDoneProgress(value) {
|
|
const candidate = value;
|
|
return candidate && Is.boolean(candidate.workDoneProgress);
|
|
}
|
|
WorkDoneProgressOptions2.hasWorkDoneProgress = hasWorkDoneProgress;
|
|
})(WorkDoneProgressOptions = exports2.WorkDoneProgressOptions || (exports2.WorkDoneProgressOptions = {}));
|
|
var InitializeRequest;
|
|
(function(InitializeRequest2) {
|
|
InitializeRequest2.type = new messages_1.ProtocolRequestType("initialize");
|
|
})(InitializeRequest = exports2.InitializeRequest || (exports2.InitializeRequest = {}));
|
|
var InitializeError;
|
|
(function(InitializeError2) {
|
|
InitializeError2.unknownProtocolVersion = 1;
|
|
})(InitializeError = exports2.InitializeError || (exports2.InitializeError = {}));
|
|
var InitializedNotification;
|
|
(function(InitializedNotification2) {
|
|
InitializedNotification2.type = new messages_1.ProtocolNotificationType("initialized");
|
|
})(InitializedNotification = exports2.InitializedNotification || (exports2.InitializedNotification = {}));
|
|
var ShutdownRequest;
|
|
(function(ShutdownRequest2) {
|
|
ShutdownRequest2.type = new messages_1.ProtocolRequestType0("shutdown");
|
|
})(ShutdownRequest = exports2.ShutdownRequest || (exports2.ShutdownRequest = {}));
|
|
var ExitNotification;
|
|
(function(ExitNotification2) {
|
|
ExitNotification2.type = new messages_1.ProtocolNotificationType0("exit");
|
|
})(ExitNotification = exports2.ExitNotification || (exports2.ExitNotification = {}));
|
|
var DidChangeConfigurationNotification;
|
|
(function(DidChangeConfigurationNotification2) {
|
|
DidChangeConfigurationNotification2.type = new messages_1.ProtocolNotificationType("workspace/didChangeConfiguration");
|
|
})(DidChangeConfigurationNotification = exports2.DidChangeConfigurationNotification || (exports2.DidChangeConfigurationNotification = {}));
|
|
var MessageType;
|
|
(function(MessageType2) {
|
|
MessageType2.Error = 1;
|
|
MessageType2.Warning = 2;
|
|
MessageType2.Info = 3;
|
|
MessageType2.Log = 4;
|
|
})(MessageType = exports2.MessageType || (exports2.MessageType = {}));
|
|
var ShowMessageNotification;
|
|
(function(ShowMessageNotification2) {
|
|
ShowMessageNotification2.type = new messages_1.ProtocolNotificationType("window/showMessage");
|
|
})(ShowMessageNotification = exports2.ShowMessageNotification || (exports2.ShowMessageNotification = {}));
|
|
var ShowMessageRequest;
|
|
(function(ShowMessageRequest2) {
|
|
ShowMessageRequest2.type = new messages_1.ProtocolRequestType("window/showMessageRequest");
|
|
})(ShowMessageRequest = exports2.ShowMessageRequest || (exports2.ShowMessageRequest = {}));
|
|
var LogMessageNotification;
|
|
(function(LogMessageNotification2) {
|
|
LogMessageNotification2.type = new messages_1.ProtocolNotificationType("window/logMessage");
|
|
})(LogMessageNotification = exports2.LogMessageNotification || (exports2.LogMessageNotification = {}));
|
|
var TelemetryEventNotification;
|
|
(function(TelemetryEventNotification2) {
|
|
TelemetryEventNotification2.type = new messages_1.ProtocolNotificationType("telemetry/event");
|
|
})(TelemetryEventNotification = exports2.TelemetryEventNotification || (exports2.TelemetryEventNotification = {}));
|
|
var TextDocumentSyncKind;
|
|
(function(TextDocumentSyncKind2) {
|
|
TextDocumentSyncKind2.None = 0;
|
|
TextDocumentSyncKind2.Full = 1;
|
|
TextDocumentSyncKind2.Incremental = 2;
|
|
})(TextDocumentSyncKind = exports2.TextDocumentSyncKind || (exports2.TextDocumentSyncKind = {}));
|
|
var DidOpenTextDocumentNotification;
|
|
(function(DidOpenTextDocumentNotification2) {
|
|
DidOpenTextDocumentNotification2.method = "textDocument/didOpen";
|
|
DidOpenTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidOpenTextDocumentNotification2.method);
|
|
})(DidOpenTextDocumentNotification = exports2.DidOpenTextDocumentNotification || (exports2.DidOpenTextDocumentNotification = {}));
|
|
var DidChangeTextDocumentNotification;
|
|
(function(DidChangeTextDocumentNotification2) {
|
|
DidChangeTextDocumentNotification2.method = "textDocument/didChange";
|
|
DidChangeTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidChangeTextDocumentNotification2.method);
|
|
})(DidChangeTextDocumentNotification = exports2.DidChangeTextDocumentNotification || (exports2.DidChangeTextDocumentNotification = {}));
|
|
var DidCloseTextDocumentNotification;
|
|
(function(DidCloseTextDocumentNotification2) {
|
|
DidCloseTextDocumentNotification2.method = "textDocument/didClose";
|
|
DidCloseTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidCloseTextDocumentNotification2.method);
|
|
})(DidCloseTextDocumentNotification = exports2.DidCloseTextDocumentNotification || (exports2.DidCloseTextDocumentNotification = {}));
|
|
var DidSaveTextDocumentNotification;
|
|
(function(DidSaveTextDocumentNotification2) {
|
|
DidSaveTextDocumentNotification2.method = "textDocument/didSave";
|
|
DidSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidSaveTextDocumentNotification2.method);
|
|
})(DidSaveTextDocumentNotification = exports2.DidSaveTextDocumentNotification || (exports2.DidSaveTextDocumentNotification = {}));
|
|
var TextDocumentSaveReason;
|
|
(function(TextDocumentSaveReason2) {
|
|
TextDocumentSaveReason2.Manual = 1;
|
|
TextDocumentSaveReason2.AfterDelay = 2;
|
|
TextDocumentSaveReason2.FocusOut = 3;
|
|
})(TextDocumentSaveReason = exports2.TextDocumentSaveReason || (exports2.TextDocumentSaveReason = {}));
|
|
var WillSaveTextDocumentNotification;
|
|
(function(WillSaveTextDocumentNotification2) {
|
|
WillSaveTextDocumentNotification2.method = "textDocument/willSave";
|
|
WillSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(WillSaveTextDocumentNotification2.method);
|
|
})(WillSaveTextDocumentNotification = exports2.WillSaveTextDocumentNotification || (exports2.WillSaveTextDocumentNotification = {}));
|
|
var WillSaveTextDocumentWaitUntilRequest;
|
|
(function(WillSaveTextDocumentWaitUntilRequest2) {
|
|
WillSaveTextDocumentWaitUntilRequest2.method = "textDocument/willSaveWaitUntil";
|
|
WillSaveTextDocumentWaitUntilRequest2.type = new messages_1.ProtocolRequestType(WillSaveTextDocumentWaitUntilRequest2.method);
|
|
})(WillSaveTextDocumentWaitUntilRequest = exports2.WillSaveTextDocumentWaitUntilRequest || (exports2.WillSaveTextDocumentWaitUntilRequest = {}));
|
|
var DidChangeWatchedFilesNotification;
|
|
(function(DidChangeWatchedFilesNotification2) {
|
|
DidChangeWatchedFilesNotification2.type = new messages_1.ProtocolNotificationType("workspace/didChangeWatchedFiles");
|
|
})(DidChangeWatchedFilesNotification = exports2.DidChangeWatchedFilesNotification || (exports2.DidChangeWatchedFilesNotification = {}));
|
|
var FileChangeType;
|
|
(function(FileChangeType2) {
|
|
FileChangeType2.Created = 1;
|
|
FileChangeType2.Changed = 2;
|
|
FileChangeType2.Deleted = 3;
|
|
})(FileChangeType = exports2.FileChangeType || (exports2.FileChangeType = {}));
|
|
var WatchKind;
|
|
(function(WatchKind2) {
|
|
WatchKind2.Create = 1;
|
|
WatchKind2.Change = 2;
|
|
WatchKind2.Delete = 4;
|
|
})(WatchKind = exports2.WatchKind || (exports2.WatchKind = {}));
|
|
var PublishDiagnosticsNotification;
|
|
(function(PublishDiagnosticsNotification2) {
|
|
PublishDiagnosticsNotification2.type = new messages_1.ProtocolNotificationType("textDocument/publishDiagnostics");
|
|
})(PublishDiagnosticsNotification = exports2.PublishDiagnosticsNotification || (exports2.PublishDiagnosticsNotification = {}));
|
|
var CompletionTriggerKind;
|
|
(function(CompletionTriggerKind2) {
|
|
CompletionTriggerKind2.Invoked = 1;
|
|
CompletionTriggerKind2.TriggerCharacter = 2;
|
|
CompletionTriggerKind2.TriggerForIncompleteCompletions = 3;
|
|
})(CompletionTriggerKind = exports2.CompletionTriggerKind || (exports2.CompletionTriggerKind = {}));
|
|
var CompletionRequest;
|
|
(function(CompletionRequest2) {
|
|
CompletionRequest2.method = "textDocument/completion";
|
|
CompletionRequest2.type = new messages_1.ProtocolRequestType(CompletionRequest2.method);
|
|
CompletionRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(CompletionRequest = exports2.CompletionRequest || (exports2.CompletionRequest = {}));
|
|
var CompletionResolveRequest;
|
|
(function(CompletionResolveRequest2) {
|
|
CompletionResolveRequest2.method = "completionItem/resolve";
|
|
CompletionResolveRequest2.type = new messages_1.ProtocolRequestType(CompletionResolveRequest2.method);
|
|
})(CompletionResolveRequest = exports2.CompletionResolveRequest || (exports2.CompletionResolveRequest = {}));
|
|
var HoverRequest;
|
|
(function(HoverRequest2) {
|
|
HoverRequest2.method = "textDocument/hover";
|
|
HoverRequest2.type = new messages_1.ProtocolRequestType(HoverRequest2.method);
|
|
})(HoverRequest = exports2.HoverRequest || (exports2.HoverRequest = {}));
|
|
var SignatureHelpTriggerKind;
|
|
(function(SignatureHelpTriggerKind2) {
|
|
SignatureHelpTriggerKind2.Invoked = 1;
|
|
SignatureHelpTriggerKind2.TriggerCharacter = 2;
|
|
SignatureHelpTriggerKind2.ContentChange = 3;
|
|
})(SignatureHelpTriggerKind = exports2.SignatureHelpTriggerKind || (exports2.SignatureHelpTriggerKind = {}));
|
|
var SignatureHelpRequest;
|
|
(function(SignatureHelpRequest2) {
|
|
SignatureHelpRequest2.method = "textDocument/signatureHelp";
|
|
SignatureHelpRequest2.type = new messages_1.ProtocolRequestType(SignatureHelpRequest2.method);
|
|
})(SignatureHelpRequest = exports2.SignatureHelpRequest || (exports2.SignatureHelpRequest = {}));
|
|
var DefinitionRequest;
|
|
(function(DefinitionRequest2) {
|
|
DefinitionRequest2.method = "textDocument/definition";
|
|
DefinitionRequest2.type = new messages_1.ProtocolRequestType(DefinitionRequest2.method);
|
|
DefinitionRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(DefinitionRequest = exports2.DefinitionRequest || (exports2.DefinitionRequest = {}));
|
|
var ReferencesRequest;
|
|
(function(ReferencesRequest2) {
|
|
ReferencesRequest2.method = "textDocument/references";
|
|
ReferencesRequest2.type = new messages_1.ProtocolRequestType(ReferencesRequest2.method);
|
|
ReferencesRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(ReferencesRequest = exports2.ReferencesRequest || (exports2.ReferencesRequest = {}));
|
|
var DocumentHighlightRequest;
|
|
(function(DocumentHighlightRequest2) {
|
|
DocumentHighlightRequest2.method = "textDocument/documentHighlight";
|
|
DocumentHighlightRequest2.type = new messages_1.ProtocolRequestType(DocumentHighlightRequest2.method);
|
|
DocumentHighlightRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(DocumentHighlightRequest = exports2.DocumentHighlightRequest || (exports2.DocumentHighlightRequest = {}));
|
|
var DocumentSymbolRequest;
|
|
(function(DocumentSymbolRequest2) {
|
|
DocumentSymbolRequest2.method = "textDocument/documentSymbol";
|
|
DocumentSymbolRequest2.type = new messages_1.ProtocolRequestType(DocumentSymbolRequest2.method);
|
|
DocumentSymbolRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(DocumentSymbolRequest = exports2.DocumentSymbolRequest || (exports2.DocumentSymbolRequest = {}));
|
|
var CodeActionRequest;
|
|
(function(CodeActionRequest2) {
|
|
CodeActionRequest2.method = "textDocument/codeAction";
|
|
CodeActionRequest2.type = new messages_1.ProtocolRequestType(CodeActionRequest2.method);
|
|
CodeActionRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(CodeActionRequest = exports2.CodeActionRequest || (exports2.CodeActionRequest = {}));
|
|
var WorkspaceSymbolRequest;
|
|
(function(WorkspaceSymbolRequest2) {
|
|
WorkspaceSymbolRequest2.method = "workspace/symbol";
|
|
WorkspaceSymbolRequest2.type = new messages_1.ProtocolRequestType(WorkspaceSymbolRequest2.method);
|
|
WorkspaceSymbolRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(WorkspaceSymbolRequest = exports2.WorkspaceSymbolRequest || (exports2.WorkspaceSymbolRequest = {}));
|
|
var CodeLensRequest;
|
|
(function(CodeLensRequest2) {
|
|
CodeLensRequest2.type = new messages_1.ProtocolRequestType("textDocument/codeLens");
|
|
CodeLensRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(CodeLensRequest = exports2.CodeLensRequest || (exports2.CodeLensRequest = {}));
|
|
var CodeLensResolveRequest;
|
|
(function(CodeLensResolveRequest2) {
|
|
CodeLensResolveRequest2.type = new messages_1.ProtocolRequestType("codeLens/resolve");
|
|
})(CodeLensResolveRequest = exports2.CodeLensResolveRequest || (exports2.CodeLensResolveRequest = {}));
|
|
var DocumentLinkRequest;
|
|
(function(DocumentLinkRequest2) {
|
|
DocumentLinkRequest2.method = "textDocument/documentLink";
|
|
DocumentLinkRequest2.type = new messages_1.ProtocolRequestType(DocumentLinkRequest2.method);
|
|
DocumentLinkRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
|
|
})(DocumentLinkRequest = exports2.DocumentLinkRequest || (exports2.DocumentLinkRequest = {}));
|
|
var DocumentLinkResolveRequest;
|
|
(function(DocumentLinkResolveRequest2) {
|
|
DocumentLinkResolveRequest2.type = new messages_1.ProtocolRequestType("documentLink/resolve");
|
|
})(DocumentLinkResolveRequest = exports2.DocumentLinkResolveRequest || (exports2.DocumentLinkResolveRequest = {}));
|
|
var DocumentFormattingRequest;
|
|
(function(DocumentFormattingRequest2) {
|
|
DocumentFormattingRequest2.method = "textDocument/formatting";
|
|
DocumentFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentFormattingRequest2.method);
|
|
})(DocumentFormattingRequest = exports2.DocumentFormattingRequest || (exports2.DocumentFormattingRequest = {}));
|
|
var DocumentRangeFormattingRequest;
|
|
(function(DocumentRangeFormattingRequest2) {
|
|
DocumentRangeFormattingRequest2.method = "textDocument/rangeFormatting";
|
|
DocumentRangeFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentRangeFormattingRequest2.method);
|
|
})(DocumentRangeFormattingRequest = exports2.DocumentRangeFormattingRequest || (exports2.DocumentRangeFormattingRequest = {}));
|
|
var DocumentOnTypeFormattingRequest;
|
|
(function(DocumentOnTypeFormattingRequest2) {
|
|
DocumentOnTypeFormattingRequest2.method = "textDocument/onTypeFormatting";
|
|
DocumentOnTypeFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentOnTypeFormattingRequest2.method);
|
|
})(DocumentOnTypeFormattingRequest = exports2.DocumentOnTypeFormattingRequest || (exports2.DocumentOnTypeFormattingRequest = {}));
|
|
var RenameRequest;
|
|
(function(RenameRequest2) {
|
|
RenameRequest2.method = "textDocument/rename";
|
|
RenameRequest2.type = new messages_1.ProtocolRequestType(RenameRequest2.method);
|
|
})(RenameRequest = exports2.RenameRequest || (exports2.RenameRequest = {}));
|
|
var PrepareRenameRequest;
|
|
(function(PrepareRenameRequest2) {
|
|
PrepareRenameRequest2.method = "textDocument/prepareRename";
|
|
PrepareRenameRequest2.type = new messages_1.ProtocolRequestType(PrepareRenameRequest2.method);
|
|
})(PrepareRenameRequest = exports2.PrepareRenameRequest || (exports2.PrepareRenameRequest = {}));
|
|
var ExecuteCommandRequest;
|
|
(function(ExecuteCommandRequest2) {
|
|
ExecuteCommandRequest2.type = new messages_1.ProtocolRequestType("workspace/executeCommand");
|
|
})(ExecuteCommandRequest = exports2.ExecuteCommandRequest || (exports2.ExecuteCommandRequest = {}));
|
|
var ApplyWorkspaceEditRequest;
|
|
(function(ApplyWorkspaceEditRequest2) {
|
|
ApplyWorkspaceEditRequest2.type = new messages_1.ProtocolRequestType("workspace/applyEdit");
|
|
})(ApplyWorkspaceEditRequest = exports2.ApplyWorkspaceEditRequest || (exports2.ApplyWorkspaceEditRequest = {}));
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/protocol.callHierarchy.proposed.js
|
|
var require_protocol_callHierarchy_proposed = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var messages_1 = require_messages2();
|
|
var CallHierarchyPrepareRequest;
|
|
(function(CallHierarchyPrepareRequest2) {
|
|
CallHierarchyPrepareRequest2.method = "textDocument/prepareCallHierarchy";
|
|
CallHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyPrepareRequest2.method);
|
|
})(CallHierarchyPrepareRequest = exports2.CallHierarchyPrepareRequest || (exports2.CallHierarchyPrepareRequest = {}));
|
|
var CallHierarchyIncomingCallsRequest;
|
|
(function(CallHierarchyIncomingCallsRequest2) {
|
|
CallHierarchyIncomingCallsRequest2.method = "callHierarchy/incomingCalls";
|
|
CallHierarchyIncomingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyIncomingCallsRequest2.method);
|
|
})(CallHierarchyIncomingCallsRequest = exports2.CallHierarchyIncomingCallsRequest || (exports2.CallHierarchyIncomingCallsRequest = {}));
|
|
var CallHierarchyOutgoingCallsRequest;
|
|
(function(CallHierarchyOutgoingCallsRequest2) {
|
|
CallHierarchyOutgoingCallsRequest2.method = "callHierarchy/outgoingCalls";
|
|
CallHierarchyOutgoingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyOutgoingCallsRequest2.method);
|
|
})(CallHierarchyOutgoingCallsRequest = exports2.CallHierarchyOutgoingCallsRequest || (exports2.CallHierarchyOutgoingCallsRequest = {}));
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/protocol.sematicTokens.proposed.js
|
|
var require_protocol_sematicTokens_proposed = __commonJS((exports2) => {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var messages_1 = require_messages2();
|
|
var SemanticTokenTypes;
|
|
(function(SemanticTokenTypes2) {
|
|
SemanticTokenTypes2["comment"] = "comment";
|
|
SemanticTokenTypes2["keyword"] = "keyword";
|
|
SemanticTokenTypes2["string"] = "string";
|
|
SemanticTokenTypes2["number"] = "number";
|
|
SemanticTokenTypes2["regexp"] = "regexp";
|
|
SemanticTokenTypes2["operator"] = "operator";
|
|
SemanticTokenTypes2["namespace"] = "namespace";
|
|
SemanticTokenTypes2["type"] = "type";
|
|
SemanticTokenTypes2["struct"] = "struct";
|
|
SemanticTokenTypes2["class"] = "class";
|
|
SemanticTokenTypes2["interface"] = "interface";
|
|
SemanticTokenTypes2["enum"] = "enum";
|
|
SemanticTokenTypes2["typeParameter"] = "typeParameter";
|
|
SemanticTokenTypes2["function"] = "function";
|
|
SemanticTokenTypes2["member"] = "member";
|
|
SemanticTokenTypes2["property"] = "property";
|
|
SemanticTokenTypes2["macro"] = "macro";
|
|
SemanticTokenTypes2["variable"] = "variable";
|
|
SemanticTokenTypes2["parameter"] = "parameter";
|
|
SemanticTokenTypes2["label"] = "label";
|
|
})(SemanticTokenTypes = exports2.SemanticTokenTypes || (exports2.SemanticTokenTypes = {}));
|
|
var SemanticTokenModifiers;
|
|
(function(SemanticTokenModifiers2) {
|
|
SemanticTokenModifiers2["documentation"] = "documentation";
|
|
SemanticTokenModifiers2["declaration"] = "declaration";
|
|
SemanticTokenModifiers2["definition"] = "definition";
|
|
SemanticTokenModifiers2["reference"] = "reference";
|
|
SemanticTokenModifiers2["static"] = "static";
|
|
SemanticTokenModifiers2["abstract"] = "abstract";
|
|
SemanticTokenModifiers2["deprecated"] = "deprecated";
|
|
SemanticTokenModifiers2["async"] = "async";
|
|
SemanticTokenModifiers2["volatile"] = "volatile";
|
|
SemanticTokenModifiers2["readonly"] = "readonly";
|
|
})(SemanticTokenModifiers = exports2.SemanticTokenModifiers || (exports2.SemanticTokenModifiers = {}));
|
|
var SemanticTokens;
|
|
(function(SemanticTokens2) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return candidate !== void 0 && (candidate.resultId === void 0 || typeof candidate.resultId === "string") && Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === "number");
|
|
}
|
|
SemanticTokens2.is = is;
|
|
})(SemanticTokens = exports2.SemanticTokens || (exports2.SemanticTokens = {}));
|
|
var SemanticTokensRequest;
|
|
(function(SemanticTokensRequest2) {
|
|
SemanticTokensRequest2.method = "textDocument/semanticTokens";
|
|
SemanticTokensRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRequest2.method);
|
|
})(SemanticTokensRequest = exports2.SemanticTokensRequest || (exports2.SemanticTokensRequest = {}));
|
|
var SemanticTokensEditsRequest;
|
|
(function(SemanticTokensEditsRequest2) {
|
|
SemanticTokensEditsRequest2.method = "textDocument/semanticTokens/edits";
|
|
SemanticTokensEditsRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensEditsRequest2.method);
|
|
})(SemanticTokensEditsRequest = exports2.SemanticTokensEditsRequest || (exports2.SemanticTokensEditsRequest = {}));
|
|
var SemanticTokensRangeRequest;
|
|
(function(SemanticTokensRangeRequest2) {
|
|
SemanticTokensRangeRequest2.method = "textDocument/semanticTokens/range";
|
|
SemanticTokensRangeRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest2.method);
|
|
})(SemanticTokensRangeRequest = exports2.SemanticTokensRangeRequest || (exports2.SemanticTokensRangeRequest = {}));
|
|
});
|
|
|
|
// node_modules/vscode-languageserver-protocol/lib/main.js
|
|
var require_main3 = __commonJS((exports2) => {
|
|
"use strict";
|
|
function __export2(m) {
|
|
for (var p in m)
|
|
if (!exports2.hasOwnProperty(p))
|
|
exports2[p] = m[p];
|
|
}
|
|
Object.defineProperty(exports2, "__esModule", {value: true});
|
|
var vscode_jsonrpc_1 = require_main();
|
|
exports2.ErrorCodes = vscode_jsonrpc_1.ErrorCodes;
|
|
exports2.ResponseError = vscode_jsonrpc_1.ResponseError;
|
|
exports2.CancellationToken = vscode_jsonrpc_1.CancellationToken;
|
|
exports2.CancellationTokenSource = vscode_jsonrpc_1.CancellationTokenSource;
|
|
exports2.Disposable = vscode_jsonrpc_1.Disposable;
|
|
exports2.Event = vscode_jsonrpc_1.Event;
|
|
exports2.Emitter = vscode_jsonrpc_1.Emitter;
|
|
exports2.Trace = vscode_jsonrpc_1.Trace;
|
|
exports2.TraceFormat = vscode_jsonrpc_1.TraceFormat;
|
|
exports2.SetTraceNotification = vscode_jsonrpc_1.SetTraceNotification;
|
|
exports2.LogTraceNotification = vscode_jsonrpc_1.LogTraceNotification;
|
|
exports2.RequestType = vscode_jsonrpc_1.RequestType;
|
|
exports2.RequestType0 = vscode_jsonrpc_1.RequestType0;
|
|
exports2.NotificationType = vscode_jsonrpc_1.NotificationType;
|
|
exports2.NotificationType0 = vscode_jsonrpc_1.NotificationType0;
|
|
exports2.MessageReader = vscode_jsonrpc_1.MessageReader;
|
|
exports2.MessageWriter = vscode_jsonrpc_1.MessageWriter;
|
|
exports2.ConnectionStrategy = vscode_jsonrpc_1.ConnectionStrategy;
|
|
exports2.StreamMessageReader = vscode_jsonrpc_1.StreamMessageReader;
|
|
exports2.StreamMessageWriter = vscode_jsonrpc_1.StreamMessageWriter;
|
|
exports2.IPCMessageReader = vscode_jsonrpc_1.IPCMessageReader;
|
|
exports2.IPCMessageWriter = vscode_jsonrpc_1.IPCMessageWriter;
|
|
exports2.createClientPipeTransport = vscode_jsonrpc_1.createClientPipeTransport;
|
|
exports2.createServerPipeTransport = vscode_jsonrpc_1.createServerPipeTransport;
|
|
exports2.generateRandomPipeName = vscode_jsonrpc_1.generateRandomPipeName;
|
|
exports2.createClientSocketTransport = vscode_jsonrpc_1.createClientSocketTransport;
|
|
exports2.createServerSocketTransport = vscode_jsonrpc_1.createServerSocketTransport;
|
|
exports2.ProgressType = vscode_jsonrpc_1.ProgressType;
|
|
__export2(require_main2());
|
|
__export2(require_protocol());
|
|
var callHierarchy = require_protocol_callHierarchy_proposed();
|
|
var st = require_protocol_sematicTokens_proposed();
|
|
var Proposed;
|
|
(function(Proposed2) {
|
|
let CallHierarchyPrepareRequest;
|
|
(function(CallHierarchyPrepareRequest2) {
|
|
CallHierarchyPrepareRequest2.method = callHierarchy.CallHierarchyPrepareRequest.method;
|
|
CallHierarchyPrepareRequest2.type = callHierarchy.CallHierarchyPrepareRequest.type;
|
|
})(CallHierarchyPrepareRequest = Proposed2.CallHierarchyPrepareRequest || (Proposed2.CallHierarchyPrepareRequest = {}));
|
|
let CallHierarchyIncomingCallsRequest;
|
|
(function(CallHierarchyIncomingCallsRequest2) {
|
|
CallHierarchyIncomingCallsRequest2.method = callHierarchy.CallHierarchyIncomingCallsRequest.method;
|
|
CallHierarchyIncomingCallsRequest2.type = callHierarchy.CallHierarchyIncomingCallsRequest.type;
|
|
})(CallHierarchyIncomingCallsRequest = Proposed2.CallHierarchyIncomingCallsRequest || (Proposed2.CallHierarchyIncomingCallsRequest = {}));
|
|
let CallHierarchyOutgoingCallsRequest;
|
|
(function(CallHierarchyOutgoingCallsRequest2) {
|
|
CallHierarchyOutgoingCallsRequest2.method = callHierarchy.CallHierarchyOutgoingCallsRequest.method;
|
|
CallHierarchyOutgoingCallsRequest2.type = callHierarchy.CallHierarchyOutgoingCallsRequest.type;
|
|
})(CallHierarchyOutgoingCallsRequest = Proposed2.CallHierarchyOutgoingCallsRequest || (Proposed2.CallHierarchyOutgoingCallsRequest = {}));
|
|
Proposed2.SemanticTokenTypes = st.SemanticTokenTypes;
|
|
Proposed2.SemanticTokenModifiers = st.SemanticTokenModifiers;
|
|
Proposed2.SemanticTokens = st.SemanticTokens;
|
|
let SemanticTokensRequest;
|
|
(function(SemanticTokensRequest2) {
|
|
SemanticTokensRequest2.method = st.SemanticTokensRequest.method;
|
|
SemanticTokensRequest2.type = st.SemanticTokensRequest.type;
|
|
})(SemanticTokensRequest = Proposed2.SemanticTokensRequest || (Proposed2.SemanticTokensRequest = {}));
|
|
let SemanticTokensEditsRequest;
|
|
(function(SemanticTokensEditsRequest2) {
|
|
SemanticTokensEditsRequest2.method = st.SemanticTokensEditsRequest.method;
|
|
SemanticTokensEditsRequest2.type = st.SemanticTokensEditsRequest.type;
|
|
})(SemanticTokensEditsRequest = Proposed2.SemanticTokensEditsRequest || (Proposed2.SemanticTokensEditsRequest = {}));
|
|
let SemanticTokensRangeRequest;
|
|
(function(SemanticTokensRangeRequest2) {
|
|
SemanticTokensRangeRequest2.method = st.SemanticTokensRangeRequest.method;
|
|
SemanticTokensRangeRequest2.type = st.SemanticTokensRangeRequest.type;
|
|
})(SemanticTokensRangeRequest = Proposed2.SemanticTokensRangeRequest || (Proposed2.SemanticTokensRangeRequest = {}));
|
|
})(Proposed = exports2.Proposed || (exports2.Proposed = {}));
|
|
function createProtocolConnection(reader, writer, logger, strategy) {
|
|
return vscode_jsonrpc_1.createMessageConnection(reader, writer, logger, strategy);
|
|
}
|
|
exports2.createProtocolConnection = createProtocolConnection;
|
|
});
|
|
|
|
// src/index.ts
|
|
__export(exports, {
|
|
activate: () => activate
|
|
});
|
|
var import_coc = __toModule(require("coc.nvim"));
|
|
var import_fs = __toModule(require("fs"));
|
|
var import_os = __toModule(require("os"));
|
|
var import_path = __toModule(require("path"));
|
|
var import_vscode_languageserver_protocol = __toModule(require_main3());
|
|
var sections = ["vetur", "emmet", "html", "javascript", "typescript", "prettier", "stylusSupremacy"];
|
|
function getConfig(config) {
|
|
let res = {};
|
|
for (let section of sections) {
|
|
let o = config.get(section);
|
|
res[section] = o || {};
|
|
}
|
|
return res;
|
|
}
|
|
async function activate(context) {
|
|
let {subscriptions} = context;
|
|
let c = import_coc.workspace.getConfiguration();
|
|
const config = c.get("vetur");
|
|
const enable = config.enable;
|
|
if (enable === false)
|
|
return;
|
|
let file;
|
|
let devPath = config.dev && config.dev.vlsPath;
|
|
if (devPath && import_fs.default.existsSync(devPath)) {
|
|
file = import_path.default.join(devPath, "dist/vueServerMain.js");
|
|
if (!import_fs.default.existsSync(file)) {
|
|
import_coc.window.showMessage(`vetur server module "${file}" not found!`, "error");
|
|
return;
|
|
}
|
|
} else {
|
|
file = context.asAbsolutePath("node_modules/vls/dist/vueServerMain.js");
|
|
file = file.replace(/vls.js$/, "vueServerMain.js");
|
|
if (!file || !import_fs.default.existsSync(file)) {
|
|
import_coc.window.showMessage("vls module not found!", "error");
|
|
return;
|
|
}
|
|
}
|
|
const selector = [{
|
|
language: "vue",
|
|
scheme: "file"
|
|
}];
|
|
let serverOptions = {
|
|
module: file,
|
|
transport: import_coc.TransportKind.ipc,
|
|
options: {
|
|
cwd: import_coc.workspace.root,
|
|
execArgv: config.execArgv || []
|
|
}
|
|
};
|
|
let clientOptions = {
|
|
documentSelector: selector,
|
|
synchronize: {
|
|
configurationSection: sections,
|
|
fileEvents: import_coc.workspace.createFileSystemWatcher("**/*.[tj]s", true, false, true)
|
|
},
|
|
outputChannelName: "vetur",
|
|
initializationOptions: {
|
|
config: getConfig(c),
|
|
globalSnippetDir: getGlobalSnippetDir()
|
|
},
|
|
middleware: {
|
|
provideCompletionItem: (document, position, context2, token, next) => {
|
|
return Promise.resolve(next(document, position, context2, token)).then((res) => {
|
|
let doc = import_coc.workspace.getDocument(document.uri);
|
|
if (!doc || !res)
|
|
return [];
|
|
let items = res.hasOwnProperty("isIncomplete") ? res.items : res;
|
|
let pre = doc.getline(position.line).slice(0, position.character);
|
|
if (context2.triggerCharacter == ":" || /\:\w*$/.test(pre)) {
|
|
items = items.filter((o) => o.label.startsWith(":"));
|
|
items.forEach(fixItem);
|
|
}
|
|
return items;
|
|
});
|
|
}
|
|
}
|
|
};
|
|
let client = new import_coc.LanguageClient("vetur", "Vetur Language Server", serverOptions, clientOptions);
|
|
client.onReady().then(() => {
|
|
registerCustomClientNotificationHandlers(client);
|
|
registerRestartVLSCommand(context, client);
|
|
}).catch((_e) => {
|
|
});
|
|
subscriptions.push(import_coc.services.registLanguageClient(client));
|
|
}
|
|
async function displayInitProgress(promise) {
|
|
return import_coc.window.withProgress({
|
|
title: "Vetur initialization",
|
|
cancellable: true
|
|
}, () => promise);
|
|
}
|
|
function registerRestartVLSCommand(context, client) {
|
|
context.subscriptions.push(import_coc.commands.registerCommand("vetur.restartVLS", () => displayInitProgress(client.stop().then(() => client.start()).then(() => client.onReady()))));
|
|
}
|
|
function registerCustomClientNotificationHandlers(client) {
|
|
client.onNotification("$/displayInfo", (msg) => {
|
|
import_coc.window.showMessage(msg, "more");
|
|
});
|
|
client.onNotification("$/displayWarning", (msg) => {
|
|
import_coc.window.showMessage(msg, "warning");
|
|
});
|
|
client.onNotification("$/displayError", (msg) => {
|
|
import_coc.window.showMessage(msg, "error");
|
|
});
|
|
}
|
|
function fixItem(item) {
|
|
item.data = item.data || {};
|
|
item.data.abbr = item.label;
|
|
item.label = item.label.slice(1);
|
|
item.textEdit = null;
|
|
item.insertTextFormat = import_vscode_languageserver_protocol.InsertTextFormat.PlainText;
|
|
}
|
|
function getGlobalSnippetDir() {
|
|
const appName = "Code";
|
|
if (process.platform === "win32") {
|
|
return import_path.default.resolve(process.env["APPDATA"] || "", appName, "User/snippets/vetur");
|
|
} else if (process.platform === "darwin") {
|
|
return import_path.default.resolve(import_os.default.homedir(), "Library/Application Support", appName, "User/snippets/vetur");
|
|
} else {
|
|
return import_path.default.resolve(import_os.default.homedir(), ".config", appName, "User/snippets/vetur");
|
|
}
|
|
}
|
|
//# sourceMappingURL=index.js.map
|