return __exportStar(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", {value: module2, enumerable: true}), module2);
};
-// node_modules/vscode-jsonrpc/lib/is.js
+// node_modules/vscode-jsonrpc/lib/common/ral.js
+var require_ral = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ var _ral;
+ function RAL() {
+ if (_ral === void 0) {
+ throw new Error(`No runtime abstraction layer installed`);
+ }
+ return _ral;
+ }
+ (function(RAL2) {
+ function install(ral) {
+ if (ral === void 0) {
+ throw new Error(`No runtime abstraction layer provided`);
+ }
+ _ral = ral;
+ }
+ RAL2.install = install;
+ })(RAL || (RAL = {}));
+ exports2.default = RAL;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/disposable.js
+var require_disposable = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.Disposable = void 0;
+ var Disposable13;
+ (function(Disposable14) {
+ function create(func) {
+ return {
+ dispose: func
+ };
+ }
+ Disposable14.create = create;
+ })(Disposable13 = exports2.Disposable || (exports2.Disposable = {}));
+});
+
+// node_modules/vscode-jsonrpc/lib/common/messageBuffer.js
+var require_messageBuffer = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.AbstractMessageBuffer = void 0;
+ var CR = 13;
+ var LF = 10;
+ var CRLF = "\r\n";
+ var AbstractMessageBuffer = class {
+ constructor(encoding = "utf-8") {
+ this._encoding = encoding;
+ this._chunks = [];
+ this._totalLength = 0;
+ }
+ get encoding() {
+ return this._encoding;
+ }
+ append(chunk) {
+ const toAppend = typeof chunk === "string" ? this.fromString(chunk, this._encoding) : chunk;
+ this._chunks.push(toAppend);
+ this._totalLength += toAppend.byteLength;
+ }
+ tryReadHeaders() {
+ if (this._chunks.length === 0) {
+ return void 0;
+ }
+ let state = 0;
+ let chunkIndex = 0;
+ let offset = 0;
+ let chunkBytesRead = 0;
+ row:
+ while (chunkIndex < this._chunks.length) {
+ const chunk = this._chunks[chunkIndex];
+ offset = 0;
+ column:
+ while (offset < chunk.length) {
+ const value = chunk[offset];
+ switch (value) {
+ case CR:
+ switch (state) {
+ case 0:
+ state = 1;
+ break;
+ case 2:
+ state = 3;
+ break;
+ default:
+ state = 0;
+ }
+ break;
+ case LF:
+ switch (state) {
+ case 1:
+ state = 2;
+ break;
+ case 3:
+ state = 4;
+ offset++;
+ break row;
+ default:
+ state = 0;
+ }
+ break;
+ default:
+ state = 0;
+ }
+ offset++;
+ }
+ chunkBytesRead += chunk.byteLength;
+ chunkIndex++;
+ }
+ if (state !== 4) {
+ return void 0;
+ }
+ const buffer = this._read(chunkBytesRead + offset);
+ const result = new Map();
+ const headers = this.toString(buffer, "ascii").split(CRLF);
+ if (headers.length < 2) {
+ return result;
+ }
+ for (let i = 0; i < headers.length - 2; i++) {
+ const header = headers[i];
+ const index = header.indexOf(":");
+ if (index === -1) {
+ throw new Error("Message header must separate key and value using :");
+ }
+ const key = header.substr(0, index);
+ const value = header.substr(index + 1).trim();
+ result.set(key, value);
+ }
+ return result;
+ }
+ tryReadBody(length) {
+ if (this._totalLength < length) {
+ return void 0;
+ }
+ return this._read(length);
+ }
+ get numberOfBytes() {
+ return this._totalLength;
+ }
+ _read(byteCount) {
+ if (byteCount === 0) {
+ return this.emptyBuffer();
+ }
+ if (byteCount > this._totalLength) {
+ throw new Error(`Cannot read so many bytes!`);
+ }
+ if (this._chunks[0].byteLength === byteCount) {
+ const chunk = this._chunks[0];
+ this._chunks.shift();
+ this._totalLength -= byteCount;
+ return this.asNative(chunk);
+ }
+ if (this._chunks[0].byteLength > byteCount) {
+ const chunk = this._chunks[0];
+ const result2 = this.asNative(chunk, byteCount);
+ this._chunks[0] = chunk.slice(byteCount);
+ this._totalLength -= byteCount;
+ return result2;
+ }
+ const result = this.allocNative(byteCount);
+ let resultOffset = 0;
+ let chunkIndex = 0;
+ while (byteCount > 0) {
+ const chunk = this._chunks[chunkIndex];
+ if (chunk.byteLength > byteCount) {
+ const chunkPart = chunk.slice(0, byteCount);
+ result.set(chunkPart, resultOffset);
+ resultOffset += byteCount;
+ this._chunks[chunkIndex] = chunk.slice(byteCount);
+ this._totalLength -= byteCount;
+ byteCount -= byteCount;
+ } else {
+ result.set(chunk, resultOffset);
+ resultOffset += chunk.byteLength;
+ this._chunks.shift();
+ this._totalLength -= chunk.byteLength;
+ byteCount -= chunk.byteLength;
+ }
+ }
+ return result;
+ }
+ };
+ exports2.AbstractMessageBuffer = AbstractMessageBuffer;
+});
+
+// node_modules/vscode-jsonrpc/lib/node/ril.js
+var require_ril = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ var ral_1 = require_ral();
+ var util_1 = require("util");
+ var disposable_1 = require_disposable();
+ var messageBuffer_1 = require_messageBuffer();
+ var MessageBuffer = class extends messageBuffer_1.AbstractMessageBuffer {
+ constructor(encoding = "utf-8") {
+ super(encoding);
+ }
+ emptyBuffer() {
+ return MessageBuffer.emptyBuffer;
+ }
+ fromString(value, encoding) {
+ return Buffer.from(value, encoding);
+ }
+ toString(value, encoding) {
+ if (value instanceof Buffer) {
+ return value.toString(encoding);
+ } else {
+ return new util_1.TextDecoder(encoding).decode(value);
+ }
+ }
+ asNative(buffer, length) {
+ if (length === void 0) {
+ return buffer instanceof Buffer ? buffer : Buffer.from(buffer);
+ } else {
+ return buffer instanceof Buffer ? buffer.slice(0, length) : Buffer.from(buffer, 0, length);
+ }
+ }
+ allocNative(length) {
+ return Buffer.allocUnsafe(length);
+ }
+ };
+ MessageBuffer.emptyBuffer = Buffer.allocUnsafe(0);
+ var ReadableStreamWrapper = class {
+ constructor(stream) {
+ this.stream = stream;
+ }
+ onClose(listener) {
+ this.stream.on("close", listener);
+ return disposable_1.Disposable.create(() => this.stream.off("close", listener));
+ }
+ onError(listener) {
+ this.stream.on("error", listener);
+ return disposable_1.Disposable.create(() => this.stream.off("error", listener));
+ }
+ onEnd(listener) {
+ this.stream.on("end", listener);
+ return disposable_1.Disposable.create(() => this.stream.off("end", listener));
+ }
+ onData(listener) {
+ this.stream.on("data", listener);
+ return disposable_1.Disposable.create(() => this.stream.off("data", listener));
+ }
+ };
+ var WritableStreamWrapper = class {
+ constructor(stream) {
+ this.stream = stream;
+ }
+ onClose(listener) {
+ this.stream.on("close", listener);
+ return disposable_1.Disposable.create(() => this.stream.off("close", listener));
+ }
+ onError(listener) {
+ this.stream.on("error", listener);
+ return disposable_1.Disposable.create(() => this.stream.off("error", listener));
+ }
+ onEnd(listener) {
+ this.stream.on("end", listener);
+ return disposable_1.Disposable.create(() => this.stream.off("end", listener));
+ }
+ write(data, encoding) {
+ return new Promise((resolve, reject) => {
+ const callback = (error) => {
+ if (error === void 0 || error === null) {
+ resolve();
+ } else {
+ reject(error);
+ }
+ };
+ if (typeof data === "string") {
+ this.stream.write(data, encoding, callback);
+ } else {
+ this.stream.write(data, callback);
+ }
+ });
+ }
+ end() {
+ this.stream.end();
+ }
+ };
+ var _ril = Object.freeze({
+ messageBuffer: Object.freeze({
+ create: (encoding) => new MessageBuffer(encoding)
+ }),
+ applicationJson: Object.freeze({
+ encoder: Object.freeze({
+ name: "application/json",
+ encode: (msg, options) => {
+ try {
+ return Promise.resolve(Buffer.from(JSON.stringify(msg, void 0, 0), options.charset));
+ } catch (err) {
+ return Promise.reject(err);
+ }
+ }
+ }),
+ decoder: Object.freeze({
+ name: "application/json",
+ decode: (buffer, options) => {
+ try {
+ if (buffer instanceof Buffer) {
+ return Promise.resolve(JSON.parse(buffer.toString(options.charset)));
+ } else {
+ return Promise.resolve(JSON.parse(new util_1.TextDecoder(options.charset).decode(buffer)));
+ }
+ } catch (err) {
+ return Promise.reject(err);
+ }
+ }
+ })
+ }),
+ stream: Object.freeze({
+ asReadableStream: (stream) => new ReadableStreamWrapper(stream),
+ asWritableStream: (stream) => new WritableStreamWrapper(stream)
+ }),
+ console,
+ timer: Object.freeze({
+ setTimeout(callback, ms, ...args) {
+ return setTimeout(callback, ms, ...args);
+ },
+ clearTimeout(handle) {
+ clearTimeout(handle);
+ },
+ setImmediate(callback, ...args) {
+ return setImmediate(callback, ...args);
+ },
+ clearImmediate(handle) {
+ clearImmediate(handle);
+ }
+ })
+ });
+ function RIL() {
+ return _ril;
+ }
+ (function(RIL2) {
+ function install() {
+ ral_1.default.install(_ril);
+ }
+ RIL2.install = install;
+ })(RIL || (RIL = {}));
+ exports2.default = RIL;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/is.js
var require_is = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.stringArray = exports2.array = exports2.func = exports2.error = exports2.number = exports2.string = exports2.boolean = void 0;
function boolean2(value) {
return value === true || value === false;
}
exports2.stringArray = stringArray;
});
-// node_modules/vscode-jsonrpc/lib/messages.js
+// node_modules/vscode-jsonrpc/lib/common/messages.js
var require_messages = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.isResponseMessage = exports2.isNotificationMessage = exports2.isRequestMessage = exports2.NotificationType9 = exports2.NotificationType8 = exports2.NotificationType7 = exports2.NotificationType6 = exports2.NotificationType5 = exports2.NotificationType4 = exports2.NotificationType3 = exports2.NotificationType2 = exports2.NotificationType1 = exports2.NotificationType0 = exports2.NotificationType = exports2.RequestType9 = exports2.RequestType8 = exports2.RequestType7 = exports2.RequestType6 = exports2.RequestType5 = exports2.RequestType4 = exports2.RequestType3 = exports2.RequestType2 = exports2.RequestType1 = exports2.RequestType = exports2.RequestType0 = exports2.AbstractMessageSignature = exports2.ParameterStructures = exports2.ResponseError = exports2.ErrorCodes = void 0;
var is2 = require_is();
var ErrorCodes;
(function(ErrorCodes2) {
ErrorCodes2.MethodNotFound = -32601;
ErrorCodes2.InvalidParams = -32602;
ErrorCodes2.InternalError = -32603;
- ErrorCodes2.serverErrorStart = -32099;
- ErrorCodes2.serverErrorEnd = -32e3;
+ ErrorCodes2.jsonrpcReservedErrorRangeStart = -32099;
+ ErrorCodes2.serverErrorStart = ErrorCodes2.jsonrpcReservedErrorRangeStart;
+ ErrorCodes2.MessageWriteError = -32099;
+ ErrorCodes2.MessageReadError = -32098;
ErrorCodes2.ServerNotInitialized = -32002;
ErrorCodes2.UnknownErrorCode = -32001;
- ErrorCodes2.RequestCancelled = -32800;
- ErrorCodes2.ContentModified = -32801;
- ErrorCodes2.MessageWriteError = 1;
- ErrorCodes2.MessageReadError = 2;
+ ErrorCodes2.jsonrpcReservedErrorRangeEnd = -32e3;
+ ErrorCodes2.serverErrorEnd = ErrorCodes2.jsonrpcReservedErrorRangeEnd;
})(ErrorCodes = exports2.ErrorCodes || (exports2.ErrorCodes = {}));
var ResponseError = class extends Error {
constructor(code, message, data) {
}
};
exports2.ResponseError = ResponseError;
- var AbstractMessageType = class {
- constructor(_method, _numberOfParams) {
- this._method = _method;
- this._numberOfParams = _numberOfParams;
+ var ParameterStructures = class {
+ constructor(kind) {
+ this.kind = kind;
}
- get method() {
- return this._method;
+ static is(value) {
+ return value === ParameterStructures.auto || value === ParameterStructures.byName || value === ParameterStructures.byPosition;
+ }
+ toString() {
+ return this.kind;
}
- get numberOfParams() {
- return this._numberOfParams;
+ };
+ exports2.ParameterStructures = ParameterStructures;
+ ParameterStructures.auto = new ParameterStructures("auto");
+ ParameterStructures.byPosition = new ParameterStructures("byPosition");
+ ParameterStructures.byName = new ParameterStructures("byName");
+ var AbstractMessageSignature = class {
+ constructor(method, numberOfParams) {
+ this.method = method;
+ this.numberOfParams = numberOfParams;
+ }
+ get parameterStructures() {
+ return ParameterStructures.auto;
}
};
- exports2.AbstractMessageType = AbstractMessageType;
- var RequestType0 = class extends AbstractMessageType {
+ exports2.AbstractMessageSignature = AbstractMessageSignature;
+ var RequestType0 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 0);
}
};
exports2.RequestType0 = RequestType0;
- var RequestType = class extends AbstractMessageType {
- constructor(method) {
+ var RequestType = class extends AbstractMessageSignature {
+ constructor(method, _parameterStructures = ParameterStructures.auto) {
super(method, 1);
+ this._parameterStructures = _parameterStructures;
+ }
+ get parameterStructures() {
+ return this._parameterStructures;
}
};
exports2.RequestType = RequestType;
- var RequestType1 = class extends AbstractMessageType {
- constructor(method) {
+ var RequestType1 = class extends AbstractMessageSignature {
+ constructor(method, _parameterStructures = ParameterStructures.auto) {
super(method, 1);
+ this._parameterStructures = _parameterStructures;
+ }
+ get parameterStructures() {
+ return this._parameterStructures;
}
};
exports2.RequestType1 = RequestType1;
- var RequestType2 = class extends AbstractMessageType {
+ var RequestType2 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 2);
}
};
exports2.RequestType2 = RequestType2;
- var RequestType3 = class extends AbstractMessageType {
+ var RequestType3 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 3);
}
};
exports2.RequestType3 = RequestType3;
- var RequestType4 = class extends AbstractMessageType {
+ var RequestType4 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 4);
}
};
exports2.RequestType4 = RequestType4;
- var RequestType5 = class extends AbstractMessageType {
+ var RequestType5 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 5);
}
};
exports2.RequestType5 = RequestType5;
- var RequestType6 = class extends AbstractMessageType {
+ var RequestType6 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 6);
}
};
exports2.RequestType6 = RequestType6;
- var RequestType7 = class extends AbstractMessageType {
+ var RequestType7 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 7);
}
};
exports2.RequestType7 = RequestType7;
- var RequestType8 = class extends AbstractMessageType {
+ var RequestType8 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 8);
}
};
exports2.RequestType8 = RequestType8;
- var RequestType9 = class extends AbstractMessageType {
+ var RequestType9 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 9);
}
};
exports2.RequestType9 = RequestType9;
- var NotificationType = class extends AbstractMessageType {
- constructor(method) {
+ var NotificationType = class extends AbstractMessageSignature {
+ constructor(method, _parameterStructures = ParameterStructures.auto) {
super(method, 1);
- this._ = void 0;
+ this._parameterStructures = _parameterStructures;
+ }
+ get parameterStructures() {
+ return this._parameterStructures;
}
};
exports2.NotificationType = NotificationType;
- var NotificationType0 = class extends AbstractMessageType {
+ var NotificationType0 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 0);
}
};
exports2.NotificationType0 = NotificationType0;
- var NotificationType1 = class extends AbstractMessageType {
- constructor(method) {
+ var NotificationType1 = class extends AbstractMessageSignature {
+ constructor(method, _parameterStructures = ParameterStructures.auto) {
super(method, 1);
+ this._parameterStructures = _parameterStructures;
+ }
+ get parameterStructures() {
+ return this._parameterStructures;
}
};
exports2.NotificationType1 = NotificationType1;
- var NotificationType2 = class extends AbstractMessageType {
+ var NotificationType2 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 2);
}
};
exports2.NotificationType2 = NotificationType2;
- var NotificationType3 = class extends AbstractMessageType {
+ var NotificationType3 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 3);
}
};
exports2.NotificationType3 = NotificationType3;
- var NotificationType4 = class extends AbstractMessageType {
+ var NotificationType4 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 4);
}
};
exports2.NotificationType4 = NotificationType4;
- var NotificationType5 = class extends AbstractMessageType {
+ var NotificationType5 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 5);
}
};
exports2.NotificationType5 = NotificationType5;
- var NotificationType6 = class extends AbstractMessageType {
+ var NotificationType6 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 6);
}
};
exports2.NotificationType6 = NotificationType6;
- var NotificationType7 = class extends AbstractMessageType {
+ var NotificationType7 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 7);
}
};
exports2.NotificationType7 = NotificationType7;
- var NotificationType8 = class extends AbstractMessageType {
+ var NotificationType8 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 8);
}
};
exports2.NotificationType8 = NotificationType8;
- var NotificationType9 = class extends AbstractMessageType {
+ var NotificationType9 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 9);
}
};
exports2.NotificationType9 = NotificationType9;
function isRequestMessage(message) {
- let candidate = message;
+ const candidate = message;
return candidate && is2.string(candidate.method) && (is2.string(candidate.id) || is2.number(candidate.id));
}
exports2.isRequestMessage = isRequestMessage;
function isNotificationMessage(message) {
- let candidate = message;
+ const candidate = message;
return candidate && is2.string(candidate.method) && message.id === void 0;
}
exports2.isNotificationMessage = isNotificationMessage;
function isResponseMessage(message) {
- let candidate = message;
+ const candidate = message;
return candidate && (candidate.result !== void 0 || !!candidate.error) && (is2.string(candidate.id) || is2.number(candidate.id) || candidate.id === null);
}
exports2.isResponseMessage = isResponseMessage;
});
-// node_modules/vscode-jsonrpc/lib/events.js
+// node_modules/vscode-jsonrpc/lib/common/events.js
var require_events = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
- var Disposable12;
- (function(Disposable13) {
- function create(func) {
- return {
- dispose: func
- };
- }
- Disposable13.create = create;
- })(Disposable12 = exports2.Disposable || (exports2.Disposable = {}));
+ exports2.Emitter = exports2.Event = void 0;
+ var ral_1 = require_ral();
var Event5;
(function(Event6) {
const _disposable = {dispose() {
if (!this._callbacks) {
return;
}
- var foundCallbackWithDifferentContext = false;
- for (var i = 0, len = this._callbacks.length; i < len; i++) {
+ let foundCallbackWithDifferentContext = false;
+ for (let i = 0, len = this._callbacks.length; i < len; i++) {
if (this._callbacks[i] === callback) {
if (this._contexts[i] === context) {
this._callbacks.splice(i, 1);
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++) {
+ const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
+ for (let i = 0, len = callbacks.length; i < len; i++) {
try {
ret.push(callbacks[i].apply(contexts[i], args));
} catch (e) {
- console.error(e);
+ ral_1.default().console.error(e);
}
}
return ret;
this._options.onFirstListenerAdd(this);
}
this._callbacks.add(listener, thisArgs);
- let result;
- result = {
+ const result = {
dispose: () => {
+ if (!this._callbacks) {
+ return;
+ }
this._callbacks.remove(listener, thisArgs);
result.dispose = Emitter6._noop;
if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
};
});
-// node_modules/vscode-jsonrpc/lib/messageReader.js
-var require_messageReader = __commonJS((exports2) => {
+// node_modules/vscode-jsonrpc/lib/common/cancellation.js
+var require_cancellation = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
- var events_1 = require_events();
+ exports2.CancellationTokenSource = exports2.CancellationToken = void 0;
+ var ral_1 = require_ral();
var Is = require_is();
- var DefaultSize2 = 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(DefaultSize2);
+ var events_1 = require_events();
+ var CancellationToken20;
+ (function(CancellationToken21) {
+ CancellationToken21.None = Object.freeze({
+ isCancellationRequested: false,
+ onCancellationRequested: events_1.Event.None
+ });
+ CancellationToken21.Cancelled = Object.freeze({
+ isCancellationRequested: true,
+ onCancellationRequested: events_1.Event.None
+ });
+ function is2(value) {
+ const candidate = value;
+ return candidate && (candidate === CancellationToken21.None || candidate === CancellationToken21.Cancelled || Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested);
}
- 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) / DefaultSize2) + 1) * DefaultSize2;
- 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);
+ CancellationToken21.is = is2;
+ })(CancellationToken20 = exports2.CancellationToken || (exports2.CancellationToken = {}));
+ var shortcutEvent = Object.freeze(function(callback, context) {
+ const handle = ral_1.default().timer.setTimeout(callback.bind(context), 0);
+ return {dispose() {
+ ral_1.default().timer.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();
}
}
- 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++;
+ get isCancellationRequested() {
+ return this._isCancelled;
+ }
+ get onCancellationRequested() {
+ if (this._isCancelled) {
+ return shortcutEvent;
}
- if (current + 3 >= this.index) {
- return result;
+ if (!this._emitter) {
+ this._emitter = new events_1.Emitter();
}
- 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;
+ return this._emitter.event;
}
- tryReadContent(length) {
- if (this.index < length) {
- return null;
+ dispose() {
+ if (this._emitter) {
+ this._emitter.dispose();
+ this._emitter = void 0;
}
- 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 CancellationTokenSource4 = class {
+ get token() {
+ if (!this._token) {
+ this._token = new MutableToken();
+ }
+ return this._token;
+ }
+ cancel() {
+ if (!this._token) {
+ this._token = CancellationToken20.Cancelled;
+ } else {
+ this._token.cancel();
+ }
+ }
+ dispose() {
+ if (!this._token) {
+ this._token = CancellationToken20.None;
+ } else if (this._token instanceof MutableToken) {
+ this._token.dispose();
+ }
}
};
+ exports2.CancellationTokenSource = CancellationTokenSource4;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/messageReader.js
+var require_messageReader = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.ReadableStreamMessageReader = exports2.AbstractMessageReader = exports2.MessageReader = void 0;
+ var ral_1 = require_ral();
+ var Is = require_is();
+ var events_1 = require_events();
var MessageReader;
(function(MessageReader2) {
function is2(value) {
}
};
exports2.AbstractMessageReader = AbstractMessageReader;
- var StreamMessageReader = class extends AbstractMessageReader {
- constructor(readable, encoding = "utf8") {
+ var ResolvedMessageReaderOptions;
+ (function(ResolvedMessageReaderOptions2) {
+ function fromOptions(options) {
+ var _a;
+ let charset;
+ let result;
+ let contentDecoder;
+ const contentDecoders = new Map();
+ let contentTypeDecoder;
+ const contentTypeDecoders = new Map();
+ if (options === void 0 || typeof options === "string") {
+ charset = options !== null && options !== void 0 ? options : "utf-8";
+ } else {
+ charset = (_a = options.charset) !== null && _a !== void 0 ? _a : "utf-8";
+ if (options.contentDecoder !== void 0) {
+ contentDecoder = options.contentDecoder;
+ contentDecoders.set(contentDecoder.name, contentDecoder);
+ }
+ if (options.contentDecoders !== void 0) {
+ for (const decoder of options.contentDecoders) {
+ contentDecoders.set(decoder.name, decoder);
+ }
+ }
+ if (options.contentTypeDecoder !== void 0) {
+ contentTypeDecoder = options.contentTypeDecoder;
+ contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
+ }
+ if (options.contentTypeDecoders !== void 0) {
+ for (const decoder of options.contentTypeDecoders) {
+ contentTypeDecoders.set(decoder.name, decoder);
+ }
+ }
+ }
+ if (contentTypeDecoder === void 0) {
+ contentTypeDecoder = ral_1.default().applicationJson.decoder;
+ contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
+ }
+ return {charset, contentDecoder, contentDecoders, contentTypeDecoder, contentTypeDecoders};
+ }
+ ResolvedMessageReaderOptions2.fromOptions = fromOptions;
+ })(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {}));
+ var ReadableStreamMessageReader = class extends AbstractMessageReader {
+ constructor(readable, options) {
super();
this.readable = readable;
- this.buffer = new MessageBuffer(encoding);
+ this.options = ResolvedMessageReaderOptions.fromOptions(options);
+ this.buffer = ral_1.default().messageBuffer.create(this.options.charset);
this._partialMessageTimeout = 1e4;
+ this.nextMessageLength = -1;
+ this.messageToken = 0;
}
set partialMessageTimeout(timeout) {
this._partialMessageTimeout = timeout;
this.messageToken = 0;
this.partialMessageTimer = void 0;
this.callback = callback;
- this.readable.on("data", (data) => {
+ const result = this.readable.onData((data) => {
this.onData(data);
});
- this.readable.on("error", (error) => this.fireError(error));
- this.readable.on("close", () => this.fireClose());
+ this.readable.onError((error) => this.fireError(error));
+ this.readable.onClose(() => this.fireClose());
+ return result;
}
onData(data) {
this.buffer.append(data);
while (true) {
if (this.nextMessageLength === -1) {
- let headers = this.buffer.tryReadHeaders();
+ const headers = this.buffer.tryReadHeaders();
if (!headers) {
return;
}
- let contentLength = headers["Content-Length"];
+ const contentLength = headers.get("Content-Length");
if (!contentLength) {
throw new Error("Header must provide a Content-Length property.");
}
- let length = parseInt(contentLength);
+ const 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) {
+ const body = this.buffer.tryReadBody(this.nextMessageLength);
+ if (body === void 0) {
this.setPartialMessageTimer();
return;
}
this.clearPartialMessageTimer();
this.nextMessageLength = -1;
- this.messageToken++;
- var json = JSON.parse(msg);
- this.callback(json);
+ let p;
+ if (this.options.contentDecoder !== void 0) {
+ p = this.options.contentDecoder.decode(body);
+ } else {
+ p = Promise.resolve(body);
+ }
+ p.then((value) => {
+ this.options.contentTypeDecoder.decode(value, this.options).then((msg) => {
+ this.callback(msg);
+ }, (error) => {
+ this.fireError(error);
+ });
+ }, (error) => {
+ this.fireError(error);
+ });
}
}
clearPartialMessageTimer() {
if (this.partialMessageTimer) {
- clearTimeout(this.partialMessageTimer);
+ ral_1.default().timer.clearTimeout(this.partialMessageTimer);
this.partialMessageTimer = void 0;
}
}
if (this._partialMessageTimeout <= 0) {
return;
}
- this.partialMessageTimer = setTimeout((token, timeout) => {
+ this.partialMessageTimer = ral_1.default().timer.setTimeout((token, timeout) => {
this.partialMessageTimer = void 0;
if (token === this.messageToken) {
this.firePartialMessage({messageToken: token, waitingTime: timeout});
}, 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());
+ exports2.ReadableStreamMessageReader = ReadableStreamMessageReader;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/semaphore.js
+var require_semaphore = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.Semaphore = void 0;
+ var ral_1 = require_ral();
+ var Semaphore = class {
+ constructor(capacity = 1) {
+ if (capacity <= 0) {
+ throw new Error("Capacity must be greater than 0");
+ }
+ this._capacity = capacity;
+ this._active = 0;
+ this._waiting = [];
+ }
+ lock(thunk) {
+ return new Promise((resolve, reject) => {
+ this._waiting.push({thunk, resolve, reject});
+ this.runNext();
+ });
}
- listen(callback) {
- this.process.on("message", callback);
+ get active() {
+ return this._active;
}
- };
- exports2.IPCMessageReader = IPCMessageReader;
- var SocketMessageReader = class extends StreamMessageReader {
- constructor(socket, encoding = "utf-8") {
- super(socket, encoding);
+ runNext() {
+ if (this._waiting.length === 0 || this._active === this._capacity) {
+ return;
+ }
+ ral_1.default().timer.setImmediate(() => this.doRunNext());
+ }
+ doRunNext() {
+ if (this._waiting.length === 0 || this._active === this._capacity) {
+ return;
+ }
+ const next = this._waiting.shift();
+ this._active++;
+ if (this._active > this._capacity) {
+ throw new Error(`To many thunks active`);
+ }
+ try {
+ const result = next.thunk();
+ if (result instanceof Promise) {
+ result.then((value) => {
+ this._active--;
+ next.resolve(value);
+ this.runNext();
+ }, (err) => {
+ this._active--;
+ next.reject(err);
+ this.runNext();
+ });
+ } else {
+ this._active--;
+ next.resolve(result);
+ this.runNext();
+ }
+ } catch (err) {
+ this._active--;
+ next.reject(err);
+ this.runNext();
+ }
}
};
- exports2.SocketMessageReader = SocketMessageReader;
+ exports2.Semaphore = Semaphore;
});
-// node_modules/vscode-jsonrpc/lib/messageWriter.js
+// node_modules/vscode-jsonrpc/lib/common/messageWriter.js
var require_messageWriter = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
- var events_1 = require_events();
+ exports2.WriteableStreamMessageWriter = exports2.AbstractMessageWriter = exports2.MessageWriter = void 0;
+ var ral_1 = require_ral();
var Is = require_is();
+ var semaphore_1 = require_semaphore();
+ var events_1 = require_events();
var ContentLength2 = "Content-Length: ";
var CRLF = "\r\n";
var MessageWriter;
}
};
exports2.AbstractMessageWriter = AbstractMessageWriter;
- var StreamMessageWriter = class extends AbstractMessageWriter {
- constructor(writable, encoding = "utf8") {
+ var ResolvedMessageWriterOptions;
+ (function(ResolvedMessageWriterOptions2) {
+ function fromOptions(options) {
+ var _a, _b;
+ if (options === void 0 || typeof options === "string") {
+ return {charset: options !== null && options !== void 0 ? options : "utf-8", contentTypeEncoder: ral_1.default().applicationJson.encoder};
+ } else {
+ return {charset: (_a = options.charset) !== null && _a !== void 0 ? _a : "utf-8", contentEncoder: options.contentEncoder, contentTypeEncoder: (_b = options.contentTypeEncoder) !== null && _b !== void 0 ? _b : ral_1.default().applicationJson.encoder};
+ }
+ }
+ ResolvedMessageWriterOptions2.fromOptions = fromOptions;
+ })(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {}));
+ var WriteableStreamMessageWriter = class extends AbstractMessageWriter {
+ constructor(writable, options) {
super();
this.writable = writable;
- this.encoding = encoding;
+ this.options = ResolvedMessageWriterOptions.fromOptions(options);
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 = [
- ContentLength2,
- 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 = [
- ContentLength2,
- 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);
+ this.writeSemaphore = new semaphore_1.Semaphore(1);
+ this.writable.onError((error) => this.fireError(error));
+ this.writable.onClose(() => this.fireClose());
+ }
+ async write(msg) {
+ return this.writeSemaphore.lock(async () => {
+ const payload = this.options.contentTypeEncoder.encode(msg, this.options).then((buffer) => {
+ if (this.options.contentEncoder !== void 0) {
+ return this.options.contentEncoder.encode(buffer);
+ } else {
+ return buffer;
}
});
+ return payload.then((buffer) => {
+ const headers = [];
+ headers.push(ContentLength2, buffer.byteLength.toString(), CRLF);
+ headers.push(CRLF);
+ return this.doWrite(msg, headers, buffer);
+ }, (error) => {
+ this.fireError(error);
+ throw error;
+ });
+ });
+ }
+ async doWrite(msg, headers, data) {
+ try {
+ await this.writable.write(headers.join(""), "ascii");
+ return this.writable.write(data);
} catch (error) {
this.handleError(error, msg);
+ return Promise.reject(error);
}
}
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 CancellationToken19;
- (function(CancellationToken20) {
- CancellationToken20.None = Object.freeze({
- isCancellationRequested: false,
- onCancellationRequested: events_1.Event.None
- });
- CancellationToken20.Cancelled = Object.freeze({
- isCancellationRequested: true,
- onCancellationRequested: events_1.Event.None
- });
- function is2(value) {
- let candidate = value;
- return candidate && (candidate === CancellationToken20.None || candidate === CancellationToken20.Cancelled || Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested);
- }
- CancellationToken20.is = is2;
- })(CancellationToken19 = 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 CancellationTokenSource3 = class {
- get token() {
- if (!this._token) {
- this._token = new MutableToken();
- }
- return this._token;
- }
- cancel() {
- if (!this._token) {
- this._token = CancellationToken19.Cancelled;
- } else {
- this._token.cancel();
- }
- }
- dispose() {
- if (!this._token) {
- this._token = CancellationToken19.None;
- } else if (this._token instanceof MutableToken) {
- this._token.dispose();
- }
+ end() {
+ this.writable.end();
}
};
- exports2.CancellationTokenSource = CancellationTokenSource3;
+ exports2.WriteableStreamMessageWriter = WriteableStreamMessageWriter;
});
-// node_modules/vscode-jsonrpc/lib/linkedMap.js
+// node_modules/vscode-jsonrpc/lib/common/linkedMap.js
var require_linkedMap = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.LRUCache = exports2.LinkedMap = exports2.Touch = void 0;
var Touch;
(function(Touch2) {
Touch2.None = 0;
Touch2.First = 1;
+ Touch2.AsOld = Touch2.First;
Touch2.Last = 2;
+ Touch2.AsNew = Touch2.Last;
})(Touch = exports2.Touch || (exports2.Touch = {}));
var LinkedMap = class {
constructor() {
+ this[Symbol.toStringTag] = "LinkedMap";
this._map = new Map();
this._head = void 0;
this._tail = void 0;
this._size = 0;
+ this._state = 0;
}
clear() {
this._map.clear();
this._head = void 0;
this._tail = void 0;
this._size = 0;
+ this._state++;
}
isEmpty() {
return !this._head && !this._tail;
get size() {
return this._size;
}
+ get first() {
+ var _a;
+ return (_a = this._head) === null || _a === void 0 ? void 0 : _a.value;
+ }
+ get last() {
+ var _a;
+ return (_a = this._tail) === null || _a === void 0 ? void 0 : _a.value;
+ }
has(key) {
return this._map.has(key);
}
- get(key) {
+ get(key, touch = Touch.None) {
const item = this._map.get(key);
if (!item) {
return void 0;
}
+ if (touch !== Touch.None) {
+ this.touch(item, touch);
+ }
return item.value;
}
set(key, value, touch = Touch.None) {
this._map.set(key, item);
this._size++;
}
+ return this;
}
delete(key) {
+ return !!this.remove(key);
+ }
+ remove(key) {
const item = this._map.get(key);
if (!item) {
- return false;
+ return void 0;
}
this._map.delete(key);
this.removeItem(item);
this._size--;
- return true;
+ return item.value;
}
shift() {
if (!this._head && !this._tail) {
return item.value;
}
forEach(callbackfn, thisArg) {
+ const state = this._state;
let current = this._head;
while (current) {
if (thisArg) {
} else {
callbackfn(current.value, current.key, this);
}
+ if (this._state !== state) {
+ throw new Error(`LinkedMap got modified during iteration.`);
+ }
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);
+ keys() {
+ const map = this;
+ const state = this._state;
+ let current = this._head;
+ const iterator = {
+ [Symbol.iterator]() {
+ return iterator;
+ },
+ next() {
+ if (map._state !== state) {
+ throw new Error(`LinkedMap got modified during iteration.`);
+ }
+ if (current) {
+ const result = {value: current.key, done: false};
+ current = current.next;
+ return result;
+ } else {
+ return {value: void 0, done: true};
+ }
}
- current = current.previous;
- }
+ };
+ return iterator;
}
values() {
- let result = [];
+ const map = this;
+ const state = this._state;
let current = this._head;
- while (current) {
- result.push(current.value);
- current = current.next;
- }
- return result;
+ const iterator = {
+ [Symbol.iterator]() {
+ return iterator;
+ },
+ next() {
+ if (map._state !== state) {
+ throw new Error(`LinkedMap got modified during iteration.`);
+ }
+ if (current) {
+ const result = {value: current.value, done: false};
+ current = current.next;
+ return result;
+ } else {
+ return {value: void 0, done: true};
+ }
+ }
+ };
+ return iterator;
}
- keys() {
- let result = [];
+ entries() {
+ const map = this;
+ const state = this._state;
let current = this._head;
- while (current) {
- result.push(current.key);
+ const iterator = {
+ [Symbol.iterator]() {
+ return iterator;
+ },
+ next() {
+ if (map._state !== state) {
+ throw new Error(`LinkedMap got modified during iteration.`);
+ }
+ if (current) {
+ const result = {value: [current.key, current.value], done: false};
+ current = current.next;
+ return result;
+ } else {
+ return {value: void 0, done: true};
+ }
+ }
+ };
+ return iterator;
+ }
+ [Symbol.iterator]() {
+ return this.entries();
+ }
+ trimOld(newSize) {
+ if (newSize >= this.size) {
+ return;
+ }
+ if (newSize === 0) {
+ this.clear();
+ return;
+ }
+ let current = this._head;
+ let currentSize = this.size;
+ while (current && currentSize > newSize) {
+ this._map.delete(current.key);
current = current.next;
+ currentSize--;
}
- return result;
+ this._head = current;
+ this._size = currentSize;
+ if (current) {
+ current.previous = void 0;
+ }
+ this._state++;
}
addItemFirst(item) {
if (!this._head && !this._tail) {
this._head.previous = item;
}
this._head = item;
+ this._state++;
}
addItemLast(item) {
if (!this._head && !this._tail) {
this._tail.next = item;
}
this._tail = item;
+ this._state++;
}
removeItem(item) {
if (item === this._head && item === this._tail) {
this._head = void 0;
this._tail = void 0;
} else if (item === this._head) {
+ if (!item.next) {
+ throw new Error("Invalid list");
+ }
+ item.next.previous = void 0;
this._head = item.next;
} else if (item === this._tail) {
+ if (!item.previous) {
+ throw new Error("Invalid list");
+ }
+ item.previous.next = void 0;
this._tail = item.previous;
} else {
const next = item.next;
next.previous = previous;
previous.next = next;
}
+ item.next = void 0;
+ item.previous = void 0;
+ this._state++;
}
touch(item, touch) {
if (!this._head || !this._tail) {
item.next = this._head;
this._head.previous = item;
this._head = item;
+ this._state++;
} else if (touch === Touch.Last) {
if (item === this._tail) {
return;
item.previous = this._tail;
this._tail.next = item;
this._tail = item;
+ this._state++;
}
}
- };
- 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)
- ]);
+ toJSON() {
+ const data = [];
+ this.forEach((value, key) => {
+ data.push([key, value]);
});
- 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;
+ return data;
+ }
+ fromJSON(data) {
+ this.clear();
+ for (const [key, value] of data) {
+ this.set(key, value);
+ }
+ }
+ };
+ exports2.LinkedMap = LinkedMap;
+ var LRUCache = class extends LinkedMap {
+ constructor(limit, ratio = 1) {
+ super();
+ this._limit = limit;
+ this._ratio = Math.min(Math.max(0, ratio), 1);
+ }
+ get limit() {
+ return this._limit;
+ }
+ set limit(limit) {
+ this._limit = limit;
+ this.checkTrim();
+ }
+ get ratio() {
+ return this._ratio;
+ }
+ set ratio(ratio) {
+ this._ratio = Math.min(Math.max(0, ratio), 1);
+ this.checkTrim();
+ }
+ get(key, touch = Touch.AsNew) {
+ return super.get(key, touch);
+ }
+ peek(key) {
+ return super.get(key, Touch.None);
+ }
+ set(key, value) {
+ super.set(key, value, Touch.Last);
+ this.checkTrim();
+ return this;
+ }
+ checkTrim() {
+ if (this.size > this._limit) {
+ this.trimOld(Math.round(this._limit * this._ratio));
+ }
+ }
+ };
+ exports2.LRUCache = LRUCache;
});
-// node_modules/vscode-jsonrpc/lib/main.js
-var require_main = __commonJS((exports2) => {
+// node_modules/vscode-jsonrpc/lib/common/connection.js
+var require_connection = __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});
+ exports2.createMessageConnection = exports2.ConnectionOptions = exports2.CancellationStrategy = exports2.CancellationSenderStrategy = exports2.CancellationReceiverStrategy = exports2.ConnectionStrategy = exports2.ConnectionError = exports2.ConnectionErrors = exports2.LogTraceNotification = exports2.SetTraceNotification = exports2.TraceFormat = exports2.Trace = exports2.NullLogger = exports2.ProgressType = void 0;
+ var ral_1 = require_ral();
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 linkedMap_1 = require_linkedMap();
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");
}
};
exports2.ProgressType = ProgressType;
+ var StarRequestHandler;
+ (function(StarRequestHandler2) {
+ function is2(value) {
+ return Is.func(value);
+ }
+ StarRequestHandler2.is = is2;
+ })(StarRequestHandler || (StarRequestHandler = {}));
exports2.NullLogger = Object.freeze({
error: () => {
},
})(TraceFormat = exports2.TraceFormat || (exports2.TraceFormat = {}));
var SetTraceNotification;
(function(SetTraceNotification2) {
- SetTraceNotification2.type = new messages_1.NotificationType("$/setTraceNotification");
+ SetTraceNotification2.type = new messages_1.NotificationType("$/setTrace");
})(SetTraceNotification = exports2.SetTraceNotification || (exports2.SetTraceNotification = {}));
var LogTraceNotification;
(function(LogTraceNotification2) {
- LogTraceNotification2.type = new messages_1.NotificationType("$/logTraceNotification");
+ LogTraceNotification2.type = new messages_1.NotificationType("$/logTrace");
})(LogTraceNotification = exports2.LogTraceNotification || (exports2.LogTraceNotification = {}));
var ConnectionErrors;
(function(ConnectionErrors2) {
var ConnectionStrategy;
(function(ConnectionStrategy2) {
function is2(value) {
- let candidate = value;
+ const candidate = value;
return candidate && Is.func(candidate.cancelUndispatched);
}
ConnectionStrategy2.is = is2;
})(ConnectionStrategy = exports2.ConnectionStrategy || (exports2.ConnectionStrategy = {}));
+ var CancellationReceiverStrategy;
+ (function(CancellationReceiverStrategy2) {
+ CancellationReceiverStrategy2.Message = Object.freeze({
+ createCancellationTokenSource(_) {
+ return new cancellation_1.CancellationTokenSource();
+ }
+ });
+ function is2(value) {
+ const candidate = value;
+ return candidate && Is.func(candidate.createCancellationTokenSource);
+ }
+ CancellationReceiverStrategy2.is = is2;
+ })(CancellationReceiverStrategy = exports2.CancellationReceiverStrategy || (exports2.CancellationReceiverStrategy = {}));
+ var CancellationSenderStrategy;
+ (function(CancellationSenderStrategy2) {
+ CancellationSenderStrategy2.Message = Object.freeze({
+ sendCancellation(conn, id) {
+ conn.sendNotification(CancelNotification.type, {id});
+ },
+ cleanup(_) {
+ }
+ });
+ function is2(value) {
+ const candidate = value;
+ return candidate && Is.func(candidate.sendCancellation) && Is.func(candidate.cleanup);
+ }
+ CancellationSenderStrategy2.is = is2;
+ })(CancellationSenderStrategy = exports2.CancellationSenderStrategy || (exports2.CancellationSenderStrategy = {}));
+ var CancellationStrategy;
+ (function(CancellationStrategy2) {
+ CancellationStrategy2.Message = Object.freeze({
+ receiver: CancellationReceiverStrategy.Message,
+ sender: CancellationSenderStrategy.Message
+ });
+ function is2(value) {
+ const candidate = value;
+ return candidate && CancellationReceiverStrategy.is(candidate.receiver) && CancellationSenderStrategy.is(candidate.sender);
+ }
+ CancellationStrategy2.is = is2;
+ })(CancellationStrategy = exports2.CancellationStrategy || (exports2.CancellationStrategy = {}));
+ var ConnectionOptions;
+ (function(ConnectionOptions2) {
+ function is2(value) {
+ const candidate = value;
+ return candidate && (CancellationStrategy.is(candidate.cancellationStrategy) || ConnectionStrategy.is(candidate.connectionStrategy));
+ }
+ ConnectionOptions2.is = is2;
+ })(ConnectionOptions = exports2.ConnectionOptions || (exports2.ConnectionOptions = {}));
var ConnectionState;
(function(ConnectionState2) {
ConnectionState2[ConnectionState2["New"] = 1] = "New";
ConnectionState2[ConnectionState2["Closed"] = 3] = "Closed";
ConnectionState2[ConnectionState2["Disposed"] = 4] = "Disposed";
})(ConnectionState || (ConnectionState = {}));
- function _createMessageConnection(messageReader, messageWriter, logger, strategy) {
+ function createMessageConnection(messageReader, messageWriter, _logger, options) {
+ const logger = _logger !== void 0 ? _logger : exports2.NullLogger;
let sequenceNumber = 0;
let notificationSquenceNumber = 0;
let unknownResponseSquenceNumber = 0;
const version = "2.0";
let starRequestHandler = void 0;
- let requestHandlers = Object.create(null);
+ const requestHandlers = Object.create(null);
let starNotificationHandler = void 0;
- let notificationHandlers = Object.create(null);
- let progressHandlers = new Map();
+ const notificationHandlers = Object.create(null);
+ const progressHandlers = new Map();
let timer;
let messageQueue = new linkedMap_1.LinkedMap();
let responsePromises = Object.create(null);
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();
+ const errorEmitter = new events_1.Emitter();
+ const closeEmitter = new events_1.Emitter();
+ const unhandledNotificationEmitter = new events_1.Emitter();
+ const unhandledProgressEmitter = new events_1.Emitter();
+ const disposeEmitter = new events_1.Emitter();
+ const cancellationStrategy = options && options.cancellationStrategy ? options.cancellationStrategy : CancellationStrategy.Message;
function createRequestQueueKey(id) {
+ if (id === null) {
+ throw new Error(`Can't send requests with id null since the response can't be correlated.`);
+ }
return "req-" + id.toString();
}
function createResponseQueueKey(id) {
if (timer || messageQueue.size === 0) {
return;
}
- timer = setImmediate(() => {
+ timer = ral_1.default().timer.setImmediate(() => {
timer = void 0;
processMessageQueue();
});
if (messageQueue.size === 0) {
return;
}
- let message = messageQueue.shift();
+ const message = messageQueue.shift();
try {
if (messages_1.isRequestMessage(message)) {
handleRequest(message);
triggerMessageQueue();
}
}
- let callback = (message) => {
+ const callback = (message) => {
try {
if (messages_1.isNotificationMessage(message) && message.method === CancelNotification.type.method) {
- let key = createRequestQueueKey(message.params.id);
- let toCancel = messageQueue.get(key);
+ const key = createRequestQueueKey(message.params.id);
+ const toCancel = messageQueue.get(key);
if (messages_1.isRequestMessage(toCancel)) {
- let response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
+ const strategy = options === null || options === void 0 ? void 0 : options.connectionStrategy;
+ const 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;
return;
}
function reply(resultOrError, method, startTime2) {
- let message = {
+ const message = {
jsonrpc: version,
id: requestMessage.id
};
messageWriter.write(message);
}
function replyError(error, method, startTime2) {
- let message = {
+ const message = {
jsonrpc: version,
id: requestMessage.id,
error: error.toJson()
if (result === void 0) {
result = null;
}
- let message = {
+ const message = {
jsonrpc: version,
id: requestMessage.id,
result
messageWriter.write(message);
}
traceReceivedRequest(requestMessage);
- let element = requestHandlers[requestMessage.method];
+ const element = requestHandlers[requestMessage.method];
let type;
let requestHandler;
if (element) {
type = element.type;
requestHandler = element.handler;
}
- let startTime = Date.now();
+ const startTime = Date.now();
if (requestHandler || starRequestHandler) {
- let cancellationSource = new cancellation_1.CancellationTokenSource();
- let tokenKey = String(requestMessage.id);
+ const tokenKey = String(requestMessage.id);
+ const cancellationSource = cancellationStrategy.receiver.createCancellationTokenSource(tokenKey);
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);
+ if (requestHandler) {
+ if (requestMessage.params === void 0) {
+ if (type !== void 0 && type.numberOfParams !== 0) {
+ replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines ${type.numberOfParams} params but recevied none.`), requestMessage.method, startTime);
+ return;
+ }
+ handlerResult = requestHandler(cancellationSource.token);
+ } else if (Array.isArray(requestMessage.params)) {
+ if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byName) {
+ replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by name but received parameters by position`), requestMessage.method, startTime);
+ return;
+ }
+ handlerResult = requestHandler(...requestMessage.params, cancellationSource.token);
+ } else {
+ if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
+ replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by position but received parameters by name`), requestMessage.method, startTime);
+ return;
+ }
+ handlerResult = requestHandler(requestMessage.params, cancellationSource.token);
+ }
+ } else if (starRequestHandler) {
+ handlerResult = starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);
}
- let promise = handlerResult;
+ const promise = handlerResult;
if (!handlerResult) {
delete requestTokens[tokenKey];
replySuccess(handlerResult, requestMessage.method, startTime);
logger.error(`Received response message without id. No further error information provided.`);
}
} else {
- let key = String(responseMessage.id);
- let responsePromise = responsePromises[key];
+ const key = String(responseMessage.id);
+ const responsePromise = responsePromises[key];
traceReceivedResponse(responseMessage, responsePromise);
if (responsePromise) {
delete responsePromises[key];
try {
if (responseMessage.error) {
- let error = responseMessage.error;
+ const 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);
let notificationHandler;
if (message.method === CancelNotification.type.method) {
notificationHandler = (params) => {
- let id = params.id;
- let source = requestTokens[String(id)];
+ const id = params.id;
+ const source = requestTokens[String(id)];
if (source) {
source.cancel();
}
};
} else {
- let element = notificationHandlers[message.method];
+ const 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);
+ if (notificationHandler) {
+ if (message.params === void 0) {
+ if (type !== void 0) {
+ if (type.numberOfParams !== 0 && type.parameterStructures !== messages_1.ParameterStructures.byName) {
+ logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but recevied none.`);
+ }
+ }
+ notificationHandler();
+ } else if (Array.isArray(message.params)) {
+ if (type !== void 0) {
+ if (type.parameterStructures === messages_1.ParameterStructures.byName) {
+ logger.error(`Notification ${message.method} defines parameters by name but received parameters by position`);
+ }
+ if (type.numberOfParams !== message.params.length) {
+ logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received ${message.params.length} argumennts`);
+ }
+ }
+ notificationHandler(...message.params);
+ } else {
+ if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
+ logger.error(`Notification ${message.method} defines parameters by position but received parameters by name`);
+ }
+ notificationHandler(message.params);
+ }
+ } else if (starNotificationHandler) {
+ starNotificationHandler(message.method, message.params);
}
} catch (error) {
if (error.message) {
}
logger.error(`Received message which is neither a response nor a notification message:
${JSON.stringify(message, null, 4)}`);
- let responseMessage = message;
+ const responseMessage = message;
if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) {
- let key = String(responseMessage.id);
- let responseHandler = responsePromises[key];
+ const key = String(responseMessage.id);
+ const responseHandler = responsePromises[key];
if (responseHandler) {
responseHandler.reject(new Error("The received response has neither a result nor an error property."));
}
}
}
if (responsePromise) {
- let error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : "";
+ const error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : "";
tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);
} else {
tracer.log(`Received response ${message.id} without active response promise.`, data);
return param;
}
}
+ function nullToUndefined(param) {
+ if (param === null) {
+ return void 0;
+ } else {
+ return param;
+ }
+ }
+ function isNamedParam(param) {
+ return param !== void 0 && param !== null && !Array.isArray(param) && typeof param === "object";
+ }
+ function computeSingleParam(parameterStructures, param) {
+ switch (parameterStructures) {
+ case messages_1.ParameterStructures.auto:
+ if (isNamedParam(param)) {
+ return nullToUndefined(param);
+ } else {
+ return [undefinedToNull(param)];
+ }
+ break;
+ case messages_1.ParameterStructures.byName:
+ if (!isNamedParam(param)) {
+ throw new Error(`Recevied parameters by name but param is not an object literal.`);
+ }
+ return nullToUndefined(param);
+ case messages_1.ParameterStructures.byPosition:
+ return [undefinedToNull(param)];
+ default:
+ throw new Error(`Unknown parameter structure ${parameterStructures.toString()}`);
+ }
+ }
function computeMessageParams(type, params) {
let result;
- let numberOfParams = type.numberOfParams;
+ const numberOfParams = type.numberOfParams;
switch (numberOfParams) {
case 0:
- result = null;
+ result = void 0;
break;
case 1:
- result = undefinedToNull(params[0]);
+ result = computeSingleParam(type.parameterStructures, params[0]);
break;
default:
result = [];
}
return result;
}
- let connection = {
- sendNotification: (type, ...params) => {
+ const connection = {
+ sendNotification: (type, ...args) => {
throwIfClosedOrDisposed();
let method;
let messageParams;
if (Is.string(type)) {
method = type;
- switch (params.length) {
+ const first = args[0];
+ let paramStart = 0;
+ let parameterStructures = messages_1.ParameterStructures.auto;
+ if (messages_1.ParameterStructures.is(first)) {
+ paramStart = 1;
+ parameterStructures = first;
+ }
+ let paramEnd = args.length;
+ const numberOfParams = paramEnd - paramStart;
+ switch (numberOfParams) {
case 0:
- messageParams = null;
+ messageParams = void 0;
break;
case 1:
- messageParams = params[0];
+ messageParams = computeSingleParam(parameterStructures, args[paramStart]);
break;
default:
- messageParams = params;
+ if (parameterStructures === messages_1.ParameterStructures.byName) {
+ throw new Error(`Recevied ${numberOfParams} parameters for 'by Name' notification parameter structure.`);
+ }
+ messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
break;
}
} else {
+ const params = args;
method = type.method;
messageParams = computeMessageParams(type, params);
}
- let notificationMessage = {
+ const notificationMessage = {
jsonrpc: version,
method,
params: messageParams
},
onNotification: (type, handler) => {
throwIfClosedOrDisposed();
+ let method;
if (Is.func(type)) {
starNotificationHandler = type;
} else if (handler) {
if (Is.string(type)) {
+ method = type;
notificationHandlers[type] = {type: void 0, handler};
} else {
+ method = type.method;
notificationHandlers[type.method] = {type, handler};
}
}
+ return {
+ dispose: () => {
+ if (method !== void 0) {
+ delete notificationHandlers[method];
+ } else {
+ starNotificationHandler = void 0;
+ }
+ }
+ };
},
onProgress: (_type, token, handler) => {
if (progressHandlers.has(token)) {
connection.sendNotification(ProgressNotification.type, {token, value});
},
onUnhandledProgress: unhandledProgressEmitter.event,
- sendRequest: (type, ...params) => {
+ sendRequest: (type, ...args) => {
throwIfClosedOrDisposed();
throwIfNotListening();
let method;
let token = void 0;
if (Is.string(type)) {
method = type;
- switch (params.length) {
+ const first = args[0];
+ const last = args[args.length - 1];
+ let paramStart = 0;
+ let parameterStructures = messages_1.ParameterStructures.auto;
+ if (messages_1.ParameterStructures.is(first)) {
+ paramStart = 1;
+ parameterStructures = first;
+ }
+ let paramEnd = args.length;
+ if (cancellation_1.CancellationToken.is(last)) {
+ paramEnd = paramEnd - 1;
+ token = last;
+ }
+ const numberOfParams = paramEnd - paramStart;
+ switch (numberOfParams) {
case 0:
- messageParams = null;
+ messageParams = void 0;
break;
case 1:
- if (cancellation_1.CancellationToken.is(params[0])) {
- messageParams = null;
- token = params[0];
- } else {
- messageParams = undefinedToNull(params[0]);
- }
+ messageParams = computeSingleParam(parameterStructures, args[paramStart]);
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));
+ if (parameterStructures === messages_1.ParameterStructures.byName) {
+ throw new Error(`Recevied ${numberOfParams} parameters for 'by Name' request parameter structure.`);
}
+ messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
break;
}
} else {
+ const params = args;
method = type.method;
messageParams = computeMessageParams(type, params);
- let numberOfParams = type.numberOfParams;
+ const 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 = {
+ const id = sequenceNumber++;
+ let disposable;
+ if (token) {
+ disposable = token.onCancellationRequested(() => {
+ cancellationStrategy.sender.sendCancellation(connection, id);
+ });
+ }
+ const result = new Promise((resolve, reject) => {
+ const requestMessage = {
jsonrpc: version,
id,
method,
params: messageParams
};
- let responsePromise = {method, timerStart: Date.now(), resolve, reject};
+ const resolveWithCleanup = (r) => {
+ resolve(r);
+ cancellationStrategy.sender.cleanup(id);
+ disposable === null || disposable === void 0 ? void 0 : disposable.dispose();
+ };
+ const rejectWithCleanup = (r) => {
+ reject(r);
+ cancellationStrategy.sender.cleanup(id);
+ disposable === null || disposable === void 0 ? void 0 : disposable.dispose();
+ };
+ let responsePromise = {method, timerStart: Date.now(), resolve: resolveWithCleanup, reject: rejectWithCleanup};
traceSendingRequest(requestMessage);
try {
messageWriter.write(requestMessage);
responsePromises[String(id)] = responsePromise;
}
});
- if (token) {
- token.onCancellationRequested(() => {
- connection.sendNotification(CancelNotification.type, {id});
- });
- }
return result;
},
onRequest: (type, handler) => {
throwIfClosedOrDisposed();
- if (Is.func(type)) {
+ let method = null;
+ if (StarRequestHandler.is(type)) {
+ method = void 0;
starRequestHandler = type;
- } else if (handler) {
- if (Is.string(type)) {
- requestHandlers[type] = {type: void 0, handler};
- } else {
+ } else if (Is.string(type)) {
+ method = null;
+ if (handler !== void 0) {
+ method = type;
+ requestHandlers[type] = {handler, type: void 0};
+ }
+ } else {
+ if (handler !== void 0) {
+ method = type.method;
requestHandlers[type.method] = {type, handler};
}
}
+ return {
+ dispose: () => {
+ if (method === null) {
+ return;
+ }
+ if (method !== void 0) {
+ delete requestHandlers[method];
+ } else {
+ starRequestHandler = void 0;
+ }
+ }
+ };
},
trace: (_value, _tracer, sendNotificationOrTraceOptions) => {
let _sendNotification = false;
onClose: closeEmitter.event,
onUnhandledNotification: unhandledNotificationEmitter.event,
onDispose: disposeEmitter.event,
+ end: () => {
+ messageWriter.end();
+ },
dispose: () => {
if (isDisposed()) {
return;
}
state = ConnectionState.Disposed;
disposeEmitter.fire(void 0);
- let error = new Error("Connection got disposed.");
+ const error = new Error("Connection got disposed.");
Object.keys(responsePromises).forEach((key) => {
responsePromises[key].reject(error);
});
messageReader.listen(callback);
},
inspect: () => {
- console.log("inspect");
+ ral_1.default().console.log("inspect");
}
};
connection.onNotification(LogTraceNotification.type, (params) => {
});
return connection;
}
- function isMessageReader(value) {
- return value.listen !== void 0 && value.read === void 0;
+ exports2.createMessageConnection = createMessageConnection;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/api.js
+var require_api = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.CancellationSenderStrategy = exports2.CancellationReceiverStrategy = exports2.ConnectionError = exports2.ConnectionErrors = exports2.LogTraceNotification = exports2.SetTraceNotification = exports2.TraceFormat = exports2.Trace = exports2.ProgressType = exports2.createMessageConnection = exports2.NullLogger = exports2.ConnectionOptions = exports2.ConnectionStrategy = exports2.WriteableStreamMessageWriter = exports2.AbstractMessageWriter = exports2.MessageWriter = exports2.ReadableStreamMessageReader = exports2.AbstractMessageReader = exports2.MessageReader = exports2.CancellationToken = exports2.CancellationTokenSource = exports2.Emitter = exports2.Event = exports2.Disposable = exports2.ParameterStructures = exports2.NotificationType9 = exports2.NotificationType8 = exports2.NotificationType7 = exports2.NotificationType6 = exports2.NotificationType5 = exports2.NotificationType4 = exports2.NotificationType3 = exports2.NotificationType2 = exports2.NotificationType1 = exports2.NotificationType0 = exports2.NotificationType = exports2.ErrorCodes = exports2.ResponseError = exports2.RequestType9 = exports2.RequestType8 = exports2.RequestType7 = exports2.RequestType6 = exports2.RequestType5 = exports2.RequestType4 = exports2.RequestType3 = exports2.RequestType2 = exports2.RequestType1 = exports2.RequestType0 = exports2.RequestType = exports2.RAL = void 0;
+ exports2.CancellationStrategy = void 0;
+ var messages_1 = require_messages();
+ Object.defineProperty(exports2, "RequestType", {enumerable: true, get: function() {
+ return messages_1.RequestType;
+ }});
+ Object.defineProperty(exports2, "RequestType0", {enumerable: true, get: function() {
+ return messages_1.RequestType0;
+ }});
+ Object.defineProperty(exports2, "RequestType1", {enumerable: true, get: function() {
+ return messages_1.RequestType1;
+ }});
+ Object.defineProperty(exports2, "RequestType2", {enumerable: true, get: function() {
+ return messages_1.RequestType2;
+ }});
+ Object.defineProperty(exports2, "RequestType3", {enumerable: true, get: function() {
+ return messages_1.RequestType3;
+ }});
+ Object.defineProperty(exports2, "RequestType4", {enumerable: true, get: function() {
+ return messages_1.RequestType4;
+ }});
+ Object.defineProperty(exports2, "RequestType5", {enumerable: true, get: function() {
+ return messages_1.RequestType5;
+ }});
+ Object.defineProperty(exports2, "RequestType6", {enumerable: true, get: function() {
+ return messages_1.RequestType6;
+ }});
+ Object.defineProperty(exports2, "RequestType7", {enumerable: true, get: function() {
+ return messages_1.RequestType7;
+ }});
+ Object.defineProperty(exports2, "RequestType8", {enumerable: true, get: function() {
+ return messages_1.RequestType8;
+ }});
+ Object.defineProperty(exports2, "RequestType9", {enumerable: true, get: function() {
+ return messages_1.RequestType9;
+ }});
+ Object.defineProperty(exports2, "ResponseError", {enumerable: true, get: function() {
+ return messages_1.ResponseError;
+ }});
+ Object.defineProperty(exports2, "ErrorCodes", {enumerable: true, get: function() {
+ return messages_1.ErrorCodes;
+ }});
+ Object.defineProperty(exports2, "NotificationType", {enumerable: true, get: function() {
+ return messages_1.NotificationType;
+ }});
+ Object.defineProperty(exports2, "NotificationType0", {enumerable: true, get: function() {
+ return messages_1.NotificationType0;
+ }});
+ Object.defineProperty(exports2, "NotificationType1", {enumerable: true, get: function() {
+ return messages_1.NotificationType1;
+ }});
+ Object.defineProperty(exports2, "NotificationType2", {enumerable: true, get: function() {
+ return messages_1.NotificationType2;
+ }});
+ Object.defineProperty(exports2, "NotificationType3", {enumerable: true, get: function() {
+ return messages_1.NotificationType3;
+ }});
+ Object.defineProperty(exports2, "NotificationType4", {enumerable: true, get: function() {
+ return messages_1.NotificationType4;
+ }});
+ Object.defineProperty(exports2, "NotificationType5", {enumerable: true, get: function() {
+ return messages_1.NotificationType5;
+ }});
+ Object.defineProperty(exports2, "NotificationType6", {enumerable: true, get: function() {
+ return messages_1.NotificationType6;
+ }});
+ Object.defineProperty(exports2, "NotificationType7", {enumerable: true, get: function() {
+ return messages_1.NotificationType7;
+ }});
+ Object.defineProperty(exports2, "NotificationType8", {enumerable: true, get: function() {
+ return messages_1.NotificationType8;
+ }});
+ Object.defineProperty(exports2, "NotificationType9", {enumerable: true, get: function() {
+ return messages_1.NotificationType9;
+ }});
+ Object.defineProperty(exports2, "ParameterStructures", {enumerable: true, get: function() {
+ return messages_1.ParameterStructures;
+ }});
+ var disposable_1 = require_disposable();
+ Object.defineProperty(exports2, "Disposable", {enumerable: true, get: function() {
+ return disposable_1.Disposable;
+ }});
+ var events_1 = require_events();
+ Object.defineProperty(exports2, "Event", {enumerable: true, get: function() {
+ return events_1.Event;
+ }});
+ Object.defineProperty(exports2, "Emitter", {enumerable: true, get: function() {
+ return events_1.Emitter;
+ }});
+ var cancellation_1 = require_cancellation();
+ Object.defineProperty(exports2, "CancellationTokenSource", {enumerable: true, get: function() {
+ return cancellation_1.CancellationTokenSource;
+ }});
+ Object.defineProperty(exports2, "CancellationToken", {enumerable: true, get: function() {
+ return cancellation_1.CancellationToken;
+ }});
+ var messageReader_1 = require_messageReader();
+ Object.defineProperty(exports2, "MessageReader", {enumerable: true, get: function() {
+ return messageReader_1.MessageReader;
+ }});
+ Object.defineProperty(exports2, "AbstractMessageReader", {enumerable: true, get: function() {
+ return messageReader_1.AbstractMessageReader;
+ }});
+ Object.defineProperty(exports2, "ReadableStreamMessageReader", {enumerable: true, get: function() {
+ return messageReader_1.ReadableStreamMessageReader;
+ }});
+ var messageWriter_1 = require_messageWriter();
+ Object.defineProperty(exports2, "MessageWriter", {enumerable: true, get: function() {
+ return messageWriter_1.MessageWriter;
+ }});
+ Object.defineProperty(exports2, "AbstractMessageWriter", {enumerable: true, get: function() {
+ return messageWriter_1.AbstractMessageWriter;
+ }});
+ Object.defineProperty(exports2, "WriteableStreamMessageWriter", {enumerable: true, get: function() {
+ return messageWriter_1.WriteableStreamMessageWriter;
+ }});
+ var connection_1 = require_connection();
+ Object.defineProperty(exports2, "ConnectionStrategy", {enumerable: true, get: function() {
+ return connection_1.ConnectionStrategy;
+ }});
+ Object.defineProperty(exports2, "ConnectionOptions", {enumerable: true, get: function() {
+ return connection_1.ConnectionOptions;
+ }});
+ Object.defineProperty(exports2, "NullLogger", {enumerable: true, get: function() {
+ return connection_1.NullLogger;
+ }});
+ Object.defineProperty(exports2, "createMessageConnection", {enumerable: true, get: function() {
+ return connection_1.createMessageConnection;
+ }});
+ Object.defineProperty(exports2, "ProgressType", {enumerable: true, get: function() {
+ return connection_1.ProgressType;
+ }});
+ Object.defineProperty(exports2, "Trace", {enumerable: true, get: function() {
+ return connection_1.Trace;
+ }});
+ Object.defineProperty(exports2, "TraceFormat", {enumerable: true, get: function() {
+ return connection_1.TraceFormat;
+ }});
+ Object.defineProperty(exports2, "SetTraceNotification", {enumerable: true, get: function() {
+ return connection_1.SetTraceNotification;
+ }});
+ Object.defineProperty(exports2, "LogTraceNotification", {enumerable: true, get: function() {
+ return connection_1.LogTraceNotification;
+ }});
+ Object.defineProperty(exports2, "ConnectionErrors", {enumerable: true, get: function() {
+ return connection_1.ConnectionErrors;
+ }});
+ Object.defineProperty(exports2, "ConnectionError", {enumerable: true, get: function() {
+ return connection_1.ConnectionError;
+ }});
+ Object.defineProperty(exports2, "CancellationReceiverStrategy", {enumerable: true, get: function() {
+ return connection_1.CancellationReceiverStrategy;
+ }});
+ Object.defineProperty(exports2, "CancellationSenderStrategy", {enumerable: true, get: function() {
+ return connection_1.CancellationSenderStrategy;
+ }});
+ Object.defineProperty(exports2, "CancellationStrategy", {enumerable: true, get: function() {
+ return connection_1.CancellationStrategy;
+ }});
+ var ral_1 = require_ral();
+ exports2.RAL = ral_1.default;
+});
+
+// node_modules/vscode-jsonrpc/lib/node/main.js
+var require_main = __commonJS((exports2) => {
+ "use strict";
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ Object.defineProperty(o, k2, {enumerable: true, get: function() {
+ return m[k];
+ }});
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ });
+ var __exportStar2 = exports2 && exports2.__exportStar || function(m, exports3) {
+ for (var p in m)
+ if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+ __createBinding(exports3, m, p);
+ };
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.createMessageConnection = exports2.createServerSocketTransport = exports2.createClientSocketTransport = exports2.createServerPipeTransport = exports2.createClientPipeTransport = exports2.generateRandomPipeName = exports2.StreamMessageWriter = exports2.StreamMessageReader = exports2.SocketMessageWriter = exports2.SocketMessageReader = exports2.IPCMessageWriter = exports2.IPCMessageReader = void 0;
+ var ril_1 = require_ril();
+ ril_1.default.install();
+ var api_1 = require_api();
+ var path9 = require("path");
+ var os3 = require("os");
+ var crypto_1 = require("crypto");
+ var net_1 = require("net");
+ __exportStar2(require_api(), exports2);
+ var IPCMessageReader = class extends api_1.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);
+ return api_1.Disposable.create(() => this.process.off("message", callback));
+ }
+ };
+ exports2.IPCMessageReader = IPCMessageReader;
+ var IPCMessageWriter = class extends api_1.AbstractMessageWriter {
+ constructor(process2) {
+ super();
+ this.process = process2;
+ this.errorCount = 0;
+ let eventEmitter = this.process;
+ eventEmitter.on("error", (error) => this.fireError(error));
+ eventEmitter.on("close", () => this.fireClose);
+ }
+ write(msg) {
+ try {
+ if (typeof this.process.send === "function") {
+ this.process.send(msg, void 0, void 0, (error) => {
+ if (error) {
+ this.errorCount++;
+ this.handleError(error, msg);
+ } else {
+ this.errorCount = 0;
+ }
+ });
+ }
+ return Promise.resolve();
+ } catch (error) {
+ this.handleError(error, msg);
+ return Promise.reject(error);
+ }
+ }
+ handleError(error, msg) {
+ this.errorCount++;
+ this.fireError(error, msg, this.errorCount);
+ }
+ end() {
+ }
+ };
+ exports2.IPCMessageWriter = IPCMessageWriter;
+ var SocketMessageReader = class extends api_1.ReadableStreamMessageReader {
+ constructor(socket, encoding = "utf-8") {
+ super(ril_1.default().stream.asReadableStream(socket), encoding);
+ }
+ };
+ exports2.SocketMessageReader = SocketMessageReader;
+ var SocketMessageWriter = class extends api_1.WriteableStreamMessageWriter {
+ constructor(socket, options) {
+ super(ril_1.default().stream.asWritableStream(socket), options);
+ this.socket = socket;
+ }
+ dispose() {
+ super.dispose();
+ this.socket.destroy();
+ }
+ };
+ exports2.SocketMessageWriter = SocketMessageWriter;
+ var StreamMessageReader = class extends api_1.ReadableStreamMessageReader {
+ constructor(readble, encoding) {
+ super(ril_1.default().stream.asReadableStream(readble), encoding);
+ }
+ };
+ exports2.StreamMessageReader = StreamMessageReader;
+ var StreamMessageWriter = class extends api_1.WriteableStreamMessageWriter {
+ constructor(writable, options) {
+ super(ril_1.default().stream.asWritableStream(writable), options);
+ }
+ };
+ exports2.StreamMessageWriter = StreamMessageWriter;
+ var XDG_RUNTIME_DIR = process.env["XDG_RUNTIME_DIR"];
+ var safeIpcPathLengths = new Map([
+ ["linux", 107],
+ ["darwin", 103]
+ ]);
+ function generateRandomPipeName() {
+ const randomSuffix = crypto_1.randomBytes(21).toString("hex");
+ if (process.platform === "win32") {
+ return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`;
+ }
+ let result;
+ if (XDG_RUNTIME_DIR) {
+ result = path9.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
+ } else {
+ result = path9.join(os3.tmpdir(), `vscode-${randomSuffix}.sock`);
+ }
+ const limit = safeIpcPathLengths.get(process.platform);
+ if (limit !== void 0 && result.length >= limit) {
+ ril_1.default().console.warn(`WARNING: IPC handle "${result}" is longer than ${limit} characters.`);
+ }
+ return result;
+ }
+ exports2.generateRandomPipeName = generateRandomPipeName;
+ function createClientPipeTransport(pipeName, encoding = "utf-8") {
+ let connectResolve;
+ const connected = new Promise((resolve, _reject) => {
+ connectResolve = resolve;
+ });
+ return new Promise((resolve, reject) => {
+ let server = net_1.createServer((socket) => {
+ server.close();
+ connectResolve([
+ new SocketMessageReader(socket, encoding),
+ new 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 SocketMessageReader(socket, encoding),
+ new SocketMessageWriter(socket, encoding)
+ ];
+ }
+ exports2.createServerPipeTransport = createServerPipeTransport;
+ function createClientSocketTransport(port, encoding = "utf-8") {
+ let connectResolve;
+ const connected = new Promise((resolve, _reject) => {
+ connectResolve = resolve;
+ });
+ return new Promise((resolve, reject) => {
+ const server = net_1.createServer((socket) => {
+ server.close();
+ connectResolve([
+ new SocketMessageReader(socket, encoding),
+ new 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 SocketMessageReader(socket, encoding),
+ new SocketMessageWriter(socket, encoding)
+ ];
+ }
+ exports2.createServerSocketTransport = createServerSocketTransport;
+ function isReadableStream(value) {
+ const candidate = value;
+ return candidate.read !== void 0 && candidate.addListener !== void 0;
}
- function isMessageWriter(value) {
- return value.write !== void 0 && value.end === void 0;
+ function isWritableStream(value) {
+ const candidate = value;
+ return candidate.write !== void 0 && candidate.addListener !== void 0;
}
- function createMessageConnection(input, output, logger, strategy) {
+ function createMessageConnection(input, output, logger, options) {
if (!logger) {
- logger = exports2.NullLogger;
+ logger = api_1.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);
+ const reader = isReadableStream(input) ? new StreamMessageReader(input) : input;
+ const writer = isWritableStream(output) ? new StreamMessageWriter(output) : output;
+ if (api_1.ConnectionStrategy.is(options)) {
+ options = {connectionStrategy: options};
+ }
+ return api_1.createMessageConnection(reader, writer, logger, options);
}
exports2.createMessageConnection = createMessageConnection;
});
+// node_modules/vscode-jsonrpc/node.js
+var require_node = __commonJS((exports2, module2) => {
+ "use strict";
+ module2.exports = require_main();
+});
+
// node_modules/vscode-languageserver-types/lib/esm/main.js
var require_main2 = __commonJS((exports2) => {
__export(exports2, {
+ AnnotatedTextEdit: () => AnnotatedTextEdit,
+ ChangeAnnotation: () => ChangeAnnotation,
+ ChangeAnnotationIdentifier: () => ChangeAnnotationIdentifier,
CodeAction: () => CodeAction6,
CodeActionContext: () => CodeActionContext6,
CodeActionKind: () => CodeActionKind6,
+ CodeDescription: () => CodeDescription,
CodeLens: () => CodeLens2,
Color: () => Color,
ColorInformation: () => ColorInformation,
Command: () => Command5,
CompletionItem: () => CompletionItem4,
CompletionItemKind: () => CompletionItemKind3,
- CompletionItemTag: () => CompletionItemTag,
+ CompletionItemTag: () => CompletionItemTag2,
CompletionList: () => CompletionList3,
CreateFile: () => CreateFile,
DeleteFile: () => DeleteFile,
- Diagnostic: () => Diagnostic5,
+ Diagnostic: () => Diagnostic6,
DiagnosticRelatedInformation: () => DiagnosticRelatedInformation2,
DiagnosticSeverity: () => DiagnosticSeverity3,
- DiagnosticTag: () => DiagnosticTag,
+ DiagnosticTag: () => DiagnosticTag3,
DocumentHighlight: () => DocumentHighlight2,
DocumentHighlightKind: () => DocumentHighlightKind2,
DocumentLink: () => DocumentLink,
FoldingRangeKind: () => FoldingRangeKind,
FormattingOptions: () => FormattingOptions,
Hover: () => Hover,
+ InsertReplaceEdit: () => InsertReplaceEdit,
InsertTextFormat: () => InsertTextFormat3,
- Location: () => Location3,
+ InsertTextMode: () => InsertTextMode,
+ Location: () => Location4,
LocationLink: () => LocationLink,
MarkedString: () => MarkedString,
MarkupContent: () => MarkupContent3,
MarkupKind: () => MarkupKind3,
+ OptionalVersionedTextDocumentIdentifier: () => OptionalVersionedTextDocumentIdentifier,
ParameterInformation: () => ParameterInformation,
- Position: () => Position7,
- Range: () => Range15,
+ Position: () => Position10,
+ Range: () => Range17,
RenameFile: () => RenameFile,
SelectionRange: () => SelectionRange,
SignatureInformation: () => SignatureInformation,
SymbolInformation: () => SymbolInformation2,
- SymbolKind: () => SymbolKind3,
- SymbolTag: () => SymbolTag,
- TextDocument: () => TextDocument11,
+ SymbolKind: () => SymbolKind5,
+ SymbolTag: () => SymbolTag4,
+ TextDocument: () => TextDocument13,
TextDocumentEdit: () => TextDocumentEdit,
TextDocumentIdentifier: () => TextDocumentIdentifier,
TextDocumentItem: () => TextDocumentItem,
TextEdit: () => TextEdit6,
VersionedTextDocumentIdentifier: () => VersionedTextDocumentIdentifier,
WorkspaceChange: () => WorkspaceChange,
- WorkspaceEdit: () => WorkspaceEdit6
+ WorkspaceEdit: () => WorkspaceEdit6,
+ integer: () => integer,
+ uinteger: () => uinteger
});
"use strict";
- var Position7;
- (function(Position8) {
+ var integer;
+ (function(integer2) {
+ integer2.MIN_VALUE = -2147483648;
+ integer2.MAX_VALUE = 2147483647;
+ })(integer || (integer = {}));
+ var uinteger;
+ (function(uinteger2) {
+ uinteger2.MIN_VALUE = 0;
+ uinteger2.MAX_VALUE = 2147483647;
+ })(uinteger || (uinteger = {}));
+ var Position10;
+ (function(Position11) {
function create(line, character) {
+ if (line === Number.MAX_VALUE) {
+ line = uinteger.MAX_VALUE;
+ }
+ if (character === Number.MAX_VALUE) {
+ character = uinteger.MAX_VALUE;
+ }
return {line, character};
}
- Position8.create = create;
+ Position11.create = create;
function is2(value) {
var candidate = value;
- return Is.objectLiteral(candidate) && Is.number(candidate.line) && Is.number(candidate.character);
+ return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
}
- Position8.is = is2;
- })(Position7 || (Position7 = {}));
- var Range15;
- (function(Range16) {
+ Position11.is = is2;
+ })(Position10 || (Position10 = {}));
+ var Range17;
+ (function(Range18) {
function create(one, two, three, four) {
- if (Is.number(one) && Is.number(two) && Is.number(three) && Is.number(four)) {
- return {start: Position7.create(one, two), end: Position7.create(three, four)};
- } else if (Position7.is(one) && Position7.is(two)) {
+ if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
+ return {start: Position10.create(one, two), end: Position10.create(three, four)};
+ } else if (Position10.is(one) && Position10.is(two)) {
return {start: one, end: two};
} else {
throw new Error("Range#create called with invalid arguments[" + one + ", " + two + ", " + three + ", " + four + "]");
}
}
- Range16.create = create;
+ Range18.create = create;
function is2(value) {
var candidate = value;
- return Is.objectLiteral(candidate) && Position7.is(candidate.start) && Position7.is(candidate.end);
+ return Is.objectLiteral(candidate) && Position10.is(candidate.start) && Position10.is(candidate.end);
}
- Range16.is = is2;
- })(Range15 || (Range15 = {}));
- var Location3;
- (function(Location4) {
+ Range18.is = is2;
+ })(Range17 || (Range17 = {}));
+ var Location4;
+ (function(Location5) {
function create(uri, range) {
return {uri, range};
}
- Location4.create = create;
+ Location5.create = create;
function is2(value) {
var candidate = value;
- return Is.defined(candidate) && Range15.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
+ return Is.defined(candidate) && Range17.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
}
- Location4.is = is2;
- })(Location3 || (Location3 = {}));
+ Location5.is = is2;
+ })(Location4 || (Location4 = {}));
var LocationLink;
(function(LocationLink2) {
function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
LocationLink2.create = create;
function is2(value) {
var candidate = value;
- return Is.defined(candidate) && Range15.is(candidate.targetRange) && Is.string(candidate.targetUri) && (Range15.is(candidate.targetSelectionRange) || Is.undefined(candidate.targetSelectionRange)) && (Range15.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
+ return Is.defined(candidate) && Range17.is(candidate.targetRange) && Is.string(candidate.targetUri) && (Range17.is(candidate.targetSelectionRange) || Is.undefined(candidate.targetSelectionRange)) && (Range17.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
}
LocationLink2.is = is2;
})(LocationLink || (LocationLink = {}));
Color2.create = create;
function is2(value) {
var candidate = value;
- return Is.number(candidate.red) && Is.number(candidate.green) && Is.number(candidate.blue) && Is.number(candidate.alpha);
+ return Is.numberRange(candidate.red, 0, 1) && Is.numberRange(candidate.green, 0, 1) && Is.numberRange(candidate.blue, 0, 1) && Is.numberRange(candidate.alpha, 0, 1);
}
Color2.is = is2;
})(Color || (Color = {}));
ColorInformation2.create = create;
function is2(value) {
var candidate = value;
- return Range15.is(candidate.range) && Color.is(candidate.color);
+ return Range17.is(candidate.range) && Color.is(candidate.color);
}
ColorInformation2.is = is2;
})(ColorInformation || (ColorInformation = {}));
FoldingRange3.create = create;
function is2(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));
+ return Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
}
FoldingRange3.is = is2;
})(FoldingRange2 || (FoldingRange2 = {}));
DiagnosticRelatedInformation3.create = create;
function is2(value) {
var candidate = value;
- return Is.defined(candidate) && Location3.is(candidate.location) && Is.string(candidate.message);
+ return Is.defined(candidate) && Location4.is(candidate.location) && Is.string(candidate.message);
}
DiagnosticRelatedInformation3.is = is2;
})(DiagnosticRelatedInformation2 || (DiagnosticRelatedInformation2 = {}));
DiagnosticSeverity4.Information = 3;
DiagnosticSeverity4.Hint = 4;
})(DiagnosticSeverity3 || (DiagnosticSeverity3 = {}));
- var DiagnosticTag;
- (function(DiagnosticTag2) {
- DiagnosticTag2.Unnecessary = 1;
- DiagnosticTag2.Deprecated = 2;
- })(DiagnosticTag || (DiagnosticTag = {}));
- var Diagnostic5;
- (function(Diagnostic6) {
+ var DiagnosticTag3;
+ (function(DiagnosticTag4) {
+ DiagnosticTag4.Unnecessary = 1;
+ DiagnosticTag4.Deprecated = 2;
+ })(DiagnosticTag3 || (DiagnosticTag3 = {}));
+ var CodeDescription;
+ (function(CodeDescription2) {
+ function is2(value) {
+ var candidate = value;
+ return candidate !== void 0 && candidate !== null && Is.string(candidate.href);
+ }
+ CodeDescription2.is = is2;
+ })(CodeDescription || (CodeDescription = {}));
+ var Diagnostic6;
+ (function(Diagnostic7) {
function create(range, message, severity, code, source, relatedInformation) {
var result = {range, message};
if (Is.defined(severity)) {
}
return result;
}
- Diagnostic6.create = create;
+ Diagnostic7.create = create;
function is2(value) {
+ var _a;
var candidate = value;
- return Is.defined(candidate) && Range15.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, DiagnosticRelatedInformation2.is));
+ return Is.defined(candidate) && Range17.is(candidate.range) && Is.string(candidate.message) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.undefined(candidate.codeDescription) || Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation2.is));
}
- Diagnostic6.is = is2;
- })(Diagnostic5 || (Diagnostic5 = {}));
+ Diagnostic7.is = is2;
+ })(Diagnostic6 || (Diagnostic6 = {}));
var Command5;
(function(Command6) {
function create(title, command) {
TextEdit7.del = del;
function is2(value) {
var candidate = value;
- return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range15.is(candidate.range);
+ return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range17.is(candidate.range);
}
TextEdit7.is = is2;
})(TextEdit6 || (TextEdit6 = {}));
+ var ChangeAnnotation;
+ (function(ChangeAnnotation2) {
+ function create(label, needsConfirmation, description) {
+ var result = {label};
+ if (needsConfirmation !== void 0) {
+ result.needsConfirmation = needsConfirmation;
+ }
+ if (description !== void 0) {
+ result.description = description;
+ }
+ return result;
+ }
+ ChangeAnnotation2.create = create;
+ function is2(value) {
+ var candidate = value;
+ return candidate !== void 0 && Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
+ }
+ ChangeAnnotation2.is = is2;
+ })(ChangeAnnotation || (ChangeAnnotation = {}));
+ var ChangeAnnotationIdentifier;
+ (function(ChangeAnnotationIdentifier2) {
+ function is2(value) {
+ var candidate = value;
+ return typeof candidate === "string";
+ }
+ ChangeAnnotationIdentifier2.is = is2;
+ })(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));
+ var AnnotatedTextEdit;
+ (function(AnnotatedTextEdit2) {
+ function replace(range, newText, annotation) {
+ return {range, newText, annotationId: annotation};
+ }
+ AnnotatedTextEdit2.replace = replace;
+ function insert(position, newText, annotation) {
+ return {range: {start: position, end: position}, newText, annotationId: annotation};
+ }
+ AnnotatedTextEdit2.insert = insert;
+ function del(range, annotation) {
+ return {range, newText: "", annotationId: annotation};
+ }
+ AnnotatedTextEdit2.del = del;
+ function is2(value) {
+ var candidate = value;
+ return TextEdit6.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
+ }
+ AnnotatedTextEdit2.is = is2;
+ })(AnnotatedTextEdit || (AnnotatedTextEdit = {}));
var TextDocumentEdit;
(function(TextDocumentEdit2) {
function create(textDocument, edits) {
TextDocumentEdit2.create = create;
function is2(value) {
var candidate = value;
- return Is.defined(candidate) && VersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
+ return Is.defined(candidate) && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
}
TextDocumentEdit2.is = is2;
})(TextDocumentEdit || (TextDocumentEdit = {}));
var CreateFile;
(function(CreateFile2) {
- function create(uri, options) {
+ function create(uri, options, annotation) {
var result = {
kind: "create",
uri
if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
result.options = options;
}
+ if (annotation !== void 0) {
+ result.annotationId = annotation;
+ }
return result;
}
CreateFile2.create = create;
function is2(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)));
+ 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))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
}
CreateFile2.is = is2;
})(CreateFile || (CreateFile = {}));
var RenameFile;
(function(RenameFile2) {
- function create(oldUri, newUri, options) {
+ function create(oldUri, newUri, options, annotation) {
var result = {
kind: "rename",
oldUri,
if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
result.options = options;
}
+ if (annotation !== void 0) {
+ result.annotationId = annotation;
+ }
return result;
}
RenameFile2.create = create;
function is2(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)));
+ 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))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
}
RenameFile2.is = is2;
})(RenameFile || (RenameFile = {}));
var DeleteFile;
(function(DeleteFile2) {
- function create(uri, options) {
+ function create(uri, options, annotation) {
var result = {
kind: "delete",
uri
if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {
result.options = options;
}
+ if (annotation !== void 0) {
+ result.annotationId = annotation;
+ }
return result;
}
DeleteFile2.create = create;
function is2(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)));
+ 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))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
}
DeleteFile2.is = is2;
})(DeleteFile || (DeleteFile = {}));
WorkspaceEdit7.is = is2;
})(WorkspaceEdit6 || (WorkspaceEdit6 = {}));
var TextEditChangeImpl = function() {
- function TextEditChangeImpl2(edits) {
+ function TextEditChangeImpl2(edits, changeAnnotations) {
this.edits = edits;
- }
- TextEditChangeImpl2.prototype.insert = function(position, newText) {
- this.edits.push(TextEdit6.insert(position, newText));
+ this.changeAnnotations = changeAnnotations;
+ }
+ TextEditChangeImpl2.prototype.insert = function(position, newText, annotation) {
+ var edit;
+ var id;
+ if (annotation === void 0) {
+ edit = TextEdit6.insert(position, newText);
+ } else if (ChangeAnnotationIdentifier.is(annotation)) {
+ id = annotation;
+ edit = AnnotatedTextEdit.insert(position, newText, annotation);
+ } else {
+ this.assertChangeAnnotations(this.changeAnnotations);
+ id = this.changeAnnotations.manage(annotation);
+ edit = AnnotatedTextEdit.insert(position, newText, id);
+ }
+ this.edits.push(edit);
+ if (id !== void 0) {
+ return id;
+ }
};
- TextEditChangeImpl2.prototype.replace = function(range, newText) {
- this.edits.push(TextEdit6.replace(range, newText));
+ TextEditChangeImpl2.prototype.replace = function(range, newText, annotation) {
+ var edit;
+ var id;
+ if (annotation === void 0) {
+ edit = TextEdit6.replace(range, newText);
+ } else if (ChangeAnnotationIdentifier.is(annotation)) {
+ id = annotation;
+ edit = AnnotatedTextEdit.replace(range, newText, annotation);
+ } else {
+ this.assertChangeAnnotations(this.changeAnnotations);
+ id = this.changeAnnotations.manage(annotation);
+ edit = AnnotatedTextEdit.replace(range, newText, id);
+ }
+ this.edits.push(edit);
+ if (id !== void 0) {
+ return id;
+ }
};
- TextEditChangeImpl2.prototype.delete = function(range) {
- this.edits.push(TextEdit6.del(range));
+ TextEditChangeImpl2.prototype.delete = function(range, annotation) {
+ var edit;
+ var id;
+ if (annotation === void 0) {
+ edit = TextEdit6.del(range);
+ } else if (ChangeAnnotationIdentifier.is(annotation)) {
+ id = annotation;
+ edit = AnnotatedTextEdit.del(range, annotation);
+ } else {
+ this.assertChangeAnnotations(this.changeAnnotations);
+ id = this.changeAnnotations.manage(annotation);
+ edit = AnnotatedTextEdit.del(range, id);
+ }
+ this.edits.push(edit);
+ if (id !== void 0) {
+ return id;
+ }
};
TextEditChangeImpl2.prototype.add = function(edit) {
this.edits.push(edit);
TextEditChangeImpl2.prototype.clear = function() {
this.edits.splice(0, this.edits.length);
};
+ TextEditChangeImpl2.prototype.assertChangeAnnotations = function(value) {
+ if (value === void 0) {
+ throw new Error("Text edit change is not configured to manage change annotations.");
+ }
+ };
return TextEditChangeImpl2;
}();
+ var ChangeAnnotations = function() {
+ function ChangeAnnotations2(annotations) {
+ this._annotations = annotations === void 0 ? Object.create(null) : annotations;
+ this._counter = 0;
+ this._size = 0;
+ }
+ ChangeAnnotations2.prototype.all = function() {
+ return this._annotations;
+ };
+ Object.defineProperty(ChangeAnnotations2.prototype, "size", {
+ get: function() {
+ return this._size;
+ },
+ enumerable: false,
+ configurable: true
+ });
+ ChangeAnnotations2.prototype.manage = function(idOrAnnotation, annotation) {
+ var id;
+ if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {
+ id = idOrAnnotation;
+ } else {
+ id = this.nextId();
+ annotation = idOrAnnotation;
+ }
+ if (this._annotations[id] !== void 0) {
+ throw new Error("Id " + id + " is already in use.");
+ }
+ if (annotation === void 0) {
+ throw new Error("No annotation provided for id " + id);
+ }
+ this._annotations[id] = annotation;
+ this._size++;
+ return id;
+ };
+ ChangeAnnotations2.prototype.nextId = function() {
+ this._counter++;
+ return this._counter.toString();
+ };
+ return ChangeAnnotations2;
+ }();
var WorkspaceChange = function() {
function WorkspaceChange2(workspaceEdit) {
var _this = this;
this._textEditChanges = Object.create(null);
- if (workspaceEdit) {
+ if (workspaceEdit !== void 0) {
this._workspaceEdit = workspaceEdit;
if (workspaceEdit.documentChanges) {
+ this._changeAnnotations = new ChangeAnnotations(workspaceEdit.changeAnnotations);
+ workspaceEdit.changeAnnotations = this._changeAnnotations.all();
workspaceEdit.documentChanges.forEach(function(change) {
if (TextDocumentEdit.is(change)) {
- var textEditChange = new TextEditChangeImpl(change.edits);
+ var textEditChange = new TextEditChangeImpl(change.edits, _this._changeAnnotations);
_this._textEditChanges[change.textDocument.uri] = textEditChange;
}
});
_this._textEditChanges[key] = textEditChange;
});
}
+ } else {
+ this._workspaceEdit = {};
}
}
Object.defineProperty(WorkspaceChange2.prototype, "edit", {
get: function() {
+ this.initDocumentChanges();
+ if (this._changeAnnotations !== void 0) {
+ if (this._changeAnnotations.size === 0) {
+ this._workspaceEdit.changeAnnotations = void 0;
+ } else {
+ this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
+ }
+ }
return this._workspaceEdit;
},
- enumerable: true,
+ enumerable: false,
configurable: true
});
WorkspaceChange2.prototype.getTextEditChange = function(key) {
- if (VersionedTextDocumentIdentifier.is(key)) {
- if (!this._workspaceEdit) {
- this._workspaceEdit = {
- documentChanges: []
- };
- }
- if (!this._workspaceEdit.documentChanges) {
+ if (OptionalVersionedTextDocumentIdentifier.is(key)) {
+ this.initDocumentChanges();
+ if (this._workspaceEdit.documentChanges === void 0) {
throw new Error("Workspace edit is not configured for document changes.");
}
- var textDocument = key;
+ var textDocument = {uri: key.uri, version: key.version};
var result = this._textEditChanges[textDocument.uri];
if (!result) {
var edits = [];
edits
};
this._workspaceEdit.documentChanges.push(textDocumentEdit);
- result = new TextEditChangeImpl(edits);
+ result = new TextEditChangeImpl(edits, this._changeAnnotations);
this._textEditChanges[textDocument.uri] = result;
}
return result;
} else {
- if (!this._workspaceEdit) {
- this._workspaceEdit = {
- changes: Object.create(null)
- };
- }
- if (!this._workspaceEdit.changes) {
+ this.initChanges();
+ if (this._workspaceEdit.changes === void 0) {
throw new Error("Workspace edit is not configured for normal text edit changes.");
}
var result = this._textEditChanges[key];
return result;
}
};
- WorkspaceChange2.prototype.createFile = function(uri, options) {
- this.checkDocumentChanges();
- this._workspaceEdit.documentChanges.push(CreateFile.create(uri, options));
+ WorkspaceChange2.prototype.initDocumentChanges = function() {
+ if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
+ this._changeAnnotations = new ChangeAnnotations();
+ this._workspaceEdit.documentChanges = [];
+ this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
+ }
+ };
+ WorkspaceChange2.prototype.initChanges = function() {
+ if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
+ this._workspaceEdit.changes = Object.create(null);
+ }
};
- WorkspaceChange2.prototype.renameFile = function(oldUri, newUri, options) {
- this.checkDocumentChanges();
- this._workspaceEdit.documentChanges.push(RenameFile.create(oldUri, newUri, options));
+ WorkspaceChange2.prototype.createFile = function(uri, optionsOrAnnotation, options) {
+ this.initDocumentChanges();
+ if (this._workspaceEdit.documentChanges === void 0) {
+ throw new Error("Workspace edit is not configured for document changes.");
+ }
+ var annotation;
+ if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
+ annotation = optionsOrAnnotation;
+ } else {
+ options = optionsOrAnnotation;
+ }
+ var operation;
+ var id;
+ if (annotation === void 0) {
+ operation = CreateFile.create(uri, options);
+ } else {
+ id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
+ operation = CreateFile.create(uri, options, id);
+ }
+ this._workspaceEdit.documentChanges.push(operation);
+ if (id !== void 0) {
+ return id;
+ }
};
- WorkspaceChange2.prototype.deleteFile = function(uri, options) {
- this.checkDocumentChanges();
- this._workspaceEdit.documentChanges.push(DeleteFile.create(uri, options));
+ WorkspaceChange2.prototype.renameFile = function(oldUri, newUri, optionsOrAnnotation, options) {
+ this.initDocumentChanges();
+ if (this._workspaceEdit.documentChanges === void 0) {
+ throw new Error("Workspace edit is not configured for document changes.");
+ }
+ var annotation;
+ if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
+ annotation = optionsOrAnnotation;
+ } else {
+ options = optionsOrAnnotation;
+ }
+ var operation;
+ var id;
+ if (annotation === void 0) {
+ operation = RenameFile.create(oldUri, newUri, options);
+ } else {
+ id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
+ operation = RenameFile.create(oldUri, newUri, options, id);
+ }
+ this._workspaceEdit.documentChanges.push(operation);
+ if (id !== void 0) {
+ return id;
+ }
};
- WorkspaceChange2.prototype.checkDocumentChanges = function() {
- if (!this._workspaceEdit || !this._workspaceEdit.documentChanges) {
+ WorkspaceChange2.prototype.deleteFile = function(uri, optionsOrAnnotation, options) {
+ this.initDocumentChanges();
+ if (this._workspaceEdit.documentChanges === void 0) {
throw new Error("Workspace edit is not configured for document changes.");
}
+ var annotation;
+ if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
+ annotation = optionsOrAnnotation;
+ } else {
+ options = optionsOrAnnotation;
+ }
+ var operation;
+ var id;
+ if (annotation === void 0) {
+ operation = DeleteFile.create(uri, options);
+ } else {
+ id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
+ operation = DeleteFile.create(uri, options, id);
+ }
+ this._workspaceEdit.documentChanges.push(operation);
+ if (id !== void 0) {
+ return id;
+ }
};
return WorkspaceChange2;
}();
VersionedTextDocumentIdentifier2.create = create;
function is2(value) {
var candidate = value;
- return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.number(candidate.version));
+ return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
}
VersionedTextDocumentIdentifier2.is = is2;
})(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));
+ var OptionalVersionedTextDocumentIdentifier;
+ (function(OptionalVersionedTextDocumentIdentifier2) {
+ function create(uri, version) {
+ return {uri, version};
+ }
+ OptionalVersionedTextDocumentIdentifier2.create = create;
+ function is2(value) {
+ var candidate = value;
+ return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
+ }
+ OptionalVersionedTextDocumentIdentifier2.is = is2;
+ })(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));
var TextDocumentItem;
(function(TextDocumentItem2) {
function create(uri, languageId, version, text) {
TextDocumentItem2.create = create;
function is2(value) {
var candidate = value;
- return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.number(candidate.version) && Is.string(candidate.text);
+ return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);
}
TextDocumentItem2.is = is2;
})(TextDocumentItem || (TextDocumentItem = {}));
InsertTextFormat4.PlainText = 1;
InsertTextFormat4.Snippet = 2;
})(InsertTextFormat3 || (InsertTextFormat3 = {}));
- var CompletionItemTag;
- (function(CompletionItemTag2) {
- CompletionItemTag2.Deprecated = 1;
- })(CompletionItemTag || (CompletionItemTag = {}));
+ var CompletionItemTag2;
+ (function(CompletionItemTag3) {
+ CompletionItemTag3.Deprecated = 1;
+ })(CompletionItemTag2 || (CompletionItemTag2 = {}));
+ var InsertReplaceEdit;
+ (function(InsertReplaceEdit2) {
+ function create(newText, insert, replace) {
+ return {newText, insert, replace};
+ }
+ InsertReplaceEdit2.create = create;
+ function is2(value) {
+ var candidate = value;
+ return candidate && Is.string(candidate.newText) && Range17.is(candidate.insert) && Range17.is(candidate.replace);
+ }
+ InsertReplaceEdit2.is = is2;
+ })(InsertReplaceEdit || (InsertReplaceEdit = {}));
+ var InsertTextMode;
+ (function(InsertTextMode2) {
+ InsertTextMode2.asIs = 1;
+ InsertTextMode2.adjustIndentation = 2;
+ })(InsertTextMode || (InsertTextMode = {}));
var CompletionItem4;
(function(CompletionItem5) {
function create(label) {
(function(Hover2) {
function is2(value) {
var candidate = value;
- return !!candidate && Is.objectLiteral(candidate) && (MarkupContent3.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range15.is(value.range));
+ return !!candidate && Is.objectLiteral(candidate) && (MarkupContent3.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range17.is(value.range));
}
Hover2.is = is2;
})(Hover || (Hover = {}));
}
DocumentHighlight3.create = create;
})(DocumentHighlight2 || (DocumentHighlight2 = {}));
- var SymbolKind3;
- (function(SymbolKind4) {
- SymbolKind4.File = 1;
- SymbolKind4.Module = 2;
- SymbolKind4.Namespace = 3;
- SymbolKind4.Package = 4;
- SymbolKind4.Class = 5;
- SymbolKind4.Method = 6;
- SymbolKind4.Property = 7;
- SymbolKind4.Field = 8;
- SymbolKind4.Constructor = 9;
- SymbolKind4.Enum = 10;
- SymbolKind4.Interface = 11;
- SymbolKind4.Function = 12;
- SymbolKind4.Variable = 13;
- SymbolKind4.Constant = 14;
- SymbolKind4.String = 15;
- SymbolKind4.Number = 16;
- SymbolKind4.Boolean = 17;
- SymbolKind4.Array = 18;
- SymbolKind4.Object = 19;
- SymbolKind4.Key = 20;
- SymbolKind4.Null = 21;
- SymbolKind4.EnumMember = 22;
- SymbolKind4.Struct = 23;
- SymbolKind4.Event = 24;
- SymbolKind4.Operator = 25;
- SymbolKind4.TypeParameter = 26;
- })(SymbolKind3 || (SymbolKind3 = {}));
- var SymbolTag;
- (function(SymbolTag2) {
- SymbolTag2.Deprecated = 1;
- })(SymbolTag || (SymbolTag = {}));
+ var SymbolKind5;
+ (function(SymbolKind6) {
+ SymbolKind6.File = 1;
+ SymbolKind6.Module = 2;
+ SymbolKind6.Namespace = 3;
+ SymbolKind6.Package = 4;
+ SymbolKind6.Class = 5;
+ SymbolKind6.Method = 6;
+ SymbolKind6.Property = 7;
+ SymbolKind6.Field = 8;
+ SymbolKind6.Constructor = 9;
+ SymbolKind6.Enum = 10;
+ SymbolKind6.Interface = 11;
+ SymbolKind6.Function = 12;
+ SymbolKind6.Variable = 13;
+ SymbolKind6.Constant = 14;
+ SymbolKind6.String = 15;
+ SymbolKind6.Number = 16;
+ SymbolKind6.Boolean = 17;
+ SymbolKind6.Array = 18;
+ SymbolKind6.Object = 19;
+ SymbolKind6.Key = 20;
+ SymbolKind6.Null = 21;
+ SymbolKind6.EnumMember = 22;
+ SymbolKind6.Struct = 23;
+ SymbolKind6.Event = 24;
+ SymbolKind6.Operator = 25;
+ SymbolKind6.TypeParameter = 26;
+ })(SymbolKind5 || (SymbolKind5 = {}));
+ var SymbolTag4;
+ (function(SymbolTag5) {
+ SymbolTag5.Deprecated = 1;
+ })(SymbolTag4 || (SymbolTag4 = {}));
var SymbolInformation2;
(function(SymbolInformation3) {
function create(name, kind, range, uri, containerName) {
DocumentSymbol3.create = create;
function is2(value) {
var candidate = value;
- return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range15.is(candidate.range) && Range15.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));
+ return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range17.is(candidate.range) && Range17.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)) && (candidate.tags === void 0 || Array.isArray(candidate.tags));
}
DocumentSymbol3.is = is2;
})(DocumentSymbol2 || (DocumentSymbol2 = {}));
CodeActionContext7.create = create;
function is2(value) {
var candidate = value;
- return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic5.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string));
+ return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic6.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string));
}
CodeActionContext7.is = is2;
})(CodeActionContext6 || (CodeActionContext6 = {}));
var CodeAction6;
(function(CodeAction7) {
- function create(title, commandOrEdit, kind) {
+ function create(title, kindOrCommandOrEdit, kind) {
var result = {title};
- if (Command5.is(commandOrEdit)) {
- result.command = commandOrEdit;
+ var checkKind = true;
+ if (typeof kindOrCommandOrEdit === "string") {
+ checkKind = false;
+ result.kind = kindOrCommandOrEdit;
+ } else if (Command5.is(kindOrCommandOrEdit)) {
+ result.command = kindOrCommandOrEdit;
} else {
- result.edit = commandOrEdit;
+ result.edit = kindOrCommandOrEdit;
}
- if (kind !== void 0) {
+ if (checkKind && kind !== void 0) {
result.kind = kind;
}
return result;
CodeAction7.create = create;
function is2(value) {
var candidate = value;
- return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic5.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command5.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit6.is(candidate.edit));
+ return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic6.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command5.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit6.is(candidate.edit));
}
CodeAction7.is = is2;
})(CodeAction6 || (CodeAction6 = {}));
CodeLens3.create = create;
function is2(value) {
var candidate = value;
- return Is.defined(candidate) && Range15.is(candidate.range) && (Is.undefined(candidate.command) || Command5.is(candidate.command));
+ return Is.defined(candidate) && Range17.is(candidate.range) && (Is.undefined(candidate.command) || Command5.is(candidate.command));
}
CodeLens3.is = is2;
})(CodeLens2 || (CodeLens2 = {}));
FormattingOptions2.create = create;
function is2(value) {
var candidate = value;
- return Is.defined(candidate) && Is.number(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
+ return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
}
FormattingOptions2.is = is2;
})(FormattingOptions || (FormattingOptions = {}));
DocumentLink2.create = create;
function is2(value) {
var candidate = value;
- return Is.defined(candidate) && Range15.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
+ return Is.defined(candidate) && Range17.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
}
DocumentLink2.is = is2;
})(DocumentLink || (DocumentLink = {}));
SelectionRange2.create = create;
function is2(value) {
var candidate = value;
- return candidate !== void 0 && Range15.is(candidate.range) && (candidate.parent === void 0 || SelectionRange2.is(candidate.parent));
+ return candidate !== void 0 && Range17.is(candidate.range) && (candidate.parent === void 0 || SelectionRange2.is(candidate.parent));
}
SelectionRange2.is = is2;
})(SelectionRange || (SelectionRange = {}));
var EOL = ["\n", "\r\n", "\r"];
- var TextDocument11;
- (function(TextDocument12) {
+ var TextDocument13;
+ (function(TextDocument14) {
function create(uri, languageId, version, content) {
return new FullTextDocument(uri, languageId, version, content);
}
- TextDocument12.create = create;
+ TextDocument14.create = create;
function is2(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;
+ return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount) && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;
}
- TextDocument12.is = is2;
+ TextDocument14.is = is2;
function applyEdits(document, edits) {
var text = document.getText();
var sortedEdits = mergeSort(edits, function(a, b) {
}
return text;
}
- TextDocument12.applyEdits = applyEdits;
+ TextDocument14.applyEdits = applyEdits;
function mergeSort(data, compare) {
if (data.length <= 1) {
return data;
}
return data;
}
- })(TextDocument11 || (TextDocument11 = {}));
+ })(TextDocument13 || (TextDocument13 = {}));
var FullTextDocument = function() {
function FullTextDocument2(uri, languageId, version, content) {
this._uri = uri;
get: function() {
return this._uri;
},
- enumerable: true,
+ enumerable: false,
configurable: true
});
Object.defineProperty(FullTextDocument2.prototype, "languageId", {
get: function() {
return this._languageId;
},
- enumerable: true,
+ enumerable: false,
configurable: true
});
Object.defineProperty(FullTextDocument2.prototype, "version", {
get: function() {
return this._version;
},
- enumerable: true,
+ enumerable: false,
configurable: true
});
FullTextDocument2.prototype.getText = function(range) {
var lineOffsets = this.getLineOffsets();
var low = 0, high = lineOffsets.length;
if (high === 0) {
- return Position7.create(0, offset);
+ return Position10.create(0, offset);
}
while (low < high) {
var mid = Math.floor((low + high) / 2);
}
}
var line = low - 1;
- return Position7.create(line, offset - lineOffsets[line]);
+ return Position10.create(line, offset - lineOffsets[line]);
};
FullTextDocument2.prototype.offsetAt = function(position) {
var lineOffsets = this.getLineOffsets();
get: function() {
return this.getLineOffsets().length;
},
- enumerable: true,
+ enumerable: false,
configurable: true
});
return FullTextDocument2;
return toString2.call(value) === "[object Number]";
}
Is2.number = number;
+ function numberRange(value, min, max) {
+ return toString2.call(value) === "[object Number]" && min <= value && value <= max;
+ }
+ Is2.numberRange = numberRange;
+ function integer2(value) {
+ return toString2.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
+ }
+ Is2.integer = integer2;
+ function uinteger2(value) {
+ return toString2.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
+ }
+ Is2.uinteger = uinteger2;
function func(value) {
return toString2.call(value) === "[object Function]";
}
})(Is || (Is = {}));
});
-// node_modules/vscode-languageserver-protocol/lib/utils/is.js
+// node_modules/vscode-languageserver-protocol/lib/common/messages.js
+var require_messages2 = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.ProtocolNotificationType = exports2.ProtocolNotificationType0 = exports2.ProtocolRequestType = exports2.ProtocolRequestType0 = exports2.RegistrationType = void 0;
+ var vscode_jsonrpc_1 = require_main();
+ var RegistrationType = class {
+ constructor(method) {
+ this.method = method;
+ }
+ };
+ exports2.RegistrationType = RegistrationType;
+ 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, vscode_jsonrpc_1.ParameterStructures.byName);
+ }
+ };
+ exports2.ProtocolRequestType = ProtocolRequestType;
+ var ProtocolNotificationType0 = class extends vscode_jsonrpc_1.NotificationType0 {
+ constructor(method) {
+ super(method);
+ }
+ };
+ exports2.ProtocolNotificationType0 = ProtocolNotificationType0;
+ var ProtocolNotificationType = class extends vscode_jsonrpc_1.NotificationType {
+ constructor(method) {
+ super(method, vscode_jsonrpc_1.ParameterStructures.byName);
+ }
+ };
+ exports2.ProtocolNotificationType = ProtocolNotificationType;
+});
+
+// node_modules/vscode-languageserver-protocol/lib/common/utils/is.js
var require_is2 = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.objectLiteral = exports2.typedArray = exports2.stringArray = exports2.array = exports2.func = exports2.error = exports2.number = exports2.string = exports2.boolean = void 0;
function boolean2(value) {
return value === true || value === false;
}
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
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js
var require_protocol_implementation = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
- var vscode_jsonrpc_1 = require_main();
+ exports2.ImplementationRequest = void 0;
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
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js
var require_protocol_typeDefinition = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
- var vscode_jsonrpc_1 = require_main();
+ exports2.TypeDefinitionRequest = void 0;
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
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolders.js
var require_protocol_workspaceFolders = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.DidChangeWorkspaceFoldersNotification = exports2.WorkspaceFoldersRequest = void 0;
var messages_1 = require_messages2();
var WorkspaceFoldersRequest;
(function(WorkspaceFoldersRequest2) {
})(DidChangeWorkspaceFoldersNotification = exports2.DidChangeWorkspaceFoldersNotification || (exports2.DidChangeWorkspaceFoldersNotification = {}));
});
-// node_modules/vscode-languageserver-protocol/lib/protocol.configuration.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js
var require_protocol_configuration = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.ConfigurationRequest = void 0;
var messages_1 = require_messages2();
var ConfigurationRequest;
(function(ConfigurationRequest2) {
})(ConfigurationRequest = exports2.ConfigurationRequest || (exports2.ConfigurationRequest = {}));
});
-// node_modules/vscode-languageserver-protocol/lib/protocol.colorProvider.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js
var require_protocol_colorProvider = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
- var vscode_jsonrpc_1 = require_main();
+ exports2.ColorPresentationRequest = exports2.DocumentColorRequest = void 0;
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) {
})(ColorPresentationRequest = exports2.ColorPresentationRequest || (exports2.ColorPresentationRequest = {}));
});
-// node_modules/vscode-languageserver-protocol/lib/protocol.foldingRange.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js
var require_protocol_foldingRange = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
- var vscode_jsonrpc_1 = require_main();
+ exports2.FoldingRangeRequest = exports2.FoldingRangeKind = void 0;
var messages_1 = require_messages2();
var FoldingRangeKind;
(function(FoldingRangeKind2) {
(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
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js
var require_protocol_declaration = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
- var vscode_jsonrpc_1 = require_main();
+ exports2.DeclarationRequest = void 0;
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
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js
var require_protocol_selectionRange = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
- var vscode_jsonrpc_1 = require_main();
+ exports2.SelectionRangeRequest = void 0;
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
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js
var require_protocol_progress = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.WorkDoneProgressCancelNotification = exports2.WorkDoneProgressCreateRequest = exports2.WorkDoneProgress = void 0;
var vscode_jsonrpc_1 = require_main();
var messages_1 = require_messages2();
var WorkDoneProgress;
(function(WorkDoneProgress2) {
WorkDoneProgress2.type = new vscode_jsonrpc_1.ProgressType();
+ function is2(value) {
+ return value === WorkDoneProgress2.type;
+ }
+ WorkDoneProgress2.is = is2;
})(WorkDoneProgress = exports2.WorkDoneProgress || (exports2.WorkDoneProgress = {}));
var WorkDoneProgressCreateRequest;
(function(WorkDoneProgressCreateRequest2) {
})(WorkDoneProgressCancelNotification = exports2.WorkDoneProgressCancelNotification || (exports2.WorkDoneProgressCancelNotification = {}));
});
-// node_modules/vscode-languageserver-protocol/lib/protocol.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js
+var require_protocol_callHierarchy = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.CallHierarchyOutgoingCallsRequest = exports2.CallHierarchyIncomingCallsRequest = exports2.CallHierarchyPrepareRequest = void 0;
+ 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/common/protocol.semanticTokens.js
+var require_protocol_semanticTokens = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.SemanticTokensRefreshRequest = exports2.SemanticTokensRangeRequest = exports2.SemanticTokensDeltaRequest = exports2.SemanticTokensRequest = exports2.SemanticTokensRegistrationType = exports2.TokenFormat = exports2.SemanticTokens = exports2.SemanticTokenModifiers = exports2.SemanticTokenTypes = void 0;
+ var messages_1 = require_messages2();
+ var SemanticTokenTypes;
+ (function(SemanticTokenTypes2) {
+ SemanticTokenTypes2["namespace"] = "namespace";
+ SemanticTokenTypes2["type"] = "type";
+ SemanticTokenTypes2["class"] = "class";
+ SemanticTokenTypes2["enum"] = "enum";
+ SemanticTokenTypes2["interface"] = "interface";
+ SemanticTokenTypes2["struct"] = "struct";
+ SemanticTokenTypes2["typeParameter"] = "typeParameter";
+ SemanticTokenTypes2["parameter"] = "parameter";
+ SemanticTokenTypes2["variable"] = "variable";
+ SemanticTokenTypes2["property"] = "property";
+ SemanticTokenTypes2["enumMember"] = "enumMember";
+ SemanticTokenTypes2["event"] = "event";
+ SemanticTokenTypes2["function"] = "function";
+ SemanticTokenTypes2["method"] = "method";
+ SemanticTokenTypes2["macro"] = "macro";
+ SemanticTokenTypes2["keyword"] = "keyword";
+ SemanticTokenTypes2["modifier"] = "modifier";
+ SemanticTokenTypes2["comment"] = "comment";
+ SemanticTokenTypes2["string"] = "string";
+ SemanticTokenTypes2["number"] = "number";
+ SemanticTokenTypes2["regexp"] = "regexp";
+ SemanticTokenTypes2["operator"] = "operator";
+ })(SemanticTokenTypes = exports2.SemanticTokenTypes || (exports2.SemanticTokenTypes = {}));
+ var SemanticTokenModifiers;
+ (function(SemanticTokenModifiers2) {
+ SemanticTokenModifiers2["declaration"] = "declaration";
+ SemanticTokenModifiers2["definition"] = "definition";
+ SemanticTokenModifiers2["readonly"] = "readonly";
+ SemanticTokenModifiers2["static"] = "static";
+ SemanticTokenModifiers2["deprecated"] = "deprecated";
+ SemanticTokenModifiers2["abstract"] = "abstract";
+ SemanticTokenModifiers2["async"] = "async";
+ SemanticTokenModifiers2["modification"] = "modification";
+ SemanticTokenModifiers2["documentation"] = "documentation";
+ SemanticTokenModifiers2["defaultLibrary"] = "defaultLibrary";
+ })(SemanticTokenModifiers = exports2.SemanticTokenModifiers || (exports2.SemanticTokenModifiers = {}));
+ var SemanticTokens;
+ (function(SemanticTokens2) {
+ function is2(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 = is2;
+ })(SemanticTokens = exports2.SemanticTokens || (exports2.SemanticTokens = {}));
+ var TokenFormat;
+ (function(TokenFormat2) {
+ TokenFormat2.Relative = "relative";
+ })(TokenFormat = exports2.TokenFormat || (exports2.TokenFormat = {}));
+ var SemanticTokensRegistrationType;
+ (function(SemanticTokensRegistrationType2) {
+ SemanticTokensRegistrationType2.method = "textDocument/semanticTokens";
+ SemanticTokensRegistrationType2.type = new messages_1.RegistrationType(SemanticTokensRegistrationType2.method);
+ })(SemanticTokensRegistrationType = exports2.SemanticTokensRegistrationType || (exports2.SemanticTokensRegistrationType = {}));
+ var SemanticTokensRequest;
+ (function(SemanticTokensRequest2) {
+ SemanticTokensRequest2.method = "textDocument/semanticTokens/full";
+ SemanticTokensRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRequest2.method);
+ })(SemanticTokensRequest = exports2.SemanticTokensRequest || (exports2.SemanticTokensRequest = {}));
+ var SemanticTokensDeltaRequest;
+ (function(SemanticTokensDeltaRequest2) {
+ SemanticTokensDeltaRequest2.method = "textDocument/semanticTokens/full/delta";
+ SemanticTokensDeltaRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensDeltaRequest2.method);
+ })(SemanticTokensDeltaRequest = exports2.SemanticTokensDeltaRequest || (exports2.SemanticTokensDeltaRequest = {}));
+ var SemanticTokensRangeRequest;
+ (function(SemanticTokensRangeRequest2) {
+ SemanticTokensRangeRequest2.method = "textDocument/semanticTokens/range";
+ SemanticTokensRangeRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest2.method);
+ })(SemanticTokensRangeRequest = exports2.SemanticTokensRangeRequest || (exports2.SemanticTokensRangeRequest = {}));
+ var SemanticTokensRefreshRequest;
+ (function(SemanticTokensRefreshRequest2) {
+ SemanticTokensRefreshRequest2.method = `workspace/semanticTokens/refresh`;
+ SemanticTokensRefreshRequest2.type = new messages_1.ProtocolRequestType0(SemanticTokensRefreshRequest2.method);
+ })(SemanticTokensRefreshRequest = exports2.SemanticTokensRefreshRequest || (exports2.SemanticTokensRefreshRequest = {}));
+});
+
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js
+var require_protocol_showDocument = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.ShowDocumentRequest = void 0;
+ var messages_1 = require_messages2();
+ var ShowDocumentRequest;
+ (function(ShowDocumentRequest2) {
+ ShowDocumentRequest2.method = "window/showDocument";
+ ShowDocumentRequest2.type = new messages_1.ProtocolRequestType(ShowDocumentRequest2.method);
+ })(ShowDocumentRequest = exports2.ShowDocumentRequest || (exports2.ShowDocumentRequest = {}));
+});
+
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js
+var require_protocol_linkedEditingRange = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.LinkedEditingRangeRequest = void 0;
+ var messages_1 = require_messages2();
+ var LinkedEditingRangeRequest;
+ (function(LinkedEditingRangeRequest2) {
+ LinkedEditingRangeRequest2.method = "textDocument/linkedEditingRange";
+ LinkedEditingRangeRequest2.type = new messages_1.ProtocolRequestType(LinkedEditingRangeRequest2.method);
+ })(LinkedEditingRangeRequest = exports2.LinkedEditingRangeRequest || (exports2.LinkedEditingRangeRequest = {}));
+});
+
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js
+var require_protocol_fileOperations = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.WillDeleteFilesRequest = exports2.DidDeleteFilesNotification = exports2.DidRenameFilesNotification = exports2.WillRenameFilesRequest = exports2.DidCreateFilesNotification = exports2.WillCreateFilesRequest = exports2.FileOperationPatternKind = void 0;
+ var messages_1 = require_messages2();
+ var FileOperationPatternKind;
+ (function(FileOperationPatternKind2) {
+ FileOperationPatternKind2.file = "file";
+ FileOperationPatternKind2.folder = "folder";
+ })(FileOperationPatternKind = exports2.FileOperationPatternKind || (exports2.FileOperationPatternKind = {}));
+ var WillCreateFilesRequest;
+ (function(WillCreateFilesRequest2) {
+ WillCreateFilesRequest2.method = "workspace/willCreateFiles";
+ WillCreateFilesRequest2.type = new messages_1.ProtocolRequestType(WillCreateFilesRequest2.method);
+ })(WillCreateFilesRequest = exports2.WillCreateFilesRequest || (exports2.WillCreateFilesRequest = {}));
+ var DidCreateFilesNotification;
+ (function(DidCreateFilesNotification2) {
+ DidCreateFilesNotification2.method = "workspace/didCreateFiles";
+ DidCreateFilesNotification2.type = new messages_1.ProtocolNotificationType(DidCreateFilesNotification2.method);
+ })(DidCreateFilesNotification = exports2.DidCreateFilesNotification || (exports2.DidCreateFilesNotification = {}));
+ var WillRenameFilesRequest;
+ (function(WillRenameFilesRequest2) {
+ WillRenameFilesRequest2.method = "workspace/willRenameFiles";
+ WillRenameFilesRequest2.type = new messages_1.ProtocolRequestType(WillRenameFilesRequest2.method);
+ })(WillRenameFilesRequest = exports2.WillRenameFilesRequest || (exports2.WillRenameFilesRequest = {}));
+ var DidRenameFilesNotification;
+ (function(DidRenameFilesNotification2) {
+ DidRenameFilesNotification2.method = "workspace/didRenameFiles";
+ DidRenameFilesNotification2.type = new messages_1.ProtocolNotificationType(DidRenameFilesNotification2.method);
+ })(DidRenameFilesNotification = exports2.DidRenameFilesNotification || (exports2.DidRenameFilesNotification = {}));
+ var DidDeleteFilesNotification;
+ (function(DidDeleteFilesNotification2) {
+ DidDeleteFilesNotification2.method = "workspace/didDeleteFiles";
+ DidDeleteFilesNotification2.type = new messages_1.ProtocolNotificationType(DidDeleteFilesNotification2.method);
+ })(DidDeleteFilesNotification = exports2.DidDeleteFilesNotification || (exports2.DidDeleteFilesNotification = {}));
+ var WillDeleteFilesRequest;
+ (function(WillDeleteFilesRequest2) {
+ WillDeleteFilesRequest2.method = "workspace/willDeleteFiles";
+ WillDeleteFilesRequest2.type = new messages_1.ProtocolRequestType(WillDeleteFilesRequest2.method);
+ })(WillDeleteFilesRequest = exports2.WillDeleteFilesRequest || (exports2.WillDeleteFilesRequest = {}));
+});
+
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js
+var require_protocol_moniker = __commonJS((exports2) => {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.MonikerRequest = exports2.MonikerKind = exports2.UniquenessLevel = void 0;
+ var messages_1 = require_messages2();
+ var UniquenessLevel;
+ (function(UniquenessLevel2) {
+ UniquenessLevel2["document"] = "document";
+ UniquenessLevel2["project"] = "project";
+ UniquenessLevel2["group"] = "group";
+ UniquenessLevel2["scheme"] = "scheme";
+ UniquenessLevel2["global"] = "global";
+ })(UniquenessLevel = exports2.UniquenessLevel || (exports2.UniquenessLevel = {}));
+ var MonikerKind;
+ (function(MonikerKind2) {
+ MonikerKind2["import"] = "import";
+ MonikerKind2["export"] = "export";
+ MonikerKind2["local"] = "local";
+ })(MonikerKind = exports2.MonikerKind || (exports2.MonikerKind = {}));
+ var MonikerRequest;
+ (function(MonikerRequest2) {
+ MonikerRequest2.method = "textDocument/moniker";
+ MonikerRequest2.type = new messages_1.ProtocolRequestType(MonikerRequest2.method);
+ })(MonikerRequest = exports2.MonikerRequest || (exports2.MonikerRequest = {}));
+});
+
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.js
var require_protocol = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
+ exports2.DocumentLinkRequest = exports2.CodeLensRefreshRequest = exports2.CodeLensResolveRequest = exports2.CodeLensRequest = exports2.WorkspaceSymbolRequest = exports2.CodeActionResolveRequest = exports2.CodeActionRequest = exports2.DocumentSymbolRequest = exports2.DocumentHighlightRequest = exports2.ReferencesRequest = exports2.DefinitionRequest = exports2.SignatureHelpRequest = exports2.SignatureHelpTriggerKind = exports2.HoverRequest = exports2.CompletionResolveRequest = exports2.CompletionRequest = exports2.CompletionTriggerKind = exports2.PublishDiagnosticsNotification = exports2.WatchKind = exports2.FileChangeType = exports2.DidChangeWatchedFilesNotification = exports2.WillSaveTextDocumentWaitUntilRequest = exports2.WillSaveTextDocumentNotification = exports2.TextDocumentSaveReason = exports2.DidSaveTextDocumentNotification = exports2.DidCloseTextDocumentNotification = exports2.DidChangeTextDocumentNotification = exports2.TextDocumentContentChangeEvent = exports2.DidOpenTextDocumentNotification = exports2.TextDocumentSyncKind = exports2.TelemetryEventNotification = exports2.LogMessageNotification = exports2.ShowMessageRequest = exports2.ShowMessageNotification = exports2.MessageType = exports2.DidChangeConfigurationNotification = exports2.ExitNotification = exports2.ShutdownRequest = exports2.InitializedNotification = exports2.InitializeError = exports2.InitializeRequest = exports2.WorkDoneProgressOptions = exports2.TextDocumentRegistrationOptions = exports2.StaticRegistrationOptions = exports2.FailureHandlingKind = exports2.ResourceOperationKind = exports2.UnregistrationRequest = exports2.RegistrationRequest = exports2.DocumentSelector = exports2.DocumentFilter = void 0;
+ exports2.MonikerRequest = exports2.MonikerKind = exports2.UniquenessLevel = exports2.WillDeleteFilesRequest = exports2.DidDeleteFilesNotification = exports2.WillRenameFilesRequest = exports2.DidRenameFilesNotification = exports2.WillCreateFilesRequest = exports2.DidCreateFilesNotification = exports2.FileOperationPatternKind = exports2.LinkedEditingRangeRequest = exports2.ShowDocumentRequest = exports2.SemanticTokensRegistrationType = exports2.SemanticTokensRefreshRequest = exports2.SemanticTokensRangeRequest = exports2.SemanticTokensDeltaRequest = exports2.SemanticTokensRequest = exports2.TokenFormat = exports2.SemanticTokens = exports2.SemanticTokenModifiers = exports2.SemanticTokenTypes = exports2.CallHierarchyPrepareRequest = exports2.CallHierarchyOutgoingCallsRequest = exports2.CallHierarchyIncomingCallsRequest = exports2.WorkDoneProgressCancelNotification = exports2.WorkDoneProgressCreateRequest = exports2.WorkDoneProgress = exports2.SelectionRangeRequest = exports2.DeclarationRequest = exports2.FoldingRangeRequest = exports2.ColorPresentationRequest = exports2.DocumentColorRequest = exports2.ConfigurationRequest = exports2.DidChangeWorkspaceFoldersNotification = exports2.WorkspaceFoldersRequest = exports2.TypeDefinitionRequest = exports2.ImplementationRequest = exports2.ApplyWorkspaceEditRequest = exports2.ExecuteCommandRequest = exports2.PrepareRenameRequest = exports2.RenameRequest = exports2.PrepareSupportDefaultBehavior = exports2.DocumentOnTypeFormattingRequest = exports2.DocumentRangeFormattingRequest = exports2.DocumentFormattingRequest = exports2.DocumentLinkResolveRequest = void 0;
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;
+ Object.defineProperty(exports2, "ImplementationRequest", {enumerable: true, get: function() {
+ return protocol_implementation_1.ImplementationRequest;
+ }});
var protocol_typeDefinition_1 = require_protocol_typeDefinition();
- exports2.TypeDefinitionRequest = protocol_typeDefinition_1.TypeDefinitionRequest;
+ Object.defineProperty(exports2, "TypeDefinitionRequest", {enumerable: true, get: function() {
+ return protocol_typeDefinition_1.TypeDefinitionRequest;
+ }});
var protocol_workspaceFolders_1 = require_protocol_workspaceFolders();
- exports2.WorkspaceFoldersRequest = protocol_workspaceFolders_1.WorkspaceFoldersRequest;
- exports2.DidChangeWorkspaceFoldersNotification = protocol_workspaceFolders_1.DidChangeWorkspaceFoldersNotification;
+ Object.defineProperty(exports2, "WorkspaceFoldersRequest", {enumerable: true, get: function() {
+ return protocol_workspaceFolders_1.WorkspaceFoldersRequest;
+ }});
+ Object.defineProperty(exports2, "DidChangeWorkspaceFoldersNotification", {enumerable: true, get: function() {
+ return protocol_workspaceFolders_1.DidChangeWorkspaceFoldersNotification;
+ }});
var protocol_configuration_1 = require_protocol_configuration();
- exports2.ConfigurationRequest = protocol_configuration_1.ConfigurationRequest;
+ Object.defineProperty(exports2, "ConfigurationRequest", {enumerable: true, get: function() {
+ return protocol_configuration_1.ConfigurationRequest;
+ }});
var protocol_colorProvider_1 = require_protocol_colorProvider();
- exports2.DocumentColorRequest = protocol_colorProvider_1.DocumentColorRequest;
- exports2.ColorPresentationRequest = protocol_colorProvider_1.ColorPresentationRequest;
+ Object.defineProperty(exports2, "DocumentColorRequest", {enumerable: true, get: function() {
+ return protocol_colorProvider_1.DocumentColorRequest;
+ }});
+ Object.defineProperty(exports2, "ColorPresentationRequest", {enumerable: true, get: function() {
+ return protocol_colorProvider_1.ColorPresentationRequest;
+ }});
var protocol_foldingRange_1 = require_protocol_foldingRange();
- exports2.FoldingRangeRequest = protocol_foldingRange_1.FoldingRangeRequest;
+ Object.defineProperty(exports2, "FoldingRangeRequest", {enumerable: true, get: function() {
+ return protocol_foldingRange_1.FoldingRangeRequest;
+ }});
var protocol_declaration_1 = require_protocol_declaration();
- exports2.DeclarationRequest = protocol_declaration_1.DeclarationRequest;
+ Object.defineProperty(exports2, "DeclarationRequest", {enumerable: true, get: function() {
+ return protocol_declaration_1.DeclarationRequest;
+ }});
var protocol_selectionRange_1 = require_protocol_selectionRange();
- exports2.SelectionRangeRequest = protocol_selectionRange_1.SelectionRangeRequest;
+ Object.defineProperty(exports2, "SelectionRangeRequest", {enumerable: true, get: function() {
+ return 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;
+ Object.defineProperty(exports2, "WorkDoneProgress", {enumerable: true, get: function() {
+ return protocol_progress_1.WorkDoneProgress;
+ }});
+ Object.defineProperty(exports2, "WorkDoneProgressCreateRequest", {enumerable: true, get: function() {
+ return protocol_progress_1.WorkDoneProgressCreateRequest;
+ }});
+ Object.defineProperty(exports2, "WorkDoneProgressCancelNotification", {enumerable: true, get: function() {
+ return protocol_progress_1.WorkDoneProgressCancelNotification;
+ }});
+ var protocol_callHierarchy_1 = require_protocol_callHierarchy();
+ Object.defineProperty(exports2, "CallHierarchyIncomingCallsRequest", {enumerable: true, get: function() {
+ return protocol_callHierarchy_1.CallHierarchyIncomingCallsRequest;
+ }});
+ Object.defineProperty(exports2, "CallHierarchyOutgoingCallsRequest", {enumerable: true, get: function() {
+ return protocol_callHierarchy_1.CallHierarchyOutgoingCallsRequest;
+ }});
+ Object.defineProperty(exports2, "CallHierarchyPrepareRequest", {enumerable: true, get: function() {
+ return protocol_callHierarchy_1.CallHierarchyPrepareRequest;
+ }});
+ var protocol_semanticTokens_1 = require_protocol_semanticTokens();
+ Object.defineProperty(exports2, "SemanticTokenTypes", {enumerable: true, get: function() {
+ return protocol_semanticTokens_1.SemanticTokenTypes;
+ }});
+ Object.defineProperty(exports2, "SemanticTokenModifiers", {enumerable: true, get: function() {
+ return protocol_semanticTokens_1.SemanticTokenModifiers;
+ }});
+ Object.defineProperty(exports2, "SemanticTokens", {enumerable: true, get: function() {
+ return protocol_semanticTokens_1.SemanticTokens;
+ }});
+ Object.defineProperty(exports2, "TokenFormat", {enumerable: true, get: function() {
+ return protocol_semanticTokens_1.TokenFormat;
+ }});
+ Object.defineProperty(exports2, "SemanticTokensRequest", {enumerable: true, get: function() {
+ return protocol_semanticTokens_1.SemanticTokensRequest;
+ }});
+ Object.defineProperty(exports2, "SemanticTokensDeltaRequest", {enumerable: true, get: function() {
+ return protocol_semanticTokens_1.SemanticTokensDeltaRequest;
+ }});
+ Object.defineProperty(exports2, "SemanticTokensRangeRequest", {enumerable: true, get: function() {
+ return protocol_semanticTokens_1.SemanticTokensRangeRequest;
+ }});
+ Object.defineProperty(exports2, "SemanticTokensRefreshRequest", {enumerable: true, get: function() {
+ return protocol_semanticTokens_1.SemanticTokensRefreshRequest;
+ }});
+ Object.defineProperty(exports2, "SemanticTokensRegistrationType", {enumerable: true, get: function() {
+ return protocol_semanticTokens_1.SemanticTokensRegistrationType;
+ }});
+ var protocol_showDocument_1 = require_protocol_showDocument();
+ Object.defineProperty(exports2, "ShowDocumentRequest", {enumerable: true, get: function() {
+ return protocol_showDocument_1.ShowDocumentRequest;
+ }});
+ var protocol_linkedEditingRange_1 = require_protocol_linkedEditingRange();
+ Object.defineProperty(exports2, "LinkedEditingRangeRequest", {enumerable: true, get: function() {
+ return protocol_linkedEditingRange_1.LinkedEditingRangeRequest;
+ }});
+ var protocol_fileOperations_1 = require_protocol_fileOperations();
+ Object.defineProperty(exports2, "FileOperationPatternKind", {enumerable: true, get: function() {
+ return protocol_fileOperations_1.FileOperationPatternKind;
+ }});
+ Object.defineProperty(exports2, "DidCreateFilesNotification", {enumerable: true, get: function() {
+ return protocol_fileOperations_1.DidCreateFilesNotification;
+ }});
+ Object.defineProperty(exports2, "WillCreateFilesRequest", {enumerable: true, get: function() {
+ return protocol_fileOperations_1.WillCreateFilesRequest;
+ }});
+ Object.defineProperty(exports2, "DidRenameFilesNotification", {enumerable: true, get: function() {
+ return protocol_fileOperations_1.DidRenameFilesNotification;
+ }});
+ Object.defineProperty(exports2, "WillRenameFilesRequest", {enumerable: true, get: function() {
+ return protocol_fileOperations_1.WillRenameFilesRequest;
+ }});
+ Object.defineProperty(exports2, "DidDeleteFilesNotification", {enumerable: true, get: function() {
+ return protocol_fileOperations_1.DidDeleteFilesNotification;
+ }});
+ Object.defineProperty(exports2, "WillDeleteFilesRequest", {enumerable: true, get: function() {
+ return protocol_fileOperations_1.WillDeleteFilesRequest;
+ }});
+ var protocol_moniker_1 = require_protocol_moniker();
+ Object.defineProperty(exports2, "UniquenessLevel", {enumerable: true, get: function() {
+ return protocol_moniker_1.UniquenessLevel;
+ }});
+ Object.defineProperty(exports2, "MonikerKind", {enumerable: true, get: function() {
+ return protocol_moniker_1.MonikerKind;
+ }});
+ Object.defineProperty(exports2, "MonikerRequest", {enumerable: true, get: function() {
+ return protocol_moniker_1.MonikerRequest;
+ }});
var DocumentFilter;
(function(DocumentFilter2) {
function is2(value) {
DidOpenTextDocumentNotification2.method = "textDocument/didOpen";
DidOpenTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidOpenTextDocumentNotification2.method);
})(DidOpenTextDocumentNotification = exports2.DidOpenTextDocumentNotification || (exports2.DidOpenTextDocumentNotification = {}));
+ var TextDocumentContentChangeEvent2;
+ (function(TextDocumentContentChangeEvent3) {
+ function isIncremental(event) {
+ let candidate = event;
+ return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range !== void 0 && (candidate.rangeLength === void 0 || typeof candidate.rangeLength === "number");
+ }
+ TextDocumentContentChangeEvent3.isIncremental = isIncremental;
+ function isFull(event) {
+ let candidate = event;
+ return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range === void 0 && candidate.rangeLength === void 0;
+ }
+ TextDocumentContentChangeEvent3.isFull = isFull;
+ })(TextDocumentContentChangeEvent2 = exports2.TextDocumentContentChangeEvent || (exports2.TextDocumentContentChangeEvent = {}));
var DidChangeTextDocumentNotification;
(function(DidChangeTextDocumentNotification2) {
DidChangeTextDocumentNotification2.method = "textDocument/didChange";
(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) {
(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 CodeActionResolveRequest;
+ (function(CodeActionResolveRequest2) {
+ CodeActionResolveRequest2.method = "codeAction/resolve";
+ CodeActionResolveRequest2.type = new messages_1.ProtocolRequestType(CodeActionResolveRequest2.method);
+ })(CodeActionResolveRequest = exports2.CodeActionResolveRequest || (exports2.CodeActionResolveRequest = {}));
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();
+ CodeLensRequest2.method = "textDocument/codeLens";
+ CodeLensRequest2.type = new messages_1.ProtocolRequestType(CodeLensRequest2.method);
})(CodeLensRequest = exports2.CodeLensRequest || (exports2.CodeLensRequest = {}));
var CodeLensResolveRequest;
(function(CodeLensResolveRequest2) {
- CodeLensResolveRequest2.type = new messages_1.ProtocolRequestType("codeLens/resolve");
+ CodeLensResolveRequest2.method = "codeLens/resolve";
+ CodeLensResolveRequest2.type = new messages_1.ProtocolRequestType(CodeLensResolveRequest2.method);
})(CodeLensResolveRequest = exports2.CodeLensResolveRequest || (exports2.CodeLensResolveRequest = {}));
+ var CodeLensRefreshRequest;
+ (function(CodeLensRefreshRequest2) {
+ CodeLensRefreshRequest2.method = `workspace/codeLens/refresh`;
+ CodeLensRefreshRequest2.type = new messages_1.ProtocolRequestType0(CodeLensRefreshRequest2.method);
+ })(CodeLensRefreshRequest = exports2.CodeLensRefreshRequest || (exports2.CodeLensRefreshRequest = {}));
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");
+ DocumentLinkResolveRequest2.method = "documentLink/resolve";
+ DocumentLinkResolveRequest2.type = new messages_1.ProtocolRequestType(DocumentLinkResolveRequest2.method);
})(DocumentLinkResolveRequest = exports2.DocumentLinkResolveRequest || (exports2.DocumentLinkResolveRequest = {}));
var DocumentFormattingRequest;
(function(DocumentFormattingRequest2) {
DocumentOnTypeFormattingRequest2.method = "textDocument/onTypeFormatting";
DocumentOnTypeFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentOnTypeFormattingRequest2.method);
})(DocumentOnTypeFormattingRequest = exports2.DocumentOnTypeFormattingRequest || (exports2.DocumentOnTypeFormattingRequest = {}));
+ var PrepareSupportDefaultBehavior;
+ (function(PrepareSupportDefaultBehavior2) {
+ PrepareSupportDefaultBehavior2.Identifier = 1;
+ })(PrepareSupportDefaultBehavior = exports2.PrepareSupportDefaultBehavior || (exports2.PrepareSupportDefaultBehavior = {}));
var RenameRequest;
(function(RenameRequest2) {
RenameRequest2.method = "textDocument/rename";
})(ApplyWorkspaceEditRequest = exports2.ApplyWorkspaceEditRequest || (exports2.ApplyWorkspaceEditRequest = {}));
});
-// node_modules/vscode-languageserver-protocol/lib/protocol.callHierarchy.proposed.js
-var require_protocol_callHierarchy_proposed = __commonJS((exports2) => {
+// node_modules/vscode-languageserver-protocol/lib/common/connection.js
+var require_connection2 = __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 = {}));
+ exports2.createProtocolConnection = void 0;
+ var vscode_jsonrpc_1 = require_main();
+ function createProtocolConnection(input, output, logger, options) {
+ if (vscode_jsonrpc_1.ConnectionStrategy.is(options)) {
+ options = {connectionStrategy: options};
+ }
+ return vscode_jsonrpc_1.createMessageConnection(input, output, logger, options);
+ }
+ exports2.createProtocolConnection = createProtocolConnection;
});
-// node_modules/vscode-languageserver-protocol/lib/protocol.sematicTokens.proposed.js
-var require_protocol_sematicTokens_proposed = __commonJS((exports2) => {
+// node_modules/vscode-languageserver-protocol/lib/common/api.js
+var require_api2 = __commonJS((exports2) => {
"use strict";
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ Object.defineProperty(o, k2, {enumerable: true, get: function() {
+ return m[k];
+ }});
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ });
+ var __exportStar2 = exports2 && exports2.__exportStar || function(m, exports3) {
+ for (var p in m)
+ if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+ __createBinding(exports3, m, p);
+ };
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 is2(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 = is2;
- })(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 = {}));
+ exports2.LSPErrorCodes = exports2.createProtocolConnection = void 0;
+ __exportStar2(require_main(), exports2);
+ __exportStar2(require_main2(), exports2);
+ __exportStar2(require_messages2(), exports2);
+ __exportStar2(require_protocol(), exports2);
+ var connection_1 = require_connection2();
+ Object.defineProperty(exports2, "createProtocolConnection", {enumerable: true, get: function() {
+ return connection_1.createProtocolConnection;
+ }});
+ var LSPErrorCodes;
+ (function(LSPErrorCodes2) {
+ LSPErrorCodes2.lspReservedErrorRangeStart = -32899;
+ LSPErrorCodes2.ContentModified = -32801;
+ LSPErrorCodes2.RequestCancelled = -32800;
+ LSPErrorCodes2.lspReservedErrorRangeEnd = -32800;
+ })(LSPErrorCodes = exports2.LSPErrorCodes || (exports2.LSPErrorCodes = {}));
});
-// node_modules/vscode-languageserver-protocol/lib/main.js
+// node_modules/vscode-languageserver-protocol/lib/node/main.js
var require_main3 = __commonJS((exports2) => {
"use strict";
- function __export2(m) {
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ Object.defineProperty(o, k2, {enumerable: true, get: function() {
+ return m[k];
+ }});
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ });
+ var __exportStar2 = exports2 && exports2.__exportStar || function(m, exports3) {
for (var p in m)
- if (!exports2.hasOwnProperty(p))
- exports2[p] = m[p];
- }
+ if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+ __createBinding(exports3, 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 = void 0;
+ var node_1 = require_node();
+ __exportStar2(require_node(), exports2);
+ __exportStar2(require_api2(), exports2);
+ function createProtocolConnection(input, output, logger, options) {
+ return node_1.createMessageConnection(input, output, logger, options);
}
exports2.createProtocolConnection = createProtocolConnection;
});
// node_modules/semver/classes/range.js
var require_range = __commonJS((exports2, module2) => {
- var Range15 = class {
+ var Range17 = class {
constructor(range, options) {
if (!options || typeof options !== "object") {
options = {
includePrerelease: false
};
}
- if (range instanceof Range15) {
+ if (range instanceof Range17) {
if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
return range;
} else {
- return new Range15(range.raw, options);
+ return new Range17(range.raw, options);
}
}
if (range instanceof Comparator) {
return range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options)).filter(this.options.loose ? (comp) => !!comp.match(compRe) : () => true).map((comp) => new Comparator(comp, this.options));
}
intersects(range, options) {
- if (!(range instanceof Range15)) {
+ if (!(range instanceof Range17)) {
throw new TypeError("a Range is required");
}
return this.set.some((thisComparators) => {
return false;
}
};
- module2.exports = Range15;
+ module2.exports = Range17;
var Comparator = require_comparator();
var debug = require_debug();
var SemVer = require_semver();
if (this.value === "") {
return true;
}
- return new Range15(comp.value, options).test(this.value);
+ return new Range17(comp.value, options).test(this.value);
} else if (comp.operator === "") {
if (comp.value === "") {
return true;
}
- return new Range15(this.value, options).test(comp.semver);
+ return new Range17(this.value, options).test(comp.semver);
}
const sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
const sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
var cmp = require_cmp();
var debug = require_debug();
var SemVer = require_semver();
- var Range15 = require_range();
+ var Range17 = require_range();
});
// node_modules/semver/functions/satisfies.js
var require_satisfies = __commonJS((exports2, module2) => {
- var Range15 = require_range();
+ var Range17 = require_range();
var satisfies = (version, range, options) => {
try {
- range = new Range15(range, options);
+ range = new Range17(range, options);
} catch (er) {
return false;
}
// node_modules/semver/ranges/to-comparators.js
var require_to_comparators = __commonJS((exports2, module2) => {
- var Range15 = require_range();
- var toComparators = (range, options) => new Range15(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+ var Range17 = require_range();
+ var toComparators = (range, options) => new Range17(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
module2.exports = toComparators;
});
// node_modules/semver/ranges/max-satisfying.js
var require_max_satisfying = __commonJS((exports2, module2) => {
var SemVer = require_semver();
- var Range15 = require_range();
+ var Range17 = require_range();
var maxSatisfying = (versions, range, options) => {
let max = null;
let maxSV = null;
let rangeObj = null;
try {
- rangeObj = new Range15(range, options);
+ rangeObj = new Range17(range, options);
} catch (er) {
return null;
}
// node_modules/semver/ranges/min-satisfying.js
var require_min_satisfying = __commonJS((exports2, module2) => {
var SemVer = require_semver();
- var Range15 = require_range();
+ var Range17 = require_range();
var minSatisfying = (versions, range, options) => {
let min = null;
let minSV = null;
let rangeObj = null;
try {
- rangeObj = new Range15(range, options);
+ rangeObj = new Range17(range, options);
} catch (er) {
return null;
}
// node_modules/semver/ranges/min-version.js
var require_min_version = __commonJS((exports2, module2) => {
var SemVer = require_semver();
- var Range15 = require_range();
+ var Range17 = require_range();
var gt = require_gt();
var minVersion = (range, loose) => {
- range = new Range15(range, loose);
+ range = new Range17(range, loose);
let minver = new SemVer("0.0.0");
if (range.test(minver)) {
return minver;
// node_modules/semver/ranges/valid.js
var require_valid2 = __commonJS((exports2, module2) => {
- var Range15 = require_range();
+ var Range17 = require_range();
var validRange = (range, options) => {
try {
- return new Range15(range, options).range || "*";
+ return new Range17(range, options).range || "*";
} catch (er) {
return null;
}
var SemVer = require_semver();
var Comparator = require_comparator();
var {ANY} = Comparator;
- var Range15 = require_range();
+ var Range17 = require_range();
var satisfies = require_satisfies();
var gt = require_gt();
var lt = require_lt();
var gte2 = require_gte();
var outside = (version, range, hilo, options) => {
version = new SemVer(version, options);
- range = new Range15(range, options);
+ range = new Range17(range, options);
let gtfn, ltefn, ltfn, comp, ecomp;
switch (hilo) {
case ">":
// node_modules/semver/ranges/intersects.js
var require_intersects = __commonJS((exports2, module2) => {
- var Range15 = require_range();
+ var Range17 = require_range();
var intersects = (r1, r2, options) => {
- r1 = new Range15(r1, options);
- r2 = new Range15(r2, options);
+ r1 = new Range17(r1, options);
+ r2 = new Range17(r2, options);
return r1.intersects(r2);
};
module2.exports = intersects;
// node_modules/semver/ranges/subset.js
var require_subset = __commonJS((exports2, module2) => {
- var Range15 = require_range();
+ var Range17 = require_range();
var {ANY} = require_comparator();
var satisfies = require_satisfies();
var compare = require_compare();
var subset = (sub, dom, options) => {
- sub = new Range15(sub, options);
- dom = new Range15(dom, options);
+ sub = new Range17(sub, options);
+ dom = new Range17(dom, options);
let sawNonNull = false;
OUTER:
for (const simpleSub of sub.set) {
module2.exports = isexe;
isexe.sync = sync;
var fs5 = require("fs");
- function checkPathExt(path8, options) {
+ function checkPathExt(path9, options) {
var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
if (!pathext) {
return true;
}
for (var i = 0; i < pathext.length; i++) {
var p = pathext[i].toLowerCase();
- if (p && path8.substr(-p.length).toLowerCase() === p) {
+ if (p && path9.substr(-p.length).toLowerCase() === p) {
return true;
}
}
return false;
}
- function checkStat(stat, path8, options) {
+ function checkStat(stat, path9, options) {
if (!stat.isSymbolicLink() && !stat.isFile()) {
return false;
}
- return checkPathExt(path8, options);
+ return checkPathExt(path9, options);
}
- function isexe(path8, options, cb) {
- fs5.stat(path8, function(er, stat) {
- cb(er, er ? false : checkStat(stat, path8, options));
+ function isexe(path9, options, cb) {
+ fs5.stat(path9, function(er, stat) {
+ cb(er, er ? false : checkStat(stat, path9, options));
});
}
- function sync(path8, options) {
- return checkStat(fs5.statSync(path8), path8, options);
+ function sync(path9, options) {
+ return checkStat(fs5.statSync(path9), path9, options);
}
});
module2.exports = isexe;
isexe.sync = sync;
var fs5 = require("fs");
- function isexe(path8, options, cb) {
- fs5.stat(path8, function(er, stat) {
+ function isexe(path9, options, cb) {
+ fs5.stat(path9, function(er, stat) {
cb(er, er ? false : checkStat(stat, options));
});
}
- function sync(path8, options) {
- return checkStat(fs5.statSync(path8), options);
+ function sync(path9, options) {
+ return checkStat(fs5.statSync(path9), options);
}
function checkStat(stat, options) {
return stat.isFile() && checkMode(stat, options);
}
module2.exports = isexe;
isexe.sync = sync;
- function isexe(path8, options, cb) {
+ function isexe(path9, options, cb) {
if (typeof options === "function") {
cb = options;
options = {};
throw new TypeError("callback not provided");
}
return new Promise(function(resolve, reject) {
- isexe(path8, options || {}, function(er, is2) {
+ isexe(path9, options || {}, function(er, is2) {
if (er) {
reject(er);
} else {
});
});
}
- core(path8, options || {}, function(er, is2) {
+ core(path9, options || {}, function(er, is2) {
if (er) {
if (er.code === "EACCES" || options && options.ignoreErrors) {
er = null;
cb(er, is2);
});
}
- function sync(path8, options) {
+ function sync(path9, options) {
try {
- return core.sync(path8, options || {});
+ return core.sync(path9, options || {});
} catch (er) {
if (options && options.ignoreErrors || er.code === "EACCES") {
return false;
// node_modules/which/which.js
var require_which = __commonJS((exports2, module2) => {
var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
- var path8 = require("path");
+ var path9 = require("path");
var COLON = isWindows ? ";" : ":";
var isexe = require_isexe();
var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), {code: "ENOENT"});
return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
const ppRaw = pathEnv[i];
const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
- const pCmd = path8.join(pathPart, cmd);
+ const pCmd = path9.join(pathPart, cmd);
const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
resolve(subStep(p, i, 0));
});
for (let i = 0; i < pathEnv.length; i++) {
const ppRaw = pathEnv[i];
const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
- const pCmd = path8.join(pathPart, cmd);
+ const pCmd = path9.join(pathPart, cmd);
const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
for (let j = 0; j < pathExt.length; j++) {
const cur = p + pathExt[j];
__export(exports, {
activate: () => activate
});
-var import_coc32 = __toModule(require("coc.nvim"));
+var import_coc37 = __toModule(require("coc.nvim"));
// src/server/index.ts
-var import_coc30 = __toModule(require("coc.nvim"));
-var import_vscode_languageserver_protocol23 = __toModule(require_main3());
+var import_coc35 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol24 = __toModule(require_main3());
// src/server/typescriptServiceClientHost.ts
-var import_coc29 = __toModule(require("coc.nvim"));
-var import_vscode_languageserver_protocol22 = __toModule(require_main3());
+var import_coc34 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol23 = __toModule(require_main3());
// src/utils/arrays.ts
function equals(one, other, itemEquals = (a, b) => a === b) {
API.v390 = API2.fromSimpleString("3.9.0");
API.v400 = API2.fromSimpleString("4.0.0");
API.v401 = API2.fromSimpleString("4.0.1");
+API.v420 = API2.fromSimpleString("4.2.0");
+API.v430 = API2.fromSimpleString("4.3.0");
var api_default = API;
// src/server/features/fileConfigurationManager.ts
}
formatEnabled(document) {
let {languageId, uri} = document;
- let language = languageId.startsWith("typescript") ? "typescript" : "javascript";
- const config = import_coc.workspace.getConfiguration(`${language}.format`, uri);
+ let language2 = languageId.startsWith("typescript") ? "typescript" : "javascript";
+ const config = import_coc.workspace.getConfiguration(`${language2}.format`, uri);
return config.get("enabled");
}
enableJavascript() {
preferences: this.getPreferences(lang, document.uri)
};
}
- getFormatOptions(options, language, uri) {
- const config = import_coc.workspace.getConfiguration(`${language}.format`, uri);
+ getFormatOptions(options, language2, uri) {
+ const config = import_coc.workspace.getConfiguration(`${language2}.format`, uri);
return {
tabSize: options.tabSize,
indentSize: options.tabSize,
paths: config.get("paths", true),
completeFunctionCalls: config.get("completeFunctionCalls", true),
autoImports: config.get("autoImports", true),
+ importStatementSuggestions: config.get("importStatements", true),
+ includeCompletionsForImportStatements: config.get("includeCompletionsForImportStatements", true),
+ includeCompletionsWithSnippetText: config.get("includeCompletionsWithSnippetText", true),
includeAutomaticOptionalChainCompletions: config.get("includeAutomaticOptionalChainCompletions", true)
};
}
- getPreferences(language, uri) {
+ getPreferences(language2, uri) {
if (this.client.apiVersion.lt(api_default.v290)) {
return {};
}
- const config = import_coc.workspace.getConfiguration(`${language}.preferences`, uri);
+ const config = import_coc.workspace.getConfiguration(`${language2}.preferences`, uri);
const preferences = {
quotePreference: this.getQuoteStyle(config),
importModuleSpecifierPreference: getImportModuleSpecifier(config),
importModuleSpecifierEnding: getImportModuleSpecifierEndingPreference(config),
allowTextChangesInNewFiles: uri.startsWith("file:"),
allowRenameOfImportPath: true,
- providePrefixAndSuffixTextForRename: config.get("renameShorthandProperties", true) === false ? false : config.get("useAliasesForRenames", true)
+ providePrefixAndSuffixTextForRename: config.get("renameShorthandProperties", true) === false ? false : config.get("useAliasesForRenames", true),
+ includeCompletionsForImportStatements: this.getCompleteOptions(language2).includeCompletionsForImportStatements,
+ includeCompletionsWithSnippetText: this.getCompleteOptions(language2).includeCompletionsWithSnippetText
};
return preferences;
}
function getImportModuleSpecifier(config) {
let val = config.get("importModuleSpecifier");
switch (val) {
+ case "project-relative":
+ return "project-relative";
case "relative":
return "relative";
case "non-relative":
return "non-relative";
default:
- return "auto";
+ return void 0;
}
}
function getImportModuleSpecifierEndingPreference(config) {
import_coc2.window.showMessage(`Local & global tsc not found`, "error");
return;
}
- let find = await import_coc2.workspace.findUp(["tsconfig.json"]);
+ const tsconfigPath = import_coc2.workspace.getConfiguration("tsserver").get("tsconfigPath", "tsconfig.json");
+ let find = await import_coc2.workspace.findUp([tsconfigPath]);
if (!find) {
- import_coc2.window.showMessage("tsconfig.json not found!", "error");
+ import_coc2.window.showMessage(`${tsconfigPath} not found!`, "error");
return;
}
let root = import_path.default.dirname(find);
return {
cmd: tscPath,
- args: ["-p", "tsconfig.json", "--watch", "true", "--pretty", "false"],
+ args: ["-p", tsconfigPath, "--watch", "true", "--pretty", "false"],
cwd: root
};
}
var import_coc3 = __toModule(require("coc.nvim"));
var import_vscode_languageserver_protocol3 = __toModule(require_main3());
+// src/server/protocol.const.ts
+var Kind = class {
+};
+Kind.alias = "alias";
+Kind.callSignature = "call";
+Kind.class = "class";
+Kind.const = "const";
+Kind.constructorImplementation = "constructor";
+Kind.constructSignature = "construct";
+Kind.directory = "directory";
+Kind.enum = "enum";
+Kind.enumMember = "enum member";
+Kind.externalModuleName = "external module name";
+Kind.function = "function";
+Kind.indexSignature = "index";
+Kind.interface = "interface";
+Kind.keyword = "keyword";
+Kind.let = "let";
+Kind.localFunction = "local function";
+Kind.localVariable = "local var";
+Kind.method = "method";
+Kind.memberGetAccessor = "getter";
+Kind.memberSetAccessor = "setter";
+Kind.memberVariable = "property";
+Kind.module = "module";
+Kind.primitiveType = "primitive type";
+Kind.script = "script";
+Kind.type = "type";
+Kind.variable = "var";
+Kind.warning = "warning";
+Kind.string = "string";
+Kind.parameter = "parameter";
+Kind.typeParameter = "type parameter";
+var DiagnosticCategory = class {
+};
+DiagnosticCategory.error = "error";
+DiagnosticCategory.warning = "warning";
+DiagnosticCategory.suggestion = "suggestion";
+var KindModifiers2 = class {
+};
+var KindModifiers = KindModifiers2;
+KindModifiers.optional = "optional";
+KindModifiers.deprecated = "deprecated";
+KindModifiers.color = "color";
+KindModifiers.dtsFile = ".d.ts";
+KindModifiers.tsFile = ".ts";
+KindModifiers.tsxFile = ".tsx";
+KindModifiers.jsFile = ".js";
+KindModifiers.jsxFile = ".jsx";
+KindModifiers.jsonFile = ".json";
+KindModifiers.fileExtensionKindModifiers = [
+ KindModifiers2.dtsFile,
+ KindModifiers2.tsFile,
+ KindModifiers2.tsxFile,
+ KindModifiers2.jsFile,
+ KindModifiers2.jsxFile,
+ KindModifiers2.jsonFile
+];
+var DisplayPartKind = class {
+};
+DisplayPartKind.functionName = "functionName";
+DisplayPartKind.methodName = "methodName";
+DisplayPartKind.parameterName = "parameterName";
+DisplayPartKind.propertyName = "propertyName";
+DisplayPartKind.punctuation = "punctuation";
+DisplayPartKind.text = "text";
+var EventName;
+(function(EventName2) {
+ EventName2["syntaxDiag"] = "syntaxDiag";
+ EventName2["semanticDiag"] = "semanticDiag";
+ EventName2["suggestionDiag"] = "suggestionDiag";
+ EventName2["configFileDiag"] = "configFileDiag";
+ EventName2["telemetry"] = "telemetry";
+ EventName2["projectLanguageServiceState"] = "projectLanguageServiceState";
+ EventName2["projectsUpdatedInBackground"] = "projectsUpdatedInBackground";
+ EventName2["beginInstallTypes"] = "beginInstallTypes";
+ EventName2["endInstallTypes"] = "endInstallTypes";
+ EventName2["typesInstallerInitializationFailed"] = "typesInstallerInitializationFailed";
+ EventName2["surveyReady"] = "surveyReady";
+ EventName2["projectLoadingStart"] = "projectLoadingStart";
+ EventName2["projectLoadingFinish"] = "projectLoadingFinish";
+})(EventName || (EventName = {}));
+
// src/server/utils/typeConverters.ts
-var Range;
-(function(Range15) {
- Range15.fromTextSpan = (span) => {
+var language = __toModule(require_main3());
+var Range2;
+(function(Range17) {
+ Range17.fromTextSpan = (span) => {
return {
start: {
line: span.start.line - 1,
}
};
};
- Range15.toFormattingRequestArgs = (file2, range) => ({
+ Range17.fromLocations = (start, end) => language.Range.create(Math.max(0, start.line - 1), Math.max(start.offset - 1, 0), Math.max(0, end.line - 1), Math.max(0, end.offset - 1));
+ Range17.toFormattingRequestArgs = (file2, range) => ({
file: file2,
line: range.start.line + 1,
offset: range.start.character + 1,
endLine: range.end.line + 1,
endOffset: range.end.character + 1
});
- Range15.toFileRangeRequestArgs = (file2, range) => ({
+ Range17.toFileRangeRequestArgs = (file2, range) => ({
file: file2,
startLine: range.start.line + 1,
startOffset: range.start.character + 1,
endLine: range.end.line + 1,
endOffset: range.end.character + 1
});
-})(Range || (Range = {}));
+})(Range2 || (Range2 = {}));
var Position;
-(function(Position7) {
- Position7.fromLocation = (tslocation) => {
+(function(Position10) {
+ Position10.fromLocation = (tslocation) => {
return {
line: tslocation.line - 1,
character: tslocation.offset - 1
};
};
- Position7.toLocation = (position) => ({
+ Position10.toLocation = (position) => ({
line: position.line + 1,
offset: position.character + 1
});
- Position7.toFileLocationRequestArgs = (file2, position) => ({
+ Position10.toFileLocationRequestArgs = (file2, position) => ({
file: file2,
line: position.line + 1,
offset: position.character + 1
});
})(Position || (Position = {}));
var Location2;
-(function(Location3) {
- Location3.fromTextSpan = (uri, tsTextSpan) => {
+(function(Location4) {
+ Location4.fromTextSpan = (uri, tsTextSpan) => {
return {
uri,
- range: Range.fromTextSpan(tsTextSpan)
+ range: Range2.fromTextSpan(tsTextSpan)
};
};
})(Location2 || (Location2 = {}));
(function(TextEdit6) {
TextEdit6.fromCodeEdit = (edit) => {
return {
- range: Range.fromTextSpan(edit),
+ range: Range2.fromTextSpan(edit),
newText: edit.newText
};
};
}
WorkspaceEdit6.fromFileCodeEdits = fromFileCodeEdits;
})(WorkspaceEdit || (WorkspaceEdit = {}));
+var SymbolKind2;
+(function(SymbolKind5) {
+ function fromProtocolScriptElementKind(kind) {
+ switch (kind) {
+ case Kind.module:
+ return language.SymbolKind.Module;
+ case Kind.class:
+ return language.SymbolKind.Class;
+ case Kind.enum:
+ return language.SymbolKind.Enum;
+ case Kind.enumMember:
+ return language.SymbolKind.EnumMember;
+ case Kind.interface:
+ return language.SymbolKind.Interface;
+ case Kind.indexSignature:
+ return language.SymbolKind.Method;
+ case Kind.callSignature:
+ return language.SymbolKind.Method;
+ case Kind.method:
+ return language.SymbolKind.Method;
+ case Kind.memberVariable:
+ return language.SymbolKind.Property;
+ case Kind.memberGetAccessor:
+ return language.SymbolKind.Property;
+ case Kind.memberSetAccessor:
+ return language.SymbolKind.Property;
+ case Kind.variable:
+ return language.SymbolKind.Variable;
+ case Kind.let:
+ return language.SymbolKind.Variable;
+ case Kind.const:
+ return language.SymbolKind.Variable;
+ case Kind.localVariable:
+ return language.SymbolKind.Variable;
+ case Kind.alias:
+ return language.SymbolKind.Variable;
+ case Kind.function:
+ return language.SymbolKind.Function;
+ case Kind.localFunction:
+ return language.SymbolKind.Function;
+ case Kind.constructSignature:
+ return language.SymbolKind.Constructor;
+ case Kind.constructorImplementation:
+ return language.SymbolKind.Constructor;
+ case Kind.typeParameter:
+ return language.SymbolKind.TypeParameter;
+ case Kind.string:
+ return language.SymbolKind.String;
+ default:
+ return language.SymbolKind.Variable;
+ }
+ }
+ SymbolKind5.fromProtocolScriptElementKind = fromProtocolScriptElementKind;
+})(SymbolKind2 || (SymbolKind2 = {}));
// src/server/features/workspaceSymbols.ts
+function parseKindModifier(kindModifiers) {
+ return new Set(kindModifiers.split(/,|\s+/g));
+}
function getSymbolKind(item) {
switch (item.kind) {
case "method":
end: Position.fromLocation(item.end)
};
const symbolInfo = import_vscode_languageserver_protocol3.SymbolInformation.create(label, getSymbolKind(item), range, this.client.toResource(item.file));
+ const kindModifiers = item.kindModifiers ? parseKindModifier(item.kindModifiers) : void 0;
+ if (kindModifiers == null ? void 0 : kindModifiers.has(KindModifiers.deprecated)) {
+ symbolInfo.tags = [import_vscode_languageserver_protocol3.SymbolTag.Deprecated];
+ }
result.push(symbolInfo);
}
return result;
var workspaceSymbols_default = TypeScriptWorkspaceSymbolProvider;
// src/server/languageProvider.ts
-var import_coc18 = __toModule(require("coc.nvim"));
-var import_path4 = __toModule(require("path"));
+var import_coc23 = __toModule(require("coc.nvim"));
+var import_path5 = __toModule(require("path"));
var import_vscode_languageserver_protocol18 = __toModule(require_main3());
// src/server/features/baseCodeLensProvider.ts
return null;
}
if (item.nameSpan) {
- return Range.fromTextSpan(item.nameSpan);
+ return Range2.fromTextSpan(item.nameSpan);
}
const span = item.spans && item.spans[0];
if (!span) {
return null;
- }
- const range = Range.fromTextSpan(span);
- const text = document.getText(range);
- const identifierMatch = new RegExp(`^(.*?(\\b|\\W))${escapeRegExp(item.text || "")}(\\b|\\W)`, "gm");
- const match = identifierMatch.exec(text);
- const prefixLength = match ? match.index + match[1].length : 0;
- const startOffset = document.offsetAt(range.start) + prefixLength;
- return {
- start: document.positionAt(startOffset),
- end: document.positionAt(startOffset + item.text.length)
- };
- }
-};
-
-// src/server/features/completionItemProvider.ts
-var import_coc5 = __toModule(require("coc.nvim"));
-var import_vscode_languageserver_protocol8 = __toModule(require_main3());
-
-// src/server/protocol.const.ts
-var Kind = class {
-};
-Kind.alias = "alias";
-Kind.callSignature = "call";
-Kind.class = "class";
-Kind.const = "const";
-Kind.constructorImplementation = "constructor";
-Kind.constructSignature = "construct";
-Kind.directory = "directory";
-Kind.enum = "enum";
-Kind.enumMember = "enum member";
-Kind.externalModuleName = "external module name";
-Kind.function = "function";
-Kind.indexSignature = "index";
-Kind.interface = "interface";
-Kind.keyword = "keyword";
-Kind.let = "let";
-Kind.localFunction = "local function";
-Kind.localVariable = "local var";
-Kind.method = "method";
-Kind.memberGetAccessor = "getter";
-Kind.memberSetAccessor = "setter";
-Kind.memberVariable = "property";
-Kind.module = "module";
-Kind.primitiveType = "primitive type";
-Kind.script = "script";
-Kind.type = "type";
-Kind.variable = "var";
-Kind.warning = "warning";
-Kind.string = "string";
-Kind.parameter = "parameter";
-Kind.typeParameter = "type parameter";
-var DiagnosticCategory = class {
-};
-DiagnosticCategory.error = "error";
-DiagnosticCategory.warning = "warning";
-DiagnosticCategory.suggestion = "suggestion";
-var KindModifiers2 = class {
-};
-var KindModifiers = KindModifiers2;
-KindModifiers.optional = "optional";
-KindModifiers.color = "color";
-KindModifiers.dtsFile = ".d.ts";
-KindModifiers.tsFile = ".ts";
-KindModifiers.tsxFile = ".tsx";
-KindModifiers.jsFile = ".js";
-KindModifiers.jsxFile = ".jsx";
-KindModifiers.jsonFile = ".json";
-KindModifiers.fileExtensionKindModifiers = [
- KindModifiers2.dtsFile,
- KindModifiers2.tsFile,
- KindModifiers2.tsxFile,
- KindModifiers2.jsFile,
- KindModifiers2.jsxFile,
- KindModifiers2.jsonFile
-];
-var DisplayPartKind = class {
+ }
+ const range = Range2.fromTextSpan(span);
+ const text = document.getText(range);
+ const identifierMatch = new RegExp(`^(.*?(\\b|\\W))${escapeRegExp(item.text || "")}(\\b|\\W)`, "gm");
+ const match = identifierMatch.exec(text);
+ const prefixLength = match ? match.index + match[1].length : 0;
+ const startOffset = document.offsetAt(range.start) + prefixLength;
+ return {
+ start: document.positionAt(startOffset),
+ end: document.positionAt(startOffset + item.text.length)
+ };
+ }
};
-DisplayPartKind.functionName = "functionName";
-DisplayPartKind.methodName = "methodName";
-DisplayPartKind.parameterName = "parameterName";
-DisplayPartKind.propertyName = "propertyName";
-DisplayPartKind.punctuation = "punctuation";
-DisplayPartKind.text = "text";
-// src/server/utils/codeAction.ts
-var import_vscode_languageserver_protocol5 = __toModule(require_main3());
+// src/server/features/callHierarchy.ts
var import_coc4 = __toModule(require("coc.nvim"));
+var import_path2 = __toModule(require("path"));
+var import_vscode_languageserver_protocol5 = __toModule(require_main3());
+var TypeScriptCallHierarchySupport = class {
+ constructor(client) {
+ this.client = client;
+ }
+ async prepareCallHierarchy(document, position, token) {
+ const filepath = this.client.toOpenedFilePath(document.uri);
+ if (!filepath) {
+ return void 0;
+ }
+ const args = Position.toFileLocationRequestArgs(filepath, position);
+ const response = await this.client.execute("prepareCallHierarchy", args, token);
+ if (response.type !== "response" || !response.body) {
+ return void 0;
+ }
+ return Array.isArray(response.body) ? response.body.map(fromProtocolCallHierarchyItem) : fromProtocolCallHierarchyItem(response.body);
+ }
+ async provideCallHierarchyIncomingCalls(item, token) {
+ const filepath = this.client.toPath(item.uri);
+ if (!filepath) {
+ return void 0;
+ }
+ const args = Position.toFileLocationRequestArgs(filepath, item.selectionRange.start);
+ const response = await this.client.execute("provideCallHierarchyIncomingCalls", args, token);
+ if (response.type !== "response" || !response.body) {
+ return void 0;
+ }
+ return response.body.map(fromProtocolCallHierarchyIncomingCall);
+ }
+ async provideCallHierarchyOutgoingCalls(item, token) {
+ const filepath = this.client.toPath(item.uri);
+ if (!filepath) {
+ return void 0;
+ }
+ const args = Position.toFileLocationRequestArgs(filepath, item.selectionRange.start);
+ const response = await this.client.execute("provideCallHierarchyOutgoingCalls", args, token);
+ if (response.type !== "response" || !response.body) {
+ return void 0;
+ }
+ return response.body.map(fromProtocolCallHierarchyOutgoingCall);
+ }
+};
+TypeScriptCallHierarchySupport.minVersion = api_default.v380;
+var callHierarchy_default = TypeScriptCallHierarchySupport;
+function isSourceFileItem(item) {
+ return item.kind === Kind.script || item.kind === Kind.module && item.selectionSpan.start.line === 1 && item.selectionSpan.start.offset === 1;
+}
+function parseKindModifier2(kindModifiers) {
+ return new Set(kindModifiers.split(/,|\s+/g));
+}
+function fromProtocolCallHierarchyItem(item) {
+ var _a;
+ const useFileName = isSourceFileItem(item);
+ const name = useFileName ? import_path2.default.basename(item.file) : item.name;
+ const detail = useFileName ? import_path2.default.relative(import_coc4.workspace.cwd, import_path2.default.dirname(item.file)) : (_a = item.containerName) != null ? _a : "";
+ const result = {
+ name,
+ detail,
+ uri: import_coc4.Uri.file(item.file).toString(),
+ kind: SymbolKind2.fromProtocolScriptElementKind(item.kind),
+ range: Range2.fromTextSpan(item.span),
+ selectionRange: Range2.fromTextSpan(item.selectionSpan)
+ };
+ const kindModifiers = item.kindModifiers ? parseKindModifier2(item.kindModifiers) : void 0;
+ if (kindModifiers == null ? void 0 : kindModifiers.has(KindModifiers.deprecated)) {
+ result.tags = [import_vscode_languageserver_protocol5.SymbolTag.Deprecated];
+ }
+ return result;
+}
+function fromProtocolCallHierarchyIncomingCall(item) {
+ return {
+ from: fromProtocolCallHierarchyItem(item.from),
+ fromRanges: item.fromSpans.map(Range2.fromTextSpan)
+ };
+}
+function fromProtocolCallHierarchyOutgoingCall(item) {
+ return {
+ to: fromProtocolCallHierarchyItem(item.to),
+ fromRanges: item.fromSpans.map(Range2.fromTextSpan)
+ };
+}
+
+// src/server/features/completionItemProvider.ts
+var import_coc8 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol9 = __toModule(require_main3());
+
+// src/server/utils/codeAction.ts
+var import_vscode_languageserver_protocol6 = __toModule(require_main3());
+var import_coc5 = __toModule(require("coc.nvim"));
function getEditForCodeAction(client, action) {
return action.changes && action.changes.length ? WorkspaceEdit.fromFileCodeEdits(client, action.changes) : void 0;
}
async function applyCodeAction(client, action) {
const workspaceEdit = getEditForCodeAction(client, action);
if (workspaceEdit) {
- if (!await import_coc4.workspace.applyEdit(workspaceEdit)) {
+ if (!await import_coc5.workspace.applyEdit(workspaceEdit)) {
return false;
}
}
async function applyCodeActionCommands(client, action) {
if (action.commands && action.commands.length) {
for (const command of action.commands) {
- const response = await client.execute("applyCodeActionCommand", {command}, import_vscode_languageserver_protocol5.CancellationToken.None);
+ const response = await client.execute("applyCodeActionCommand", {command}, import_vscode_languageserver_protocol6.CancellationToken.None);
if (!response || response.type != "response" || !response.body) {
return false;
}
}
// src/server/utils/completionItem.ts
-var import_vscode_languageserver_protocol6 = __toModule(require_main3());
+var import_coc6 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol7 = __toModule(require_main3());
function convertCompletionEntry(tsEntry, uri, position, context) {
let label = tsEntry.name;
let sortText = tsEntry.sortText;
if (tsEntry.isRecommended) {
preselect = true;
}
- if (tsEntry.source) {
+ if (tsEntry.source && tsEntry.hasAction) {
sortText = "\uFFFF" + sortText;
} else {
sortText = tsEntry.sortText;
}
let kind = convertKind(tsEntry.kind);
- let insertTextFormat = context.enableCallCompletions && (kind === import_vscode_languageserver_protocol6.CompletionItemKind.Function || kind === import_vscode_languageserver_protocol6.CompletionItemKind.Method) ? import_vscode_languageserver_protocol6.InsertTextFormat.Snippet : import_vscode_languageserver_protocol6.InsertTextFormat.PlainText;
+ let insertTextFormat = context.enableCallCompletions && (kind === import_coc6.CompletionItemKind.Function || kind === import_coc6.CompletionItemKind.Method) ? import_coc6.InsertTextFormat.Snippet : import_coc6.InsertTextFormat.PlainText;
let insertText = tsEntry.insertText;
let commitCharacters = getCommitCharacters(tsEntry, context);
+ let tags;
+ if (tsEntry.isImportStatementCompletion) {
+ insertText = label;
+ insertTextFormat = import_coc6.InsertTextFormat.Snippet;
+ }
let textEdit = null;
if (tsEntry.replacementSpan) {
let {start, end} = tsEntry.replacementSpan;
if (start.line == end.line) {
textEdit = {
- range: import_vscode_languageserver_protocol6.Range.create(start.line - 1, start.offset - 1, end.line - 1, end.offset - 1),
- newText: insertText || label
+ range: import_coc6.Range.create(start.line - 1, start.offset - 1, end.line - 1, end.offset - 1),
+ newText: tsEntry.insertText || label
};
}
}
insertText = label;
label += "?";
}
+ if (kindModifiers.has(KindModifiers.deprecated)) {
+ tags = [import_vscode_languageserver_protocol7.CompletionItemTag.Deprecated];
+ }
if (kindModifiers.has(KindModifiers.color)) {
- kind = import_vscode_languageserver_protocol6.CompletionItemKind.Color;
+ kind = import_coc6.CompletionItemKind.Color;
}
if (tsEntry.kind === Kind.script) {
for (const extModifier of KindModifiers.fileExtensionKindModifiers) {
insertText,
textEdit,
kind,
+ tags,
preselect,
insertTextFormat,
sortText,
uri,
position,
name: tsEntry.name,
+ data: tsEntry.data,
source: tsEntry.source || ""
}
};
switch (kind) {
case Kind.primitiveType:
case Kind.keyword:
- return import_vscode_languageserver_protocol6.CompletionItemKind.Keyword;
+ return import_coc6.CompletionItemKind.Keyword;
case Kind.const:
- return import_vscode_languageserver_protocol6.CompletionItemKind.Constant;
+ return import_coc6.CompletionItemKind.Constant;
case Kind.let:
case Kind.variable:
case Kind.localVariable:
case Kind.alias:
- return import_vscode_languageserver_protocol6.CompletionItemKind.Variable;
+ return import_coc6.CompletionItemKind.Variable;
case Kind.memberVariable:
case Kind.memberGetAccessor:
case Kind.memberSetAccessor:
- return import_vscode_languageserver_protocol6.CompletionItemKind.Field;
+ return import_coc6.CompletionItemKind.Field;
case Kind.function:
- return import_vscode_languageserver_protocol6.CompletionItemKind.Function;
+ return import_coc6.CompletionItemKind.Function;
case Kind.method:
case Kind.constructSignature:
case Kind.callSignature:
case Kind.indexSignature:
- return import_vscode_languageserver_protocol6.CompletionItemKind.Method;
+ return import_coc6.CompletionItemKind.Method;
case Kind.enum:
- return import_vscode_languageserver_protocol6.CompletionItemKind.Enum;
+ return import_coc6.CompletionItemKind.Enum;
case Kind.module:
case Kind.externalModuleName:
- return import_vscode_languageserver_protocol6.CompletionItemKind.Module;
+ return import_coc6.CompletionItemKind.Module;
case Kind.class:
case Kind.type:
- return import_vscode_languageserver_protocol6.CompletionItemKind.Class;
+ return import_coc6.CompletionItemKind.Class;
case Kind.interface:
- return import_vscode_languageserver_protocol6.CompletionItemKind.Interface;
+ return import_coc6.CompletionItemKind.Interface;
case Kind.warning:
case Kind.script:
- return import_vscode_languageserver_protocol6.CompletionItemKind.File;
+ return import_coc6.CompletionItemKind.File;
case Kind.directory:
- return import_vscode_languageserver_protocol6.CompletionItemKind.Folder;
+ return import_coc6.CompletionItemKind.Folder;
}
- return import_vscode_languageserver_protocol6.CompletionItemKind.Variable;
+ return import_coc6.CompletionItemKind.Variable;
}
function getCommitCharacters(tsEntry, context) {
if (context.isNewIdentifierLocation || !context.isInValidCommitCharacterContext) {
}
// src/server/utils/previewer.ts
-var import_vscode_languageserver_protocol7 = __toModule(require_main3());
+var import_vscode_languageserver_protocol8 = __toModule(require_main3());
+var import_coc7 = __toModule(require("coc.nvim"));
+function toResource(filepath) {
+ return import_coc7.Uri.file(filepath);
+}
+function replaceLinks(text) {
+ return text.replace(/\{@(link|linkplain|linkcode) (https?:\/\/[^ |}]+?)(?:[| ]([^{}\n]+?))?\}/gi, (_, tag, link, text2) => {
+ switch (tag) {
+ case "linkcode":
+ return `[\`${text2 ? text2.trim() : link}\`](${link})`;
+ default:
+ return `[${text2 ? text2.trim() : link}](${link})`;
+ }
+ });
+}
+function processInlineTags(text) {
+ return replaceLinks(text);
+}
function getTagBodyText(tag) {
if (!tag.text) {
return void 0;
}
+ function makeCodeblock(text2) {
+ if (text2.match(/^\s*[~`]{3}/g)) {
+ return text2;
+ }
+ return "```\n" + text2 + "\n```";
+ }
+ const text = convertLinkTags(tag.text);
switch (tag.name) {
case "example":
- case "default":
- if (tag.text.match(/^\s*[~`]{3}/g)) {
- return tag.text;
+ const captionTagMatches = text.match(/<caption>(.*?)<\/caption>\s*(\r\n|\n)/);
+ if (captionTagMatches && captionTagMatches.index === 0) {
+ return captionTagMatches[1] + "\n\n" + makeCodeblock(text.substr(captionTagMatches[0].length));
+ } else {
+ return makeCodeblock(text);
+ }
+ case "author":
+ const emailMatch = text.match(/(.+)\s<([-.\w]+@[-.\w]+)>/);
+ if (emailMatch === null) {
+ return text;
+ } else {
+ return `${emailMatch[1]} ${emailMatch[2]}`;
}
- return "```\n" + tag.text + "\n```";
+ case "default":
+ return makeCodeblock(text);
}
- return tag.text;
+ return processInlineTags(text);
}
function getTagDocumentation(tag) {
switch (tag.name) {
+ case "augments":
+ case "extends":
case "param":
- const body = (tag.text || "").split(/^([\w\.]+)\s*/);
- if (body && body.length === 3) {
+ case "template":
+ const body = convertLinkTags(tag.text).split(/^(\S+)\s*-?\s*/);
+ if ((body == null ? void 0 : body.length) === 3) {
const param = body[1];
const doc = body[2];
const label2 = `*@${tag.name}* \`${param}\``;
if (!doc) {
return label2;
}
- return label2 + (doc.match(/\r\n|\n/g) ? "\n" + doc : ` \u2014 ${doc}`);
+ return label2 + (doc.match(/\r\n|\n/g) ? " \n" + processInlineTags(doc) : ` \u2014 ${processInlineTags(doc)}`);
}
}
const label = `*@${tag.name}*`;
if (!text) {
return label;
}
- return label + (text.match(/\r\n|\n/g) ? "\n" + text : ` \u2014 ${text}`);
+ return label + (text.match(/\r\n|\n/g) ? " \n" + text : ` \u2014 ${text}`);
}
function plain(parts) {
if (!parts || !parts.length)
out = out + ("\n\n" + tagsPreview);
}
return {
- kind: import_vscode_languageserver_protocol7.MarkupKind.Markdown,
+ kind: import_vscode_languageserver_protocol8.MarkupKind.Markdown,
value: out
};
}
+function convertLinkTags(parts) {
+ var _a;
+ if (!parts) {
+ return "";
+ }
+ if (typeof parts === "string") {
+ return parts;
+ }
+ const out = [];
+ let currentLink;
+ for (const part of parts) {
+ switch (part.kind) {
+ case "link":
+ if (currentLink) {
+ const text = (_a = currentLink.text) != null ? _a : currentLink.name;
+ if (currentLink.target) {
+ const link = toResource(currentLink.target.file).with({
+ fragment: `L${currentLink.target.start.line},${currentLink.target.start.offset}`
+ });
+ out.push(`[${text}](${link.toString()})`);
+ } else {
+ if (text) {
+ if (/^https?:/.test(text)) {
+ const parts2 = text.split(" ");
+ if (parts2.length === 1) {
+ out.push(parts2[0]);
+ } else if (parts2.length > 1) {
+ out.push(`[${parts2.slice(1).join(" ")}](${parts2[0]})`);
+ }
+ } else {
+ out.push(text);
+ }
+ }
+ }
+ currentLink = void 0;
+ } else {
+ currentLink = {};
+ }
+ break;
+ case "linkName":
+ if (currentLink) {
+ currentLink.name = part.text;
+ currentLink.target = part.target;
+ }
+ break;
+ case "linkText":
+ if (currentLink) {
+ currentLink.text = part.text;
+ }
+ break;
+ default:
+ out.push(part.text);
+ break;
+ }
+ }
+ return processInlineTags(out.join(""));
+}
// src/server/utils/SnippetString.ts
var SnippetString = class {
await applyCodeAction(this.client, codeActions[0]);
return;
}
- const idx = await import_coc5.window.showQuickpick(codeActions.map((o) => o.description), "Select code action to apply");
+ const idx = await import_coc8.window.showQuickpick(codeActions.map((o) => o.description), "Select code action to apply");
if (idx < 0)
return;
const action = codeActions[idx];
this.typingsStatus = typingsStatus;
this.fileConfigurationManager = fileConfigurationManager;
this.setCompleteOption(languageId);
- import_coc5.commands.registerCommand(ApplyCompletionCodeActionCommand.ID, async (codeActions) => {
+ import_coc8.commands.registerCommand(ApplyCompletionCodeActionCommand.ID, async (codeActions) => {
let cmd = new ApplyCompletionCodeActionCommand(this.client);
await cmd.execute(codeActions);
});
- import_coc5.workspace.onDidChangeConfiguration((_e) => {
+ import_coc8.workspace.onDidChangeConfiguration((_e) => {
this.setCompleteOption(languageId);
});
}
if (isMemberCompletion) {
const dotMatch = preText.slice(0, position.character).match(/\??\.\s*$/) || void 0;
if (dotMatch) {
- const range = import_vscode_languageserver_protocol8.Range.create({
+ const range = import_vscode_languageserver_protocol9.Range.create({
line: position.line,
character: position.character - dotMatch.length
}, position);
dotAccessorContext = {range, text};
}
}
- isIncomplete = response.metadata && response.metadata.isIncomplete;
+ isIncomplete = !!response.body.isIncomplete || response.metadata && response.metadata.isIncomplete;
entries = response.body.entries;
} catch (e) {
if (e.message == "No content available.") {
return this.client.apiVersion.gte(api_default.v310) && this.client.apiVersion.lt(api_default.v320) ? void 0 : "@";
case "#":
return this.client.apiVersion.lt(api_default.v381) ? void 0 : "#";
+ case " ":
+ return this.client.apiVersion.gte(api_default.v430) ? " " : void 0;
case ".":
case '"':
case "'":
async resolveCompletionItem(item, token) {
if (item == null)
return void 0;
- let {uri, position, source, name} = item.data;
+ let {uri, position, source, name, data} = item.data;
const filepath = this.client.toPath(uri);
if (!filepath)
return void 0;
- let document = import_coc5.workspace.getDocument(uri);
+ let document = import_coc8.workspace.getDocument(uri);
if (!document)
return void 0;
const args = {
...Position.toFileLocationRequestArgs(filepath, position),
- entryNames: [source ? {name, source} : name]
+ entryNames: [source ? {name, source, data} : name]
};
let response;
try {
if (command)
item.command = command;
item.additionalTextEdits = additionalTextEdits;
- if (detail && item.insertTextFormat == import_vscode_languageserver_protocol8.InsertTextFormat.Snippet) {
+ if (detail && item.insertTextFormat == import_vscode_languageserver_protocol9.InsertTextFormat.Snippet) {
const shouldCompleteFunction = await this.isValidFunctionCompletionContext(filepath, position, token);
if (shouldCompleteFunction) {
this.createSnippetOfFunctionCall(item, detail);
return false;
}
}
+ if (triggerCharacter === " ") {
+ if (!this.completeOption.importStatementSuggestions || !this.client.apiVersion.lt(api_default.v430)) {
+ return false;
+ }
+ return pre === "import ";
+ }
return true;
}
getDocumentation(detail) {
documentation += parts.join("\n\n");
if (documentation.length) {
return {
- kind: import_vscode_languageserver_protocol8.MarkupKind.Markdown,
+ kind: import_vscode_languageserver_protocol9.MarkupKind.Markdown,
value: documentation
};
}
isInValidCommitCharacterContext(document, position) {
if (this.client.apiVersion.lt(api_default.v320)) {
if (position.character > 1) {
- const preText = document.getText(import_vscode_languageserver_protocol8.Range.create(position.line, 0, position.line, position.character));
+ const preText = document.getText(import_vscode_languageserver_protocol9.Range.create(position.line, 0, position.line, position.character));
return preText.match(/(\s|^)\.$/ig) === null;
}
}
return true;
}
};
-TypeScriptCompletionItemProvider.triggerCharacters = [".", '"', "'", "`", "/", "@", "<", "#"];
+TypeScriptCompletionItemProvider.triggerCharacters = [".", '"', "'", "`", "/", "@", "<", "#", " "];
var completionItemProvider_default = TypeScriptCompletionItemProvider;
function shouldExcludeCompletionEntry(element, completionConfiguration) {
return !completionConfiguration.names && element.kind === Kind.warning || !completionConfiguration.paths && (element.kind === Kind.directory || element.kind === Kind.script || element.kind === Kind.externalModuleName) || !completionConfiguration.autoImports && element.hasAction;
return [];
}
}
- provideDefinition(document, position, token) {
- return this.getSymbolLocations("definition", document, position, token);
+ async provideDefinition(document, position, token) {
+ if (this.client.apiVersion.gte(api_default.v270)) {
+ const filepath = this.client.toOpenedFilePath(document.uri);
+ if (!filepath) {
+ return void 0;
+ }
+ const args = Position.toFileLocationRequestArgs(filepath, position);
+ const response = await this.client.execute("definitionAndBoundSpan", args, token);
+ if (response.type !== "response" || !response.body) {
+ return void 0;
+ }
+ const span = response.body.textSpan ? Range2.fromTextSpan(response.body.textSpan) : void 0;
+ return response.body.definitions.map((location) => {
+ const target = Location2.fromTextSpan(this.client.toResource(location.file), location);
+ if (location.contextStart && location.contextEnd) {
+ return {
+ originSelectionRange: span,
+ targetRange: Range2.fromLocations(location.contextStart, location.contextEnd),
+ targetUri: target.uri,
+ targetSelectionRange: target.range
+ };
+ }
+ return {
+ originSelectionRange: span,
+ targetRange: target.range,
+ targetUri: target.uri,
+ targetSelectionRange: target.range
+ };
+ });
+ }
+ return await this.getSymbolLocations("definition", document, position, token);
}
provideTypeDefinition(document, position, token) {
return this.getSymbolLocations("typeDefinition", document, position, token);
var definitionProvider_default = TypeScriptDefinitionProvider;
// src/server/features/directiveCommentCompletions.ts
-var import_vscode_languageserver_protocol9 = __toModule(require_main3());
-var import_coc6 = __toModule(require("coc.nvim"));
+var import_coc9 = __toModule(require("coc.nvim"));
+var import_coc10 = __toModule(require("coc.nvim"));
var tsDirectives = [
{
value: "@ts-check",
if (!file2) {
return [];
}
- const doc = import_coc6.workspace.getDocument(document.uri);
+ const doc = import_coc10.workspace.getDocument(document.uri);
const line = doc.getline(position.line);
const prefix = line.slice(0, position.character);
const match = prefix.match(/^\s*\/\/+\s?(@[a-zA-Z\-]*)?$/);
if (match) {
const directives = this.client.apiVersion.gte(api_default.v390) ? tsDirectives390 : tsDirectives;
let items = directives.map((directive) => {
- const item = import_vscode_languageserver_protocol9.CompletionItem.create(directive.value);
- item.kind = import_vscode_languageserver_protocol9.CompletionItemKind.Snippet;
+ const item = {label: directive.value};
+ item.kind = import_coc9.CompletionItemKind.Snippet;
item.detail = directive.description;
item.textEdit = {
- range: import_vscode_languageserver_protocol9.Range.create(position.line, Math.max(0, position.character - (match[1] ? match[1].length : 0)), position.line, position.character),
+ range: import_coc9.Range.create(position.line, Math.max(0, position.character - (match[1] ? match[1].length : 0)), position.line, position.character),
newText: directive.value
};
return item;
function convertDocumentHighlight(highlight) {
return highlight.highlightSpans.map((span) => {
return {
- range: Range.fromTextSpan(span),
+ range: Range2.fromTextSpan(span),
kind: span.kind === "writtenReference" ? import_vscode_languageserver_protocol10.DocumentHighlightKind.Write : import_vscode_languageserver_protocol10.DocumentHighlightKind.Read
};
});
return [];
}
}
- static convertNavTree(bucket, item) {
+ static convertNavTree(output, item) {
let shouldInclude = TypeScriptDocumentSymbolProvider.shouldInclueEntry(item);
const children = new Set(item.childItems || []);
for (const span of item.spans) {
- const range = Range.fromTextSpan(span);
- const symbolInfo = import_vscode_languageserver_protocol11.DocumentSymbol.create(item.text, "", getSymbolKind2(item.kind), range, range);
- symbolInfo.children = children.size > 0 ? [] : null;
+ const range = Range2.fromTextSpan(span);
+ const symbolInfo = TypeScriptDocumentSymbolProvider.convertSymbol(item, range);
+ if (children.size)
+ symbolInfo.children = [];
for (const child of children) {
- if (child.spans.some((span2) => !!containsRange(range, Range.fromTextSpan(span2)))) {
+ if (child.spans.some((span2) => !!containsRange(range, Range2.fromTextSpan(span2)))) {
const includedChild = TypeScriptDocumentSymbolProvider.convertNavTree(symbolInfo.children, child);
shouldInclude = shouldInclude || includedChild;
children.delete(child);
}
}
if (shouldInclude) {
- bucket.push(symbolInfo);
+ output.push(symbolInfo);
}
}
return shouldInclude;
}
+ static convertSymbol(item, range) {
+ const selectionRange = item.nameSpan ? Range2.fromTextSpan(item.nameSpan) : range;
+ let label = item.text;
+ switch (item.kind) {
+ case Kind.memberGetAccessor:
+ label = `(get) ${label}`;
+ break;
+ case Kind.memberSetAccessor:
+ label = `(set) ${label}`;
+ break;
+ }
+ const symbolInfo = import_vscode_languageserver_protocol11.DocumentSymbol.create(label, "", getSymbolKind2(item.kind), range, containsRange(range, selectionRange) ? selectionRange : range);
+ const kindModifiers = parseKindModifier3(item.kindModifiers);
+ if (kindModifiers.has(KindModifiers.deprecated)) {
+ symbolInfo.tags = [import_vscode_languageserver_protocol11.SymbolTag.Deprecated];
+ }
+ return symbolInfo;
+ }
static shouldInclueEntry(item) {
if (item.kind === Kind.alias) {
return false;
}
return true;
}
+function parseKindModifier3(kindModifiers) {
+ return new Set(kindModifiers.split(/,|\s+/g));
+}
// src/server/features/folding.ts
-var import_coc7 = __toModule(require("coc.nvim"));
+var import_coc11 = __toModule(require("coc.nvim"));
var import_vscode_languageserver_types = __toModule(require_main2());
var TypeScriptFoldingProvider = class {
constructor(client) {
return body.map((span) => this.convertOutliningSpan(span, document)).filter((foldingRange) => !!foldingRange);
}
convertOutliningSpan(span, document) {
- const range = Range.fromTextSpan(span.textSpan);
+ const range = Range2.fromTextSpan(span.textSpan);
const kind = TypeScriptFoldingProvider.getFoldingRangeKind(span);
if (span.kind === "comment") {
- let doc = import_coc7.workspace.getDocument(document.uri);
+ let doc = import_coc11.workspace.getDocument(document.uri);
const line = doc.getline(range.start.line);
if (line.match(/\/\/\s*#endregion/gi)) {
return void 0;
var folding_default = TypeScriptFoldingProvider;
// src/server/features/formatting.ts
-var import_coc8 = __toModule(require("coc.nvim"));
+var import_coc12 = __toModule(require("coc.nvim"));
var TypeScriptFormattingProvider = class {
constructor(client, formattingOptionsManager) {
this.client = client;
if (!file2)
return [];
await this.formattingOptionsManager.ensureConfigurationOptions(document, options.insertSpaces, options.tabSize, token);
- const doc = import_coc8.workspace.getDocument(document.uri);
+ const doc = import_coc12.workspace.getDocument(document.uri);
const args = {
...Position.toFileLocationRequestArgs(file2, position),
key: ch
const data = response.body;
return {
contents: TypeScriptHoverProvider.getContents(data),
- range: Range.fromTextSpan(data)
+ range: Range2.fromTextSpan(data)
};
}
} catch (e) {
var implementationsCodeLens_default = TypeScriptImplementationsCodeLensProvider;
// src/server/features/importFix.ts
-var import_coc9 = __toModule(require("coc.nvim"));
+var import_coc13 = __toModule(require("coc.nvim"));
var import_vscode_languageserver_protocol12 = __toModule(require_main3());
// src/server/utils/helper.ts
return [];
let edits = [];
let names = [];
- let doc = import_coc9.workspace.getDocument(document.uri);
+ let doc = import_coc13.workspace.getDocument(document.uri);
let command;
for (const diagnostic of diagnostics) {
let {range} = diagnostic;
var importFix_default = ImportFixProvider;
// src/server/features/moduleInstall.ts
-var import_coc11 = __toModule(require("coc.nvim"));
+var import_coc15 = __toModule(require("coc.nvim"));
var import_vscode_languageserver_protocol13 = __toModule(require_main3());
// src/server/utils/modules.ts
var import_child_process = __toModule(require("child_process"));
-var import_coc10 = __toModule(require("coc.nvim"));
+var import_coc14 = __toModule(require("coc.nvim"));
var import_fs = __toModule(require("fs"));
-var import_path2 = __toModule(require("path"));
+var import_path3 = __toModule(require("path"));
function runCommand(cmd, cwd, timeout) {
return new Promise((resolve, reject) => {
let timer;
});
}
async function getManager() {
- let res = await import_coc10.workspace.findUp(["yarn.lock", "package-lock.json"]);
+ let res = await import_coc14.workspace.findUp(["yarn.lock", "package-lock.json"]);
if (!res)
return "yarn";
return res.endsWith("yarn.lock") ? "yarn" : "npm";
}
async function installModules(uri, names) {
names = distinct(names);
- let workspaceFolder = import_coc10.workspace.getWorkspaceFolder(uri);
- let root = workspaceFolder ? import_coc10.Uri.parse(workspaceFolder.uri).fsPath : void 0;
- if (!root || !import_fs.default.existsSync(import_path2.default.join(root, "package.json"))) {
- import_coc10.window.showMessage(`package.json not found from workspaceFolder: ${root}`, "error");
+ let workspaceFolder = import_coc14.workspace.getWorkspaceFolder(uri);
+ let root = workspaceFolder ? import_coc14.Uri.parse(workspaceFolder.uri).fsPath : void 0;
+ if (!root || !import_fs.default.existsSync(import_path3.default.join(root, "package.json"))) {
+ import_coc14.window.showMessage(`package.json not found from workspaceFolder: ${root}`, "error");
return;
}
let arr = names.concat(names.map((s) => `@types/${s}`));
- let statusItem = import_coc10.window.createStatusBarItem(99, {progress: true});
+ let statusItem = import_coc14.window.createStatusBarItem(99, {progress: true});
statusItem.text = `Checking module ${arr.join(" ")}`;
statusItem.show();
let exists = await Promise.all(arr.map((name) => {
await runCommand(cmd, root);
} catch (e) {
statusItem.dispose();
- import_coc10.window.showMessage(`Install error ${e.message}`, "error");
+ import_coc14.window.showMessage(`Install error ${e.message}`, "error");
return;
}
statusItem.dispose();
- import_coc10.window.showMessage(`Installed: ${exists.join(" ")}`, "more");
+ import_coc14.window.showMessage(`Installed: ${exists.join(" ")}`, "more");
}
// src/server/features/moduleInstall.ts
var InstallModuleProvider = class {
constructor(client) {
this.client = client;
- import_coc11.commands.registerCommand("_tsserver.installModule", async (uri, name) => {
+ import_coc15.commands.registerCommand("_tsserver.installModule", async (uri, name) => {
await installModules(uri, [name]);
});
}
async provideCodeActions(document, _range, context, _token) {
- const uri = import_coc11.Uri.parse(document.uri);
+ const uri = import_coc15.Uri.parse(document.uri);
if (uri.scheme != "file")
return null;
let {diagnostics} = context;
var moduleInstall_default = InstallModuleProvider;
// src/server/features/quickfix.ts
-var import_coc13 = __toModule(require("coc.nvim"));
+var import_coc17 = __toModule(require("coc.nvim"));
var import_vscode_languageserver_protocol14 = __toModule(require_main3());
// src/server/commands.ts
-var import_coc12 = __toModule(require("coc.nvim"));
+var import_coc16 = __toModule(require("coc.nvim"));
var import_vscode_languageserver_types2 = __toModule(require_main2());
var ReloadProjectsCommand = class {
constructor(service) {
async execute() {
let client = await this.service.getClientHost();
client.reloadProjects();
- import_coc12.window.showMessage("projects reloaded");
+ import_coc16.window.showMessage("projects reloaded");
}
};
var OpenTsServerLogCommand = class {
}
async execute() {
let client = await this.service.getClientHost();
- let doc = await import_coc12.workspace.document;
+ let doc = await import_coc16.workspace.document;
let {languageId} = doc.textDocument;
if (client.serviceClient.modeIds.indexOf(languageId) == -1) {
throw new Error(`Could not determine TypeScript or JavaScript project. Unsupported file type: ${languageId}`);
const file2 = client.toPath(uri);
let res;
try {
- res = await client.execute("projectInfo", {file: file2, needFileNameList: false}, import_coc12.CancellationToken.None);
+ res = await client.execute("projectInfo", {file: file2, needFileNameList: false}, import_coc16.CancellationToken.None);
} catch {
}
if (!res || !res.body) {
- import_coc12.window.showMessage("Could not determine TypeScript or JavaScript project.", "warning");
+ import_coc16.window.showMessage("Could not determine TypeScript or JavaScript project.", "warning");
return;
}
const {configFileName} = res.body;
if (configFileName && !isImplicitProjectConfigFile(configFileName)) {
- await import_coc12.workspace.openResource(import_coc12.Uri.file(configFileName).toString());
+ await import_coc16.workspace.openResource(import_coc16.Uri.file(configFileName).toString());
return;
}
- import_coc12.window.showMessage("Config file not found", "warning");
+ import_coc16.window.showMessage("Config file not found", "warning");
}
function isImplicitProjectConfigFile(configFileName) {
return configFileName.indexOf("/dev/null/") === 0;
this.id = "tsserver.executeAutofix";
}
async execute() {
- if (this.service.state != import_coc12.ServiceStat.Running) {
+ if (this.service.state != import_coc16.ServiceStat.Running) {
throw new Error("service not running");
return;
}
let client = await this.service.getClientHost();
- let document = await import_coc12.workspace.document;
+ let document = await import_coc16.workspace.document;
let handles = await client.handles(document.textDocument);
if (!handles) {
throw new Error(`Document ${document.uri} is not handled by tsserver.`);
return;
}
let file2 = client.serviceClient.toPath(document.uri);
- let diagnostics = import_coc12.diagnosticManager.getDiagnostics(document.uri).slice();
+ let diagnostics = client.serviceClient.diagnosticsManager.getDiagnostics(document.uri);
let missingDiagnostics = diagnostics.filter((o) => o.code == 2307);
if (missingDiagnostics.length) {
let names2 = missingDiagnostics.map((o) => {
let names = [];
for (let diagnostic of diagnostics) {
const args = {
- ...Range.toFileRangeRequestArgs(file2, diagnostic.range),
+ ...Range2.toFileRangeRequestArgs(file2, diagnostic.range),
errorCodes: [+diagnostic.code]
};
- const response = await client.serviceClient.execute("getCodeFixes", args, import_coc12.CancellationToken.None);
+ const response = await client.serviceClient.execute("getCodeFixes", args, import_coc16.CancellationToken.None);
if (response.type !== "response" || !response.body || response.body.length < 1) {
if (diagnostic.code == 2304) {
let {range} = diagnostic;
continue;
for (let ch of change.textChanges) {
edits.push({
- range: Range.fromTextSpan(ch),
+ range: Range2.fromTextSpan(ch),
newText: ch.newText
});
}
if (edits.length)
await document.applyEdits(edits);
if (command)
- import_coc12.commands.executeCommand(command);
+ import_coc16.commands.executeCommand(command);
}
};
var ConfigurePluginCommand = class {
this.pluginManager.setConfiguration(pluginId, configuration);
}
};
+var FileReferencesCommand2 = class {
+ constructor(service) {
+ this.service = service;
+ this.id = "tsserver.findAllFileReferences";
+ }
+ async execute() {
+ const client = await this.service.getClientHost();
+ if (client.serviceClient.apiVersion.lt(FileReferencesCommand2.minVersion)) {
+ import_coc16.window.showMessage("Find file references failed. Requires TypeScript 4.2+.", "error");
+ return;
+ }
+ const doc = await import_coc16.workspace.document;
+ let {languageId} = doc.textDocument;
+ if (client.serviceClient.modeIds.indexOf(languageId) == -1)
+ return;
+ const openedFiledPath = client.serviceClient.toOpenedFilePath(doc.uri);
+ if (!openedFiledPath)
+ return;
+ const response = await client.serviceClient.execute("fileReferences", {file: openedFiledPath}, import_coc16.CancellationToken.None);
+ if (response.type !== "response" || !response.body)
+ return;
+ const locations = response.body.refs.map((r) => Location2.fromTextSpan(client.serviceClient.toResource(r.file), r));
+ await import_coc16.commands.executeCommand("editor.action.showReferences", doc.uri, import_vscode_languageserver_types2.Position.create(0, 0), locations);
+ }
+};
+var FileReferencesCommand = FileReferencesCommand2;
+FileReferencesCommand.minVersion = api_default.v420;
function registCommand(cmd) {
let {id, execute} = cmd;
- return import_coc12.commands.registerCommand(id, execute, cmd);
+ return import_coc16.commands.registerCommand(id, execute, cmd);
}
// src/server/features/quickfix.ts
}
let {body} = res;
const edit = WorkspaceEdit.fromFileCodeEdits(this.client, body.changes);
- await import_coc13.workspace.applyEdit(edit);
+ await import_coc17.workspace.applyEdit(edit);
const token = import_vscode_languageserver_protocol14.CancellationToken.None;
const {commands: commands7} = body;
if (commands7 && commands7.length) {
}
async getFixesForDiagnostic(document, file2, diagnostic, token) {
const args = {
- ...Range.toFileRangeRequestArgs(file2, diagnostic.range),
+ ...Range2.toFileRangeRequestArgs(file2, diagnostic.range),
errorCodes: [+diagnostic.code]
};
const codeFixesResponse = await this.client.execute("getCodeFixes", args, token);
var quickfix_default = TypeScriptQuickFixProvider;
// src/server/features/refactor.ts
-var import_coc14 = __toModule(require("coc.nvim"));
+var import_coc18 = __toModule(require("coc.nvim"));
var import_vscode_languageserver_protocol15 = __toModule(require_main3());
var ApplyRefactoringCommand2 = class {
constructor(client) {
}
async execute(document, file2, refactor, action, range) {
const args = {
- ...Range.toFileRangeRequestArgs(file2, range),
+ ...Range2.toFileRangeRequestArgs(file2, range),
refactor,
action
};
return false;
}
const workspaceEdit = await this.toWorkspaceEdit(body);
- if (!await import_coc14.workspace.applyEdit(workspaceEdit)) {
+ if (!await import_coc18.workspace.applyEdit(workspaceEdit)) {
return false;
}
const renameLocation = body.renameLocation;
if (renameLocation) {
- import_coc14.commands.executeCommand("editor.action.rename", document.uri, Position.fromLocation(renameLocation));
+ import_coc18.commands.executeCommand("editor.action.rename", document.uri, Position.fromLocation(renameLocation));
}
return true;
}
async toWorkspaceEdit(body) {
for (const edit of body.edits) {
- await import_coc14.workspace.createFile(edit.fileName, {ignoreIfExists: true});
+ await import_coc18.workspace.createFile(edit.fileName, {ignoreIfExists: true});
}
let workspaceEdit = WorkspaceEdit.fromFileCodeEdits(this.client, body.edits);
return workspaceEdit;
}
async execute(document, file2, info, range) {
let {actions} = info;
- const idx = actions.length == 1 ? 0 : await import_coc14.window.showQuickpick(actions.map((action) => action.description || action.name));
+ const idx = actions.length == 1 ? 0 : await import_coc18.window.showQuickpick(actions.map((action) => action.description || action.name));
if (idx == -1)
return false;
let label = info.actions[idx].name;
if (!file2)
return void 0;
await this.formattingOptionsManager.ensureConfigurationForDocument(document, token);
- const args = Range.toFileRangeRequestArgs(file2, range);
+ const args = Range2.toFileRangeRequestArgs(file2, range);
let response;
try {
response = await this.client.interruptGetErr(() => {
var referencesCodeLens_default = TypeScriptReferencesCodeLensProvider;
// src/server/features/rename.ts
-var import_coc15 = __toModule(require("coc.nvim"));
-var import_path3 = __toModule(require("path"));
+var import_coc19 = __toModule(require("coc.nvim"));
+var import_path4 = __toModule(require("path"));
var TypeScriptRenameProvider = class {
constructor(client, fileConfigurationManager) {
this.client = client;
if (this.client.apiVersion.gte(api_default.v310)) {
const triggerSpan = renameInfo.triggerSpan;
if (triggerSpan) {
- const range = Range.fromTextSpan(triggerSpan);
+ const range = Range2.fromTextSpan(triggerSpan);
return range;
}
}
changes[uri] = [];
for (const textSpan of spanGroup.locs) {
changes[uri].push({
- range: Range.fromTextSpan(textSpan),
+ range: Range2.fromTextSpan(textSpan),
newText: (textSpan.prefixText || "") + newName + (textSpan.suffixText || "")
});
}
return {changes};
}
async renameFile(fileToRename, newName, token) {
- if (!import_path3.default.extname(newName)) {
- newName += import_path3.default.extname(fileToRename);
+ if (!import_path4.default.extname(newName)) {
+ newName += import_path4.default.extname(fileToRename);
}
- const dirname = import_path3.default.dirname(fileToRename);
- const newFilePath = import_path3.default.join(dirname, newName);
+ const dirname = import_path4.default.dirname(fileToRename);
+ const newFilePath = import_path4.default.join(dirname, newName);
const args = {
file: fileToRename,
oldFilePath: fileToRename,
edits.documentChanges = edits.documentChanges || [];
edits.documentChanges.push({
kind: "rename",
- oldUri: import_coc15.Uri.file(fileToRename).toString(),
- newUri: import_coc15.Uri.file(newFilePath).toString(),
+ oldUri: import_coc19.Uri.file(fileToRename).toString(),
+ newUri: import_coc19.Uri.file(newFilePath).toString(),
options: {
overwrite: false,
ignoreIfExists: true
}
static convertSelectionRange(selectionRange) {
return {
- range: Range.fromTextSpan(selectionRange.textSpan),
+ range: Range2.fromTextSpan(selectionRange.textSpan),
parent: selectionRange.parent ? SmartSelection.convertSelectionRange(selectionRange.parent) : void 0
};
}
};
var smartSelect_default = SmartSelection;
+// src/server/features/tagClosing.ts
+var import_coc20 = __toModule(require("coc.nvim"));
+var TagClosing2 = class {
+ constructor(client, descriptionLanguageId) {
+ this.client = client;
+ this.descriptionLanguageId = descriptionLanguageId;
+ this._disposables = [];
+ this._disposed = false;
+ this._timeout = void 0;
+ this._cancel = void 0;
+ import_coc20.events.on("InsertCharPre", (character) => {
+ this.lastInsert = character;
+ }, null, this._disposables);
+ import_coc20.events.on("TextChangedI", this.onChange, this, this._disposables);
+ import_coc20.events.on("TextChangedP", this.onChange, this, this._disposables);
+ }
+ async onChange(bufnr, change) {
+ let doc = import_coc20.workspace.getDocument(bufnr);
+ if (!doc || !doc.attached)
+ return;
+ let enabled = this.isEnabled(doc.filetype, doc.uri);
+ if (!enabled)
+ return;
+ let {pre, changedtick, lnum} = change;
+ if (!pre.endsWith("/") && !pre.endsWith(">"))
+ return;
+ if (!pre.endsWith(this.lastInsert))
+ return;
+ if (pre.length > 1 && pre[pre.length - 2] == ">")
+ return;
+ const filepath = this.client.toOpenedFilePath(doc.uri);
+ if (!filepath)
+ return;
+ if (this._timeout) {
+ clearTimeout(this._timeout);
+ }
+ if (this._cancel) {
+ this._cancel.cancel();
+ this._cancel.dispose();
+ this._cancel = void 0;
+ }
+ await doc.patchChange();
+ this._timeout = setTimeout(async () => {
+ this._timeout = void 0;
+ if (this._disposed)
+ return;
+ if (doc.changedtick > changedtick)
+ return;
+ const position = import_coc20.Position.create(lnum - 1, pre.length);
+ const args = Position.toFileLocationRequestArgs(filepath, position);
+ this._cancel = new import_coc20.CancellationTokenSource();
+ const response = await this.client.execute("jsxClosingTag", args, this._cancel.token);
+ if (response.type !== "response" || !response.body) {
+ return;
+ }
+ if (this._disposed)
+ return;
+ const insertion = response.body;
+ if (doc.changedtick === changedtick) {
+ import_coc20.snippetManager.insertSnippet(this.getTagSnippet(insertion).value, false, import_coc20.Range.create(position, position));
+ }
+ }, 50);
+ }
+ isEnabled(languageId, uri) {
+ const configLang = TagClosing2._configurationLanguages[languageId];
+ if (!configLang || configLang !== this.descriptionLanguageId) {
+ return false;
+ }
+ if (!import_coc20.workspace.getConfiguration(void 0, uri).get(`${configLang}.autoClosingTags`)) {
+ return false;
+ }
+ return true;
+ }
+ dispose() {
+ this._disposed = true;
+ if (this._timeout) {
+ clearTimeout(this._timeout);
+ this._timeout = void 0;
+ }
+ if (this._cancel) {
+ this._cancel.cancel();
+ this._cancel.dispose();
+ this._cancel = void 0;
+ }
+ import_coc20.disposeAll(this._disposables);
+ this._disposables = [];
+ }
+ getTagSnippet(closingTag) {
+ const snippet = new SnippetString_default();
+ snippet.appendPlaceholder("", 0);
+ snippet.appendText(closingTag.newText);
+ return snippet;
+ }
+};
+var TagClosing = TagClosing2;
+TagClosing.minVersion = api_default.v300;
+TagClosing._configurationLanguages = {
+ javascriptreact: "javascript",
+ typescriptreact: "typescript"
+};
+var tagClosing_default = TagClosing;
+
// src/server/features/updatePathOnRename.ts
-var import_coc16 = __toModule(require("coc.nvim"));
+var import_coc21 = __toModule(require("coc.nvim"));
var import_vscode_languageserver_protocol16 = __toModule(require_main3());
// src/server/utils/mutex.ts
this.fileConfigurationManager = fileConfigurationManager;
this.disposables = [];
let glob = languageId == "typescript" ? "**/*.{ts,tsx}" : "**/*.{js,jsx}";
- const watcher = import_coc16.workspace.createFileSystemWatcher(glob);
+ const watcher = import_coc21.workspace.createFileSystemWatcher(glob);
this.disposables.push(watcher);
let mutex = new Mutex();
watcher.onDidRename(async (e) => {
}, null, this.disposables);
}
dispose() {
- import_coc16.disposeAll(this.disposables);
+ import_coc21.disposeAll(this.disposables);
}
async doRename(oldResource, newResource) {
if (oldResource.scheme !== "file" || newResource.scheme !== "file") {
const targetFile = newResource.fsPath;
const oldFile = oldResource.fsPath;
const newUri = newResource.toString();
- let oldDocument = import_coc16.workspace.getDocument(oldResource.toString());
+ let oldDocument = import_coc21.workspace.getDocument(oldResource.toString());
if (oldDocument) {
- await import_coc16.workspace.nvim.command(`silent ${oldDocument.bufnr}bwipeout!`);
+ await import_coc21.workspace.nvim.command(`silent ${oldDocument.bufnr}bwipeout!`);
}
- let document = import_coc16.workspace.getDocument(newUri);
+ let document = import_coc21.workspace.getDocument(newUri);
if (document) {
- await import_coc16.workspace.nvim.command(`silent ${document.bufnr}bwipeout!`);
+ await import_coc21.workspace.nvim.command(`silent ${document.bufnr}bwipeout!`);
await wait(30);
}
- document = await import_coc16.workspace.loadFile(newUri);
+ document = await import_coc21.workspace.loadFile(newUri);
if (!document)
return;
await wait(50);
if (!edits)
return;
if (await this.promptUser(newResource)) {
- await import_coc16.workspace.applyEdit(edits);
+ await import_coc21.workspace.applyEdit(edits);
}
}
async promptUser(newResource) {
- return await import_coc16.window.showPrompt(`Update imports for moved file: ${newResource.fsPath}?`);
+ return await import_coc21.window.showPrompt(`Update imports for moved file: ${newResource.fsPath}?`);
}
async getEditsForFileRename(document, oldFile, newFile) {
await this.fileConfigurationManager.ensureConfigurationForDocument(document, import_vscode_languageserver_protocol16.CancellationToken.None);
var updatePathOnRename_default = UpdateImportsOnFileRenameHandler;
// src/server/organizeImports.ts
-var import_coc17 = __toModule(require("coc.nvim"));
+var import_coc22 = __toModule(require("coc.nvim"));
var import_vscode_languageserver_protocol17 = __toModule(require_main3());
var OrganizeImportsCommand = class {
constructor(service) {
const edit = WorkspaceEdit.fromFileCodeEdits(client, response.body);
let keys = Object.keys(edit.changes);
if (keys.length == 1) {
- let doc = import_coc17.workspace.getDocument(keys[0]);
+ let doc = import_coc22.workspace.getDocument(keys[0]);
if (doc) {
await doc.applyEdits(edit.changes[keys[0]]);
return;
}
}
if (edit)
- await import_coc17.workspace.applyEdit(edit);
+ await import_coc22.workspace.applyEdit(edit);
}
async execute(document) {
let client = await this.service.getClientHost();
if (!document) {
- let doc = await import_coc17.workspace.document;
+ let doc = await import_coc22.workspace.document;
if (!doc.attached) {
throw new Error(`Document not attached.`);
}
this.client = client;
this.fileConfigurationManager = fileConfigurationManager;
this.description = description;
- this.typingsStatus = typingsStatus;
this.disposables = [];
- import_coc18.workspace.onDidChangeConfiguration(this.configurationChanged, this, this.disposables);
+ import_coc23.workspace.onDidChangeConfiguration(this.configurationChanged, this, this.disposables);
this.configurationChanged();
let initialized = false;
client.onTsServerStarted(async () => {
});
}
configurationChanged() {
- const config = import_coc18.workspace.getConfiguration(this.id, null);
+ const config = import_coc23.workspace.getConfiguration(this.id, null);
this.client.diagnosticsManager.setEnableSuggestions(this.id, config.get(suggestionSetting, true));
}
dispose() {
- import_coc18.disposeAll(this.disposables);
+ import_coc23.disposeAll(this.disposables);
}
_register(disposable) {
this.disposables.push(disposable);
registerProviders(client, typingsStatus) {
let languageIds = this.description.modeIds;
let clientId = `tsserver-${this.description.id}`;
- this._register(import_coc18.languages.registerCompletionItemProvider(clientId, "TSC", languageIds, new completionItemProvider_default(client, typingsStatus, this.fileConfigurationManager, this.description.id), completionItemProvider_default.triggerCharacters));
+ this._register(import_coc23.languages.registerCompletionItemProvider(clientId, "TSC", languageIds, new completionItemProvider_default(client, typingsStatus, this.fileConfigurationManager, this.description.id), completionItemProvider_default.triggerCharacters));
if (this.client.apiVersion.gte(api_default.v230)) {
- this._register(import_coc18.languages.registerCompletionItemProvider(`${this.description.id}-directive`, "TSC", languageIds, new directiveCommentCompletions_default(client), ["@"]));
+ this._register(import_coc23.languages.registerCompletionItemProvider(`${this.description.id}-directive`, "TSC", languageIds, new directiveCommentCompletions_default(client), ["@"]));
}
let definitionProvider = new definitionProvider_default(client);
- this._register(import_coc18.languages.registerDefinitionProvider(languageIds, definitionProvider));
- this._register(import_coc18.languages.registerTypeDefinitionProvider(languageIds, definitionProvider));
- this._register(import_coc18.languages.registerImplementationProvider(languageIds, definitionProvider));
- this._register(import_coc18.languages.registerReferencesProvider(languageIds, new references_default(client)));
- this._register(import_coc18.languages.registerHoverProvider(languageIds, new hover_default(client)));
- this._register(import_coc18.languages.registerDocumentHighlightProvider(languageIds, new documentHighlight_default(this.client)));
- this._register(import_coc18.languages.registerSignatureHelpProvider(languageIds, new signatureHelp_default(client), ["(", ",", "<", ")"]));
- this._register(import_coc18.languages.registerDocumentSymbolProvider(languageIds, new documentSymbol_default(client)));
- this._register(import_coc18.languages.registerRenameProvider(languageIds, new rename_default(client, this.fileConfigurationManager)));
+ this._register(import_coc23.languages.registerDefinitionProvider(languageIds, definitionProvider));
+ this._register(import_coc23.languages.registerTypeDefinitionProvider(languageIds, definitionProvider));
+ this._register(import_coc23.languages.registerImplementationProvider(languageIds, definitionProvider));
+ this._register(import_coc23.languages.registerReferencesProvider(languageIds, new references_default(client)));
+ this._register(import_coc23.languages.registerHoverProvider(languageIds, new hover_default(client)));
+ this._register(import_coc23.languages.registerDocumentHighlightProvider(languageIds, new documentHighlight_default(this.client)));
+ this._register(import_coc23.languages.registerSignatureHelpProvider(languageIds, new signatureHelp_default(client), ["(", ",", "<", ")"]));
+ this._register(import_coc23.languages.registerDocumentSymbolProvider(languageIds, new documentSymbol_default(client)));
+ this._register(import_coc23.languages.registerRenameProvider(languageIds, new rename_default(client, this.fileConfigurationManager)));
let formatProvider = new formatting_default(client, this.fileConfigurationManager);
- this._register(import_coc18.languages.registerDocumentFormatProvider(languageIds, formatProvider));
- this._register(import_coc18.languages.registerDocumentRangeFormatProvider(languageIds, formatProvider));
- this._register(import_coc18.languages.registerOnTypeFormattingEditProvider(languageIds, formatProvider, [";", "}", "\n", String.fromCharCode(27)]));
- this._register(import_coc18.languages.registerCodeActionProvider(languageIds, new moduleInstall_default(client), "tsserver"));
+ this._register(import_coc23.languages.registerDocumentFormatProvider(languageIds, formatProvider));
+ this._register(import_coc23.languages.registerDocumentRangeFormatProvider(languageIds, formatProvider));
+ this._register(import_coc23.languages.registerOnTypeFormattingEditProvider(languageIds, formatProvider, [";", "}", "\n", String.fromCharCode(27)]));
+ this._register(import_coc23.languages.registerCodeActionProvider(languageIds, new moduleInstall_default(client), "tsserver"));
+ if (typeof import_coc23.languages["registerCallHierarchyProvider"] === "function") {
+ this._register(import_coc23.languages.registerCallHierarchyProvider(languageIds, new callHierarchy_default(client)));
+ }
let {fileConfigurationManager} = this;
let conf = fileConfigurationManager.getLanguageConfiguration(this.id);
if (["javascript", "typescript"].includes(this.id)) {
}
}
if (this.client.apiVersion.gte(api_default.v280)) {
- this._register(import_coc18.languages.registerFoldingRangeProvider(languageIds, new folding_default(this.client)));
- this._register(import_coc18.languages.registerCodeActionProvider(languageIds, new OrganizeImportsCodeActionProvider(this.client, this.fileConfigurationManager), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.SourceOrganizeImports]));
+ this._register(import_coc23.languages.registerFoldingRangeProvider(languageIds, new folding_default(this.client)));
+ this._register(import_coc23.languages.registerCodeActionProvider(languageIds, new OrganizeImportsCodeActionProvider(this.client, this.fileConfigurationManager), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.SourceOrganizeImports]));
}
if (this.client.apiVersion.gte(api_default.v240)) {
- this._register(import_coc18.languages.registerCodeActionProvider(languageIds, new refactor_default(client, this.fileConfigurationManager), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.Refactor]));
+ this._register(import_coc23.languages.registerCodeActionProvider(languageIds, new refactor_default(client, this.fileConfigurationManager), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.Refactor]));
}
- this._register(import_coc18.languages.registerCodeActionProvider(languageIds, new quickfix_default(client, this.fileConfigurationManager), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.QuickFix]));
- this._register(import_coc18.languages.registerCodeActionProvider(languageIds, new importFix_default(this.client.bufferSyncSupport), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.QuickFix]));
+ this._register(import_coc23.languages.registerCodeActionProvider(languageIds, new quickfix_default(client, this.fileConfigurationManager), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.QuickFix]));
+ this._register(import_coc23.languages.registerCodeActionProvider(languageIds, new importFix_default(this.client.bufferSyncSupport), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.QuickFix]));
let cachedResponse = new CachedNavTreeResponse();
if (this.client.apiVersion.gte(api_default.v206) && conf.get("referencesCodeLens.enable")) {
- this._register(import_coc18.languages.registerCodeLensProvider(languageIds, new referencesCodeLens_default(client, cachedResponse)));
+ this._register(import_coc23.languages.registerCodeLensProvider(languageIds, new referencesCodeLens_default(client, cachedResponse)));
}
if (this.client.apiVersion.gte(api_default.v220) && conf.get("implementationsCodeLens.enable")) {
- this._register(import_coc18.languages.registerCodeLensProvider(languageIds, new implementationsCodeLens_default(client, cachedResponse)));
+ this._register(import_coc23.languages.registerCodeLensProvider(languageIds, new implementationsCodeLens_default(client, cachedResponse)));
}
if (this.client.apiVersion.gte(api_default.v350)) {
- this._register(import_coc18.languages.registerSelectionRangeProvider(languageIds, new smartSelect_default(this.client)));
+ this._register(import_coc23.languages.registerSelectionRangeProvider(languageIds, new smartSelect_default(this.client)));
+ }
+ if (this.client.apiVersion.gte(api_default.v300)) {
+ this._register(new tagClosing_default(this.client, this.description.id));
}
}
handles(resource, doc) {
if (doc && this.description.modeIds.indexOf(doc.languageId) >= 0) {
return true;
}
- const base = import_path4.default.basename(import_coc18.Uri.parse(resource).fsPath);
+ const base = import_path5.default.basename(import_coc23.Uri.parse(resource).fsPath);
return !!base && (!!this.description.configFilePattern && this.description.configFilePattern.test(base));
}
get id() {
this.client.bufferSyncSupport.requestAllDiagnostics();
}
diagnosticsReceived(diagnosticsKind, file2, diagnostics) {
- const config = import_coc18.workspace.getConfiguration(this.id, file2.toString());
+ const config = import_coc23.workspace.getConfiguration(this.id, file2.toString());
const reportUnnecessary = config.get("showUnused", true);
+ const reportDeprecated = config.get("showDeprecated", true);
this.client.diagnosticsManager.diagnosticsReceived(diagnosticsKind, file2.toString(), diagnostics.filter((diag) => {
if (!reportUnnecessary) {
- diag.tags = void 0;
if (diag.reportUnnecessary && diag.severity === import_vscode_languageserver_protocol18.DiagnosticSeverity.Information) {
return false;
}
}
+ if (!reportDeprecated) {
+ if (diag.reportDeprecated && diag.severity === import_vscode_languageserver_protocol18.DiagnosticSeverity.Hint) {
+ return false;
+ }
+ }
return true;
}));
}
var languageProvider_default = LanguageProvider;
// src/server/typescriptServiceClient.ts
-var import_coc27 = __toModule(require("coc.nvim"));
+var import_coc32 = __toModule(require("coc.nvim"));
var import_fs4 = __toModule(require("fs"));
var import_os2 = __toModule(require("os"));
-var import_path7 = __toModule(require("path"));
-var import_vscode_languageserver_protocol20 = __toModule(require_main3());
+var import_path8 = __toModule(require("path"));
+var import_vscode_languageserver_protocol21 = __toModule(require_main3());
// src/utils/fileSchemess.ts
var file = "file";
};
// src/server/features/bufferSyncSupport.ts
-var import_coc20 = __toModule(require("coc.nvim"));
+var import_coc25 = __toModule(require("coc.nvim"));
var import_vscode_languageserver_protocol19 = __toModule(require_main3());
// src/server/utils/async.ts
}
// src/server/features/resourceMap.ts
-var import_coc19 = __toModule(require("coc.nvim"));
+var import_coc24 = __toModule(require("coc.nvim"));
function defaultPathNormalizer(resource) {
- let u = import_coc19.Uri.parse(resource);
+ let u = import_coc24.Uri.parse(resource);
if (u.scheme === "file") {
return u.fsPath;
}
}
return this.isCaseInsensitivePath(key) ? key.toLowerCase() : key;
}
- isCaseInsensitivePath(path8) {
- if (isWindowsPath(path8)) {
+ isCaseInsensitivePath(path9) {
+ if (isWindowsPath(path9)) {
return true;
}
- return path8[0] === "/" && this.onIsCaseInsenitiveFileSystem;
+ return path9[0] === "/" && this.onIsCaseInsenitiveFileSystem;
}
get onIsCaseInsenitiveFileSystem() {
if (process.platform === "win32") {
return false;
}
};
-function isWindowsPath(path8) {
- return /^[a-zA-Z]:\\/.test(path8);
+function isWindowsPath(path9) {
+ return /^[a-zA-Z]:\\/.test(path9);
}
// src/server/features/bufferSyncSupport.ts
this.state = 2;
return this.synchronizer.close(this.resource, this.filepath);
}
- onContentChanged(events2) {
+ onContentChanged(events3) {
if (this.state !== 2) {
console.error(`Unexpected buffer state: ${this.state}`);
}
- this.synchronizer.change(this.resource, this.filepath, events2);
+ this.synchronizer.change(this.resource, this.filepath, events3);
}
};
var SyncedBufferMap = class extends ResourceMap {
getForPath(filePath) {
- return this.get(import_coc20.Uri.file(filePath).toString());
+ return this.get(import_coc25.Uri.file(filePath).toString());
}
get allBuffers() {
return this.values;
return true;
}
}
- change(resource, filepath, events2) {
- if (!events2.length) {
+ change(resource, filepath, events3) {
+ if (!events3.length) {
return;
}
if (this.supportsBatching) {
this.updatePending(resource, new ChangeOperation({
fileName: filepath,
- textChanges: events2.map((change) => ({
+ textChanges: events3.map((change) => ({
newText: change.text,
start: Position.toLocation(change.range.start),
end: Position.toLocation(change.range.end)
})).reverse()
}));
} else {
- for (const {range, text} of events2) {
+ for (const {range, text} of events3) {
const args = {
insertString: text,
- ...Range.toFormattingRequestArgs(filepath, range)
+ ...Range2.toFormattingRequestArgs(filepath, range)
};
this.client.executeWithoutWaitingForResponse("change", args);
}
this.client = client;
this.modeIds = new Set(modeIds);
this.diagnosticDelayer = new Delayer(300);
- const pathNormalizer = (path8) => this.client.toPath(path8);
+ const pathNormalizer = (path9) => this.client.toPath(path9);
this.syncedBuffers = new SyncedBufferMap(pathNormalizer);
this.pendingDiagnostics = new PendingDiagnostics(pathNormalizer);
this.synchronizer = new BufferSynchronizer(client, pathNormalizer);
this.updateConfiguration();
- import_coc20.workspace.onDidChangeConfiguration(this.updateConfiguration, this, this.disposables);
+ import_coc25.workspace.onDidChangeConfiguration(this.updateConfiguration, this, this.disposables);
}
listen() {
if (this.listening) {
return;
}
this.listening = true;
- import_coc20.workspace.onDidOpenTextDocument(this.openTextDocument, this, this.disposables);
- import_coc20.workspace.onDidCloseTextDocument(this.onDidCloseTextDocument, this, this.disposables);
- import_coc20.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this, this.disposables);
- import_coc20.workspace.textDocuments.forEach(this.openTextDocument, this);
+ import_coc25.workspace.onDidOpenTextDocument(this.openTextDocument, this, this.disposables);
+ import_coc25.workspace.onDidCloseTextDocument(this.onDidCloseTextDocument, this, this.disposables);
+ import_coc25.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this, this.disposables);
+ import_coc25.workspace.textDocuments.forEach(this.openTextDocument, this);
}
handles(resource) {
return this.syncedBuffers.has(resource);
}
dispose() {
this.pendingDiagnostics.clear();
- import_coc20.disposeAll(this.disposables);
+ import_coc25.disposeAll(this.disposables);
this._onWillChange.dispose();
this._onDelete.dispose();
}
if (this.syncedBuffers.has(resource)) {
return true;
}
- const existingDocument = import_coc20.workspace.textDocuments.find((doc) => doc.uri.toString() === resource);
+ const existingDocument = import_coc25.workspace.textDocuments.find((doc) => doc.uri.toString() === resource);
if (existingDocument) {
return this.openTextDocument(existingDocument);
}
const buffer = this.syncedBuffers.getForPath(filePath);
if (buffer)
return buffer.resource;
- return import_coc20.Uri.file(filePath).toString();
+ return import_coc25.Uri.file(filePath).toString();
}
reset() {
var _a;
return false;
}
const resource = document.uri;
- const filepath = this.client.normalizePath(import_coc20.Uri.parse(resource));
+ const filepath = this.client.normalizePath(import_coc25.Uri.parse(resource));
if (!filepath) {
return false;
}
}
}
if (orderedFileSet.size) {
- let uris = Array.from(orderedFileSet.uris).map((uri) => import_coc20.Uri.parse(uri));
+ let uris = Array.from(orderedFileSet.uris).map((uri) => import_coc25.Uri.parse(uri));
const getErr = this.pendingGetErr = GetErrRequest.executeGetErrRequest(this.client, uris, () => {
if (this.pendingGetErr === getErr) {
this.pendingGetErr = void 0;
this.pendingDiagnostics.clear();
}
updateConfiguration() {
- const jsConfig = import_coc20.workspace.getConfiguration("javascript", null);
- const tsConfig = import_coc20.workspace.getConfiguration("typescript", null);
+ const jsConfig = import_coc25.workspace.getConfiguration("javascript", null);
+ const tsConfig = import_coc25.workspace.getConfiguration("typescript", null);
this._validateJavaScript = jsConfig.get("validate.enable", true);
this._validateTypeScript = tsConfig.get("validate.enable", true);
}
var bufferSyncSupport_default = BufferSyncSupport;
// src/server/features/diagnostics.ts
-var import_coc21 = __toModule(require("coc.nvim"));
+var import_coc26 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol20 = __toModule(require_main3());
var DiagnosticSet = class {
constructor() {
this._map = new ResourceMap();
for (const kind of allDiagnosticKinds) {
this._diagnostics.set(kind, new DiagnosticSet());
}
- this._currentDiagnostics = import_coc21.languages.createDiagnosticCollection("tsserver");
+ this._currentDiagnostics = import_coc26.languages.createDiagnosticCollection("tsserver");
}
dispose() {
this._currentDiagnostics.dispose();
const collection = this._diagnostics.get(kind);
if (!collection)
return;
- let doc = import_coc21.workspace.getDocument(uri);
+ let doc = import_coc26.workspace.getDocument(uri);
if (doc)
uri = doc.uri;
if (diagnostics.length === 0) {
const enabled = this.suggestionsEnabled(uri);
return this._diagnostics.get(2).get(uri).filter((x) => {
if (!enabled) {
- return x.code == 6133;
+ return x.tags && (x.tags.includes(import_vscode_languageserver_protocol20.DiagnosticTag.Unnecessary) || x.tags.includes(import_vscode_languageserver_protocol20.DiagnosticTag.Deprecated));
}
return enabled;
});
}
suggestionsEnabled(uri) {
- let doc = import_coc21.workspace.getDocument(uri);
+ let doc = import_coc26.workspace.getDocument(uri);
if (!doc)
return false;
if (doc.filetype.startsWith("javascript")) {
};
// src/server/utils/configuration.ts
-var import_coc22 = __toModule(require("coc.nvim"));
+var import_coc27 = __toModule(require("coc.nvim"));
var import_which = __toModule(require_which());
var TsServerLogLevel;
(function(TsServerLogLevel2) {
})(TsServerLogLevel || (TsServerLogLevel = {}));
var TypeScriptServiceConfiguration = class {
constructor() {
- this._configuration = import_coc22.workspace.getConfiguration("tsserver");
- import_coc22.workspace.onDidChangeConfiguration(() => {
- this._configuration = import_coc22.workspace.getConfiguration("tsserver");
+ this._configuration = import_coc27.workspace.getConfiguration("tsserver");
+ import_coc27.workspace.onDidChangeConfiguration(() => {
+ this._configuration = import_coc27.workspace.getConfiguration("tsserver");
});
}
get locale() {
return this._configuration.get("debugPort", parseInt(process.env["TSS_DEBUG"], 10));
}
get npmLocation() {
- let path8 = this._configuration.get("npm", "");
- if (path8)
- return import_coc22.workspace.expand(path8);
+ let path9 = this._configuration.get("npm", "");
+ if (path9)
+ return import_coc27.workspace.expand(path9);
try {
- path8 = import_which.default.sync("npm");
+ path9 = import_which.default.sync("npm");
} catch (e) {
return null;
}
- return path8;
+ return path9;
}
static loadFromWorkspace() {
return new TypeScriptServiceConfiguration();
};
// src/server/utils/logger.ts
-var import_coc23 = __toModule(require("coc.nvim"));
+var import_coc28 = __toModule(require("coc.nvim"));
// src/server/utils/is.ts
var toString = Object.prototype.toString;
if (this._channel) {
return this._channel;
}
- this._channel = import_coc23.window.createOutputChannel("tsserver");
+ this._channel = import_coc28.window.createOutputChannel("tsserver");
return this._channel;
}
dispose() {
var import_child_process2 = __toModule(require("child_process"));
var import_net = __toModule(require("net"));
var import_os = __toModule(require("os"));
-var import_path5 = __toModule(require("path"));
+var import_path6 = __toModule(require("path"));
var import_fs2 = __toModule(require("fs"));
function makeRandomHexString(length) {
let chars = ["0", "1", "2", "3", "4", "5", "6", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
return result;
}
function getTempDirectory() {
- let dir = import_path5.default.join(import_os.default.tmpdir(), `coc.nvim-${process.pid}`);
+ let dir = import_path6.default.join(import_os.default.tmpdir(), `coc.nvim-${process.pid}`);
if (!import_fs2.default.existsSync(dir)) {
import_fs2.default.mkdirSync(dir);
}
return "\\\\.\\pipe\\" + fullName + "-sock";
}
const tmpdir = getTempDirectory();
- return import_path5.default.join(tmpdir, fullName + ".sock");
+ return import_path6.default.join(tmpdir, fullName + ".sock");
}
function getTempFile(name) {
const fullName = "coc-nvim-" + name;
- return import_path5.default.join(getTempDirectory(), fullName + ".sock");
+ return import_path6.default.join(getTempDirectory(), fullName + ".sock");
}
function generatePatchedEnv(env, stdInPipeName, stdOutPipeName, stdErrPipeName) {
const newEnv = Object.assign({}, env);
newEnv["STDIN_PIPE_NAME"] = stdInPipeName;
newEnv["STDOUT_PIPE_NAME"] = stdOutPipeName;
newEnv["STDERR_PIPE_NAME"] = stdErrPipeName;
- newEnv["TSS_LOG"] = `-level verbose -file ${import_path5.default.join(import_os.default.tmpdir(), "coc-nvim-tsc.log")}`;
+ newEnv["TSS_LOG"] = `-level verbose -file ${import_path6.default.join(import_os.default.tmpdir(), "coc-nvim-tsc.log")}`;
newEnv["PATH"] = newEnv["PATH"] || process.env.PATH;
return newEnv;
}
const stdOutPipeName = generatePipeName();
const stdErrPipeName = generatePipeName();
const newEnv = generatePatchedEnv(process.env, stdInPipeName, stdOutPipeName, stdErrPipeName);
- newEnv["NODE_PATH"] = import_path5.default.join(modulePath, "..", "..", "..");
+ newEnv["NODE_PATH"] = import_path6.default.join(modulePath, "..", "..", "..");
let childProcess;
let stdErrServer = import_net.default.createServer((stdErrStream) => {
childProcess.stderr = stdErrStream;
stdErrServer.close();
};
logger.info("Forking TSServer", `PATH: ${newEnv["PATH"]} `);
- const bootstrapperPath = import_path5.default.resolve(__dirname, "../bin/tsserverForkStart");
+ const bootstrapperPath = import_path6.default.resolve(__dirname, "../bin/tsserverForkStart");
childProcess = import_child_process2.default.fork(bootstrapperPath, [modulePath].concat(args), {
silent: true,
env: newEnv,
}
// src/server/utils/tracer.ts
-var import_coc24 = __toModule(require("coc.nvim"));
+var import_coc29 = __toModule(require("coc.nvim"));
var Trace;
(function(Trace2) {
Trace2[Trace2["Off"] = 0] = "Off";
this.trace = Tracer.readTrace();
}
static readTrace() {
- let result = Trace.fromString(import_coc24.workspace.getConfiguration("tsserver").get("trace.server", "off"));
+ let result = Trace.fromString(import_coc29.workspace.getConfiguration("tsserver").get("trace.server", "off"));
if (result === 0 && !!process.env.TSS_TRACE) {
result = 1;
}
}
// src/server/utils/versionProvider.ts
-var import_coc25 = __toModule(require("coc.nvim"));
+var import_coc30 = __toModule(require("coc.nvim"));
var import_fs3 = __toModule(require("fs"));
-var import_path6 = __toModule(require("path"));
+var import_path7 = __toModule(require("path"));
var TypeScriptVersion = class {
- constructor(path8, _pathLabel) {
- this.path = path8;
+ constructor(path9, _pathLabel) {
+ this.path = path9;
this._pathLabel = _pathLabel;
this._api = null;
}
get tscPath() {
- return import_path6.default.resolve(this.path, "../bin/tsc");
+ return import_path7.default.resolve(this.path, "../bin/tsc");
}
get tsServerPath() {
- return import_path6.default.resolve(this.path, "tsserver.js");
+ return import_path7.default.resolve(this.path, "tsserver.js");
}
get pathLabel() {
return typeof this._pathLabel === "undefined" ? this.path : this._pathLabel;
if (!import_fs3.default.existsSync(serverPath)) {
return void 0;
}
- const p = serverPath.split(import_path6.default.sep);
+ const p = serverPath.split(import_path7.default.sep);
if (p.length <= 2) {
return void 0;
}
const p2 = p.slice(0, -2);
- const modulePath = p2.join(import_path6.default.sep);
- let fileName = import_path6.default.join(modulePath, "package.json");
+ const modulePath = p2.join(import_path7.default.sep);
+ let fileName = import_path7.default.join(modulePath, "package.json");
if (!import_fs3.default.existsSync(fileName)) {
- if (import_path6.default.basename(modulePath) === "built") {
- fileName = import_path6.default.join(modulePath, "..", "package.json");
+ if (import_path7.default.basename(modulePath) === "built") {
+ fileName = import_path7.default.join(modulePath, "..", "package.json");
}
}
if (!import_fs3.default.existsSync(fileName)) {
get globalVersion() {
let {globalTsdk} = this.configuration;
if (globalTsdk)
- return new TypeScriptVersion(import_coc25.workspace.expand(globalTsdk));
+ return new TypeScriptVersion(import_coc30.workspace.expand(globalTsdk));
return void 0;
}
getLocalVersion() {
- let folders = import_coc25.workspace.workspaceFolders.map((f) => import_coc25.Uri.parse(f.uri).fsPath);
+ let folders = import_coc30.workspace.workspaceFolders.map((f) => import_coc30.Uri.parse(f.uri).fsPath);
for (let p of folders) {
for (let folder of MODULE_FOLDERS) {
- let libFolder = import_path6.default.join(p, folder);
+ let libFolder = import_path7.default.join(p, folder);
if (import_fs3.default.existsSync(libFolder)) {
let version = new TypeScriptVersion(libFolder);
if (version.isValid)
get bundledVersion() {
try {
const file2 = require.resolve("typescript");
- const bundledVersion = new TypeScriptVersion(import_path6.default.dirname(file2), "");
+ const bundledVersion = new TypeScriptVersion(import_path7.default.dirname(file2), "");
return bundledVersion;
} catch (e) {
- import_coc25.window.showMessage("Bundled typescript module not found", "error");
+ import_coc30.window.showMessage("Bundled typescript module not found", "error");
return null;
}
}
};
// src/server/utils/versionStatus.ts
-var import_coc26 = __toModule(require("coc.nvim"));
+var import_coc31 = __toModule(require("coc.nvim"));
var VersionStatus = class {
constructor(_normalizePath, enableJavascript) {
this._normalizePath = _normalizePath;
this.enableJavascript = enableJavascript;
this._versionString = "";
- this._versionBarEntry = import_coc26.window.createStatusBarItem(99);
- this._onChangeEditorSub = import_coc26.events.on("BufEnter", this.onBufEnter, this);
+ this._versionBarEntry = import_coc31.window.createStatusBarItem(99);
+ this._onChangeEditorSub = import_coc31.events.on("BufEnter", this.onBufEnter, this);
this._versionBarEntry.show();
}
dispose() {
}
set loading(isLoading) {
if (isLoading) {
- this._versionBarEntry.text = `Initialing tsserver ${this._versionString}`;
+ this._versionBarEntry.text = `Initializing tsserver ${this._versionString}`;
} else {
this._versionBarEntry.text = `TSC ${this._versionString}`;
}
return filetype.startsWith("typescript");
}
async onBufEnter(bufnr) {
- let filetype = await import_coc26.workspace.nvim.call("getbufvar", [bufnr, "&filetype", ""]);
+ let filetype = await import_coc31.workspace.nvim.call("getbufvar", [bufnr, "&filetype", ""]);
if (this.checkFiletype(filetype)) {
this._versionBarEntry.show();
} else {
constructor(pluginManager, modeIds) {
this.pluginManager = pluginManager;
this.modeIds = modeIds;
- this.state = import_coc27.ServiceStat.Initial;
+ this.state = import_coc32.ServiceStat.Initial;
this.logger = new logger_default();
this.tsServerLogFile = null;
this.cancellationPipeName = null;
this._callbacks = new CallbackMap();
this._requestQueue = new RequestQueue();
this._pendingResponses = new Set();
- this._onTsServerStarted = new import_vscode_languageserver_protocol20.Emitter();
- this._onProjectLanguageServiceStateChanged = new import_vscode_languageserver_protocol20.Emitter();
- this._onDidBeginInstallTypings = new import_vscode_languageserver_protocol20.Emitter();
- this._onDidEndInstallTypings = new import_vscode_languageserver_protocol20.Emitter();
- this._onTypesInstallerInitializationFailed = new import_vscode_languageserver_protocol20.Emitter();
+ this._onTsServerStarted = new import_vscode_languageserver_protocol21.Emitter();
+ this._onProjectLanguageServiceStateChanged = new import_vscode_languageserver_protocol21.Emitter();
+ this._onDidBeginInstallTypings = new import_vscode_languageserver_protocol21.Emitter();
+ this._onDidEndInstallTypings = new import_vscode_languageserver_protocol21.Emitter();
+ this._onTypesInstallerInitializationFailed = new import_vscode_languageserver_protocol21.Emitter();
this.disposables = [];
this.isRestarting = false;
- this._onDiagnosticsReceived = new import_vscode_languageserver_protocol20.Emitter();
- this._onConfigDiagnosticsReceived = new import_vscode_languageserver_protocol20.Emitter();
- this._onResendModelsRequested = new import_vscode_languageserver_protocol20.Emitter();
- this.pathSeparator = import_path7.default.sep;
+ this._onDiagnosticsReceived = new import_vscode_languageserver_protocol21.Emitter();
+ this._onConfigDiagnosticsReceived = new import_vscode_languageserver_protocol21.Emitter();
+ this._onResendModelsRequested = new import_vscode_languageserver_protocol21.Emitter();
+ this.pathSeparator = import_path8.default.sep;
this.lastStart = Date.now();
this.servicePromise = null;
this.lastError = null;
};
if (this.servicePromise) {
return Promise.resolve(this.servicePromise.then((childProcess) => {
- this.state = import_coc27.ServiceStat.Stopping;
+ this.state = import_coc32.ServiceStat.Stopping;
this.info("Killing TS Server");
this.isRestarting = true;
childProcess.kill();
return;
return new Promise((resolve, reject) => {
this.servicePromise.then((childProcess) => {
- if (this.state == import_coc27.ServiceStat.Running) {
+ if (this.state == import_coc32.ServiceStat.Running) {
this.info("Killing TS Server");
childProcess.onExit(() => {
resolve();
ensureServiceStarted() {
if (!this.servicePromise) {
this.startService().catch((err) => {
- import_coc27.window.showMessage(`TSServer start failed: ${err.message}`, "error");
+ import_coc32.window.showMessage(`TSServer start failed: ${err.message}`, "error");
this.error(`Service start failed: ${err.stack}`);
});
}
}
if (!currentVersion || !currentVersion.isValid) {
if (this.configuration.globalTsdk) {
- import_coc27.window.showMessage(`Can not find typescript module, in 'tsserver.tsdk': ${this.configuration.globalTsdk}`, "error");
+ import_coc32.window.showMessage(`Can not find typescript module, in 'tsserver.tsdk': ${this.configuration.globalTsdk}`, "error");
} else {
- import_coc27.window.showMessage(`Can not find typescript module, run ':CocInstall coc-tsserver' to fix it!`, "error");
+ import_coc32.window.showMessage(`Can not find typescript module, run ':CocInstall coc-tsserver' to fix it!`, "error");
}
return;
}
...debugPort ? [`--inspect=${debugPort}`] : [],
...maxTsServerMemory ? [`--max-old-space-size=${maxTsServerMemory}`] : []
],
- cwd: import_coc27.workspace.root
+ cwd: import_coc32.workspace.root
};
this.servicePromise = this.startProcess(currentVersion, tsServerForkArgs, options, resendModels);
return this.servicePromise;
}
startProcess(currentVersion, args, options, resendModels) {
- this.state = import_coc27.ServiceStat.Starting;
+ this.state = import_coc32.ServiceStat.Starting;
return new Promise((resolve, reject) => {
try {
fork(currentVersion.tsServerPath, args, options, this.logger, (err, childProcess) => {
if (err || !childProcess) {
- this.state = import_coc27.ServiceStat.StartFailed;
+ this.state = import_coc32.ServiceStat.StartFailed;
this.lastError = err;
this.error("Starting TSServer failed with error.", err.stack);
return;
}
- this.state = import_coc27.ServiceStat.Running;
+ this.state = import_coc32.ServiceStat.Running;
this.info("Started TSServer", JSON.stringify(currentVersion, null, 2));
const handle = new ForkedTsServerProcess(childProcess);
this.tsServerProcess = handle;
this.lastError = err2;
this.error("TSServer errored with error.", err2);
this.error(`TSServer log file: ${this.tsServerLogFile || ""}`);
- import_coc27.window.showMessage(`TSServer errored with error. ${err2.message}`, "error");
+ import_coc32.window.showMessage(`TSServer errored with error. ${err2.message}`, "error");
this.serviceExited(false);
});
handle.onExit((code) => {
async openTsServerLogFile() {
const isRoot = process.getuid && process.getuid() == 0;
let echoErr = (msg) => {
- import_coc27.window.showMessage(msg, "error");
+ import_coc32.window.showMessage(msg, "error");
};
if (isRoot) {
echoErr("Log disabled for root user.");
return false;
}
try {
- await import_coc27.workspace.nvim.command(`edit ${this.tsServerLogFile}`);
+ await import_coc32.workspace.nvim.command(`edit ${this.tsServerLogFile}`);
return true;
} catch {
echoErr("Could not open TS Server log file");
};
}
serviceExited(restart) {
- this.state = import_coc27.ServiceStat.Stopped;
+ this.state = import_coc32.ServiceStat.Stopped;
this.servicePromise = null;
this.tsServerLogFile = null;
this._callbacks.destroy("Service died.");
if (diff < 10 * 1e3) {
this.lastStart = Date.now();
startService = false;
- import_coc27.window.showMessage("The TypeScript language service died 5 times right after it got started.", "error");
+ import_coc32.window.showMessage("The TypeScript language service died 5 times right after it got started.", "error");
} else if (diff < 60 * 1e3) {
this.lastStart = Date.now();
- import_coc27.window.showMessage("The TypeScript language service died unexpectedly 5 times in the last 5 Minutes.", "error");
+ import_coc32.window.showMessage("The TypeScript language service died unexpectedly 5 times in the last 5 Minutes.", "error");
}
}
if (startService) {
}
}
toPath(uri) {
- return this.normalizePath(import_coc27.Uri.parse(uri));
+ return this.normalizePath(import_coc32.Uri.parse(uri));
}
toOpenedFilePath(uri, options = {}) {
if (!this.bufferSyncSupport.ensureHasBuffer(uri)) {
toResource(filepath) {
if (this._apiVersion.gte(api_default.v213)) {
if (filepath.startsWith(this.inMemoryResourcePrefix + "untitled:")) {
- let resource = import_coc27.Uri.parse(filepath);
+ let resource = import_coc32.Uri.parse(filepath);
if (this.inMemoryResourcePrefix) {
- const dirName = import_path7.default.dirname(resource.path);
- const fileName = import_path7.default.basename(resource.path);
+ const dirName = import_path8.default.dirname(resource.path);
+ const fileName = import_path8.default.basename(resource.path);
if (fileName.startsWith(this.inMemoryResourcePrefix)) {
- resource = resource.with({path: import_path7.default.posix.join(dirName, fileName.slice(this.inMemoryResourcePrefix.length))});
+ resource = resource.with({path: import_path8.default.posix.join(dirName, fileName.slice(this.inMemoryResourcePrefix.length))});
}
}
return resource.toString();
}
}
- return import_coc27.Uri.file(filepath).toString();
+ return import_coc32.Uri.file(filepath).toString();
}
normalizePath(resource) {
if (disabledSchemes.has(resource.scheme)) {
let result = resource.fsPath;
if (!result)
return void 0;
- result = import_path7.default.normalize(result);
+ result = import_path8.default.normalize(result);
return result.replace(new RegExp("\\" + this.pathSeparator, "g"), "/");
}
default: {
getDocument(resource) {
if (resource.startsWith("untitled:")) {
let bufnr = parseInt(resource.split(":", 2)[1], 10);
- return import_coc27.workspace.getDocument(bufnr);
+ return import_coc32.workspace.getDocument(bufnr);
}
- return import_coc27.workspace.getDocument(resource);
+ return import_coc32.workspace.getDocument(resource);
}
get inMemoryResourcePrefix() {
return this._apiVersion.gte(api_default.v270) ? "^" : "";
asUrl(filepath) {
if (this._apiVersion.gte(api_default.v213)) {
if (filepath.startsWith(this.inMemoryResourcePrefix + "untitled:")) {
- let resource = import_coc27.Uri.parse(filepath.slice(this.inMemoryResourcePrefix.length));
+ let resource = import_coc32.Uri.parse(filepath.slice(this.inMemoryResourcePrefix.length));
if (this.inMemoryResourcePrefix) {
- const dirName = import_path7.default.dirname(resource.path);
- const fileName = import_path7.default.basename(resource.path);
+ const dirName = import_path8.default.dirname(resource.path);
+ const fileName = import_path8.default.basename(resource.path);
if (fileName.startsWith(this.inMemoryResourcePrefix)) {
resource = resource.with({
- path: import_path7.default.posix.join(dirName, fileName.slice(this.inMemoryResourcePrefix.length))
+ path: import_path8.default.posix.join(dirName, fileName.slice(this.inMemoryResourcePrefix.length))
});
}
}
return resource;
}
}
- return import_coc27.Uri.file(filepath);
+ return import_coc32.Uri.file(filepath);
}
execute(command, args, token, config) {
var _a;
let execution;
if (config == null ? void 0 : config.cancelOnResourceChange) {
- const source = new import_vscode_languageserver_protocol20.CancellationTokenSource();
+ const source = new import_vscode_languageserver_protocol21.CancellationTokenSource();
token.onCancellationRequested(() => source.cancel());
const inFlight = {
resource: config.cancelOnResourceChange,
}
fatalError(command, error) {
console.error(`A non-recoverable error occured while executing tsserver command: ${command}`);
- if (this.state === import_coc27.ServiceStat.Running) {
+ if (this.state === import_coc32.ServiceStat.Running) {
this.info("Killing TS Server by fatal error:", error);
this.service().then((service) => {
service.kill();
break;
case "projectsUpdatedInBackground":
const body = event.body;
- const resources = body.openFiles.map(import_coc27.Uri.file);
+ const resources = body.openFiles.map(import_coc32.Uri.file);
this.bufferSyncSupport.getErr(resources);
break;
case "typesInstallerInitializationFailed":
if (this._configuration.tsServerLogLevel !== TsServerLogLevel.Off && !isRoot) {
const logDir = getTempDirectory();
if (logDir) {
- this.tsServerLogFile = import_path7.default.join(logDir, `tsserver.log`);
+ this.tsServerLogFile = import_path8.default.join(logDir, `tsserver.log`);
this.info("TSServer log file :", this.tsServerLogFile);
} else {
this.tsServerLogFile = null;
const pluginNames = this.pluginManager.plugins.map((x) => x.name);
let pluginPaths = this._configuration.tsServerPluginPaths;
pluginPaths = pluginPaths.reduce((p, c) => {
- if (import_path7.default.isAbsolute(c)) {
+ if (import_path8.default.isAbsolute(c)) {
p.push(c);
} else {
- let roots = import_coc27.workspace.workspaceFolders.map((o) => import_coc27.Uri.parse(o.uri).fsPath);
- p.push(...roots.map((r) => import_path7.default.join(r, c)));
+ let roots = import_coc32.workspace.workspaceFolders.map((o) => import_coc32.Uri.parse(o.uri).fsPath);
+ p.push(...roots.map((r) => import_path8.default.join(r, c)));
}
return p;
}, []);
return args;
}
getProjectRootPath(uri) {
- let root = import_coc27.workspace.cwd;
- let u = import_coc27.Uri.parse(uri);
+ let root = import_coc32.workspace.cwd;
+ let u = import_coc32.Uri.parse(uri);
if (u.scheme !== "file")
return void 0;
- let folder = import_coc27.workspace.getWorkspaceFolder(uri);
+ let folder = import_coc32.workspace.getWorkspaceFolder(uri);
if (folder) {
- root = import_coc27.Uri.parse(folder.uri).fsPath;
+ root = import_coc32.Uri.parse(folder.uri).fsPath;
} else {
- let filepath = import_coc27.Uri.parse(uri).fsPath;
+ let filepath = import_coc32.Uri.parse(uri).fsPath;
if (!filepath.startsWith(root)) {
- root = import_path7.default.dirname(filepath);
+ root = import_path8.default.dirname(filepath);
}
}
if (root == import_os2.default.homedir())
return this.bufferSyncSupport.interuptGetErr(f);
}
cancelInflightRequestsForResource(resource) {
- if (this.state !== import_coc27.ServiceStat.Running || !this.tsServerProcess) {
+ if (this.state !== import_coc32.ServiceStat.Running || !this.tsServerProcess) {
return;
}
for (const request of this.tsServerProcess.toCancelOnResourceChange) {
];
// src/server/utils/typingsStatus.ts
-var import_coc28 = __toModule(require("coc.nvim"));
-var import_vscode_languageserver_protocol21 = __toModule(require_main3());
+var import_coc33 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol22 = __toModule(require_main3());
var typingsInstallTimeout = 30 * 1e3;
var TypingsStatus = class {
constructor(client) {
constructor(client) {
this._promises = new Map();
this._invalid = false;
- this.statusItem = import_coc28.window.createStatusBarItem(10, {progress: true});
+ this.statusItem = import_coc33.window.createStatusBarItem(10, {progress: true});
const disposables = [];
disposables.push(client.onDidBeginInstallTypings((e) => this._onBegin(e.eventId)));
disposables.push(client.onDidEndInstallTypings((e) => this._onEndOrTimeout(e.eventId)));
disposables.push(client.onTypesInstallerInitializationFailed((_) => this.onTypesInstallerInitializationFailed()));
- this._disposable = import_vscode_languageserver_protocol21.Disposable.create(() => {
+ this._disposable = import_vscode_languageserver_protocol22.Disposable.create(() => {
disposables.forEach((disposable) => {
disposable.dispose();
});
onTypesInstallerInitializationFailed() {
this.statusItem.hide();
if (!this._invalid) {
- import_coc28.window.showMessage("Could not install typings files for JavaScript language features. Please ensure that NPM is installed", "error");
+ import_coc33.window.showMessage("Could not install typings files for JavaScript language features. Please ensure that NPM is installed", "error");
}
this._invalid = true;
}
this.triggerAllDiagnostics();
}, 1500);
};
- const configFileWatcher = import_coc29.workspace.createFileSystemWatcher("**/[tj]sconfig.json");
+ const configFileWatcher = import_coc34.workspace.createFileSystemWatcher("**/[tj]sconfig.json");
this.disposables.push(configFileWatcher);
configFileWatcher.onDidCreate(this.reloadProjects, this, this.disposables);
configFileWatcher.onDidDelete(this.reloadProjects, this, this.disposables);
configFileWatcher.onDidChange(handleProjectChange, this, this.disposables);
- const packageFileWatcher = import_coc29.workspace.createFileSystemWatcher("**/package.json");
+ const packageFileWatcher = import_coc34.workspace.createFileSystemWatcher("**/package.json");
packageFileWatcher.onDidCreate(this.reloadProjects, this, this.disposables);
packageFileWatcher.onDidChange(handleProjectChange, this, this.disposables);
const allModeIds = this.getAllModeIds(descriptions, pluginManager);
});
}, null, this.disposables);
this.disposables.push(new watchBuild_default(this.client));
- this.disposables.push(import_coc29.languages.registerWorkspaceSymbolProvider(new workspaceSymbols_default(this.client, allModeIds)));
+ this.disposables.push(import_coc34.languages.registerWorkspaceSymbolProvider(new workspaceSymbols_default(this.client, allModeIds)));
this.client.onConfigDiagnosticsReceived((diag) => {
let {body} = diag;
if (body) {
let {configFile, diagnostics} = body;
- let uri = import_coc29.Uri.file(configFile);
+ let uri = import_coc34.Uri.file(configFile);
if (diagnostics.length == 0) {
this.client.diagnosticsManager.configFileDiagnosticsReceived(uri.toString(), []);
} else {
let {text, code, category, start, end} = o;
let range;
if (!start || !end) {
- range = import_vscode_languageserver_protocol22.Range.create(import_vscode_languageserver_protocol22.Position.create(0, 0), import_vscode_languageserver_protocol22.Position.create(0, 1));
+ range = import_vscode_languageserver_protocol23.Range.create(import_vscode_languageserver_protocol23.Position.create(0, 0), import_vscode_languageserver_protocol23.Position.create(0, 1));
} else {
- range = import_vscode_languageserver_protocol22.Range.create(start.line - 1, start.offset - 1, end.line - 1, end.offset - 1);
+ range = import_vscode_languageserver_protocol23.Range.create(start.line - 1, start.offset - 1, end.line - 1, end.offset - 1);
}
- let severity = category == "error" ? import_vscode_languageserver_protocol22.DiagnosticSeverity.Error : import_vscode_languageserver_protocol22.DiagnosticSeverity.Warning;
- return import_vscode_languageserver_protocol22.Diagnostic.create(range, text, severity, code);
+ let severity = category == "error" ? import_vscode_languageserver_protocol23.DiagnosticSeverity.Error : import_vscode_languageserver_protocol23.DiagnosticSeverity.Warning;
+ return import_vscode_languageserver_protocol23.Diagnostic.create(range, text, severity, code);
});
this.client.diagnosticsManager.configFileDiagnosticsReceived(uri.toString(), diagnosticList);
}
isExternal: true
});
} else {
- for (const language of plugin.languages) {
- languageIds.add(language);
+ for (const language2 of plugin.languages) {
+ languageIds.add(language2);
}
}
}
this.client.onTsServerStarted(() => {
this.triggerAllDiagnostics();
});
- import_coc29.workspace.onDidChangeConfiguration(this.configurationChanged, this, this.disposables);
+ import_coc34.workspace.onDidChangeConfiguration(this.configurationChanged, this, this.disposables);
this.configurationChanged();
}
registerExtensionLanguageProvider(description) {
this.languagePerId.set(description.id, manager);
}
dispose() {
- import_coc29.disposeAll(this.disposables);
- for (let language of this.languagePerId.values()) {
- language.dispose();
+ import_coc34.disposeAll(this.disposables);
+ for (let language2 of this.languagePerId.values()) {
+ language2.dispose();
}
this.languagePerId.clear();
this.fileConfigurationManager.dispose();
}
reloadProjects() {
this.client.diagnosticsManager.reInitialize();
- this.client.execute("reloadProjects", null, import_vscode_languageserver_protocol22.CancellationToken.None);
+ this.client.execute("reloadProjects", null, import_vscode_languageserver_protocol23.CancellationToken.None);
this.triggerAllDiagnostics();
}
getProvider(languageId) {
return this.languagePerId.get(languageId);
}
configurationChanged() {
- const config = import_coc29.workspace.getConfiguration("tsserver");
+ const config = import_coc34.workspace.getConfiguration("tsserver");
this.reportStyleCheckAsWarnings = config.get("reportStyleChecksAsWarnings", true);
}
async findLanguage(uri) {
if (!doc)
return void 0;
let languages4 = Array.from(this.languagePerId.values());
- return languages4.find((language) => language.handles(uri, doc.textDocument));
+ return languages4.find((language2) => language2.handles(uri, doc.textDocument));
} catch {
return void 0;
}
}
async handles(doc) {
let languages4 = Array.from(this.languagePerId.values());
- let idx = languages4.findIndex((language) => language.handles(doc.uri, doc));
+ let idx = languages4.findIndex((language2) => language2.handles(doc.uri, doc));
if (idx != -1)
return true;
return this.client.bufferSyncSupport.handles(doc.uri);
}
triggerAllDiagnostics() {
- for (const language of this.languagePerId.values()) {
- language.triggerAllDiagnostics();
+ for (const language2 of this.languagePerId.values()) {
+ language2.triggerAllDiagnostics();
}
}
async diagnosticsReceived(kind, resource, diagnostics) {
- const language = await this.findLanguage(resource.toString());
- if (language) {
- language.diagnosticsReceived(kind, resource, this.createMarkerDatas(diagnostics));
+ const language2 = await this.findLanguage(resource.toString());
+ if (language2) {
+ language2.diagnosticsReceived(kind, resource, this.createMarkerDatas(diagnostics));
}
}
createMarkerDatas(diagnostics) {
};
});
}
+ let tags = [];
+ if (diagnostic.reportsUnnecessary) {
+ tags.push(import_vscode_languageserver_protocol23.DiagnosticTag.Unnecessary);
+ }
+ if (diagnostic.reportsDeprecated) {
+ tags.push(import_vscode_languageserver_protocol23.DiagnosticTag.Deprecated);
+ }
+ tags = tags.length ? tags : void 0;
return {
range,
+ tags,
message: text,
code: diagnostic.code ? diagnostic.code : null,
severity: this.getDiagnosticSeverity(diagnostic),
+ reportDeprecated: diagnostic.reportsDeprecated,
reportUnnecessary: diagnostic.reportsUnnecessary,
source: diagnostic.source || "tsserver",
relatedInformation
}
getDiagnosticSeverity(diagnostic) {
if (this.reportStyleCheckAsWarnings && this.isStyleCheckDiagnostic(diagnostic.code) && diagnostic.category === DiagnosticCategory.error) {
- return import_vscode_languageserver_protocol22.DiagnosticSeverity.Warning;
+ return import_vscode_languageserver_protocol23.DiagnosticSeverity.Warning;
}
switch (diagnostic.category) {
case DiagnosticCategory.error:
- return import_vscode_languageserver_protocol22.DiagnosticSeverity.Error;
+ return import_vscode_languageserver_protocol23.DiagnosticSeverity.Error;
case DiagnosticCategory.warning:
- return import_vscode_languageserver_protocol22.DiagnosticSeverity.Warning;
+ return import_vscode_languageserver_protocol23.DiagnosticSeverity.Warning;
case DiagnosticCategory.suggestion:
- return import_vscode_languageserver_protocol22.DiagnosticSeverity.Information;
+ return import_vscode_languageserver_protocol23.DiagnosticSeverity.Information;
default:
- return import_vscode_languageserver_protocol22.DiagnosticSeverity.Error;
+ return import_vscode_languageserver_protocol23.DiagnosticSeverity.Error;
}
}
isStyleCheckDiagnostic(code) {
this.pluginManager = pluginManager;
this.id = "tsserver";
this.name = "tsserver";
- this.state = import_coc30.ServiceStat.Initial;
- this._onDidServiceReady = new import_vscode_languageserver_protocol23.Emitter();
+ this.state = import_coc35.ServiceStat.Initial;
+ this._onDidServiceReady = new import_vscode_languageserver_protocol24.Emitter();
this.onServiceReady = this._onDidServiceReady.event;
this.disposables = [];
this.descriptions = [];
- const config = import_coc30.workspace.getConfiguration("tsserver");
+ const config = import_coc35.workspace.getConfiguration("tsserver");
const enableJavascript = !!config.get("enableJavascript");
this.enable = config.get("enable");
this.descriptions = standardLanguageDescriptions.filter((o) => {
}, []);
}
get config() {
- return import_coc30.workspace.getConfiguration("tsserver");
+ return import_coc35.workspace.getConfiguration("tsserver");
}
getClientHost() {
- if (this.state == import_coc30.ServiceStat.Running)
+ if (this.state == import_coc35.ServiceStat.Running)
return Promise.resolve(this.clientHost);
this.start();
return new Promise((resolve, reject) => {
start() {
if (this.clientHost)
return;
- this.state = import_coc30.ServiceStat.Starting;
+ this.state = import_coc35.ServiceStat.Starting;
this.clientHost = new typescriptServiceClientHost_default(this.descriptions, this.pluginManager);
this.disposables.push(this.clientHost);
let client = this.clientHost.serviceClient;
});
}
dispose() {
- import_coc30.disposeAll(this.disposables);
+ import_coc35.disposeAll(this.disposables);
}
async restart() {
if (!this.clientHost)
var server_default = TsserverService;
// src/utils/plugins.ts
-var import_coc31 = __toModule(require("coc.nvim"));
-var import_vscode_languageserver_protocol24 = __toModule(require_main3());
+var import_coc36 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol25 = __toModule(require_main3());
var TypeScriptServerPlugin;
(function(TypeScriptServerPlugin2) {
function equals2(a, b) {
constructor() {
this._pluginConfigurations = new Map();
this._disposables = [];
- this._onDidUpdatePlugins = this._register(new import_vscode_languageserver_protocol24.Emitter());
+ this._onDidUpdatePlugins = this._register(new import_vscode_languageserver_protocol25.Emitter());
this.onDidChangePlugins = this._onDidUpdatePlugins.event;
- this._onDidUpdateConfig = this._register(new import_vscode_languageserver_protocol24.Emitter());
+ this._onDidUpdateConfig = this._register(new import_vscode_languageserver_protocol25.Emitter());
this.onDidUpdateConfig = this._onDidUpdateConfig.event;
let loadPlugins = () => {
if (!this._plugins) {
this._onDidUpdatePlugins.fire(this);
}
};
- import_coc31.extensions.onDidActiveExtension(loadPlugins, void 0, this._disposables);
- import_coc31.extensions.onDidUnloadExtension(loadPlugins, void 0, this._disposables);
+ import_coc36.extensions.onDidActiveExtension(loadPlugins, void 0, this._disposables);
+ import_coc36.extensions.onDidUnloadExtension(loadPlugins, void 0, this._disposables);
}
dispose() {
- import_coc31.disposeAll(this._disposables);
+ import_coc36.disposeAll(this._disposables);
}
get plugins() {
if (!this._plugins) {
}
readPlugins() {
const pluginMap = new Map();
- for (const extension of import_coc31.extensions.all) {
+ for (const extension of import_coc36.extensions.all) {
const pack = extension.packageJSON;
if (pack.contributes && Array.isArray(pack.contributes.typescriptServerPlugins)) {
const plugins = [];
// src/index.ts
async function activate(context) {
let {subscriptions, logger} = context;
- const config = import_coc32.workspace.getConfiguration().get("tsserver", {});
+ const config = import_coc37.workspace.getConfiguration().get("tsserver", {});
if (!config.enable)
return;
const pluginManager = new PluginManager();
const service = new server_default(pluginManager);
function registCommand2(cmd) {
let {id, execute} = cmd;
- subscriptions.push(import_coc32.commands.registerCommand(id, execute, cmd));
+ subscriptions.push(import_coc37.commands.registerCommand(id, execute, cmd));
}
registCommand2(new ConfigurePluginCommand(pluginManager));
registCommand2(new AutoFixCommand(service));
registCommand2(new ReloadProjectsCommand(service));
+ registCommand2(new FileReferencesCommand(service));
registCommand2(new OpenTsServerLogCommand(service));
registCommand2(new TypeScriptGoToProjectConfigCommand(service));
registCommand2(new OrganizeImportsCommand(service));
}
});
service.start().then(() => {
- subscriptions.push(import_coc32.services.regist(service));
+ subscriptions.push(import_coc37.services.regist(service));
}, (e) => {
logger.error(`Error on service start:`, e);
});
projects / dotfiles / .git / blobdiff