monaco-editor
Version:
A browser based code editor
1,165 lines (1,162 loc) • 138 kB
JavaScript
import '../../../vs/editor/browser/coreCommands.js';
import '../../../vs/editor/browser/widget/codeEditor/codeEditorWidget.js';
import '../../../vs/editor/browser/widget/diffEditor/diffEditor.contribution.js';
import '../../../vs/editor/contrib/anchorSelect/browser/anchorSelect.js';
import '../../../vs/editor/contrib/bracketMatching/browser/bracketMatching.js';
import '../../../vs/editor/contrib/caretOperations/browser/caretOperations.js';
import '../../../vs/editor/contrib/caretOperations/browser/transpose.js';
import '../../../vs/editor/contrib/clipboard/browser/clipboard.js';
import '../../../vs/editor/contrib/codeAction/browser/codeActionContributions.js';
import '../../../vs/editor/contrib/codelens/browser/codelensController.js';
import '../../../vs/editor/contrib/colorPicker/browser/colorPickerContribution.js';
import '../../../vs/editor/contrib/comment/browser/comment.js';
import '../../../vs/editor/contrib/contextmenu/browser/contextmenu.js';
import '../../../vs/editor/contrib/cursorUndo/browser/cursorUndo.js';
import '../../../vs/editor/contrib/dnd/browser/dnd.js';
import '../../../vs/editor/contrib/dropOrPasteInto/browser/copyPasteContribution.js';
import '../../../vs/editor/contrib/dropOrPasteInto/browser/dropIntoEditorContribution.js';
import '../../../vs/editor/contrib/find/browser/findController.js';
import '../../../vs/editor/contrib/folding/browser/folding.js';
import '../../../vs/editor/contrib/fontZoom/browser/fontZoom.js';
import '../../../vs/editor/contrib/format/browser/formatActions.js';
import '../../../vs/editor/contrib/documentSymbols/browser/documentSymbols.js';
import '../../../vs/editor/contrib/inlineCompletions/browser/inlineCompletions.contribution.js';
import '../../../vs/editor/contrib/inlineProgress/browser/inlineProgress.js';
import '../../../vs/editor/contrib/gotoSymbol/browser/goToCommands.js';
import '../../../vs/editor/contrib/gotoSymbol/browser/link/goToDefinitionAtPosition.js';
import '../../../vs/editor/contrib/gotoError/browser/gotoError.js';
import '../../../vs/editor/contrib/gpu/browser/gpuActions.js';
import '../../../vs/editor/contrib/hover/browser/hoverContribution.js';
import '../../../vs/editor/contrib/indentation/browser/indentation.js';
import '../../../vs/editor/contrib/inlayHints/browser/inlayHintsContribution.js';
import '../../../vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace.js';
import '../../../vs/editor/contrib/insertFinalNewLine/browser/insertFinalNewLine.js';
import '../../../vs/editor/contrib/lineSelection/browser/lineSelection.js';
import '../../../vs/editor/contrib/linesOperations/browser/linesOperations.js';
import '../../../vs/editor/contrib/linkedEditing/browser/linkedEditing.js';
import '../../../vs/editor/contrib/links/browser/links.js';
import '../../../vs/editor/contrib/longLinesHelper/browser/longLinesHelper.js';
import '../../../vs/editor/contrib/middleScroll/browser/middleScroll.contribution.js';
import '../../../vs/editor/contrib/multicursor/browser/multicursor.js';
import '../../../vs/editor/contrib/parameterHints/browser/parameterHints.js';
import '../../../vs/editor/contrib/placeholderText/browser/placeholderText.contribution.js';
import '../../../vs/editor/contrib/rename/browser/rename.js';
import '../../../vs/editor/contrib/sectionHeaders/browser/sectionHeaders.js';
import '../../../vs/editor/contrib/semanticTokens/browser/documentSemanticTokens.js';
import '../../../vs/editor/contrib/semanticTokens/browser/viewportSemanticTokens.js';
import '../../../vs/editor/contrib/smartSelect/browser/smartSelect.js';
import '../../../vs/editor/contrib/snippet/browser/snippetController2.js';
import '../../../vs/editor/contrib/stickyScroll/browser/stickyScrollContribution.js';
import '../../../vs/editor/contrib/suggest/browser/suggestController.js';
import '../../../vs/editor/contrib/suggest/browser/suggestInlineCompletions.js';
import '../../../vs/editor/contrib/tokenization/browser/tokenization.js';
import '../../../vs/editor/contrib/toggleTabFocusMode/browser/toggleTabFocusMode.js';
import '../../../vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter.js';
import '../../../vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators.js';
import '../../../vs/editor/contrib/wordHighlighter/browser/wordHighlighter.js';
import '../../../vs/editor/contrib/wordOperations/browser/wordOperations.js';
import '../../../vs/editor/contrib/wordPartOperations/browser/wordPartOperations.js';
import '../../../vs/editor/contrib/readOnlyMessage/browser/contribution.js';
import '../../../vs/editor/contrib/diffEditorBreadcrumbs/browser/contribution.js';
import '../../../vs/editor/contrib/floatingMenu/browser/floatingMenu.contribution.js';
import '../../../vs/editor/common/standaloneStrings.js';
import '../../../vs/base/browser/ui/codicons/codicon/codicon.css';
import '../../../vs/base/browser/ui/codicons/codicon/codicon-modifiers.css';
import '../../../vs/editor/standalone/browser/iPadShowKeyboard/iPadShowKeyboard.js';
import '../../../vs/editor/standalone/browser/inspectTokens/inspectTokens.js';
import '../../../vs/editor/standalone/browser/quickAccess/standaloneHelpQuickAccess.js';
import '../../../vs/editor/standalone/browser/quickAccess/standaloneGotoLineQuickAccess.js';
import '../../../vs/editor/standalone/browser/quickAccess/standaloneGotoSymbolQuickAccess.js';
import '../../../vs/editor/standalone/browser/quickAccess/standaloneCommandsQuickAccess.js';
import '../../../vs/editor/standalone/browser/referenceSearch/standaloneReferenceSearch.js';
import '../../../vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast.js';
import { languages, MarkerSeverity, MarkerTag, editor, Position, Range, Emitter, Uri } from '../../../vs/editor/editor.api2.js';
var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
var _a, _b, _c, _d, _e;
function isRequestOrNotification(msg) {
return msg.method !== void 0;
}
var ErrorObject;
(function(ErrorObject$1) {
function create(obj) {
return obj;
}
ErrorObject$1.create = create;
})(ErrorObject || (ErrorObject = {}));
var ErrorCode;
(function(ErrorCode$1) {
ErrorCode$1.parseError = -32700;
ErrorCode$1.invalidRequest = -32600;
ErrorCode$1.methodNotFound = -32601;
ErrorCode$1.invalidParams = -32602;
ErrorCode$1.internalError = -32603;
function isServerError(code) {
return -32099 <= code && code <= -32e3;
}
ErrorCode$1.isServerError = isServerError;
function serverError(code) {
if (!isServerError(code)) throw new Error("Invalid range for a server error.");
return code;
}
ErrorCode$1.serverError = serverError;
ErrorCode$1.unexpectedServerError = -32e3;
function isApplicationError(code) {
return true;
}
ErrorCode$1.isApplicationError = isApplicationError;
function applicationError(code) {
return code;
}
ErrorCode$1.applicationError = applicationError;
ErrorCode$1.genericApplicationError = -320100;
})(ErrorCode || (ErrorCode = {}));
var EventEmitter = class {
constructor() {
__publicField(this, "listeners", /* @__PURE__ */ new Set());
__publicField(this, "event", (listener) => {
this.listeners.add(listener);
return { dispose: () => {
this.listeners.delete(listener);
} };
});
}
fire(args) {
this.listeners.forEach((listener) => listener(args));
}
};
var ValueWithChangeEvent = class {
constructor(initialValue) {
__publicField(this, "_value");
__publicField(this, "eventEmitter");
this._value = initialValue;
this.eventEmitter = new EventEmitter();
}
get value() {
return this._value;
}
set value(newValue) {
if (this._value !== newValue) {
this._value = newValue;
this.eventEmitter.fire(newValue);
}
}
get onChange() {
return this.eventEmitter.event;
}
};
function createTimeout(delay, callback) {
const handle = setTimeout(callback, delay);
return { dispose: () => clearTimeout(handle) };
}
function setAndDeleteOnDispose(set, keyOrItem, item) {
if (set instanceof Set) {
set.add(keyOrItem);
return { dispose: () => set.delete(keyOrItem) };
} else {
set.set(keyOrItem, item);
return { dispose: () => set.delete(keyOrItem) };
}
}
var Deferred = class {
constructor() {
__publicField(this, "_state", "none");
__publicField(this, "promise");
__publicField(this, "resolve", () => {
});
__publicField(this, "reject", () => {
});
this.promise = new Promise((resolve, reject) => {
this.resolve = resolve;
this.reject = reject;
});
}
get state() {
return this._state;
}
};
var BaseMessageTransport = (_a = class {
constructor() {
__publicField(this, "_unprocessedMessages", []);
__publicField(this, "_messageListener");
__publicField(this, "id", _a.id++);
__publicField(this, "_state", new ValueWithChangeEvent({ state: "open" }));
__publicField(this, "state", this._state);
}
/**
* Sets a callback for incoming messages.
*/
setListener(listener) {
this._messageListener = listener;
if (!listener) return;
while (this._unprocessedMessages.length > 0 && this._messageListener !== void 0) {
const msg = this._unprocessedMessages.shift();
this._messageListener(msg);
}
}
/**
* Writes a message to the stream.
*/
send(message) {
return this._sendImpl(message);
}
/**
* Call this in derived classes to signal a new message.
*/
_dispatchReceivedMessage(message) {
if (this._unprocessedMessages.length === 0 && this._messageListener) this._messageListener(message);
else this._unprocessedMessages.push(message);
}
/**
* Call this in derived classes to signal that the connection closed.
*/
_onConnectionClosed() {
this._state.value = {
state: "closed",
error: void 0
};
}
log(logger) {
return new StreamLogger(this, logger ?? new ConsoleMessageLogger());
}
}, __publicField(_a, "id", 0), _a);
var StreamLogger = class {
constructor(baseStream, logger) {
__publicField(this, "baseStream");
__publicField(this, "logger");
this.baseStream = baseStream;
this.logger = logger;
}
get state() {
return this.baseStream.state;
}
setListener(listener) {
if (listener === void 0) {
this.baseStream.setListener(void 0);
return;
}
this.baseStream.setListener((readMessage) => {
this.logger.log(this.baseStream, "incoming", readMessage);
listener(readMessage);
});
}
send(message) {
this.logger.log(this.baseStream, "outgoing", message);
return this.baseStream.send(message);
}
toString() {
return `StreamLogger/${this.baseStream.toString()}`;
}
};
var ConsoleMessageLogger = class {
log(stream, type, message) {
const char = type === "incoming" ? "<-" : "->";
console.log(`${char} [${stream.toString()}] ${JSON.stringify(message)}`);
}
};
var Channel = class Channel2 {
constructor(connect) {
__publicField(this, "connect");
this.connect = connect;
}
mapContext(map) {
return new Channel2((listener) => this.connect(listener ? mapRequestHandlerContext(listener, map) : void 0));
}
};
function mapRequestHandlerContext(messageHandler, map) {
return {
handleNotification: (request, context) => messageHandler.handleNotification(request, map(context)),
handleRequest: (request, requestId, context) => messageHandler.handleRequest(request, requestId, map(context))
};
}
var StreamBasedChannel = class StreamBasedChannel2 {
constructor(_stream, _listener, _logger) {
__publicField(this, "_stream");
__publicField(this, "_listener");
__publicField(this, "_logger");
__publicField(this, "_unprocessedResponses", /* @__PURE__ */ new Map());
__publicField(this, "_lastUsedRequestId", 0);
this._stream = _stream;
this._listener = _listener;
this._logger = _logger;
this._stream.setListener((message) => {
if (isRequestOrNotification(message)) if (message.id === void 0) this._processNotification(message);
else this._processRequest(message);
else this._processResponse(message);
});
}
/**
* Creates a channel factory from a given stream and logger.
* This allows to delay specifying a `RequestHandler`.
* Once the channel is created, it processes incoming messages.
*/
static createChannel(stream, logger) {
let constructed = false;
return new Channel((listener) => {
if (constructed) throw new Error(`A channel to the stream ${stream} was already constructed!`);
else constructed = true;
return new StreamBasedChannel2(stream, listener, logger);
});
}
get state() {
return this._stream.state;
}
async _processNotification(message) {
if (message.id !== void 0) throw new Error();
if (!this._listener) {
if (this._logger) this._logger.debug({
text: "Notification ignored",
message
});
return;
}
try {
await this._listener.handleNotification({
method: message.method,
params: message.params || null
});
} catch (exception) {
if (this._logger) this._logger.warn({
text: `Exception was thrown while handling notification: ${exception}`,
exception,
message
});
}
}
async _processRequest(message) {
if (message.id === void 0) throw new Error();
let result;
if (this._listener) try {
result = await this._listener.handleRequest({
method: message.method,
params: message.params || null
}, message.id);
} catch (exception) {
if (this._logger) this._logger.warn({
text: `Exception was thrown while handling request: ${exception}`,
message,
exception
});
result = { error: {
code: ErrorCode.internalError,
message: "An unexpected exception was thrown.",
data: void 0
} };
}
else {
if (this._logger) this._logger.debug({
text: "Received request even though not listening for requests",
message
});
result = { error: {
code: ErrorCode.methodNotFound,
message: "This endpoint does not listen for requests or notifications.",
data: void 0
} };
}
let responseMsg;
if ("result" in result) responseMsg = {
jsonrpc: "2.0",
id: message.id,
result: result.result
};
else responseMsg = {
jsonrpc: "2.0",
id: message.id,
error: result.error
};
await this._stream.send(responseMsg);
}
_processResponse(message) {
const strId = "" + message.id;
const callback = this._unprocessedResponses.get(strId);
if (!callback) {
if (this._logger) this._logger.debug({
text: "Got an unexpected response message",
message
});
return;
}
this._unprocessedResponses.delete(strId);
callback(message);
}
_newRequestId() {
return this._lastUsedRequestId++;
}
sendRequest(request, _context, messageIdCallback) {
const message = {
jsonrpc: "2.0",
id: this._newRequestId(),
method: request.method,
params: request.params || void 0
};
if (messageIdCallback) messageIdCallback(message.id);
return new Promise((resolve, reject) => {
const strId = "" + message.id;
this._unprocessedResponses.set(strId, (response) => {
if ("result" in response) resolve({ result: response.result });
else {
if (!response.error) reject(/* @__PURE__ */ new Error("Response had neither 'result' nor 'error' field set."));
resolve({ error: response.error });
}
});
this._stream.send(message).then(void 0, (reason) => {
this._unprocessedResponses.delete(strId);
reject(reason);
});
});
}
sendNotification(notification, context) {
const msg = {
jsonrpc: "2.0",
id: void 0,
method: notification.method,
params: notification.params || void 0
};
return this._stream.send(msg);
}
toString() {
return "StreamChannel/" + this._stream.toString();
}
};
var Serializers;
(function(Serializers$1) {
function sAny() {
return {
deserializeFromJson: (input) => ({
hasErrors: false,
value: input
}),
serializeToJson: (input) => input
};
}
Serializers$1.sAny = sAny;
function sEmptyObject() {
return {
deserializeFromJson: (input) => ({
hasErrors: false,
value: {}
}),
serializeToJson: (input) => ({})
};
}
Serializers$1.sEmptyObject = sEmptyObject;
function sVoidFromNull() {
return {
deserializeFromJson: (input) => ({
hasErrors: false,
value: void 0
}),
serializeToJson: (input) => null
};
}
Serializers$1.sVoidFromNull = sVoidFromNull;
})(Serializers || (Serializers = {}));
const OptionalMethodNotFound = Symbol("OptionalMethodNotFound");
var TypedChannelBase = class {
contextualize(args) {
return new ContextualizedTypedChannel(this, args);
}
};
var ContextualizedTypedChannel = class extends TypedChannelBase {
constructor(underylingTypedChannel, converters) {
super();
__publicField(this, "underylingTypedChannel");
__publicField(this, "converters");
this.underylingTypedChannel = underylingTypedChannel;
this.converters = converters;
}
async request(requestType, args, newContext) {
const context = await this.converters.getSendContext(newContext);
return this.underylingTypedChannel.request(requestType, args, context);
}
async notify(notificationType, params, newContext) {
const context = await this.converters.getSendContext(newContext);
return this.underylingTypedChannel.notify(notificationType, params, context);
}
registerNotificationHandler(type, handler) {
return this.underylingTypedChannel.registerNotificationHandler(type, async (arg, context) => {
return await handler(arg, await this.converters.getNewContext(context));
});
}
registerRequestHandler(requestType, handler) {
return this.underylingTypedChannel.registerRequestHandler(requestType, async (arg, requestId, context) => {
return await handler(arg, requestId, await this.converters.getNewContext(context));
});
}
};
var TypedChannel = class TypedChannel2 extends TypedChannelBase {
constructor(channelCtor, options = {}) {
super();
__publicField(this, "channelCtor");
__publicField(this, "_requestSender");
__publicField(this, "_handler", /* @__PURE__ */ new Map());
__publicField(this, "_unknownNotificationHandler", /* @__PURE__ */ new Set());
__publicField(this, "_timeout");
__publicField(this, "sendExceptionDetails", false);
__publicField(this, "_logger");
__publicField(this, "listeningDeferred", new Deferred());
__publicField(this, "onListening", this.listeningDeferred.promise);
__publicField(this, "_requestDidErrorEventEmitter", new EventEmitter());
__publicField(this, "onRequestDidError", this._requestDidErrorEventEmitter.event);
this.channelCtor = channelCtor;
this._logger = options.logger;
this.sendExceptionDetails = !!options.sendExceptionDetails;
this._timeout = createTimeout(1e3, () => {
if (!this._requestSender) console.warn(`"${this.startListen.name}" has not been called within 1 second after construction of this channel. Did you forget to call it?`, this);
});
}
static fromTransport(stream, options = {}) {
return new TypedChannel2(StreamBasedChannel.createChannel(stream, options.logger), options);
}
/**
* This method must be called to forward messages from the stream to this channel.
* This is not done automatically on construction so that this instance
* can be setup properly before handling messages.
*/
startListen() {
if (this._requestSender) throw new Error(`"${this.startListen.name}" can be called only once, but it already has been called.`);
if (this._timeout) {
this._timeout.dispose();
this._timeout = void 0;
}
this._requestSender = this.channelCtor.connect({
handleRequest: (req, id, context) => this.handleRequest(req, id, context),
handleNotification: (req, context) => this.handleNotification(req, context)
});
this.listeningDeferred.resolve();
}
checkChannel(channel) {
if (!channel) throw new Error(`"${this.startListen.name}" must be called before any messages can be sent or received.`);
return true;
}
async handleRequest(request, requestId, context) {
const handler = this._handler.get(request.method);
if (!handler) {
if (this._logger) this._logger.debug({
text: `No request handler for "${request.method}".`,
data: { requestObject: request }
});
return { error: {
code: ErrorCode.methodNotFound,
message: `No request handler for "${request.method}".`,
data: { method: request.method }
} };
}
if (handler.kind != "request") {
const message = `"${request.method}" is registered as notification, but was sent as request.`;
if (this._logger) this._logger.debug({
text: message,
data: { requestObject: request }
});
return { error: {
code: ErrorCode.invalidRequest,
message,
data: { method: request.method }
} };
}
const decodeResult = handler.requestType.paramsSerializer.deserializeFromJson(request.params);
if (decodeResult.hasErrors) {
const message = `Got invalid params: ${decodeResult.errorMessage}`;
if (this._logger) this._logger.debug({
text: message,
data: {
requestObject: request,
errorMessage: decodeResult.errorMessage
}
});
return { error: {
code: ErrorCode.invalidParams,
message,
data: { errors: decodeResult.errorMessage }
} };
} else {
const args = decodeResult.value;
let response;
try {
const result = await handler.handler(args, requestId, context);
if ("error" in result || "errorMessage" in result) {
const errorData = result.error ? handler.requestType.errorSerializer.serializeToJson(result.error) : void 0;
response = { error: {
code: result.errorCode || ErrorCode.genericApplicationError,
message: result.errorMessage || "An error was returned",
data: errorData
} };
} else response = { result: handler.requestType.resultSerializer.serializeToJson(result.ok) };
} catch (exception) {
if (exception instanceof RequestHandlingError) response = { error: {
code: exception.code,
message: exception.message
} };
else {
if (this._logger) this._logger.warn({
text: `An exception was thrown while handling a request: ${exception}.`,
exception,
data: { requestObject: request }
});
response = { error: {
code: ErrorCode.unexpectedServerError,
message: this.sendExceptionDetails ? `An exception was thrown while handling a request: ${exception}.` : "Server has thrown an unexpected exception"
} };
}
}
return response;
}
}
async handleNotification(request, context) {
const handler = this._handler.get(request.method);
if (!handler) {
for (const h of this._unknownNotificationHandler) h(request);
if (this._unknownNotificationHandler.size === 0) {
if (this._logger) this._logger.debug({
text: `Unhandled notification "${request.method}"`,
data: { requestObject: request }
});
}
return;
}
if (handler.kind != "notification") {
if (this._logger) this._logger.debug({
text: `"${request.method}" is registered as request, but was sent as notification.`,
data: { requestObject: request }
});
return;
}
const decodeResult = handler.notificationType.paramsSerializer.deserializeFromJson(request.params);
if (decodeResult.hasErrors) {
if (this._logger) this._logger.debug({
text: `Got invalid params: ${decodeResult}`,
data: {
requestObject: request,
errorMessage: decodeResult.errorMessage
}
});
return;
}
const val = decodeResult.value;
for (const handlerFunc of handler.handlers) try {
handlerFunc(val, context);
} catch (exception) {
if (this._logger) this._logger.warn({
text: `An exception was thrown while handling a notification: ${exception}.`,
exception,
data: { requestObject: request }
});
}
}
registerUnknownNotificationHandler(handler) {
return setAndDeleteOnDispose(this._unknownNotificationHandler, handler);
}
registerRequestHandler(requestType, handler) {
if (this._handler.get(requestType.method)) throw new Error(`Handler with method "${requestType.method}" already registered.`);
return setAndDeleteOnDispose(this._handler, requestType.method, {
kind: "request",
requestType,
handler
});
}
registerNotificationHandler(type, handler) {
let registeredHandler = this._handler.get(type.method);
if (!registeredHandler) {
registeredHandler = {
kind: "notification",
notificationType: type,
handlers: /* @__PURE__ */ new Set()
};
this._handler.set(type.method, registeredHandler);
} else {
if (registeredHandler.kind !== "notification") throw new Error(`Method "${type.method}" was already registered as request handler.`);
if (registeredHandler.notificationType !== type) throw new Error(`Method "${type.method}" was registered for a different type.`);
}
return setAndDeleteOnDispose(registeredHandler.handlers, handler);
}
getRegisteredTypes() {
const result = [];
for (const h of this._handler.values()) if (h.kind === "notification") result.push(h.notificationType);
else if (h.kind === "request") result.push(h.requestType);
return result;
}
async request(requestType, args, context) {
if (!this.checkChannel(this._requestSender)) throw new Error("Impossible");
const params = requestType.paramsSerializer.serializeToJson(args);
assertObjectArrayOrNull(params);
const response = await this._requestSender.sendRequest({
method: requestType.method,
params
}, context);
if ("error" in response) {
if (requestType.isOptional && response.error.code === ErrorCode.methodNotFound) return OptionalMethodNotFound;
let errorData;
if (response.error.data !== void 0) {
const deserializationResult = requestType.errorSerializer.deserializeFromJson(response.error.data);
if (deserializationResult.hasErrors) throw new Error(deserializationResult.errorMessage);
errorData = deserializationResult.value;
} else errorData = void 0;
const error = new RequestHandlingError(response.error.message, errorData, response.error.code);
this._requestDidErrorEventEmitter.fire({ error });
throw error;
} else {
const result = requestType.resultSerializer.deserializeFromJson(response.result);
if (result.hasErrors) throw new Error("Could not deserialize response: " + result.errorMessage + `
${JSON.stringify(response, null, 2)}`);
else return result.value;
}
}
async notify(notificationType, params, context) {
if (!this.checkChannel(this._requestSender)) throw new Error();
const encodedParams = notificationType.paramsSerializer.serializeToJson(params);
assertObjectArrayOrNull(encodedParams);
this._requestSender.sendNotification({
method: notificationType.method,
params: encodedParams
}, context);
}
};
function assertObjectArrayOrNull(val) {
if (val !== null && Array.isArray(val) && typeof val !== "object") throw new Error("Invalid value! Only null, array and object is allowed.");
}
var RequestHandlingError = class RequestHandlingError2 extends Error {
constructor(message, data, code = ErrorCode.genericApplicationError) {
super(message);
__publicField(this, "data");
__publicField(this, "code");
this.data = data;
this.code = code;
Object.setPrototypeOf(this, RequestHandlingError2.prototype);
}
};
var RequestType = class RequestType2 {
constructor(method, paramsSerializer, resultSerializer, errorSerializer, isOptional = false) {
__publicField(this, "method");
__publicField(this, "paramsSerializer");
__publicField(this, "resultSerializer");
__publicField(this, "errorSerializer");
__publicField(this, "isOptional");
__publicField(this, "kind", "request");
this.method = method;
this.paramsSerializer = paramsSerializer;
this.resultSerializer = resultSerializer;
this.errorSerializer = errorSerializer;
this.isOptional = isOptional;
}
withMethod(method) {
return new RequestType2(method, this.paramsSerializer, this.resultSerializer, this.errorSerializer);
}
optional() {
return new RequestType2(this.method, this.paramsSerializer, this.resultSerializer, this.errorSerializer, true);
}
};
var NotificationType = class NotificationType2 {
constructor(method, paramsSerializer) {
__publicField(this, "method");
__publicField(this, "paramsSerializer");
__publicField(this, "kind", "notification");
this.method = method;
this.paramsSerializer = paramsSerializer;
}
withMethod(method) {
return new NotificationType2(method, this.paramsSerializer);
}
};
function unverifiedRequest(request) {
return new RequestType((request || {}).method, Serializers.sAny(), Serializers.sAny(), Serializers.sAny());
}
function unverifiedNotification(request) {
return new NotificationType((request || {}).method, Serializers.sAny());
}
const IsErrorWrapper = Symbol();
var ErrorWrapper = (_b = IsErrorWrapper, _c = class {
constructor(error) {
__publicField(this, "error");
__publicField(this, _b);
this.error = error;
}
}, __publicField(_c, "factory", (error) => {
return new _c(error);
}), _c);
function contract(contractObj) {
const server = transform(contractObj["server"]);
const client = transform(contractObj["client"]);
return new Contract(contractObj.tags || [], server, client);
}
function transform(requestMap) {
const result = {};
for (const [key, req] of Object.entries(requestMap)) {
const method = req.method ? req.method : key;
result[key] = req.withMethod(method);
}
return result;
}
var Contract = class Contract2 {
constructor(tags = [], server, client) {
__publicField(this, "tags");
__publicField(this, "server");
__publicField(this, "client");
this.tags = tags;
this.server = server;
this.client = client;
}
_onlyDesignTime() {
return /* @__PURE__ */ new Error("This property is not meant to be accessed at runtime");
}
get TContractObject() {
throw this._onlyDesignTime();
}
get TClientInterface() {
throw this._onlyDesignTime();
}
get TServerInterface() {
throw this._onlyDesignTime();
}
get TClientHandler() {
throw this._onlyDesignTime();
}
get TServerHandler() {
throw this._onlyDesignTime();
}
get TTags() {
throw this._onlyDesignTime();
}
getInterface(typedChannel, myContract, otherContract, myInterface) {
const counterpart = this.buildCounterpart(typedChannel, otherContract);
const disposable = this.registerHandlers(typedChannel, myContract, myInterface, counterpart);
return {
counterpart,
dispose: () => disposable.dispose()
};
}
buildCounterpart(typedChannel, otherContract) {
const counterpart = {};
for (const [key, req] of Object.entries(otherContract)) {
let method;
if (req.kind === "request") if (req.isOptional) method = async (args, context) => {
if (args === void 0) args = {};
try {
return await typedChannel.request(req, args, context);
} catch (error) {
if (error && error.code === ErrorCode.methodNotFound) return OptionalMethodNotFound;
throw error;
}
};
else method = (args, context) => {
if (args === void 0) args = {};
return typedChannel.request(req, args, context);
};
else method = (args, context) => {
if (args === void 0) args = {};
return typedChannel.notify(req, args, context);
};
counterpart[key] = method;
}
return counterpart;
}
registerHandlers(typedChannel, myContract, myInterface, counterpart) {
const disposables = [];
for (const [key, req] of Object.entries(myContract)) if (req.kind === "request") {
let method = myInterface[key];
if (!method) continue;
const handler = this.createRequestHandler(counterpart, method);
disposables.push(typedChannel.registerRequestHandler(req, handler));
} else {
const method = myInterface[key];
if (method) disposables.push(typedChannel.registerNotificationHandler(req, (args, context) => {
method(args, {
context,
counterpart
});
}));
}
return { dispose: () => disposables.forEach((d) => d.dispose()) };
}
createRequestHandler(counterpart, method) {
return async (args, requestId, listenerContext) => {
const result = await method(args, {
context: listenerContext,
counterpart,
newErr: ErrorWrapper.factory,
requestId
});
if (result instanceof ErrorWrapper) return result.error;
return { ok: result };
};
}
/**
* Gets a server object directly from a stream by constructing a new `TypedChannel`.
* It also registers the client implementation to the stream.
* The channel starts listening immediately.
*/
static getServerFromStream(contract$1, stream, options, clientImplementation) {
const channel = TypedChannel.fromTransport(stream, options);
const { server } = contract$1.getServer(channel, clientImplementation);
channel.startListen();
return {
channel,
server
};
}
/**
* Gets a client object directly from a stream by constructing a new `TypedChannel`.
* It also registers the server implementation to the stream.
* The channel starts listening immediately.
*/
static registerServerToStream(contract$1, stream, options, serverImplementation) {
const channel = TypedChannel.fromTransport(stream, options);
const { client } = contract$1.registerServer(channel, serverImplementation);
channel.startListen();
return {
channel,
client
};
}
getServer(typedChannel, clientImplementation) {
const { counterpart, dispose } = this.getInterface(typedChannel, this.client, this.server, clientImplementation);
return {
server: counterpart,
dispose
};
}
registerServer(typedChannel, serverImplementation) {
const { counterpart, dispose } = this.getInterface(typedChannel, this.server, this.client, serverImplementation);
return {
client: counterpart,
dispose
};
}
withContext() {
return new Contract2(this.tags, this.server, this.client);
}
};
let FoldingRangeKind = /* @__PURE__ */ (function(FoldingRangeKind$1) {
FoldingRangeKind$1["Comment"] = "comment";
FoldingRangeKind$1["Imports"] = "imports";
FoldingRangeKind$1["Region"] = "region";
return FoldingRangeKind$1;
})({});
let SymbolKind = /* @__PURE__ */ (function(SymbolKind$1) {
SymbolKind$1[SymbolKind$1["File"] = 1] = "File";
SymbolKind$1[SymbolKind$1["Module"] = 2] = "Module";
SymbolKind$1[SymbolKind$1["Namespace"] = 3] = "Namespace";
SymbolKind$1[SymbolKind$1["Package"] = 4] = "Package";
SymbolKind$1[SymbolKind$1["Class"] = 5] = "Class";
SymbolKind$1[SymbolKind$1["Method"] = 6] = "Method";
SymbolKind$1[SymbolKind$1["Property"] = 7] = "Property";
SymbolKind$1[SymbolKind$1["Field"] = 8] = "Field";
SymbolKind$1[SymbolKind$1["Constructor"] = 9] = "Constructor";
SymbolKind$1[SymbolKind$1["Enum"] = 10] = "Enum";
SymbolKind$1[SymbolKind$1["Interface"] = 11] = "Interface";
SymbolKind$1[SymbolKind$1["Function"] = 12] = "Function";
SymbolKind$1[SymbolKind$1["Variable"] = 13] = "Variable";
SymbolKind$1[SymbolKind$1["Constant"] = 14] = "Constant";
SymbolKind$1[SymbolKind$1["String"] = 15] = "String";
SymbolKind$1[SymbolKind$1["Number"] = 16] = "Number";
SymbolKind$1[SymbolKind$1["Boolean"] = 17] = "Boolean";
SymbolKind$1[SymbolKind$1["Array"] = 18] = "Array";
SymbolKind$1[SymbolKind$1["Object"] = 19] = "Object";
SymbolKind$1[SymbolKind$1["Key"] = 20] = "Key";
SymbolKind$1[SymbolKind$1["Null"] = 21] = "Null";
SymbolKind$1[SymbolKind$1["EnumMember"] = 22] = "EnumMember";
SymbolKind$1[SymbolKind$1["Struct"] = 23] = "Struct";
SymbolKind$1[SymbolKind$1["Event"] = 24] = "Event";
SymbolKind$1[SymbolKind$1["Operator"] = 25] = "Operator";
SymbolKind$1[SymbolKind$1["TypeParameter"] = 26] = "TypeParameter";
return SymbolKind$1;
})({});
let SymbolTag = /* @__PURE__ */ (function(SymbolTag$1) {
SymbolTag$1[SymbolTag$1["Deprecated"] = 1] = "Deprecated";
return SymbolTag$1;
})({});
let InlayHintKind = /* @__PURE__ */ (function(InlayHintKind$1) {
InlayHintKind$1[InlayHintKind$1["Type"] = 1] = "Type";
InlayHintKind$1[InlayHintKind$1["Parameter"] = 2] = "Parameter";
return InlayHintKind$1;
})({});
let TextDocumentSyncKind = /* @__PURE__ */ (function(TextDocumentSyncKind$1) {
TextDocumentSyncKind$1[TextDocumentSyncKind$1["None"] = 0] = "None";
TextDocumentSyncKind$1[TextDocumentSyncKind$1["Full"] = 1] = "Full";
TextDocumentSyncKind$1[TextDocumentSyncKind$1["Incremental"] = 2] = "Incremental";
return TextDocumentSyncKind$1;
})({});
let CompletionItemKind = /* @__PURE__ */ (function(CompletionItemKind$1) {
CompletionItemKind$1[CompletionItemKind$1["Text"] = 1] = "Text";
CompletionItemKind$1[CompletionItemKind$1["Method"] = 2] = "Method";
CompletionItemKind$1[CompletionItemKind$1["Function"] = 3] = "Function";
CompletionItemKind$1[CompletionItemKind$1["Constructor"] = 4] = "Constructor";
CompletionItemKind$1[CompletionItemKind$1["Field"] = 5] = "Field";
CompletionItemKind$1[CompletionItemKind$1["Variable"] = 6] = "Variable";
CompletionItemKind$1[CompletionItemKind$1["Class"] = 7] = "Class";
CompletionItemKind$1[CompletionItemKind$1["Interface"] = 8] = "Interface";
CompletionItemKind$1[CompletionItemKind$1["Module"] = 9] = "Module";
CompletionItemKind$1[CompletionItemKind$1["Property"] = 10] = "Property";
CompletionItemKind$1[CompletionItemKind$1["Unit"] = 11] = "Unit";
CompletionItemKind$1[CompletionItemKind$1["Value"] = 12] = "Value";
CompletionItemKind$1[CompletionItemKind$1["Enum"] = 13] = "Enum";
CompletionItemKind$1[CompletionItemKind$1["Keyword"] = 14] = "Keyword";
CompletionItemKind$1[CompletionItemKind$1["Snippet"] = 15] = "Snippet";
CompletionItemKind$1[CompletionItemKind$1["Color"] = 16] = "Color";
CompletionItemKind$1[CompletionItemKind$1["File"] = 17] = "File";
CompletionItemKind$1[CompletionItemKind$1["Reference"] = 18] = "Reference";
CompletionItemKind$1[CompletionItemKind$1["Folder"] = 19] = "Folder";
CompletionItemKind$1[CompletionItemKind$1["EnumMember"] = 20] = "EnumMember";
CompletionItemKind$1[CompletionItemKind$1["Constant"] = 21] = "Constant";
CompletionItemKind$1[CompletionItemKind$1["Struct"] = 22] = "Struct";
CompletionItemKind$1[CompletionItemKind$1["Event"] = 23] = "Event";
CompletionItemKind$1[CompletionItemKind$1["Operator"] = 24] = "Operator";
CompletionItemKind$1[CompletionItemKind$1["TypeParameter"] = 25] = "TypeParameter";
return CompletionItemKind$1;
})({});
let CompletionItemTag = /* @__PURE__ */ (function(CompletionItemTag$1) {
CompletionItemTag$1[CompletionItemTag$1["Deprecated"] = 1] = "Deprecated";
return CompletionItemTag$1;
})({});
let InsertTextFormat = /* @__PURE__ */ (function(InsertTextFormat$1) {
InsertTextFormat$1[InsertTextFormat$1["PlainText"] = 1] = "PlainText";
InsertTextFormat$1[InsertTextFormat$1["Snippet"] = 2] = "Snippet";
return InsertTextFormat$1;
})({});
let DocumentHighlightKind = /* @__PURE__ */ (function(DocumentHighlightKind$1) {
DocumentHighlightKind$1[DocumentHighlightKind$1["Text"] = 1] = "Text";
DocumentHighlightKind$1[DocumentHighlightKind$1["Read"] = 2] = "Read";
DocumentHighlightKind$1[DocumentHighlightKind$1["Write"] = 3] = "Write";
return DocumentHighlightKind$1;
})({});
let CodeActionKind = /* @__PURE__ */ (function(CodeActionKind$1) {
CodeActionKind$1["Empty"] = "";
CodeActionKind$1["QuickFix"] = "quickfix";
CodeActionKind$1["Refactor"] = "refactor";
CodeActionKind$1["RefactorExtract"] = "refactor.extract";
CodeActionKind$1["RefactorInline"] = "refactor.inline";
CodeActionKind$1["RefactorRewrite"] = "refactor.rewrite";
CodeActionKind$1["Source"] = "source";
CodeActionKind$1["SourceOrganizeImports"] = "source.organizeImports";
CodeActionKind$1["SourceFixAll"] = "source.fixAll";
return CodeActionKind$1;
})({});
let MarkupKind = /* @__PURE__ */ (function(MarkupKind$1) {
MarkupKind$1["PlainText"] = "plaintext";
MarkupKind$1["Markdown"] = "markdown";
return MarkupKind$1;
})({});
let DiagnosticSeverity = /* @__PURE__ */ (function(DiagnosticSeverity$1) {
DiagnosticSeverity$1[DiagnosticSeverity$1["Error"] = 1] = "Error";
DiagnosticSeverity$1[DiagnosticSeverity$1["Warning"] = 2] = "Warning";
DiagnosticSeverity$1[DiagnosticSeverity$1["Information"] = 3] = "Information";
DiagnosticSeverity$1[DiagnosticSeverity$1["Hint"] = 4] = "Hint";
return DiagnosticSeverity$1;
})({});
let DiagnosticTag = /* @__PURE__ */ (function(DiagnosticTag$1) {
DiagnosticTag$1[DiagnosticTag$1["Unnecessary"] = 1] = "Unnecessary";
DiagnosticTag$1[DiagnosticTag$1["Deprecated"] = 2] = "Deprecated";
return DiagnosticTag$1;
})({});
let CompletionTriggerKind = /* @__PURE__ */ (function(CompletionTriggerKind$1) {
CompletionTriggerKind$1[CompletionTriggerKind$1["Invoked"] = 1] = "Invoked";
CompletionTriggerKind$1[CompletionTriggerKind$1["TriggerCharacter"] = 2] = "TriggerCharacter";
CompletionTriggerKind$1[CompletionTriggerKind$1["TriggerForIncompleteCompletions"] = 3] = "TriggerForIncompleteCompletions";
return CompletionTriggerKind$1;
})({});
let SignatureHelpTriggerKind = /* @__PURE__ */ (function(SignatureHelpTriggerKind$1) {
SignatureHelpTriggerKind$1[SignatureHelpTriggerKind$1["Invoked"] = 1] = "Invoked";
SignatureHelpTriggerKind$1[SignatureHelpTriggerKind$1["TriggerCharacter"] = 2] = "TriggerCharacter";
SignatureHelpTriggerKind$1[SignatureHelpTriggerKind$1["ContentChange"] = 3] = "ContentChange";
return SignatureHelpTriggerKind$1;
})({});
let CodeActionTriggerKind = /* @__PURE__ */ (function(CodeActionTriggerKind$1) {
CodeActionTriggerKind$1[CodeActionTriggerKind$1["Invoked"] = 1] = "Invoked";
CodeActionTriggerKind$1[CodeActionTriggerKind$1["Automatic"] = 2] = "Automatic";
return CodeActionTriggerKind$1;
})({});
let TokenFormat = /* @__PURE__ */ (function(TokenFormat$1) {
TokenFormat$1["Relative"] = "relative";
return TokenFormat$1;
})({});
var Capability = class {
constructor(method) {
this.method = method;
}
};
const capabilities = {
textDocumentImplementation: new Capability("textDocument/implementation"),
textDocumentTypeDefinition: new Capability("textDocument/typeDefinition"),
textDocumentDocumentColor: new Capability("textDocument/documentColor"),
textDocumentColorPresentation: new Capability("textDocument/colorPresentation"),
textDocumentFoldingRange: new Capability("textDocument/foldingRange"),
textDocumentDeclaration: new Capability("textDocument/declaration"),
textDocumentSelectionRange: new Capability("textDocument/selectionRange"),
textDocumentPrepareCallHierarchy: new Capability("textDocument/prepareCallHierarchy"),
textDocumentSemanticTokensFull: new Capability("textDocument/semanticTokens/full"),
textDocumentSemanticTokensFullDelta: new Capability("textDocument/semanticTokens/full/delta"),
textDocumentLinkedEditingRange: new Capability("textDocument/linkedEditingRange"),
workspaceWillCreateFiles: new Capability("workspace/willCreateFiles"),
workspaceWillRenameFiles: new Capability("workspace/willRenameFiles"),
workspaceWillDeleteFiles: new Capability("workspace/willDeleteFiles"),
textDocumentMoniker: new Capability("textDocument/moniker"),
textDocumentPrepareTypeHierarchy: new Capability("textDocument/prepareTypeHierarchy"),
textDocumentInlineValue: new Capability("textDocument/inlineValue"),
textDocumentInlayHint: new Capability("textDocument/inlayHint"),
textDocumentDiagnostic: new Capability("textDocument/diagnostic"),
textDocumentInlineCompletion: new Capability("textDocument/inlineCompletion"),
textDocumentWillSaveWaitUntil: new Capability("textDocument/willSaveWaitUntil"),
textDocumentCompletion: new Capability("textDocument/completion"),
textDocumentHover: new Capability("textDocument/hover"),
textDocumentSignatureHelp: new Capability("textDocument/signatureHelp"),
textDocumentDefinition: new Capability("textDocument/definition"),
textDocumentReferences: new Capability("textDocument/references"),
textDocumentDocumentHighlight: new Capability("textDocument/documentHighlight"),
textDocumentDocumentSymbol: new Capability("textDocument/documentSymbol"),
textDocumentCodeAction: new Capability("textDocument/codeAction"),
workspaceSymbol: new Capability("workspace/symbol"),
textDocumentCodeLens: new Capability("textDocument/codeLens"),
textDocumentDocumentLink: new Capability("textDocument/documentLink"),
textDocumentFormatting: new Capability("textDocument/formatting"),
textDocumentRangeFormatting: new Capability("textDocument/rangeFormatting"),
textDocumentRangesFormatting: new Capability("textDocument/rangesFormatting"),
textDocumentOnTypeFormatting: new Capability("textDocument/onTypeFormatting"),
textDocumentRename: new Capability("textDocument/rename"),
workspaceExecuteCommand: new Capability("workspace/executeCommand"),
workspaceDidCreateFiles: new Capability("workspace/didCreateFiles"),
workspaceDidRenameFiles: new Capability("workspace/didRenameFiles"),
workspaceDidDeleteFiles: new Capability("workspace/didDeleteFiles"),
workspaceDidChangeConfiguration: new Capability("workspace/didChangeConfiguration"),
textDocumentDidOpen: new Capability("textDocument/didOpen"),
textDocumentDidChange: new Capability("textDocument/didChange"),
textDocumentDidClose: new Capability("textDocument/didClose"),
textDocumentDidSave: new Capability("textDocument/didSave"),
textDocumentWillSave: new Capability("textDocument/willSave"),
workspaceDidChangeWatchedFiles: new Capability("workspace/didChangeWatchedFiles")
};
const api = contract({
server: {
textDocumentImplementation: unverifiedRequest({ method: "textDocument/implementation" }),
textDocumentTypeDefinition: unverifiedRequest({ method: "textDocument/typeDefinition" }),
textDocumentDocumentColor: unverifiedRequest({ method: "textDocument/documentColor" }),
textDocumentColorPresentation: unverifiedRequest({ method: "textDocument/colorPresentation" }),
textDocumentFoldingRange: unverifiedRequest({ method: "textDocument/foldingRange" }),
textDocumentDeclaration: unverifiedRequest({ method: "textDocument/declaration" }),
textDocumentSelectionRange: unverifiedRequest({ method: "textDocument/selectionRange" }),
textDocumentPrepareCallHierarchy: unverifiedRequest({ method: "textDocument/prepareCallHierarchy" }),
callHierarchyIncomingCalls: unverifiedRequest({ method: "callHierarchy/incomingCalls" }),
callHierarchyOutgoingCalls: unverifiedRequest({ method: "callHierarchy/outgoingCalls" }),
textDocumentSemanticTokensFull: unverifiedRequest({ method: "textDocument/semanticTokens/full" }),
textDocumentSemanticTokensFullDelta: unverifiedRequest({ method: "textDocument/semanticTokens/full/delta" }),
textDocumentSemanticTokensRange: unverifiedRequest({ method: "textDocument/semanticTokens/range" }),
textDocumentLinkedEditingRange: unverifiedRequest({ method: "textDocument/linkedEditingRange" }),
workspaceWillCreateFiles: unverifiedRequest({ method: "workspace/willCreateFiles" }),
workspaceWillRenameFiles: unverifiedRequest({ method: "workspace/willRenameFiles" }),
workspaceWillDeleteFiles: unverifiedRequest({ method: "workspace/willDeleteFiles" }),
textDocumentMoniker: unverifiedRequest({ method: "textDocument/moniker" }),
textDocumentPrepareTypeHierarchy: unverifiedRequest({ method: "textDocument/prepareTypeHierarchy" }),
typeHierarchySupertypes: unverifiedRequest({ method: "typeHierarchy/supertypes" }),
typeHierarchySubtypes: unverifiedRequest({ method: "typeHierarchy/subtypes" }),
textDocumentInlineValue: unverifiedRequest({ method: "textDocument/inlineValue" }),
textDocumentInlayHint: unverifiedRequest({ method: "textDocument/inlayHint" }),
inlayHintResolve: unverifiedRequest({ method: "inlayHint/resolve" }),
textDocumentDiagnostic: unverifiedRequest({ method: "textDocument/diagnostic" }),
workspaceDiagnostic: unverifiedRequest({ method: "workspace/diagnostic" }),
textDocumentInlineCompletion: unverifiedRequest({ method: "textDocument/inlineCompletion" }),
initialize: unverifiedRequest({ method: "initialize" }),
shutdown: unverifiedRequest({ method: "shutdown" }),
textDocumentWillSaveWaitUntil: unverifiedRequest({ method: "textDocument/willSaveWaitUntil" }),
textDocumentCompletion: unverifiedRequest({ method: "textDocument/completion" }),
completionItemResolve: unverifiedRequest({ method: "completionItem/resolve" }),
textDocumentHover: unverifiedRequest({ method: "textDocument/hover" }),