{
+ return new Promise((resolve, reject) => {
+ glob(
+ './out/monaco-editor/esm/vs/language/*/monaco.contribution.js',
+ { cwd: path.dirname(__dirname) },
+ (err, files) => {
+ if (err) {
+ reject(err);
+ return;
+ }
+
+ resolve(
+ files
+ .map((file) => file.substring('./out/monaco-editor/esm/vs/language/'.length))
+ .map((file) => file.substring(0, file.length - '/monaco.contribution.js'.length))
+ );
+ }
+ );
+ });
+}
+
+function getAdvancedLanguages(): Promise<
+ { label: string; entry: string; worker: { id: string; entry: string } }[]
+> {
+ return readAdvancedLanguages().then((languages) => {
+ let result = [];
+ for (const lang of languages) {
+ let shortLang = lang === 'typescript' ? 'ts' : lang;
+ const entry = `vs/language/${lang}/monaco.contribution`;
+ checkFileExists(entry);
+ const workerId = `vs/language/${lang}/${shortLang}Worker`;
+ const workerEntry = `vs/language/${lang}/${shortLang}.worker`;
+ checkFileExists(workerEntry);
+ result.push({
+ label: lang,
+ entry: entry,
+ worker: {
+ id: workerId,
+ entry: workerEntry
+ }
+ });
+ }
+ return result;
+ });
+
+ function checkFileExists(moduleName) {
+ const filePath = path.join(REPO_ROOT, 'out/monaco-editor/esm', `${moduleName}.js`);
+ if (!fs.existsSync(filePath)) {
+ console.error(`Could not find ${filePath}.`);
+ process.exit(1);
+ }
+ }
+}
+
+export function generateEsmMetadataJsAndDTs() {
+ return Promise.all([getBasicLanguages(), getAdvancedLanguages()]).then(
+ ([basicLanguages, advancedLanguages]) => {
+ basicLanguages.sort((a, b) => strcmp(a.entry, b.entry));
+ advancedLanguages.sort((a, b) => strcmp(a.entry, b.entry));
+
+ let i = 0,
+ len = basicLanguages.length;
+ let j = 0,
+ lenJ = advancedLanguages.length;
+ let languages = [];
+ while (i < len || j < lenJ) {
+ if (i < len && j < lenJ) {
+ if (basicLanguages[i].label === advancedLanguages[j].label) {
+ let entry = [];
+ entry.push(basicLanguages[i].entry);
+ entry.push(advancedLanguages[j].entry);
+ languages.push({
+ label: basicLanguages[i].label,
+ entry: entry,
+ worker: advancedLanguages[j].worker
+ });
+ i++;
+ j++;
+ } else if (basicLanguages[i].label < advancedLanguages[j].label) {
+ languages.push(basicLanguages[i]);
+ i++;
+ } else {
+ languages.push(advancedLanguages[j]);
+ j++;
+ }
+ } else if (i < len) {
+ languages.push(basicLanguages[i]);
+ i++;
+ } else {
+ languages.push(advancedLanguages[j]);
+ j++;
+ }
+ }
+
+ const features = getFeatures();
+
+ const dtsContents = `
+/*!----------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *----------------------------------------------------------------*/
+
+export interface IWorkerDefinition {
+ id: string;
+ entry: string;
+}
+
+export interface IFeatureDefinition {
+ label: string;
+ entry: string | string[] | undefined;
+ worker?: IWorkerDefinition;
+}
+
+export const features: IFeatureDefinition[];
+
+export const languages: IFeatureDefinition[];
+
+export type EditorLanguage = ${languages.map((el) => `'${el.label}'`).join(' | ')};
+
+export type EditorFeature = ${features.map((el) => `'${el.label}'`).join(' | ')};
+
+export type NegatedEditorFeature = ${features.map((el) => `'!${el.label}'`).join(' | ')};
+
+`;
+ const dtsDestination = path.join(REPO_ROOT, 'out/monaco-editor/esm/metadata.d.ts');
+ ensureDir(path.dirname(dtsDestination));
+ fs.writeFileSync(dtsDestination, dtsContents.replace(/\r\n/g, '\n'));
+
+ const jsContents = `
+exports.features = ${JSON.stringify(features, null, ' ')};
+exports.languages = ${JSON.stringify(languages, null, ' ')};
+`;
+ const jsDestination = path.join(REPO_ROOT, 'out/monaco-editor/esm/metadata.js');
+ ensureDir(path.dirname(jsDestination));
+ fs.writeFileSync(jsDestination, jsContents.replace(/\r\n/g, '\n'));
+
+ for (const feature of [...features, ...languages]) {
+ const entries = [].concat(feature.entry);
+ for (const entry of entries) {
+ const dtsDestination = path.join(REPO_ROOT, 'out/monaco-editor/esm', entry) + '.d.ts';
+ ensureDir(path.dirname(dtsDestination));
+ fs.writeFileSync(dtsDestination, 'export {}\n');
+ }
+ }
+ }
+ );
+}
+
+function strcmp(a: string, b: string) {
+ if (a < b) {
+ return -1;
+ }
+ if (a > b) {
+ return 1;
+ }
+ return 0;
+}
+
+function getFeatures(): { label: string; entry: string | string[] }[] {
+ const skipImports = [
+ 'vs/editor/browser/widget/codeEditorWidget',
+ 'vs/editor/browser/widget/diffEditorWidget',
+ 'vs/editor/browser/widget/diffNavigator',
+ 'vs/editor/common/standaloneStrings',
+ 'vs/editor/contrib/tokenization/tokenization',
+ 'vs/editor/editor.all',
+ 'vs/base/browser/ui/codicons/codiconStyles',
+ 'vs/editor/contrib/gotoSymbol/documentSymbols'
+ ];
+
+ let features: string[] = [];
+ const files =
+ fs
+ .readFileSync(path.join(REPO_ROOT, 'out/monaco-editor/esm/vs/editor/edcore.main.js'))
+ .toString() +
+ fs
+ .readFileSync(path.join(REPO_ROOT, 'out/monaco-editor/esm/vs/editor/editor.all.js'))
+ .toString();
+ files.split(/\r\n|\n/).forEach((line) => {
+ const m = line.match(/import '([^']+)'/);
+ if (m) {
+ const tmp = path.posix.join('vs/editor', m[1]).replace(/\.js$/, '');
+ if (skipImports.indexOf(tmp) === -1) {
+ features.push(tmp);
+ }
+ }
+ });
+
+ let result: { label: string; entry: any }[] = features.map((feature) => {
+ /** @type {string} */ let label;
+ if (customFeatureLabels[feature]) {
+ label = customFeatureLabels[feature];
+ } else {
+ const m1 = feature.match(/^vs\/editor\/contrib\/([^\/]+)/);
+ if (m1) {
+ // for editor/contrib features, use the first segment
+ label = m1[1];
+ } else {
+ // for everything else, use the last segment folder
+ label = path.basename(path.dirname(feature));
+ }
+ }
+ return {
+ label: label,
+ entry: feature
+ };
+ });
+
+ result.sort((a, b) => {
+ const labelCmp = strcmp(a.label, b.label);
+ if (labelCmp === 0) {
+ return strcmp(a.entry, b.entry);
+ }
+ return labelCmp;
+ });
+
+ for (let i = 0; i < result.length; i++) {
+ if (i + 1 < result.length && result[i].label === result[i + 1].label) {
+ if (typeof result[i].entry === 'string') {
+ result[i].entry = [result[i].entry];
+ }
+ result[i].entry.push(result[i + 1].entry);
+ result.splice(i + 1, 1);
+ }
+ }
+
+ return result;
+}
diff --git a/build/shared.mjs b/build/shared.mjs
new file mode 100644
index 00000000..dc471455
--- /dev/null
+++ b/build/shared.mjs
@@ -0,0 +1,96 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// @ts-check
+
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { readdirSync } from 'fs';
+
+/**
+ * @param {string} filePath
+ * @param {string} newExt
+ */
+export function changeExt(filePath, newExt) {
+ const idx = filePath.lastIndexOf('.');
+ if (idx === -1) {
+ return filePath + newExt;
+ } else {
+ return filePath.substring(0, idx) + newExt;
+ }
+}
+
+export function getNlsEntryPoints() {
+ const nlsDir = dirname(fileURLToPath(import.meta.resolve('monaco-editor-core/esm/nls.messages.en.js')));
+ const nlsFiles = readdirSync(nlsDir)
+ .filter(file => file.startsWith('nls.messages.') && file.endsWith('.js'))
+ .reduce((acc, file) => {
+ // @ts-ignore
+ acc[file] = join(nlsDir, file);
+ return acc;
+ }, {});
+ return nlsFiles;
+}
+
+const root = join(import.meta.dirname, '../');
+
+const mappedPaths = {
+ [join(root, 'node_modules/monaco-editor-core/esm/')]: '.',
+ [join(root, 'node_modules/')]: 'external/',
+ [join(root, 'monaco-lsp-client/')]: 'external/monaco-lsp-client/',
+ [join(root, 'src/')]: 'vs/',
+};
+
+/**
+ * @param {string} moduleId
+ * @param {string} newExt (with leading .)
+ * @returns {string | undefined}
+ */
+export function mapModuleId(moduleId, newExt) {
+ for (const [key, val] of Object.entries(mappedPaths)) {
+ if (moduleId.startsWith(key)) {
+ const relativePath = moduleId.substring(key.length);
+ return changeExt(join(val, relativePath), newExt);
+ }
+ }
+ return undefined;
+}
+
+/**
+ * @param {(moduleId: string) => boolean} [filter]
+ * @return {import('rollup').Plugin}
+ */
+export function dtsDeprecationWarning(filter) {
+ return {
+ name: 'add-dts-deprecation-warning',
+ generateBundle(options, bundle) {
+ for (const fileName in bundle) {
+ if (filter && !filter(fileName)) {
+ continue;
+ }
+ const file = bundle[fileName];
+ if (file.type === 'chunk' && fileName.endsWith('.d.ts')) {
+ let content = file.code.toString();
+ content = content + `
+declare namespace languages {
+ /** @deprecated Use the new top level "css" namespace instead. */
+ export const css: { deprecated: true };
+
+ /** @deprecated Use the new top level "html" namespace instead. */
+ export const html: { deprecated: true };
+
+ /** @deprecated Use the new top level "json" namespace instead. */
+ export const json: { deprecated: true };
+
+ /** @deprecated Use the new top level "typescript" namespace instead. */
+ export const typescript: { deprecated: true };
+}
+`;
+ file.code = content;
+ }
+ }
+ }
+ };
+}
diff --git a/build/simpleserver.ts b/build/simpleserver.ts
new file mode 100644
index 00000000..bdfe8e51
--- /dev/null
+++ b/build/simpleserver.ts
@@ -0,0 +1,69 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import fs = require('fs');
+import path = require('path');
+import http = require('http');
+import yaserver = require('yaserver');
+import { REPO_ROOT } from './utils';
+import { ensureDir } from './fs';
+
+generateTestSamplesTask();
+
+const SERVER_ROOT = path.normalize(path.join(REPO_ROOT, '../'));
+createSimpleServer(SERVER_ROOT, 8080);
+createSimpleServer(SERVER_ROOT, 8088);
+
+function generateTestSamplesTask() {
+ const sampleNames = fs.readdirSync(path.join(REPO_ROOT, 'test/manual/samples'));
+ let samples = sampleNames.map((sampleName) => {
+ const samplePath = path.join(REPO_ROOT, 'test/manual/samples', sampleName);
+ const sampleContent = fs.readFileSync(samplePath).toString();
+ return {
+ name: sampleName,
+ content: sampleContent
+ };
+ });
+
+ // Add samples from website
+ {
+ let sampleNames = fs.readdirSync(path.join(REPO_ROOT, 'website/index/samples'));
+ sampleNames = sampleNames.filter((name) => /^sample/.test(name));
+
+ samples = samples.concat(
+ sampleNames.map((sampleName) => {
+ const samplePath = path.join(REPO_ROOT, 'website/index/samples', sampleName);
+ const sampleContent = fs.readFileSync(samplePath).toString();
+ return {
+ name: sampleName,
+ content: sampleContent
+ };
+ })
+ );
+ }
+
+ const prefix =
+ '//This is a generated file via `npm run simpleserver`\ndefine([], function() { return';
+ const suffix = '; });';
+
+ const destination = path.join(REPO_ROOT, 'test/manual/generated/all-samples.js');
+ ensureDir(path.dirname(destination));
+ fs.writeFileSync(destination, prefix + JSON.stringify(samples, null, '\t') + suffix);
+}
+
+function createSimpleServer(rootDir: string, port: number) {
+ yaserver
+ .createServer({
+ rootDir: rootDir
+ })
+ .then((staticServer) => {
+ const server = http.createServer((request, response) => {
+ return staticServer.handle(request, response);
+ });
+ server.listen(port, '127.0.0.1', () => {
+ console.log(`Running at http://127.0.0.1:${port}`);
+ });
+ });
+}
diff --git a/build/tsconfig.json b/build/tsconfig.json
new file mode 100644
index 00000000..9d84cea7
--- /dev/null
+++ b/build/tsconfig.json
@@ -0,0 +1,8 @@
+{
+ "compilerOptions": {
+ "noEmit": true,
+ "module": "CommonJS",
+ "esModuleInterop": true
+ },
+ "include": ["./**/*"]
+}
diff --git a/build/utils.ts b/build/utils.ts
new file mode 100644
index 00000000..8a11841c
--- /dev/null
+++ b/build/utils.ts
@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as glob from 'glob';
+import { ensureDir } from './fs';
+
+export const REPO_ROOT = path.join(__dirname, '../');
+
+
+export interface IFile {
+ path: string;
+ contents: Buffer;
+}
+
+export function readFiles(
+ pattern: string,
+ options: { base: string; ignore?: string[]; dot?: boolean }
+): IFile[] {
+ let files = glob.sync(pattern, { cwd: REPO_ROOT, ignore: options.ignore, dot: options.dot });
+ // remove dirs
+ files = files.filter((file) => {
+ const fullPath = path.join(REPO_ROOT, file);
+ const stats = fs.statSync(fullPath);
+ return stats.isFile();
+ });
+
+ const base = options.base;
+ return files.map((file) => readFile(file, base));
+}
+
+export function readFile(file: string, base: string = '') {
+ const baseLength = base === '' ? 0 : base.endsWith('/') ? base.length : base.length + 1;
+ const fullPath = path.join(REPO_ROOT, file);
+ const contents = fs.readFileSync(fullPath);
+ const relativePath = file.substring(baseLength);
+ return {
+ path: relativePath,
+ contents
+ };
+}
+
+export function writeFiles(files: IFile[], dest: string) {
+ for (const file of files) {
+ const fullPath = path.join(REPO_ROOT, dest, file.path);
+ ensureDir(path.dirname(fullPath));
+ fs.writeFileSync(fullPath, file.contents);
+ }
+}
diff --git a/docs/code-structure.dio.svg b/docs/code-structure.dio.svg
new file mode 100644
index 00000000..f4b0abb2
--- /dev/null
+++ b/docs/code-structure.dio.svg
@@ -0,0 +1,275 @@
+
diff --git a/docs/debugging-core.gif b/docs/debugging-core.gif
new file mode 100644
index 00000000..37179f6d
Binary files /dev/null and b/docs/debugging-core.gif differ
diff --git a/docs/debugging-languages.gif b/docs/debugging-languages.gif
new file mode 100644
index 00000000..73c0d6d4
Binary files /dev/null and b/docs/debugging-languages.gif differ
diff --git a/docs/integrate-esm.md b/docs/integrate-esm.md
new file mode 100644
index 00000000..d4b11cc9
--- /dev/null
+++ b/docs/integrate-esm.md
@@ -0,0 +1,229 @@
+## Integrating the ESM version of the Monaco Editor
+
+- [Webpack](#using-webpack)
+ - [Option 1: Using the Monaco Editor WebPack Plugin](#option-1-using-the-monaco-editor-webpack-plugin)
+ - [Option 2: Using plain webpack](#option-2-using-plain-webpack)
+- [Parcel](#using-parcel)
+- [Vite](#using-vite)
+
+### Using webpack
+
+Here is the most basic script that imports the editor using ESM with webpack.
+
+More self-contained samples are available in the [samples folder](../samples/).
+
+---
+
+### Option 1: Using the Monaco Editor WebPack Plugin
+
+This is the easiest method, and it allows for options to be passed into the plugin in order to select only a subset of editor features or editor languages. Read more about the [Monaco Editor WebPack Plugin](../webpack-plugin/), which is a community authored plugin.
+
+- `index.js`
+
+```js
+import * as monaco from 'monaco-editor';
+
+monaco.editor.create(document.getElementById('container'), {
+ value: ['function x() {', '\tconsole.log("Hello world!");', '}'].join('\n'),
+ language: 'javascript'
+});
+```
+
+- `webpack.config.js`
+
+```js
+const MonacoWebpackPlugin = require('monaco-editor-webpack-plugin');
+const path = require('path');
+
+module.exports = {
+ entry: './index.js',
+ output: {
+ path: path.resolve(__dirname, 'dist'),
+ filename: 'app.js'
+ },
+ module: {
+ rules: [
+ {
+ test: /\.css$/,
+ use: ['style-loader', 'css-loader']
+ },
+ {
+ test: /\.ttf$/,
+ use: ['file-loader']
+ }
+ ]
+ },
+ plugins: [new MonacoWebpackPlugin()]
+};
+```
+
+---
+
+### Option 2: Using plain webpack
+
+Full working samples are available at https://github.com/microsoft/monaco-editor/tree/main/samples/browser-esm-webpack or https://github.com/microsoft/monaco-editor/tree/main/samples/browser-esm-webpack-small
+
+- `index.js`
+
+```js
+import * as monaco from 'monaco-editor';
+
+// Since packaging is done by you, you need
+// to instruct the editor how you named the
+// bundles that contain the web workers.
+self.MonacoEnvironment = {
+ getWorkerUrl: function (moduleId, label) {
+ if (label === 'json') {
+ return './json.worker.bundle.js';
+ }
+ if (label === 'css' || label === 'scss' || label === 'less') {
+ return './css.worker.bundle.js';
+ }
+ if (label === 'html' || label === 'handlebars' || label === 'razor') {
+ return './html.worker.bundle.js';
+ }
+ if (label === 'typescript' || label === 'javascript') {
+ return './ts.worker.bundle.js';
+ }
+ return './editor.worker.bundle.js';
+ }
+};
+
+monaco.editor.create(document.getElementById('container'), {
+ value: ['function x() {', '\tconsole.log("Hello world!");', '}'].join('\n'),
+ language: 'javascript'
+});
+```
+
+- `webpack.config.js`:
+
+```js
+const path = require('path');
+
+module.exports = {
+ entry: {
+ app: './index.js',
+ // Package each language's worker and give these filenames in `getWorkerUrl`
+ 'editor.worker': 'monaco-editor/esm/vs/editor/editor.worker.js',
+ 'json.worker': 'monaco-editor/esm/vs/language/json/json.worker',
+ 'css.worker': 'monaco-editor/esm/vs/language/css/css.worker',
+ 'html.worker': 'monaco-editor/esm/vs/language/html/html.worker',
+ 'ts.worker': 'monaco-editor/esm/vs/language/typescript/ts.worker'
+ },
+ output: {
+ globalObject: 'self',
+ filename: '[name].bundle.js',
+ path: path.resolve(__dirname, 'dist')
+ },
+ module: {
+ rules: [
+ {
+ test: /\.css$/,
+ use: ['style-loader', 'css-loader']
+ },
+ {
+ test: /\.ttf$/,
+ use: ['file-loader']
+ }
+ ]
+ }
+};
+```
+
+---
+
+### Using parcel
+
+A full working sample is available at https://github.com/microsoft/monaco-editor/tree/main/samples/browser-esm-parcel
+
+When using parcel, we need to use the `getWorkerUrl` function and build the workers seperately from our main source. To simplify things, we can write a tiny bash script to build the workers for us.
+
+- `index.js`
+
+```js
+import * as monaco from 'monaco-editor';
+
+self.MonacoEnvironment = {
+ getWorkerUrl: function (moduleId, label) {
+ if (label === 'json') {
+ return './json.worker.js';
+ }
+ if (label === 'css' || label === 'scss' || label === 'less') {
+ return './css.worker.js';
+ }
+ if (label === 'html' || label === 'handlebars' || label === 'razor') {
+ return './html.worker.js';
+ }
+ if (label === 'typescript' || label === 'javascript') {
+ return './ts.worker.js';
+ }
+ return './editor.worker.js';
+ }
+};
+
+monaco.editor.create(document.getElementById('container'), {
+ value: ['function x() {', '\tconsole.log("Hello world!");', '}'].join('\n'),
+ language: 'javascript'
+});
+```
+
+- `build_workers.sh`
+
+```sh
+ROOT=$PWD/node_modules/monaco-editor/esm/vs
+OPTS="--no-source-maps --log-level 1" # Parcel options - See: https://parceljs.org/cli.html
+
+parcel build $ROOT/language/json/json.worker.js $OPTS
+parcel build $ROOT/language/css/css.worker.js $OPTS
+parcel build $ROOT/language/html/html.worker.js $OPTS
+parcel build $ROOT/language/typescript/ts.worker.js $OPTS
+parcel build $ROOT/editor/editor.worker.js $OPTS
+```
+
+Then, simply run `sh ./build_workers.sh && parcel index.html`. This builds the workers into the same directory as your main bundle (usually `./dist`). If you want to change the `--out-dir` of the workers, you must change the paths in `index.js` to reflect their new location.
+
+_note - the `getWorkerUrl` paths are relative to the build directory of your src bundle_
+
+---
+
+### Using Vite
+
+Adding monaco editor to [Vite](https://vitejs.dev/) is simple since it has built-in support for web workers. You only need to implement the `getWorker` function (NOT the `getWorkerUrl`) to use Vite's output ([Source](https://github.com/vitejs/vite/discussions/1791#discussioncomment-321046)):
+
+```js
+import * as monaco from 'monaco-editor';
+
+self.MonacoEnvironment = {
+ getWorker: function (workerId, label) {
+ const getWorkerModule = (moduleUrl, label) => {
+ return new Worker(self.MonacoEnvironment.getWorkerUrl(moduleUrl), {
+ name: label,
+ type: 'module'
+ });
+ };
+
+ switch (label) {
+ case 'json':
+ return getWorkerModule('/monaco-editor/esm/vs/language/json/json.worker?worker', label);
+ case 'css':
+ case 'scss':
+ case 'less':
+ return getWorkerModule('/monaco-editor/esm/vs/language/css/css.worker?worker', label);
+ case 'html':
+ case 'handlebars':
+ case 'razor':
+ return getWorkerModule('/monaco-editor/esm/vs/language/html/html.worker?worker', label);
+ case 'typescript':
+ case 'javascript':
+ return getWorkerModule('/monaco-editor/esm/vs/language/typescript/ts.worker?worker', label);
+ default:
+ return getWorkerModule('/monaco-editor/esm/vs/editor/editor.worker?worker', label);
+ }
+ }
+};
+
+monaco.editor.create(document.getElementById('container'), {
+ value: "function hello() {\n\talert('Hello world!');\n}",
+ language: 'javascript'
+});
+```
diff --git a/docs/launch config.png b/docs/launch config.png
new file mode 100644
index 00000000..d39e0b15
Binary files /dev/null and b/docs/launch config.png differ
diff --git a/docs/out-folders.dio.svg b/docs/out-folders.dio.svg
new file mode 100644
index 00000000..81022ce4
--- /dev/null
+++ b/docs/out-folders.dio.svg
@@ -0,0 +1,347 @@
+
diff --git a/editor.code-workspace b/editor.code-workspace
new file mode 100644
index 00000000..18ac4963
--- /dev/null
+++ b/editor.code-workspace
@@ -0,0 +1,13 @@
+{
+ "folders": [
+ {
+ "path": "../vscode"
+ },
+ {
+ "path": "../vscode-loc"
+ },
+ {
+ "path": "."
+ }
+ ]
+}
diff --git a/gulpfile.js b/gulpfile.js
index 21b661a4..b59b7b03 100644
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -1,487 +1,9 @@
-
-var gulp = require('gulp');
-var metadata = require('./metadata');
-var es = require('event-stream');
-var path = require('path');
-var fs = require('fs');
-var rimraf = require('rimraf');
-var cp = require('child_process');
-var httpServer = require('http-server');
-var typedoc = require("gulp-typedoc");
-var CleanCSS = require('clean-css');
-var uncss = require('uncss');
-
-var WEBSITE_GENERATED_PATH = path.join(__dirname, 'website/playground/new-samples');
-var MONACO_EDITOR_VERSION = (function() {
- var packageJsonPath = path.join(__dirname, 'package.json');
- var packageJson = JSON.parse(fs.readFileSync(packageJsonPath).toString());
- var version = packageJson.version;
- if (!/\d+\.\d+\.\d+/.test(version)) {
- console.log('unrecognized package.json version: ' + version);
- process.exit(0);
- }
- return version;
-})();
-
-gulp.task('clean-release', function(cb) { rimraf('release', { maxBusyTries: 1 }, cb); });
-gulp.task('release', ['clean-release'], function() {
- return es.merge(
-
- // dev folder
- releaseOne('dev'),
-
- // min folder
- releaseOne('min'),
-
- // package.json
- gulp.src('package.json')
- .pipe(es.through(function(data) {
- var json = JSON.parse(data.contents.toString());
- json.private = false;
- data.contents = new Buffer(JSON.stringify(json, null, ' '));
- this.emit('data', data);
- }))
- .pipe(gulp.dest('release')),
-
- gulp.src('CHANGELOG.md')
- .pipe(gulp.dest('release')),
-
- // min-maps folder
- gulp.src('node_modules/monaco-editor-core/min-maps/**/*').pipe(gulp.dest('release/min-maps')),
-
- // other files
- gulp.src([
- 'node_modules/monaco-editor-core/LICENSE',
- 'node_modules/monaco-editor-core/monaco.d.ts',
- 'node_modules/monaco-editor-core/ThirdPartyNotices.txt',
- 'README.md'
- ])
- .pipe(addPluginDTS())
- .pipe(addPluginThirdPartyNotices())
- .pipe(gulp.dest('release'))
- )
-});
-
-function releaseOne(type) {
- return es.merge(
- gulp.src('node_modules/monaco-editor-core/' + type + '/**/*')
- .pipe(addPluginContribs())
- .pipe(gulp.dest('release/' + type)),
- pluginStreams('release/' + type + '/')
- )
-}
-
-function pluginStreams(destinationPath) {
- return es.merge(
- metadata.METADATA.PLUGINS.map(function(plugin) {
- return pluginStream(plugin, destinationPath);
- })
- );
-}
-
-function pluginStream(plugin, destinationPath) {
- var contribPath = path.join(plugin.paths.npm, plugin.contrib.substr(plugin.modulePrefix.length)) + '.js';
- return (
- gulp.src([
- plugin.paths.npm + '/**/*',
- '!' + contribPath,
- '!' + plugin.paths.npm + '/**/monaco.d.ts'
- ])
- .pipe(gulp.dest(destinationPath + plugin.modulePrefix))
- );
-}
-
-/**
- * Edit editor.main.js:
- * - rename the AMD module 'vs/editor/editor.main' to 'vs/editor/edcore.main'
- * - append contribs from plugins
- * - append new AMD module 'vs/editor/editor.main' that stiches things together
- */
-function addPluginContribs() {
- return es.through(function(data) {
- if (!/editor\.main\.js$/.test(data.path)) {
- this.emit('data', data);
- return;
- }
- var contents = data.contents.toString();
-
- // Rename the AMD module 'vs/editor/editor.main' to 'vs/editor/edcore.main'
- contents = contents.replace(/"vs\/editor\/editor\.main\"/, '"vs/editor/edcore.main"');
-
- var extraContent = [];
- var allPluginsModuleIds = [];
-
- metadata.METADATA.PLUGINS.forEach(function(plugin) {
- allPluginsModuleIds.push(plugin.contrib);
- var contribPath = path.join(__dirname, plugin.paths.npm, plugin.contrib.substr(plugin.modulePrefix.length)) + '.js';
- var contribContents = fs.readFileSync(contribPath).toString();
-
- var contribDefineIndex = contribContents.indexOf('define("' + plugin.contrib);
- if (contribDefineIndex === -1) {
- console.error('(1) CANNOT DETERMINE AMD define location for contribution', plugin);
- process.exit(-1);
- }
-
- var depsEndIndex = contribContents.indexOf(']', contribDefineIndex);
- if (contribDefineIndex === -1) {
- console.error('(2) CANNOT DETERMINE AMD define location for contribution', plugin);
- process.exit(-1);
- }
-
- contribContents = contribContents.substring(0, depsEndIndex) + ',"vs/editor/edcore.main"' + contribContents.substring(depsEndIndex);
-
- extraContent.push(contribContents);
- });
-
- extraContent.push(`define("vs/editor/editor.main", ["vs/editor/edcore.main","${allPluginsModuleIds.join('","')}"], function() {});`);
- var insertIndex = contents.lastIndexOf('//# sourceMappingURL=');
- if (insertIndex === -1) {
- insertIndex = contents.length;
- }
- contents = contents.substring(0, insertIndex) + '\n' + extraContent.join('\n') + '\n' + contents.substring(insertIndex);
-
- data.contents = new Buffer(contents);
- this.emit('data', data);
- });
-}
-
-/**
- * Edit monaco.d.ts:
- * - append monaco.d.ts from plugins
- */
-function addPluginDTS() {
- return es.through(function(data) {
- if (!/monaco\.d\.ts$/.test(data.path)) {
- this.emit('data', data);
- return;
- }
- var contents = data.contents.toString();
-
- var extraContent = [];
- metadata.METADATA.PLUGINS.forEach(function(plugin) {
- var dtsPath = path.join(plugin.paths.npm, 'monaco.d.ts');
- try {
- extraContent.push(fs.readFileSync(dtsPath).toString());
- } catch (err) {
- return;
- }
- });
-
- contents = [
- '/*!-----------------------------------------------------------',
- ' * Copyright (c) Microsoft Corporation. All rights reserved.',
- ' * Type definitions for monaco-editor v'+MONACO_EDITOR_VERSION,
- ' * Released under the MIT license',
- '*-----------------------------------------------------------*/',
- ].join('\n') + '\n' + contents + '\n' + extraContent.join('\n');
-
- // Ensure consistent indentation and line endings
- contents = cleanFile(contents);
-
- data.contents = new Buffer(contents);
-
- fs.writeFileSync('website/playground/monaco.d.ts.txt', contents);
- fs.writeFileSync('monaco.d.ts', contents);
- this.emit('data', data);
- });
-}
-
-/**
- * Normalize line endings and ensure consistent 4 spaces indentation
- */
-function cleanFile(contents) {
- return contents.split(/\r\n|\r|\n/).map(function(line) {
- var m = line.match(/^(\t+)/);
- if (!m) {
- return line;
- }
- var tabsCount = m[1].length;
- var newIndent = '';
- for (var i = 0; i < 4 * tabsCount; i++) {
- newIndent += ' ';
- }
- return newIndent + line.substring(tabsCount);
- }).join('\n');
-}
-
-/**
- * Edit ThirdPartyNotices.txt:
- * - append ThirdPartyNotices.txt from plugins
- */
-function addPluginThirdPartyNotices() {
- return es.through(function(data) {
- if (!/ThirdPartyNotices\.txt$/.test(data.path)) {
- this.emit('data', data);
- return;
- }
- var contents = data.contents.toString();
-
- var extraContent = [];
- metadata.METADATA.PLUGINS.forEach(function(plugin) {
- if (!plugin.thirdPartyNotices) {
- return;
- }
-
- console.log('ADDING ThirdPartyNotices from ' + plugin.thirdPartyNotices);
- var thirdPartyNoticeContent = fs.readFileSync(plugin.thirdPartyNotices).toString();
- thirdPartyNoticeContent = thirdPartyNoticeContent.split('\n').slice(8).join('\n');
- extraContent.push(thirdPartyNoticeContent);
- });
-
- contents += '\n' + extraContent.join('\n');
- data.contents = new Buffer(contents);
-
- this.emit('data', data);
- });
-}
-
-
-// --- website
-
-gulp.task('clean-website', function(cb) { rimraf('../monaco-editor-website', { maxBusyTries: 1 }, cb); });
-gulp.task('website', ['clean-website'], function() {
-
- function replaceWithRelativeResource(dataPath, contents, regex, callback) {
- return contents.replace(regex, function(_, m0) {
- var filePath = path.join(path.dirname(dataPath), m0);
- return callback(m0, fs.readFileSync(filePath));
- });
- }
-
- var waiting = 0;
- var done = false;
-
- return (
- es.merge(
- gulp.src([
- 'website/**/*',
- '!website/typedoc-theme/**'
- ], { dot: true })
- .pipe(es.through(function(data) {
- if (!data.contents || !/\.(html)$/.test(data.path) || /new-samples/.test(data.path)) {
- return this.emit('data', data);
- }
-
- var contents = data.contents.toString();
- contents = contents.replace(/\.\.\/release\/dev/g, 'node_modules/monaco-editor/min');
- contents = contents.replace(/{{version}}/g, MONACO_EDITOR_VERSION);
- // contents = contents.replace('© 2017 Microsoft', '© 2017 Microsoft [' + builtTime + ']');
-
- // Preload xhr contents
- contents = replaceWithRelativeResource(data.path, contents, /'
- + fileContents.toString('utf8')
- .replace(/&/g, '&')
- .replace(//g, '>')
- + ''
- );
- });
-
- // Inline fork.png
- contents = replaceWithRelativeResource(data.path, contents, /src="(\.\/fork.png)"/g, function(m0, fileContents) {
- return (
- 'src="data:image/png;base64,' + fileContents.toString('base64') + '"'
- );
- });
-
- var allCSS = '';
- var tmpcontents = replaceWithRelativeResource(data.path, contents, /' + output + '';
- }
- return '';
- });
- }
-
- // Inline javascript
- contents = replaceWithRelativeResource(data.path, contents, /';
- });
-
- data.contents = new Buffer(contents.split(/\r\n|\r|\n/).join('\n'));
- this.emit('data', data);
-
- if (done && waiting === 0) {
- this.emit('end');
- }
- }.bind(this));
-
- }, function() {
- done = true;
- if (waiting === 0) {
- this.emit('end');
- }
- }))
- .pipe(gulp.dest('../monaco-editor-website')),
-
- gulp.src('monaco.d.ts')
- .pipe(typedoc({
- mode: 'file',
- out: '../monaco-editor-website/api',
- includeDeclarations: true,
- theme: 'website/typedoc-theme',
- entryPoint: 'monaco',
- name: 'Monaco Editor API v' + MONACO_EDITOR_VERSION,
- readme: 'none',
- hideGenerator: true
- }))
- )
-
- .pipe(es.through(function(data) {
- this.emit('data', data);
- }, function() {
-
- // temporarily create package.json so that npm install doesn't bark
- fs.writeFileSync('../monaco-editor-website/package.json', '{}');
- fs.writeFileSync('../monaco-editor-website/.nojekyll', '');
- cp.execSync('npm install monaco-editor', {
- cwd: path.join(__dirname, '../monaco-editor-website')
- });
- fs.unlink('../monaco-editor-website/package.json');
-
- cp.execSync('git init', {
- cwd: path.join(__dirname, '../monaco-editor-website')
- });
- cp.execSync('git checkout -b gh-pages', {
- cwd: path.join(__dirname, '../monaco-editor-website')
- });
- cp.execSync('git add .', {
- cwd: path.join(__dirname, '../monaco-editor-website')
- });
- cp.execSync('git commit -m "Publish website"', {
- cwd: path.join(__dirname, '../monaco-editor-website')
- });
- cp.execSync('git remote add origin https://github.com/Microsoft/monaco-editor.git', {
- cwd: path.join(__dirname, '../monaco-editor-website')
- });
- console.log('RUN monaco-editor-website>git push origin gh-pages --force')
- this.emit('end');
- }))
- );
-
-});
-
-gulp.task('generate-test-samples', function() {
- var sampleNames = fs.readdirSync(path.join(__dirname, 'test/samples'));
- var samples = sampleNames.map(function(sampleName) {
- var samplePath = path.join(__dirname, 'test/samples', sampleName);
- var sampleContent = fs.readFileSync(samplePath).toString();
- return {
- name: sampleName,
- content: sampleContent
- };
- });
- var prefix = '//This is a generated file via gulp generate-test-samples\ndefine([], function() { return';
- var suffix = '; });'
- fs.writeFileSync(path.join(__dirname, 'test/samples-all.generated.js'), prefix + JSON.stringify(samples, null, '\t') + suffix );
-
- var PLAY_SAMPLES = require(path.join(WEBSITE_GENERATED_PATH, 'all.js')).PLAY_SAMPLES;
- var locations = [];
- for (var i = 0; i < PLAY_SAMPLES.length; i++) {
- var sample = PLAY_SAMPLES[i];
- var sampleId = sample.id;
- var samplePath = path.join(WEBSITE_GENERATED_PATH, sample.path);
-
- var html = fs.readFileSync(path.join(samplePath, 'sample.html'));
- var js = fs.readFileSync(path.join(samplePath, 'sample.js'));
- var css = fs.readFileSync(path.join(samplePath, 'sample.css'));
-
- var result = [
- '',
- '',
- '',
- '',
- ' ',
- ' ',
- ' ',
- '',
- '',
- '',
- '[<< BACK]
',
- 'THIS IS A GENERATED FILE VIA gulp generate-test-samples',
- '',
- '',
- '',
- '',
- '',
- '',
- '',
- html,
- '',
- '',
- '
',
- '',
- '',
- '',
- '',
- '',
- '',
- '',
- ];
- fs.writeFileSync(path.join(__dirname, 'test/playground.generated/' + sampleId + '.html'), result.join('\n'));
- locations.push({
- path: sampleId + '.html',
- name: sample.chapter + ' > ' + sample.name
- })
- }
-
- var index = [
- '',
- '',
- '',
- '',
- ' ',
- '',
- '',
- '[<< BACK]
',
- 'THIS IS A GENERATED FILE VIA gulp generate-test-samples
',
- locations.map(function(location) {
- return '' + location.name + '';
- }).join('
\n'),
- '',
- '',
- '',
- '',
- ]
- fs.writeFileSync(path.join(__dirname, 'test/playground.generated/index.html'), index.join('\n'));
-});
-
-gulp.task('simpleserver', ['generate-test-samples'], function(cb) {
- httpServer.createServer({ root: '../', cache: 5 }).listen(8080);
- httpServer.createServer({ root: '../', cache: 5 }).listen(8088);
- console.log('LISTENING on 8080 and 8088');
-});
+const gulp = require('gulp');
+const es = require('event-stream');
+const path = require('path');
+const fs = require('fs');
+const rimraf = require('rimraf');
+const cp = require('child_process');
+const CleanCSS = require('clean-css');
+const uncss = require('uncss');
+const File = require('vinyl');
diff --git a/metadata.js b/metadata.js
deleted file mode 100644
index b87aee0e..00000000
--- a/metadata.js
+++ /dev/null
@@ -1,66 +0,0 @@
-(function() {
-
- var METADATA = {
- CORE: {
- paths: {
- npm: 'node_modules/monaco-editor-core/min/vs',
- // npm: 'node_modules/monaco-editor-core/dev/vs',
- dev: '/vscode/out/vs',
- built: '/vscode/out-monaco-editor-core/min/vs',
- releaseDev: 'release/dev/vs',
- releaseMin: 'release/min/vs',
- }
- },
- PLUGINS: [{
- name: 'monaco-typescript',
- contrib: 'vs/language/typescript/src/monaco.contribution',
- modulePrefix: 'vs/language/typescript',
- thirdPartyNotices: 'node_modules/monaco-typescript/ThirdPartyNotices.txt',
- paths: {
- npm: 'node_modules/monaco-typescript/release',
- dev: '/monaco-typescript/out'
- }
- },{
- name: 'monaco-css',
- contrib: 'vs/language/css/monaco.contribution',
- modulePrefix: 'vs/language/css',
- paths: {
- npm: 'node_modules/monaco-css/release/min',
- dev: '/monaco-css/release/dev'
- }
- },{
- name: 'monaco-json',
- contrib: 'vs/language/json/monaco.contribution',
- modulePrefix: 'vs/language/json',
- paths: {
- npm: 'node_modules/monaco-json/release/min',
- dev: '/monaco-json/release/dev'
- }
- },{
- name: 'monaco-html',
- contrib: 'vs/language/html/monaco.contribution',
- modulePrefix: 'vs/language/html',
- thirdPartyNotices: 'node_modules/monaco-html/ThirdPartyNotices.txt',
- paths: {
- npm: 'node_modules/monaco-html/release/min',
- dev: '/monaco-html/release/dev'
- }
- },{
- name: 'monaco-languages',
- contrib: 'vs/basic-languages/src/monaco.contribution',
- modulePrefix: 'vs/basic-languages',
- thirdPartyNotices: 'node_modules/monaco-languages/ThirdPartyNotices.txt',
- paths: {
- npm: 'node_modules/monaco-languages/release',
- dev: '/monaco-languages/out'
- }
- }]
- }
-
- if (typeof exports !== 'undefined') {
- exports.METADATA = METADATA
- } else {
- self.METADATA = METADATA;
- }
-
-})();
diff --git a/monaco-lsp-client/README.md b/monaco-lsp-client/README.md
new file mode 100644
index 00000000..8e6f3433
--- /dev/null
+++ b/monaco-lsp-client/README.md
@@ -0,0 +1,5 @@
+# Monaco LSP Client
+
+Provides a Language Server Protocol (LSP) client for the Monaco Editor.
+
+This package is in alpha stage and might contain many bugs.
diff --git a/monaco-lsp-client/generator/index.ts b/monaco-lsp-client/generator/index.ts
new file mode 100644
index 00000000..df3b100c
--- /dev/null
+++ b/monaco-lsp-client/generator/index.ts
@@ -0,0 +1,687 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Utility class for writing formatted code with proper indentation
+ */
+class LineWriter {
+ private lines: string[] = [];
+ private indentLevel: number = 0;
+ private indentStr: string = ' '; // 4 spaces
+
+ /**
+ * Write a line with current indentation
+ */
+ writeLine(line: string = ''): void {
+ if (line.trim() === '') {
+ this.lines.push('');
+ } else {
+ this.lines.push(this.indentStr.repeat(this.indentLevel) + line);
+ }
+ }
+
+ /**
+ * Write text without adding a new line
+ */
+ write(text: string): void {
+ if (this.lines.length === 0) {
+ this.lines.push('');
+ }
+ const lastIndex = this.lines.length - 1;
+ if (this.lines[lastIndex] === '') {
+ this.lines[lastIndex] = this.indentStr.repeat(this.indentLevel) + text;
+ } else {
+ this.lines[lastIndex] += text;
+ }
+ }
+
+ /**
+ * Increase indentation level
+ */
+ indent(): void {
+ this.indentLevel++;
+ }
+
+ /**
+ * Decrease indentation level
+ */
+ outdent(): void {
+ if (this.indentLevel > 0) {
+ this.indentLevel--;
+ }
+ }
+
+ /**
+ * Get the generated content as a string
+ */
+ toString(): string {
+ return this.lines.join('\n');
+ }
+
+ /**
+ * Clear all content and reset indentation
+ */
+ clear(): void {
+ this.lines = [];
+ this.indentLevel = 0;
+ }
+}
+
+/**
+ * Interface definitions based on the metaModel schema
+ */
+interface MetaModel {
+ metaData: MetaData;
+ requests: Request[];
+ notifications: Notification[];
+ structures: Structure[];
+ enumerations: Enumeration[];
+ typeAliases: TypeAlias[];
+}
+
+interface MetaData {
+ version: string;
+}
+
+interface Request {
+ method: string;
+ result: Type;
+ messageDirection: MessageDirection;
+ params?: Type | Type[];
+ partialResult?: Type;
+ errorData?: Type;
+ registrationOptions?: Type;
+ registrationMethod?: string;
+ documentation?: string;
+ since?: string;
+ proposed?: boolean;
+ deprecated?: string;
+}
+
+interface Notification {
+ method: string;
+ messageDirection: MessageDirection;
+ params?: Type | Type[];
+ registrationOptions?: Type;
+ registrationMethod?: string;
+ documentation?: string;
+ since?: string;
+ proposed?: boolean;
+ deprecated?: string;
+}
+
+interface Structure {
+ name: string;
+ properties: Property[];
+ extends?: Type[];
+ mixins?: Type[];
+ documentation?: string;
+ since?: string;
+ proposed?: boolean;
+ deprecated?: string;
+}
+
+interface Property {
+ name: string;
+ type: Type;
+ optional?: boolean;
+ documentation?: string;
+ since?: string;
+ proposed?: boolean;
+ deprecated?: string;
+}
+
+interface Enumeration {
+ name: string;
+ type: EnumerationType;
+ values: EnumerationEntry[];
+ supportsCustomValues?: boolean;
+ documentation?: string;
+ since?: string;
+ proposed?: boolean;
+ deprecated?: string;
+}
+
+interface EnumerationEntry {
+ name: string;
+ value: string | number;
+ documentation?: string;
+ since?: string;
+ proposed?: boolean;
+ deprecated?: string;
+}
+
+interface EnumerationType {
+ kind: 'base';
+ name: 'string' | 'integer' | 'uinteger';
+}
+
+interface TypeAlias {
+ name: string;
+ type: Type;
+ documentation?: string;
+ since?: string;
+ proposed?: boolean;
+ deprecated?: string;
+}
+
+type MessageDirection = 'clientToServer' | 'serverToClient' | 'both';
+
+type Type =
+ | BaseType
+ | ReferenceType
+ | ArrayType
+ | MapType
+ | AndType
+ | OrType
+ | TupleType
+ | StructureLiteralType
+ | StringLiteralType
+ | IntegerLiteralType
+ | BooleanLiteralType;
+
+interface BaseType {
+ kind: 'base';
+ name:
+ | 'URI'
+ | 'DocumentUri'
+ | 'integer'
+ | 'uinteger'
+ | 'decimal'
+ | 'RegExp'
+ | 'string'
+ | 'boolean'
+ | 'null';
+}
+
+interface ReferenceType {
+ kind: 'reference';
+ name: string;
+}
+
+interface ArrayType {
+ kind: 'array';
+ element: Type;
+}
+
+interface MapType {
+ kind: 'map';
+ key: Type;
+ value: Type;
+}
+
+interface AndType {
+ kind: 'and';
+ items: Type[];
+}
+
+interface OrType {
+ kind: 'or';
+ items: Type[];
+}
+
+interface TupleType {
+ kind: 'tuple';
+ items: Type[];
+}
+
+interface StructureLiteralType {
+ kind: 'literal';
+ value: StructureLiteral;
+}
+
+interface StructureLiteral {
+ properties: Property[];
+ documentation?: string;
+ since?: string;
+ proposed?: boolean;
+ deprecated?: string;
+}
+
+interface StringLiteralType {
+ kind: 'stringLiteral';
+ value: string;
+}
+
+interface IntegerLiteralType {
+ kind: 'integerLiteral';
+ value: number;
+}
+
+interface BooleanLiteralType {
+ kind: 'booleanLiteral';
+ value: boolean;
+}
+
+/**
+ * TypeScript types generator for LSP client
+ */
+class LSPTypesGenerator {
+ private writer = new LineWriter();
+
+ /**
+ * Load and parse the metaModel.json file
+ */
+ private loadMetaModel(): MetaModel {
+ const metaModelPath = path.join(__dirname, '..', 'metaModel.json');
+ const content = fs.readFileSync(metaModelPath, 'utf-8');
+ return JSON.parse(content) as MetaModel;
+ }
+
+ /**
+ * Convert Type to TypeScript type string
+ */
+ private typeToTypeScript(type: Type): string {
+ switch (type.kind) {
+ case 'base':
+ switch (type.name) {
+ case 'string':
+ case 'DocumentUri':
+ case 'URI':
+ return 'string';
+ case 'integer':
+ case 'uinteger':
+ case 'decimal':
+ return 'number';
+ case 'boolean':
+ return 'boolean';
+ case 'null':
+ return 'null';
+ case 'RegExp':
+ return 'RegExp';
+ default:
+ return 'any';
+ }
+ case 'reference':
+ return type.name;
+ case 'array':
+ return `(${this.typeToTypeScript(type.element)})[]`;
+ case 'map':
+ return `{ [key: ${this.typeToTypeScript(type.key)}]: ${this.typeToTypeScript(
+ type.value
+ )} }`;
+ case 'and':
+ return type.items.map((item) => this.typeToTypeScript(item)).join(' & ');
+ case 'or':
+ return type.items.map((item) => this.typeToTypeScript(item)).join(' | ');
+ case 'tuple':
+ return `[${type.items.map((item) => this.typeToTypeScript(item)).join(', ')}]`;
+ case 'literal':
+ return this.structureLiteralToTypeScript(type.value);
+ case 'stringLiteral':
+ return `'${type.value}'`;
+ case 'integerLiteral':
+ return type.value.toString();
+ case 'booleanLiteral':
+ return type.value.toString();
+ default:
+ return 'any';
+ }
+ }
+
+ /**
+ * Convert structure literal to TypeScript interface
+ */
+ private structureLiteralToTypeScript(literal: StructureLiteral): string {
+ const properties = literal.properties.map((prop) => {
+ const optional = prop.optional ? '?' : '';
+ return `${prop.name}${optional}: ${this.typeToTypeScript(prop.type)}`;
+ });
+ return `{\n ${properties.join(';\n ')}\n}`;
+ }
+
+ /**
+ * Generate TypeScript interface for a structure
+ */
+ private generateStructure(structure: Structure): void {
+ if (structure.documentation) {
+ this.writer.writeLine('/**');
+ this.writer.writeLine(` * ${structure.documentation.replace(/\n/g, '\n * ')}`);
+ this.writer.writeLine(' */');
+ }
+
+ // Build extends clause combining extends and mixins
+ const allParents: string[] = [];
+
+ if (structure.extends && structure.extends.length > 0) {
+ allParents.push(...structure.extends.map((type) => this.typeToTypeScript(type)));
+ }
+
+ if (structure.mixins && structure.mixins.length > 0) {
+ allParents.push(...structure.mixins.map((type) => this.typeToTypeScript(type)));
+ }
+
+ const extendsClause = allParents.length > 0 ? ` extends ${allParents.join(', ')}` : '';
+
+ this.writer.writeLine(`export interface ${structure.name}${extendsClause} {`);
+ this.writer.indent();
+
+ // Add properties
+ for (const property of structure.properties) {
+ if (property.documentation) {
+ this.writer.writeLine('/**');
+ this.writer.writeLine(` * ${property.documentation.replace(/\n/g, '\n * ')}`);
+ this.writer.writeLine(' */');
+ }
+ const optional = property.optional ? '?' : '';
+ this.writer.writeLine(
+ `${property.name}${optional}: ${this.typeToTypeScript(property.type)};`
+ );
+ }
+
+ this.writer.outdent();
+ this.writer.writeLine('}');
+ this.writer.writeLine('');
+ }
+
+ /**
+ * Generate TypeScript enum for an enumeration
+ */
+ private generateEnumeration(enumeration: Enumeration): void {
+ if (enumeration.documentation) {
+ this.writer.writeLine('/**');
+ this.writer.writeLine(` * ${enumeration.documentation.replace(/\n/g, '\n * ')}`);
+ this.writer.writeLine(' */');
+ }
+
+ this.writer.writeLine(`export enum ${enumeration.name} {`);
+ this.writer.indent();
+
+ for (let i = 0; i < enumeration.values.length; i++) {
+ const entry = enumeration.values[i];
+ if (entry.documentation) {
+ this.writer.writeLine('/**');
+ this.writer.writeLine(` * ${entry.documentation.replace(/\n/g, '\n * ')}`);
+ this.writer.writeLine(' */');
+ }
+ const isLast = i === enumeration.values.length - 1;
+ const comma = isLast ? '' : ',';
+ if (typeof entry.value === 'string') {
+ this.writer.writeLine(`${entry.name} = '${entry.value}'${comma}`);
+ } else {
+ this.writer.writeLine(`${entry.name} = ${entry.value}${comma}`);
+ }
+ }
+
+ this.writer.outdent();
+ this.writer.writeLine('}');
+ this.writer.writeLine('');
+ }
+
+ /**
+ * Generate TypeScript type alias
+ */
+ private generateTypeAlias(typeAlias: TypeAlias): void {
+ if (typeAlias.documentation) {
+ this.writer.writeLine('/**');
+ this.writer.writeLine(` * ${typeAlias.documentation.replace(/\n/g, '\n * ')}`);
+ this.writer.writeLine(' */');
+ }
+
+ this.writer.writeLine(
+ `export type ${typeAlias.name} = ${this.typeToTypeScript(typeAlias.type)};`
+ );
+ this.writer.writeLine('');
+ }
+
+ /**
+ * Generate the Capability class
+ */
+ private generateCapabilityClass(): void {
+ this.writer.writeLine('/**');
+ this.writer.writeLine(
+ ' * Represents a capability with its associated method and registration options type'
+ );
+ this.writer.writeLine(' */');
+ this.writer.writeLine('export class Capability {');
+ this.writer.indent();
+ this.writer.writeLine('constructor(public readonly method: string) {}');
+ this.writer.outdent();
+ this.writer.writeLine('}');
+ this.writer.writeLine('');
+ }
+
+ /**
+ * Generate the capabilities map
+ */
+ private generateCapabilitiesMap(metaModel: MetaModel): void {
+ this.writer.writeLine('/**');
+ this.writer.writeLine(' * Map of all LSP capabilities with their registration options');
+ this.writer.writeLine(' */');
+ this.writer.writeLine('export const capabilities = {');
+ this.writer.indent();
+
+ // Collect all requests and notifications with registration options
+ const itemsWithRegistration: Array<{ method: string; registrationOptions?: Type }> = [];
+
+ for (const request of metaModel.requests) {
+ if (request.registrationOptions) {
+ itemsWithRegistration.push({
+ method: request.method,
+ registrationOptions: request.registrationOptions
+ });
+ }
+ }
+
+ for (const notification of metaModel.notifications) {
+ if (notification.registrationOptions) {
+ itemsWithRegistration.push({
+ method: notification.method,
+ registrationOptions: notification.registrationOptions
+ });
+ }
+ }
+
+ // Generate capability entries
+ for (const item of itemsWithRegistration) {
+ const methodIdentifier = this.methodToIdentifier(item.method);
+ const registrationType = item.registrationOptions
+ ? this.typeToTypeScript(item.registrationOptions)
+ : 'unknown';
+
+ this.writer.writeLine(
+ `${methodIdentifier}: new Capability<${registrationType}>('${item.method}'),`
+ );
+ }
+
+ this.writer.outdent();
+ this.writer.writeLine('};');
+ this.writer.writeLine('');
+ }
+
+ /**
+ * Convert LSP method name to valid JavaScript identifier
+ */
+ private methodToIdentifier(method: string): string {
+ const parts = method
+ .replace(/\$/g, '') // Remove $ characters
+ .split('/') // Split on forward slashes
+ .filter((part) => part.length > 0); // Remove empty parts
+
+ return parts
+ .map((part, index) => {
+ // Convert kebab-case to camelCase for each part
+ const camelCase = part.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+ // Capitalize first letter of all parts except the first non-empty part
+ return index === 0 ? camelCase : camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+ })
+ .join('');
+ }
+
+ /**
+ * Generate the API contract object
+ */
+ private generateApiContract(metaModel: MetaModel): void {
+ this.writer.writeLine('/**');
+ this.writer.writeLine(' * LSP API Contract');
+ this.writer.writeLine(' */');
+
+ this.writer.writeLine('export const api = contract({');
+ this.writer.indent();
+
+ this.writer.writeLine('name: "LSP",');
+
+ // Helper function to generate request entries
+ const generateRequest = (request: Request, isOptional: boolean = false) => {
+ const methodIdentifier = this.methodToIdentifier(request.method);
+ const paramsType = this.getParamsType(request.params);
+ const resultType = this.typeToTypeScript(request.result);
+
+ if (request.documentation) {
+ this.writer.writeLine('/**');
+ this.writer.writeLine(` * ${request.documentation.replace(/\n/g, '\n * ')}`);
+ this.writer.writeLine(' */');
+ }
+
+ const optional = isOptional ? '.optional()' : '';
+ this.writer.writeLine(
+ `${methodIdentifier}: unverifiedRequest<${paramsType}, ${resultType}>({ method: "${request.method}" })${optional},`
+ );
+ };
+
+ // Helper function to generate notification entries
+ const generateNotification = (notification: Notification) => {
+ const methodIdentifier = this.methodToIdentifier(notification.method);
+ const paramsType = this.getParamsType(notification.params);
+
+ if (notification.documentation) {
+ this.writer.writeLine('/**');
+ this.writer.writeLine(` * ${notification.documentation.replace(/\n/g, '\n * ')}`);
+ this.writer.writeLine(' */');
+ }
+ this.writer.writeLine(
+ `${methodIdentifier}: unverifiedNotification<${paramsType}>({ method: "${notification.method}" }),`
+ );
+ };
+
+ // Server section
+ this.writer.writeLine('server: {');
+ this.writer.indent();
+
+ // Server requests (sent from client to server)
+ for (const request of metaModel.requests) {
+ if (request.messageDirection === 'clientToServer' || request.messageDirection === 'both') {
+ generateRequest(request);
+ }
+ }
+
+ // Server notifications (sent from client to server)
+ for (const notification of metaModel.notifications) {
+ if (
+ notification.messageDirection === 'clientToServer' ||
+ notification.messageDirection === 'both'
+ ) {
+ generateNotification(notification);
+ }
+ }
+
+ this.writer.outdent();
+ this.writer.writeLine('},');
+
+ // Client section
+ this.writer.writeLine('client: {');
+ this.writer.indent();
+
+ // Client requests (handled by server)
+ for (const request of metaModel.requests) {
+ if (request.messageDirection === 'serverToClient' || request.messageDirection === 'both') {
+ generateRequest(request, true); // serverToClient requests are optional
+ }
+ }
+
+ // Client notifications (sent from server to client)
+ for (const notification of metaModel.notifications) {
+ if (
+ notification.messageDirection === 'serverToClient' ||
+ notification.messageDirection === 'both'
+ ) {
+ generateNotification(notification);
+ }
+ }
+
+ this.writer.outdent();
+ this.writer.writeLine('}');
+
+ this.writer.outdent();
+ this.writer.writeLine('});');
+ this.writer.writeLine('');
+ }
+
+ /**
+ * Helper method to get parameter type
+ */
+ private getParamsType(params?: Type | Type[]): string {
+ if (!params) {
+ return 'void';
+ }
+ if (Array.isArray(params)) {
+ const paramTypes = params.map((p) => this.typeToTypeScript(p));
+ return `[${paramTypes.join(', ')}]`;
+ } else {
+ return this.typeToTypeScript(params);
+ }
+ }
+
+ /**
+ * Generate the complete TypeScript types
+ */
+ generate(): void {
+ const metaModel = this.loadMetaModel();
+
+ this.writer.clear();
+ this.writer.writeLine('// Generated TypeScript definitions for LSP');
+ this.writer.writeLine(`// Protocol version: ${metaModel.metaData.version}`);
+ this.writer.writeLine('// This file is auto-generated. Do not edit manually.');
+ this.writer.writeLine('');
+
+ // Import contract types from @hediet/json-rpc
+ this.writer.writeLine('import {');
+ this.writer.indent();
+ this.writer.writeLine('contract,');
+ this.writer.writeLine('Contract,');
+ this.writer.writeLine('unverifiedRequest,');
+ this.writer.writeLine('unverifiedNotification,');
+ this.writer.outdent();
+ this.writer.writeLine('} from "@hediet/json-rpc";');
+ this.writer.writeLine('');
+
+ // Generate enumerations
+ for (const enumeration of metaModel.enumerations) {
+ this.generateEnumeration(enumeration);
+ }
+
+ // Generate type aliases
+ for (const typeAlias of metaModel.typeAliases) {
+ this.generateTypeAlias(typeAlias);
+ }
+
+ // Generate structures
+ for (const structure of metaModel.structures) {
+ this.generateStructure(structure);
+ }
+
+ // Generate Capability class
+ this.generateCapabilityClass();
+
+ // Generate capabilities map
+ this.generateCapabilitiesMap(metaModel);
+
+ // Generate API contract
+ this.generateApiContract(metaModel);
+
+ // Write types file
+ const srcDir = path.join(__dirname, '..', 'src');
+ if (!fs.existsSync(srcDir)) {
+ fs.mkdirSync(srcDir, { recursive: true });
+ }
+ fs.writeFileSync(path.join(srcDir, 'types.ts'), this.writer.toString());
+
+ console.log('Generated LSP types file: src/types.ts');
+ }
+}
+
+// Run the generator
+if (require.main === module) {
+ const generator = new LSPTypesGenerator();
+ generator.generate();
+}
diff --git a/monaco-lsp-client/package-lock.json b/monaco-lsp-client/package-lock.json
new file mode 100644
index 00000000..2f47ccae
--- /dev/null
+++ b/monaco-lsp-client/package-lock.json
@@ -0,0 +1,1607 @@
+{
+ "name": "@vscode/monaco-lsp-client",
+ "version": "0.1.0",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "": {
+ "name": "@vscode/monaco-lsp-client",
+ "version": "0.1.0",
+ "dependencies": {
+ "@hediet/json-rpc": "^0.5.0",
+ "@hediet/json-rpc-browser": "^0.5.1",
+ "@hediet/json-rpc-websocket": "^0.5.1"
+ },
+ "devDependencies": {
+ "rolldown": "^1.0.0-beta.41",
+ "rolldown-plugin-dts": "^0.16.11",
+ "rollup-plugin-delete": "^3.0.1"
+ },
+ "peerDependencies": {
+ "monaco-editor-core": "^0.54.0-dev-20250929"
+ }
+ },
+ "../../../hediet/typed-json-rpc/json-rpc-node": {
+ "name": "@hediet/json-rpc-node",
+ "version": "0.5.0",
+ "extraneous": true,
+ "license": "MIT",
+ "dependencies": {
+ "@hediet/json-rpc": "^0.5.0",
+ "@types/node": "^12.0.7"
+ },
+ "devDependencies": {
+ "@types/mocha": "^5.2.7",
+ "coveralls": "^3.0.4",
+ "mocha": "^6.1.4",
+ "mocha-lcov-reporter": "^1.3.0",
+ "nyc": "^14.1.1",
+ "source-map-support": "^0.5.12"
+ }
+ },
+ "../../hediet/typed-json-rpc/json-rpc-browser": {
+ "extraneous": true
+ },
+ "node_modules/@babel/generator": {
+ "version": "7.28.3",
+ "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.3.tgz",
+ "integrity": "sha512-3lSpxGgvnmZznmBkCRnVREPUFJv2wrv9iAoFDvADJc0ypmdOxdUtcLeBgBJ6zE0PMeTKnxeQzyk0xTBq4Ep7zw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/parser": "^7.28.3",
+ "@babel/types": "^7.28.2",
+ "@jridgewell/gen-mapping": "^0.3.12",
+ "@jridgewell/trace-mapping": "^0.3.28",
+ "jsesc": "^3.0.2"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-string-parser": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+ "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-validator-identifier": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+ "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/parser": {
+ "version": "7.28.4",
+ "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.4.tgz",
+ "integrity": "sha512-yZbBqeM6TkpP9du/I2pUZnJsRMGGvOuIrhjzC1AwHwW+6he4mni6Bp/m8ijn0iOuZuPI2BfkCoSRunpyjnrQKg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/types": "^7.28.4"
+ },
+ "bin": {
+ "parser": "bin/babel-parser.js"
+ },
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/@babel/types": {
+ "version": "7.28.4",
+ "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.4.tgz",
+ "integrity": "sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-string-parser": "^7.27.1",
+ "@babel/helper-validator-identifier": "^7.27.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@emnapi/core": {
+ "version": "1.5.0",
+ "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.5.0.tgz",
+ "integrity": "sha512-sbP8GzB1WDzacS8fgNPpHlp6C9VZe+SJP3F90W9rLemaQj2PzIuTEl1qDOYQf58YIpyjViI24y9aPWCjEzY2cg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "@emnapi/wasi-threads": "1.1.0",
+ "tslib": "^2.4.0"
+ }
+ },
+ "node_modules/@emnapi/runtime": {
+ "version": "1.5.0",
+ "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.5.0.tgz",
+ "integrity": "sha512-97/BJ3iXHww3djw6hYIfErCZFee7qCtrneuLa20UXFCOTCfBM2cvQHjWJ2EG0s0MtdNwInarqCTz35i4wWXHsQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "tslib": "^2.4.0"
+ }
+ },
+ "node_modules/@emnapi/wasi-threads": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.1.0.tgz",
+ "integrity": "sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "tslib": "^2.4.0"
+ }
+ },
+ "node_modules/@hediet/json-rpc": {
+ "version": "0.5.0",
+ "resolved": "https://registry.npmjs.org/@hediet/json-rpc/-/json-rpc-0.5.0.tgz",
+ "integrity": "sha512-SApO7NbKJztClcznEqg46ZGQzO2v3Q3gVIuRVC9QE/m75J/5AipJdclxEXgT++7j4x4LI2JjEpf2xhi67Ngu9A==",
+ "license": "MIT"
+ },
+ "node_modules/@hediet/json-rpc-browser": {
+ "version": "0.5.1",
+ "resolved": "https://registry.npmjs.org/@hediet/json-rpc-browser/-/json-rpc-browser-0.5.1.tgz",
+ "integrity": "sha512-iR+WrTdM7WozRJ/MElfeT8CmH2f911Y8P6xfcj5RCfywp7kjnnqKPUV/VnNnzToxRZUO8WAfJtLvmhDBsSjMtA==",
+ "license": "MIT",
+ "dependencies": {
+ "@hediet/json-rpc": "^0.5.0"
+ }
+ },
+ "node_modules/@hediet/json-rpc-websocket": {
+ "version": "0.5.1",
+ "resolved": "https://registry.npmjs.org/@hediet/json-rpc-websocket/-/json-rpc-websocket-0.5.1.tgz",
+ "integrity": "sha512-1H9UjKyR00ZjwcReQdzTxyEoZKaEubeOvxBVrwHGo4n9HeQt6SvQgtef+1AJ9MT7/sV2Qfe0VWarYivx6BWgIA==",
+ "license": "MIT",
+ "dependencies": {
+ "@hediet/json-rpc": "^0.5.0",
+ "@types/ws": "^6.0.4",
+ "isomorphic-ws": "^5.0.0"
+ }
+ },
+ "node_modules/@jridgewell/gen-mapping": {
+ "version": "0.3.13",
+ "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+ "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/sourcemap-codec": "^1.5.0",
+ "@jridgewell/trace-mapping": "^0.3.24"
+ }
+ },
+ "node_modules/@jridgewell/resolve-uri": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+ "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/@jridgewell/sourcemap-codec": {
+ "version": "1.5.5",
+ "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+ "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@jridgewell/trace-mapping": {
+ "version": "0.3.31",
+ "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+ "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/resolve-uri": "^3.1.0",
+ "@jridgewell/sourcemap-codec": "^1.4.14"
+ }
+ },
+ "node_modules/@napi-rs/wasm-runtime": {
+ "version": "1.0.6",
+ "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.0.6.tgz",
+ "integrity": "sha512-DXj75ewm11LIWUk198QSKUTxjyRjsBwk09MuMk5DGK+GDUtyPhhEHOGP/Xwwj3DjQXXkivoBirmOnKrLfc0+9g==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "@emnapi/core": "^1.5.0",
+ "@emnapi/runtime": "^1.5.0",
+ "@tybys/wasm-util": "^0.10.1"
+ }
+ },
+ "node_modules/@nodelib/fs.scandir": {
+ "version": "2.1.5",
+ "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+ "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@nodelib/fs.stat": "2.0.5",
+ "run-parallel": "^1.1.9"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/@nodelib/fs.stat": {
+ "version": "2.0.5",
+ "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+ "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/@nodelib/fs.walk": {
+ "version": "1.2.8",
+ "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+ "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@nodelib/fs.scandir": "2.1.5",
+ "fastq": "^1.6.0"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/@oxc-project/types": {
+ "version": "0.94.0",
+ "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.94.0.tgz",
+ "integrity": "sha512-+UgQT/4o59cZfH6Cp7G0hwmqEQ0wE+AdIwhikdwnhWI9Dp8CgSY081+Q3O67/wq3VJu8mgUEB93J9EHHn70fOw==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/Boshen"
+ }
+ },
+ "node_modules/@rolldown/binding-android-arm64": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-beta.42.tgz",
+ "integrity": "sha512-W5ZKF3TP3bOWuBfotAGp+UGjxOkGV7jRmIRbBA7NFjggx7Oi6vOmGDqpHEIX7kDCiry1cnIsWQaxNvWbMdkvzQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-darwin-arm64": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-beta.42.tgz",
+ "integrity": "sha512-abw/wtgJA8OCgaTlL+xJxnN/Z01BwV1rfzIp5Hh9x+IIO6xOBfPsQ0nzi0+rWx3TyZ9FZXyC7bbC+5NpQ9EaXQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-darwin-x64": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-beta.42.tgz",
+ "integrity": "sha512-Y/UrZIRVr8CvXVEB88t6PeC46r1K9/QdPEo2ASE/b/KBEyXIx+QbM6kv9QfQVWU2Atly2+SVsQzxQsIvuk3lZQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-freebsd-x64": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-beta.42.tgz",
+ "integrity": "sha512-zRM0oOk7BZiy6DoWBvdV4hyEg+j6+WcBZIMHVirMEZRu8hd18kZdJkg+bjVMfCEhwpWeFUfBfZ1qcaZ5UdYzlQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-beta.42.tgz",
+ "integrity": "sha512-6RjFaC52QNwo7ilU8C5H7swbGlgfTkG9pudXwzr3VYyT18s0C9gLg3mvc7OMPIGqNxnQ0M5lU8j6aQCk2DTRVg==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-arm64-gnu": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-beta.42.tgz",
+ "integrity": "sha512-LMYHM5Sf6ROq+VUwHMDVX2IAuEsWTv4SnlFEedBnMGpvRuQ14lCmD4m5Q8sjyAQCgyha9oghdGoK8AEg1sXZKg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-arm64-musl": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-beta.42.tgz",
+ "integrity": "sha512-/bNTYb9aKNhzdbPn3O4MK2aLv55AlrkUKPE4KNfBYjkoZUfDr4jWp7gsSlvTc5A/99V1RCm9axvt616ZzeXGyA==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-x64-gnu": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-beta.42.tgz",
+ "integrity": "sha512-n/SLa4h342oyeGykZdch7Y3GNCNliRPL4k5wkeZ/5eQZs+c6/ZG1SHCJQoy7bZcmxiMyaXs9HoFmv1PEKrZgWg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-x64-musl": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-beta.42.tgz",
+ "integrity": "sha512-4PSd46sFzqpLHSGdaSViAb1mk55sCUMpJg+X8ittXaVocQsV3QLG/uydSH8RyL0ngHX5fy3D70LcCzlB15AgHw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-openharmony-arm64": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-beta.42.tgz",
+ "integrity": "sha512-BmWoeJJyeZXmZBcfoxG6J9+rl2G7eO47qdTkAzEegj4n3aC6CBIHOuDcbE8BvhZaEjQR0nh0nJrtEDlt65Q7Sw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "openharmony"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-wasm32-wasi": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-beta.42.tgz",
+ "integrity": "sha512-2Ft32F7uiDTrGZUKws6CLNTlvTWHC33l4vpXrzUucf9rYtUThAdPCOt89Pmn13tNX6AulxjGEP2R0nZjTSW3eQ==",
+ "cpu": [
+ "wasm32"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "@napi-rs/wasm-runtime": "^1.0.6"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ }
+ },
+ "node_modules/@rolldown/binding-win32-arm64-msvc": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-beta.42.tgz",
+ "integrity": "sha512-hC1kShXW/z221eG+WzQMN06KepvPbMBknF0iGR3VMYJLOe9gwnSTfGxFT5hf8XrPv7CEZqTWRd0GQpkSHRbGsw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-win32-ia32-msvc": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-ia32-msvc/-/binding-win32-ia32-msvc-1.0.0-beta.42.tgz",
+ "integrity": "sha512-AICBYromawouGjj+GS33369E8Vwhy6UwhQEhQ5evfS8jPCsyVvoICJatbDGDGH01dwtVGLD5eDFzPicUOVpe4g==",
+ "cpu": [
+ "ia32"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-win32-x64-msvc": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-beta.42.tgz",
+ "integrity": "sha512-XpZ0M+tjoEiSc9c+uZR7FCnOI0uxDRNs1elGOMjeB0pUP1QmvVbZGYNsyLbLoP4u7e3VQN8rie1OQ8/mB6rcJg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/pluginutils": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.42.tgz",
+ "integrity": "sha512-N7pQzk9CyE7q0bBN/q0J8s6Db279r5kUZc6d7/wWRe9/zXqC52HQovVyu6iXPIDY4BEzzgbVLhVFXrOuGJ22ZQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@rollup/rollup-android-arm-eabi": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.52.4.tgz",
+ "integrity": "sha512-BTm2qKNnWIQ5auf4deoetINJm2JzvihvGb9R6K/ETwKLql/Bb3Eg2H1FBp1gUb4YGbydMA3jcmQTR73q7J+GAA==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-android-arm64": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.52.4.tgz",
+ "integrity": "sha512-P9LDQiC5vpgGFgz7GSM6dKPCiqR3XYN1WwJKA4/BUVDjHpYsf3iBEmVz62uyq20NGYbiGPR5cNHI7T1HqxNs2w==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-darwin-arm64": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.52.4.tgz",
+ "integrity": "sha512-QRWSW+bVccAvZF6cbNZBJwAehmvG9NwfWHwMy4GbWi/BQIA/laTIktebT2ipVjNncqE6GLPxOok5hsECgAxGZg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-darwin-x64": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.52.4.tgz",
+ "integrity": "sha512-hZgP05pResAkRJxL1b+7yxCnXPGsXU0fG9Yfd6dUaoGk+FhdPKCJ5L1Sumyxn8kvw8Qi5PvQ8ulenUbRjzeCTw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-freebsd-arm64": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.52.4.tgz",
+ "integrity": "sha512-xmc30VshuBNUd58Xk4TKAEcRZHaXlV+tCxIXELiE9sQuK3kG8ZFgSPi57UBJt8/ogfhAF5Oz4ZSUBN77weM+mQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-freebsd-x64": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.52.4.tgz",
+ "integrity": "sha512-WdSLpZFjOEqNZGmHflxyifolwAiZmDQzuOzIq9L27ButpCVpD7KzTRtEG1I0wMPFyiyUdOO+4t8GvrnBLQSwpw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.52.4.tgz",
+ "integrity": "sha512-xRiOu9Of1FZ4SxVbB0iEDXc4ddIcjCv2aj03dmW8UrZIW7aIQ9jVJdLBIhxBI+MaTnGAKyvMwPwQnoOEvP7FgQ==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.52.4.tgz",
+ "integrity": "sha512-FbhM2p9TJAmEIEhIgzR4soUcsW49e9veAQCziwbR+XWB2zqJ12b4i/+hel9yLiD8pLncDH4fKIPIbt5238341Q==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-linux-arm64-gnu": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.52.4.tgz",
+ "integrity": "sha512-4n4gVwhPHR9q/g8lKCyz0yuaD0MvDf7dV4f9tHt0C73Mp8h38UCtSCSE6R9iBlTbXlmA8CjpsZoujhszefqueg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-linux-arm64-musl": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.52.4.tgz",
+ "integrity": "sha512-u0n17nGA0nvi/11gcZKsjkLj1QIpAuPFQbR48Subo7SmZJnGxDpspyw2kbpuoQnyK+9pwf3pAoEXerJs/8Mi9g==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-linux-loong64-gnu": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.52.4.tgz",
+ "integrity": "sha512-0G2c2lpYtbTuXo8KEJkDkClE/+/2AFPdPAbmaHoE870foRFs4pBrDehilMcrSScrN/fB/1HTaWO4bqw+ewBzMQ==",
+ "cpu": [
+ "loong64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.52.4.tgz",
+ "integrity": "sha512-teSACug1GyZHmPDv14VNbvZFX779UqWTsd7KtTM9JIZRDI5NUwYSIS30kzI8m06gOPB//jtpqlhmraQ68b5X2g==",
+ "cpu": [
+ "ppc64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.52.4.tgz",
+ "integrity": "sha512-/MOEW3aHjjs1p4Pw1Xk4+3egRevx8Ji9N6HUIA1Ifh8Q+cg9dremvFCUbOX2Zebz80BwJIgCBUemjqhU5XI5Eg==",
+ "cpu": [
+ "riscv64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-linux-riscv64-musl": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.52.4.tgz",
+ "integrity": "sha512-1HHmsRyh845QDpEWzOFtMCph5Ts+9+yllCrREuBR/vg2RogAQGGBRC8lDPrPOMnrdOJ+mt1WLMOC2Kao/UwcvA==",
+ "cpu": [
+ "riscv64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-linux-s390x-gnu": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.52.4.tgz",
+ "integrity": "sha512-seoeZp4L/6D1MUyjWkOMRU6/iLmCU2EjbMTyAG4oIOs1/I82Y5lTeaxW0KBfkUdHAWN7j25bpkt0rjnOgAcQcA==",
+ "cpu": [
+ "s390x"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-linux-x64-gnu": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.52.4.tgz",
+ "integrity": "sha512-Wi6AXf0k0L7E2gteNsNHUs7UMwCIhsCTs6+tqQ5GPwVRWMaflqGec4Sd8n6+FNFDw9vGcReqk2KzBDhCa1DLYg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-linux-x64-musl": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.52.4.tgz",
+ "integrity": "sha512-dtBZYjDmCQ9hW+WgEkaffvRRCKm767wWhxsFW3Lw86VXz/uJRuD438/XvbZT//B96Vs8oTA8Q4A0AfHbrxP9zw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-openharmony-arm64": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.52.4.tgz",
+ "integrity": "sha512-1ox+GqgRWqaB1RnyZXL8PD6E5f7YyRUJYnCqKpNzxzP0TkaUh112NDrR9Tt+C8rJ4x5G9Mk8PQR3o7Ku2RKqKA==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "openharmony"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-win32-arm64-msvc": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.52.4.tgz",
+ "integrity": "sha512-8GKr640PdFNXwzIE0IrkMWUNUomILLkfeHjXBi/nUvFlpZP+FA8BKGKpacjW6OUUHaNI6sUURxR2U2g78FOHWQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-win32-ia32-msvc": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.52.4.tgz",
+ "integrity": "sha512-AIy/jdJ7WtJ/F6EcfOb2GjR9UweO0n43jNObQMb6oGxkYTfLcnN7vYYpG+CN3lLxrQkzWnMOoNSHTW54pgbVxw==",
+ "cpu": [
+ "ia32"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-win32-x64-gnu": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.52.4.tgz",
+ "integrity": "sha512-UF9KfsH9yEam0UjTwAgdK0anlQ7c8/pWPU2yVjyWcF1I1thABt6WXE47cI71pGiZ8wGvxohBoLnxM04L/wj8mQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "peer": true
+ },
+ "node_modules/@rollup/rollup-win32-x64-msvc": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.52.4.tgz",
+ "integrity": "sha512-bf9PtUa0u8IXDVxzRToFQKsNCRz9qLYfR/MpECxl4mRoWYjAeFjgxj1XdZr2M/GNVpT05p+LgQOHopYDlUu6/w==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "peer": true
+ },
+ "node_modules/@sindresorhus/merge-streams": {
+ "version": "2.3.0",
+ "resolved": "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-2.3.0.tgz",
+ "integrity": "sha512-LtoMMhxAlorcGhmFYI+LhPgbPZCkgP6ra1YL604EeF6U98pLlQ3iWIGMdWSC+vWmPBWBNgmDBAhnAobLROJmwg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/@tybys/wasm-util": {
+ "version": "0.10.1",
+ "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.1.tgz",
+ "integrity": "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "tslib": "^2.4.0"
+ }
+ },
+ "node_modules/@types/estree": {
+ "version": "1.0.8",
+ "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+ "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true
+ },
+ "node_modules/@types/node": {
+ "version": "24.10.0",
+ "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.0.tgz",
+ "integrity": "sha512-qzQZRBqkFsYyaSWXuEHc2WR9c0a0CXwiE5FWUvn7ZM+vdy1uZLfCunD38UzhuB7YN/J11ndbDBcTmOdxJo9Q7A==",
+ "license": "MIT",
+ "dependencies": {
+ "undici-types": "~7.16.0"
+ }
+ },
+ "node_modules/@types/ws": {
+ "version": "6.0.4",
+ "resolved": "https://registry.npmjs.org/@types/ws/-/ws-6.0.4.tgz",
+ "integrity": "sha512-PpPrX7SZW9re6+Ha8ojZG4Se8AZXgf0GK6zmfqEuCsY49LFDNXO3SByp44X3dFEqtB73lkCDAdUazhAjVPiNwg==",
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/ansis": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/ansis/-/ansis-4.2.0.tgz",
+ "integrity": "sha512-HqZ5rWlFjGiV0tDm3UxxgNRqsOTniqoKZu0pIAfh7TZQMGuZK+hH0drySty0si0QXj1ieop4+SkSfPZBPPkHig==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">=14"
+ }
+ },
+ "node_modules/ast-kit": {
+ "version": "2.1.3",
+ "resolved": "https://registry.npmjs.org/ast-kit/-/ast-kit-2.1.3.tgz",
+ "integrity": "sha512-TH+b3Lv6pUjy/Nu0m6A2JULtdzLpmqF9x1Dhj00ZoEiML8qvVA9j1flkzTKNYgdEhWrjDwtWNpyyCUbfQe514g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/parser": "^7.28.4",
+ "pathe": "^2.0.3"
+ },
+ "engines": {
+ "node": ">=20.19.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sxzz"
+ }
+ },
+ "node_modules/birpc": {
+ "version": "2.6.1",
+ "resolved": "https://registry.npmjs.org/birpc/-/birpc-2.6.1.tgz",
+ "integrity": "sha512-LPnFhlDpdSH6FJhJyn4M0kFO7vtQ5iPw24FnG0y21q09xC7e8+1LeR31S1MAIrDAHp4m7aas4bEkTDTvMAtebQ==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/antfu"
+ }
+ },
+ "node_modules/braces": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+ "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fill-range": "^7.1.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/debug": {
+ "version": "4.4.3",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+ "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ms": "^2.1.3"
+ },
+ "engines": {
+ "node": ">=6.0"
+ },
+ "peerDependenciesMeta": {
+ "supports-color": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/del": {
+ "version": "8.0.1",
+ "resolved": "https://registry.npmjs.org/del/-/del-8.0.1.tgz",
+ "integrity": "sha512-gPqh0mKTPvaUZGAuHbrBUYKZWBNAeHG7TU3QH5EhVwPMyKvmfJaNXhcD2jTcXsJRRcffuho4vaYweu80dRrMGA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "globby": "^14.0.2",
+ "is-glob": "^4.0.3",
+ "is-path-cwd": "^3.0.0",
+ "is-path-inside": "^4.0.0",
+ "p-map": "^7.0.2",
+ "presentable-error": "^0.0.1",
+ "slash": "^5.1.0"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/dompurify": {
+ "version": "3.1.7",
+ "license": "(MPL-2.0 OR Apache-2.0)",
+ "peer": true
+ },
+ "node_modules/dts-resolver": {
+ "version": "2.1.2",
+ "resolved": "https://registry.npmjs.org/dts-resolver/-/dts-resolver-2.1.2.tgz",
+ "integrity": "sha512-xeXHBQkn2ISSXxbJWD828PFjtyg+/UrMDo7W4Ffcs7+YWCquxU8YjV1KoxuiL+eJ5pg3ll+bC6flVv61L3LKZg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=20.18.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sxzz"
+ },
+ "peerDependencies": {
+ "oxc-resolver": ">=11.0.0"
+ },
+ "peerDependenciesMeta": {
+ "oxc-resolver": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/fast-glob": {
+ "version": "3.3.3",
+ "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
+ "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@nodelib/fs.stat": "^2.0.2",
+ "@nodelib/fs.walk": "^1.2.3",
+ "glob-parent": "^5.1.2",
+ "merge2": "^1.3.0",
+ "micromatch": "^4.0.8"
+ },
+ "engines": {
+ "node": ">=8.6.0"
+ }
+ },
+ "node_modules/fastq": {
+ "version": "1.19.1",
+ "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz",
+ "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "reusify": "^1.0.4"
+ }
+ },
+ "node_modules/fill-range": {
+ "version": "7.1.1",
+ "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+ "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "to-regex-range": "^5.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/fsevents": {
+ "version": "2.3.3",
+ "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+ "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "peer": true,
+ "engines": {
+ "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+ }
+ },
+ "node_modules/get-tsconfig": {
+ "version": "4.11.0",
+ "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.11.0.tgz",
+ "integrity": "sha512-sNsqf7XKQ38IawiVGPOoAlqZo1DMrO7TU+ZcZwi7yLl7/7S0JwmoBMKz/IkUPhSoXM0Ng3vT0yB1iCe5XavDeQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "resolve-pkg-maps": "^1.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
+ }
+ },
+ "node_modules/glob-parent": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+ "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "is-glob": "^4.0.1"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/globby": {
+ "version": "14.1.0",
+ "resolved": "https://registry.npmjs.org/globby/-/globby-14.1.0.tgz",
+ "integrity": "sha512-0Ia46fDOaT7k4og1PDW4YbodWWr3scS2vAr2lTbsplOt2WkKp0vQbkI9wKis/T5LV/dqPjO3bpS/z6GTJB82LA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@sindresorhus/merge-streams": "^2.1.0",
+ "fast-glob": "^3.3.3",
+ "ignore": "^7.0.3",
+ "path-type": "^6.0.0",
+ "slash": "^5.1.0",
+ "unicorn-magic": "^0.3.0"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/ignore": {
+ "version": "7.0.5",
+ "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
+ "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 4"
+ }
+ },
+ "node_modules/is-extglob": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+ "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/is-glob": {
+ "version": "4.0.3",
+ "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+ "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "is-extglob": "^2.1.1"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/is-number": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+ "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.12.0"
+ }
+ },
+ "node_modules/is-path-cwd": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-3.0.0.tgz",
+ "integrity": "sha512-kyiNFFLU0Ampr6SDZitD/DwUo4Zs1nSdnygUBqsu3LooL00Qvb5j+UnvApUn/TTj1J3OuE6BTdQ5rudKmU2ZaA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/is-path-inside": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-4.0.0.tgz",
+ "integrity": "sha512-lJJV/5dYS+RcL8uQdBDW9c9uWFLLBNRyFhnAKXw5tVqLlKZ4RMGZKv+YQ/IA3OhD+RpbJa1LLFM1FQPGyIXvOA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/isomorphic-ws": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/isomorphic-ws/-/isomorphic-ws-5.0.0.tgz",
+ "integrity": "sha512-muId7Zzn9ywDsyXgTIafTry2sV3nySZeUDe6YedVd1Hvuuep5AsIlqK+XefWpYTyJG5e503F2xIuT2lcU6rCSw==",
+ "license": "MIT",
+ "peerDependencies": {
+ "ws": "*"
+ }
+ },
+ "node_modules/jsesc": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+ "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "jsesc": "bin/jsesc"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/magic-string": {
+ "version": "0.30.19",
+ "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.19.tgz",
+ "integrity": "sha512-2N21sPY9Ws53PZvsEpVtNuSW+ScYbQdp4b9qUaL+9QkHUrGFKo56Lg9Emg5s9V/qrtNBmiR01sYhUOwu3H+VOw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/sourcemap-codec": "^1.5.5"
+ }
+ },
+ "node_modules/marked": {
+ "version": "14.0.0",
+ "license": "MIT",
+ "peer": true,
+ "bin": {
+ "marked": "bin/marked.js"
+ },
+ "engines": {
+ "node": ">= 18"
+ }
+ },
+ "node_modules/merge2": {
+ "version": "1.4.1",
+ "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+ "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/micromatch": {
+ "version": "4.0.8",
+ "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+ "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "braces": "^3.0.3",
+ "picomatch": "^2.3.1"
+ },
+ "engines": {
+ "node": ">=8.6"
+ }
+ },
+ "node_modules/monaco-editor-core": {
+ "version": "0.54.0",
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "dompurify": "3.1.7",
+ "marked": "14.0.0"
+ }
+ },
+ "node_modules/ms": {
+ "version": "2.1.3",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+ "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/p-map": {
+ "version": "7.0.3",
+ "resolved": "https://registry.npmjs.org/p-map/-/p-map-7.0.3.tgz",
+ "integrity": "sha512-VkndIv2fIB99swvQoA65bm+fsmt6UNdGeIB0oxBs+WhAhdh08QA04JXpI7rbB9r08/nkbysKoya9rtDERYOYMA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/path-type": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/path-type/-/path-type-6.0.0.tgz",
+ "integrity": "sha512-Vj7sf++t5pBD637NSfkxpHSMfWaeig5+DKWLhcqIYx6mWQz5hdJTGDVMQiJcw1ZYkhs7AazKDGpRVji1LJCZUQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/pathe": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+ "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/picomatch": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+ "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8.6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/jonschlinkert"
+ }
+ },
+ "node_modules/presentable-error": {
+ "version": "0.0.1",
+ "resolved": "https://registry.npmjs.org/presentable-error/-/presentable-error-0.0.1.tgz",
+ "integrity": "sha512-E6rsNU1QNJgB3sjj7OANinGncFKuK+164sLXw1/CqBjj/EkXSoSdHCtWQGBNlREIGLnL7IEUEGa08YFVUbrhVg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=16"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/queue-microtask": {
+ "version": "1.2.3",
+ "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+ "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "MIT"
+ },
+ "node_modules/resolve-pkg-maps": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
+ "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
+ }
+ },
+ "node_modules/reusify": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
+ "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "iojs": ">=1.0.0",
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/rolldown": {
+ "version": "1.0.0-beta.42",
+ "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.0-beta.42.tgz",
+ "integrity": "sha512-xaPcckj+BbJhYLsv8gOqezc8EdMcKKe/gk8v47B0KPvgABDrQ0qmNPAiT/gh9n9Foe0bUkEv2qzj42uU5q1WRg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@oxc-project/types": "=0.94.0",
+ "@rolldown/pluginutils": "1.0.0-beta.42",
+ "ansis": "=4.2.0"
+ },
+ "bin": {
+ "rolldown": "bin/cli.mjs"
+ },
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ },
+ "optionalDependencies": {
+ "@rolldown/binding-android-arm64": "1.0.0-beta.42",
+ "@rolldown/binding-darwin-arm64": "1.0.0-beta.42",
+ "@rolldown/binding-darwin-x64": "1.0.0-beta.42",
+ "@rolldown/binding-freebsd-x64": "1.0.0-beta.42",
+ "@rolldown/binding-linux-arm-gnueabihf": "1.0.0-beta.42",
+ "@rolldown/binding-linux-arm64-gnu": "1.0.0-beta.42",
+ "@rolldown/binding-linux-arm64-musl": "1.0.0-beta.42",
+ "@rolldown/binding-linux-x64-gnu": "1.0.0-beta.42",
+ "@rolldown/binding-linux-x64-musl": "1.0.0-beta.42",
+ "@rolldown/binding-openharmony-arm64": "1.0.0-beta.42",
+ "@rolldown/binding-wasm32-wasi": "1.0.0-beta.42",
+ "@rolldown/binding-win32-arm64-msvc": "1.0.0-beta.42",
+ "@rolldown/binding-win32-ia32-msvc": "1.0.0-beta.42",
+ "@rolldown/binding-win32-x64-msvc": "1.0.0-beta.42"
+ }
+ },
+ "node_modules/rolldown-plugin-dts": {
+ "version": "0.16.11",
+ "resolved": "https://registry.npmjs.org/rolldown-plugin-dts/-/rolldown-plugin-dts-0.16.11.tgz",
+ "integrity": "sha512-9IQDaPvPqTx3RjG2eQCK5GYZITo203BxKunGI80AGYicu1ySFTUyugicAaTZWRzFWh9DSnzkgNeMNbDWBbSs0w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/generator": "^7.28.3",
+ "@babel/parser": "^7.28.4",
+ "@babel/types": "^7.28.4",
+ "ast-kit": "^2.1.2",
+ "birpc": "^2.6.1",
+ "debug": "^4.4.3",
+ "dts-resolver": "^2.1.2",
+ "get-tsconfig": "^4.10.1",
+ "magic-string": "^0.30.19"
+ },
+ "engines": {
+ "node": ">=20.18.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sxzz"
+ },
+ "peerDependencies": {
+ "@ts-macro/tsc": "^0.3.6",
+ "@typescript/native-preview": ">=7.0.0-dev.20250601.1",
+ "rolldown": "^1.0.0-beta.9",
+ "typescript": "^5.0.0",
+ "vue-tsc": "~3.1.0"
+ },
+ "peerDependenciesMeta": {
+ "@ts-macro/tsc": {
+ "optional": true
+ },
+ "@typescript/native-preview": {
+ "optional": true
+ },
+ "typescript": {
+ "optional": true
+ },
+ "vue-tsc": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/rollup": {
+ "version": "4.52.4",
+ "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.52.4.tgz",
+ "integrity": "sha512-CLEVl+MnPAiKh5pl4dEWSyMTpuflgNQiLGhMv8ezD5W/qP8AKvmYpCOKRRNOh7oRKnauBZ4SyeYkMS+1VSyKwQ==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@types/estree": "1.0.8"
+ },
+ "bin": {
+ "rollup": "dist/bin/rollup"
+ },
+ "engines": {
+ "node": ">=18.0.0",
+ "npm": ">=8.0.0"
+ },
+ "optionalDependencies": {
+ "@rollup/rollup-android-arm-eabi": "4.52.4",
+ "@rollup/rollup-android-arm64": "4.52.4",
+ "@rollup/rollup-darwin-arm64": "4.52.4",
+ "@rollup/rollup-darwin-x64": "4.52.4",
+ "@rollup/rollup-freebsd-arm64": "4.52.4",
+ "@rollup/rollup-freebsd-x64": "4.52.4",
+ "@rollup/rollup-linux-arm-gnueabihf": "4.52.4",
+ "@rollup/rollup-linux-arm-musleabihf": "4.52.4",
+ "@rollup/rollup-linux-arm64-gnu": "4.52.4",
+ "@rollup/rollup-linux-arm64-musl": "4.52.4",
+ "@rollup/rollup-linux-loong64-gnu": "4.52.4",
+ "@rollup/rollup-linux-ppc64-gnu": "4.52.4",
+ "@rollup/rollup-linux-riscv64-gnu": "4.52.4",
+ "@rollup/rollup-linux-riscv64-musl": "4.52.4",
+ "@rollup/rollup-linux-s390x-gnu": "4.52.4",
+ "@rollup/rollup-linux-x64-gnu": "4.52.4",
+ "@rollup/rollup-linux-x64-musl": "4.52.4",
+ "@rollup/rollup-openharmony-arm64": "4.52.4",
+ "@rollup/rollup-win32-arm64-msvc": "4.52.4",
+ "@rollup/rollup-win32-ia32-msvc": "4.52.4",
+ "@rollup/rollup-win32-x64-gnu": "4.52.4",
+ "@rollup/rollup-win32-x64-msvc": "4.52.4",
+ "fsevents": "~2.3.2"
+ }
+ },
+ "node_modules/rollup-plugin-delete": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/rollup-plugin-delete/-/rollup-plugin-delete-3.0.1.tgz",
+ "integrity": "sha512-4tyijMQFwSDLA04DAHwbI2TrRwPiRwAqBQ17dxyr9CgHeHXLdgk8IDVWHFWPrL3UZJWrAmHohQ2MgmVghQDrlg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "del": "^8.0.0"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "peerDependencies": {
+ "rollup": "*"
+ }
+ },
+ "node_modules/run-parallel": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+ "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "queue-microtask": "^1.2.2"
+ }
+ },
+ "node_modules/slash": {
+ "version": "5.1.0",
+ "resolved": "https://registry.npmjs.org/slash/-/slash-5.1.0.tgz",
+ "integrity": "sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=14.16"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/to-regex-range": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+ "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "is-number": "^7.0.0"
+ },
+ "engines": {
+ "node": ">=8.0"
+ }
+ },
+ "node_modules/tslib": {
+ "version": "2.8.1",
+ "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+ "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+ "dev": true,
+ "license": "0BSD",
+ "optional": true
+ },
+ "node_modules/undici-types": {
+ "version": "7.16.0",
+ "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
+ "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
+ "license": "MIT"
+ },
+ "node_modules/unicorn-magic": {
+ "version": "0.3.0",
+ "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz",
+ "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/ws": {
+ "version": "8.18.3",
+ "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+ "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+ "license": "MIT",
+ "peer": true,
+ "engines": {
+ "node": ">=10.0.0"
+ },
+ "peerDependencies": {
+ "bufferutil": "^4.0.1",
+ "utf-8-validate": ">=5.0.2"
+ },
+ "peerDependenciesMeta": {
+ "bufferutil": {
+ "optional": true
+ },
+ "utf-8-validate": {
+ "optional": true
+ }
+ }
+ }
+ }
+}
diff --git a/monaco-lsp-client/package.json b/monaco-lsp-client/package.json
new file mode 100644
index 00000000..98b09fe5
--- /dev/null
+++ b/monaco-lsp-client/package.json
@@ -0,0 +1,26 @@
+{
+ "name": "@vscode/monaco-lsp-client",
+ "description": "description",
+ "authors": "vscode",
+ "version": "0.1.0",
+ "main": "out/index.js",
+ "types": "out/index.d.ts",
+ "dependencies": {
+ "@hediet/json-rpc": "^0.5.0",
+ "@hediet/json-rpc-browser": "^0.5.1",
+ "@hediet/json-rpc-websocket": "^0.5.1"
+ },
+ "peerDependencies": {
+ "monaco-editor-core": "^0.54.0-dev-20250929"
+ },
+ "devDependencies": {
+ "rolldown": "^1.0.0-beta.41",
+ "rolldown-plugin-dts": "^0.16.11",
+ "rollup-plugin-delete": "^3.0.1"
+ },
+ "scripts": {
+ "build": "npx rolldown -c rolldown.config.mjs",
+ "dev": "npx rolldown -c rolldown.config.mjs --watch",
+ "generate": "tsx generator/index.ts"
+ }
+}
diff --git a/monaco-lsp-client/rolldown.config.mjs b/monaco-lsp-client/rolldown.config.mjs
new file mode 100644
index 00000000..e6336a2b
--- /dev/null
+++ b/monaco-lsp-client/rolldown.config.mjs
@@ -0,0 +1,33 @@
+// @ts-check
+
+import { join } from 'path';
+import { defineConfig } from 'rolldown';
+import { dts } from 'rolldown-plugin-dts';
+import del from 'rollup-plugin-delete';
+import alias from '@rollup/plugin-alias';
+
+export default defineConfig({
+ input: {
+ index: join(import.meta.dirname, './src/index.ts')
+ },
+ output: {
+ dir: join(import.meta.dirname, './out'),
+ format: 'es'
+ },
+ external: ['monaco-editor-core'],
+ plugins: [
+ del({ targets: 'out/*' }),
+ alias({
+ entries: {
+ ws: 'undefined'
+ }
+ }),
+ dts({
+ tsconfig: false,
+ compilerOptions: {
+ stripInternal: true
+ },
+ resolve: true
+ })
+ ]
+});
diff --git a/monaco-lsp-client/src/adapters/ITextModelBridge.ts b/monaco-lsp-client/src/adapters/ITextModelBridge.ts
new file mode 100644
index 00000000..2193bb85
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/ITextModelBridge.ts
@@ -0,0 +1,40 @@
+import * as monaco from 'monaco-editor-core';
+import { Position, Range, TextDocumentIdentifier } from '../../src/types';
+
+export interface ITextModelBridge {
+ translate(
+ textModel: monaco.editor.ITextModel,
+ monacoPos: monaco.Position
+ ): {
+ textDocument: TextDocumentIdentifier;
+ position: Position;
+ };
+
+ translateRange(textModel: monaco.editor.ITextModel, monacoRange: monaco.Range): Range;
+
+ translateBack(
+ textDocument: TextDocumentIdentifier,
+ position: Position
+ ): {
+ textModel: monaco.editor.ITextModel;
+ position: monaco.Position;
+ };
+
+ translateBackRange(
+ textDocument: TextDocumentIdentifier,
+ range: Range
+ ): {
+ textModel: monaco.editor.ITextModel;
+ range: monaco.Range;
+ };
+}
+
+export function assertTargetTextModel(
+ input: T,
+ expectedTextModel: monaco.editor.ITextModel
+): T {
+ if (input.textModel !== expectedTextModel) {
+ throw new Error(`Expected text model to be ${expectedTextModel}, but got ${input.textModel}`);
+ }
+ return input;
+}
diff --git a/monaco-lsp-client/src/adapters/LspCapabilitiesRegistry.ts b/monaco-lsp-client/src/adapters/LspCapabilitiesRegistry.ts
new file mode 100644
index 00000000..0f87f574
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/LspCapabilitiesRegistry.ts
@@ -0,0 +1,254 @@
+import { TypedChannel } from '@hediet/json-rpc';
+import { ClientCapabilities, Capability, ServerCapabilities, api, capabilities, TextDocumentChangeRegistrationOptions, TextDocumentSyncKind } from '../../src/types';
+import { IDisposable, Disposable } from '../utils';
+
+export interface ILspCapabilitiesRegistry {
+ addStaticClientCapabilities(capability: ClientCapabilities): IDisposable;
+ registerCapabilityHandler(capability: Capability, handleStaticCapability: boolean, handler: (capability: T) => IDisposable): IDisposable;
+}
+
+export class LspCapabilitiesRegistry extends Disposable implements ILspCapabilitiesRegistry {
+ private readonly _staticCapabilities = new Set<{ cap: ClientCapabilities; }>();
+ private readonly _dynamicFromStatic = DynamicFromStaticOptions.create();
+ private readonly _registrations = new Map, CapabilityInfo>();
+ private _serverCapabilities: ServerCapabilities | undefined = undefined;
+
+ constructor(
+ private readonly _connection: TypedChannel
+ ) {
+ super();
+
+ this._register(this._connection.registerRequestHandler(api.client.clientRegisterCapability, async (params) => {
+ for (const registration of params.registrations) {
+ const capability = getCapabilityByMethod(registration.method);
+ const r = new CapabilityRegistration(registration.id, capability, registration.registerOptions, false);
+ this._registerCapabilityOptions(r);
+ }
+ return { ok: null };
+ }));
+
+ this._register(this._connection.registerRequestHandler(api.client.clientUnregisterCapability, async (params) => {
+ for (const unregistration of params.unregisterations) {
+ const capability = getCapabilityByMethod(unregistration.method);
+ const info = this._registrations.get(capability);
+ const handlerInfo = info?.registrations.get(unregistration.id);
+ if (!handlerInfo) {
+ throw new Error(`No registration for method ${unregistration.method} with id ${unregistration.id}`);
+ }
+ handlerInfo?.handlerDisposables.forEach(d => d.dispose());
+ info?.registrations.delete(unregistration.id);
+ }
+ return { ok: null };
+ }));
+ }
+
+ private _registerCapabilityOptions(registration: CapabilityRegistration) {
+ let registrationForMethod = this._registrations.get(registration.capability);
+ if (!registrationForMethod) {
+ registrationForMethod = new CapabilityInfo();
+ this._registrations.set(registration.capability, registrationForMethod);
+ }
+ if (registrationForMethod.registrations.has(registration.id)) {
+ throw new Error(`Handler for method ${registration.capability.method} with id ${registration.id} already registered`);
+ }
+ registrationForMethod.registrations.set(registration.id, registration);
+ for (const h of registrationForMethod.handlers) {
+ if (!h.handleStaticCapability && registration.isFromStatic) {
+ continue;
+ }
+ registration.handlerDisposables.set(h, h.handler(registration.options));
+ }
+ }
+
+ setServerCapabilities(serverCapabilities: ServerCapabilities) {
+ if (this._serverCapabilities) {
+ throw new Error('Server capabilities already set');
+ }
+ this._serverCapabilities = serverCapabilities;
+ for (const cap of Object.values(capabilities)) {
+ const options = this._dynamicFromStatic.getOptions(cap, serverCapabilities);
+ if (options) {
+ this._registerCapabilityOptions(new CapabilityRegistration(cap.method, cap, options, true));
+ }
+ }
+ }
+
+ getClientCapabilities(): ClientCapabilities {
+ const result: ClientCapabilities = {};
+ for (const c of this._staticCapabilities) {
+ deepAssign(result, c.cap);
+ }
+ return result;
+ }
+
+ addStaticClientCapabilities(capability: ClientCapabilities): IDisposable {
+ const obj = { cap: capability };
+ this._staticCapabilities.add(obj);
+ return {
+ dispose: () => {
+ this._staticCapabilities.delete(obj);
+ }
+ };
+ }
+
+ registerCapabilityHandler(capability: Capability, handleStaticCapability: boolean, handler: (capability: T) => IDisposable): IDisposable {
+ let info = this._registrations.get(capability);
+ if (!info) {
+ info = new CapabilityInfo();
+ this._registrations.set(capability, info);
+ }
+ const handlerInfo = new CapabilityHandler(capability, handleStaticCapability, handler);
+ info.handlers.add(handlerInfo);
+
+ for (const registration of info.registrations.values()) {
+ if (!handlerInfo.handleStaticCapability && registration.isFromStatic) {
+ continue;
+ }
+ registration.handlerDisposables.set(handlerInfo, handler(registration.options));
+ }
+
+ return {
+ dispose: () => {
+ info.handlers.delete(handlerInfo);
+ for (const registration of info.registrations.values()) {
+ const disposable = registration.handlerDisposables.get(handlerInfo);
+ if (disposable) {
+ disposable.dispose();
+ registration.handlerDisposables.delete(handlerInfo);
+ }
+ }
+ }
+ };
+ }
+}
+
+class CapabilityHandler {
+ constructor(
+ public readonly capability: Capability,
+ public readonly handleStaticCapability: boolean,
+ public readonly handler: (capabilityOptions: T) => IDisposable
+ ) { }
+}
+
+class CapabilityRegistration {
+ public readonly handlerDisposables = new Map, IDisposable>();
+
+ constructor(
+ public readonly id: string,
+ public readonly capability: Capability,
+ public readonly options: T,
+ public readonly isFromStatic: boolean
+ ) { }
+}
+
+const capabilitiesByMethod = new Map([...Object.values(capabilities)].map(c => [c.method, c]));
+function getCapabilityByMethod(method: string): Capability {
+ const c = capabilitiesByMethod.get(method);
+ if (!c) {
+ throw new Error(`No capability found for method ${method}`);
+ }
+ return c;
+}
+
+class CapabilityInfo {
+ public readonly handlers = new Set>();
+ public readonly registrations = new Map* id */ string, CapabilityRegistration>();
+}
+
+class DynamicFromStaticOptions {
+ private readonly _mappings = new Map* method */ string, (serverCapabilities: ServerCapabilities) => any>();
+
+ public static create(): DynamicFromStaticOptions {
+ const o = new DynamicFromStaticOptions();
+ o.set(capabilities.textDocumentDidChange, s => {
+ if (s.textDocumentSync === undefined) {
+ return undefined;
+ }
+ if (typeof s.textDocumentSync === 'object') {
+ return {
+ syncKind: s.textDocumentSync.change ?? TextDocumentSyncKind.None,
+ documentSelector: null,
+ } satisfies TextDocumentChangeRegistrationOptions;
+ } else {
+ return {
+ syncKind: s.textDocumentSync,
+ documentSelector: null,
+ } satisfies TextDocumentChangeRegistrationOptions;
+ }
+ return null!;
+ });
+
+ o.set(capabilities.textDocumentCompletion, s => s.completionProvider);
+ o.set(capabilities.textDocumentHover, s => s.hoverProvider);
+ o.set(capabilities.textDocumentSignatureHelp, s => s.signatureHelpProvider);
+ o.set(capabilities.textDocumentDefinition, s => s.definitionProvider);
+ o.set(capabilities.textDocumentReferences, s => s.referencesProvider);
+ o.set(capabilities.textDocumentDocumentHighlight, s => s.documentHighlightProvider);
+ o.set(capabilities.textDocumentDocumentSymbol, s => s.documentSymbolProvider);
+ o.set(capabilities.textDocumentCodeAction, s => s.codeActionProvider);
+ o.set(capabilities.textDocumentCodeLens, s => s.codeLensProvider);
+ o.set(capabilities.textDocumentDocumentLink, s => s.documentLinkProvider);
+ o.set(capabilities.textDocumentFormatting, s => s.documentFormattingProvider);
+ o.set(capabilities.textDocumentRangeFormatting, s => s.documentRangeFormattingProvider);
+ o.set(capabilities.textDocumentOnTypeFormatting, s => s.documentOnTypeFormattingProvider);
+ o.set(capabilities.textDocumentRename, s => s.renameProvider);
+ o.set(capabilities.textDocumentFoldingRange, s => s.foldingRangeProvider);
+ o.set(capabilities.textDocumentDeclaration, s => s.declarationProvider);
+ o.set(capabilities.textDocumentTypeDefinition, s => s.typeDefinitionProvider);
+ o.set(capabilities.textDocumentImplementation, s => s.implementationProvider);
+ o.set(capabilities.textDocumentDocumentColor, s => s.colorProvider);
+ o.set(capabilities.textDocumentSelectionRange, s => s.selectionRangeProvider);
+ o.set(capabilities.textDocumentLinkedEditingRange, s => s.linkedEditingRangeProvider);
+ o.set(capabilities.textDocumentPrepareCallHierarchy, s => s.callHierarchyProvider);
+ o.set(capabilities.textDocumentSemanticTokensFull, s => s.semanticTokensProvider);
+ o.set(capabilities.textDocumentInlayHint, s => s.inlayHintProvider);
+ o.set(capabilities.textDocumentInlineValue, s => s.inlineValueProvider);
+ o.set(capabilities.textDocumentDiagnostic, s => s.diagnosticProvider);
+ o.set(capabilities.textDocumentMoniker, s => s.monikerProvider);
+ o.set(capabilities.textDocumentPrepareTypeHierarchy, s => s.typeHierarchyProvider);
+ o.set(capabilities.workspaceSymbol, s => s.workspaceSymbolProvider);
+ o.set(capabilities.workspaceExecuteCommand, s => s.executeCommandProvider);
+ return o;
+ }
+
+ set(capability: Capability, getOptionsFromStatic: (serverCapabilities: ServerCapabilities) => T | boolean | undefined): void {
+ if (this._mappings.has(capability.method)) {
+ throw new Error(`Capability for method ${capability.method} already registered`);
+ }
+ this._mappings.set(capability.method, getOptionsFromStatic);
+ }
+
+ getOptions(capability: Capability, serverCapabilities: ServerCapabilities): T | undefined {
+ const getter = this._mappings.get(capability.method);
+ if (!getter) {
+ return undefined;
+ }
+ const result = getter(serverCapabilities);
+ return result;
+ }
+}
+
+function deepAssign(target: any, source: any) {
+ for (const key of Object.keys(source)) {
+ const srcValue = source[key];
+ if (srcValue === undefined) {
+ continue;
+ }
+ const tgtValue = target[key];
+ if (tgtValue === undefined) {
+ target[key] = srcValue;
+ continue;
+ }
+
+ if (typeof srcValue !== 'object' || srcValue === null) {
+ target[key] = srcValue;
+ continue;
+ }
+ if (typeof tgtValue !== 'object' || tgtValue === null) {
+ target[key] = srcValue;
+ continue;
+ }
+
+ deepAssign(tgtValue, srcValue);
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/LspClient.ts b/monaco-lsp-client/src/adapters/LspClient.ts
new file mode 100644
index 00000000..1c5d7321
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/LspClient.ts
@@ -0,0 +1,90 @@
+import { IMessageTransport, TypedChannel } from "@hediet/json-rpc";
+import { LspCompletionFeature } from "./languageFeatures/LspCompletionFeature";
+import { LspHoverFeature } from "./languageFeatures/LspHoverFeature";
+import { LspSignatureHelpFeature } from "./languageFeatures/LspSignatureHelpFeature";
+import { LspDefinitionFeature } from "./languageFeatures/LspDefinitionFeature";
+import { LspDeclarationFeature } from "./languageFeatures/LspDeclarationFeature";
+import { LspTypeDefinitionFeature } from "./languageFeatures/LspTypeDefinitionFeature";
+import { LspImplementationFeature } from "./languageFeatures/LspImplementationFeature";
+import { LspReferencesFeature } from "./languageFeatures/LspReferencesFeature";
+import { LspDocumentHighlightFeature } from "./languageFeatures/LspDocumentHighlightFeature";
+import { LspDocumentSymbolFeature } from "./languageFeatures/LspDocumentSymbolFeature";
+import { LspRenameFeature } from "./languageFeatures/LspRenameFeature";
+import { LspCodeActionFeature } from "./languageFeatures/LspCodeActionFeature";
+import { LspCodeLensFeature } from "./languageFeatures/LspCodeLensFeature";
+import { LspDocumentLinkFeature } from "./languageFeatures/LspDocumentLinkFeature";
+import { LspFormattingFeature } from "./languageFeatures/LspFormattingFeature";
+import { LspRangeFormattingFeature } from "./languageFeatures/LspRangeFormattingFeature";
+import { LspOnTypeFormattingFeature } from "./languageFeatures/LspOnTypeFormattingFeature";
+import { LspFoldingRangeFeature } from "./languageFeatures/LspFoldingRangeFeature";
+import { LspSelectionRangeFeature } from "./languageFeatures/LspSelectionRangeFeature";
+import { LspInlayHintsFeature } from "./languageFeatures/LspInlayHintsFeature";
+import { LspSemanticTokensFeature } from "./languageFeatures/LspSemanticTokensFeature";
+import { LspDiagnosticsFeature } from "./languageFeatures/LspDiagnosticsFeature";
+import { api } from "../../src/types";
+import { LspConnection } from "./LspConnection";
+import { LspCapabilitiesRegistry } from './LspCapabilitiesRegistry';
+import { TextDocumentSynchronizer } from "./TextDocumentSynchronizer";
+import { DisposableStore, IDisposable } from "../utils";
+
+export class MonacoLspClient {
+ private _connection: LspConnection;
+ private readonly _capabilitiesRegistry: LspCapabilitiesRegistry;
+ private readonly _bridge: TextDocumentSynchronizer;
+
+ private _initPromise: Promise;
+
+ constructor(transport: IMessageTransport) {
+ const c = TypedChannel.fromTransport(transport);
+ const s = api.getServer(c, {});
+ c.startListen();
+
+ this._capabilitiesRegistry = new LspCapabilitiesRegistry(c);
+ this._bridge = new TextDocumentSynchronizer(s.server, this._capabilitiesRegistry);
+
+ this._connection = new LspConnection(s.server, this._bridge, this._capabilitiesRegistry, c);
+ this.createFeatures();
+
+ this._initPromise = this._init();
+ }
+
+ private async _init() {
+ const result = await this._connection.server.initialize({
+ processId: null,
+ capabilities: this._capabilitiesRegistry.getClientCapabilities(),
+ rootUri: null,
+ });
+
+ this._connection.server.initialized({});
+ this._capabilitiesRegistry.setServerCapabilities(result.capabilities);
+ }
+
+ protected createFeatures(): IDisposable {
+ const store = new DisposableStore();
+
+ store.add(new LspCompletionFeature(this._connection));
+ store.add(new LspHoverFeature(this._connection));
+ store.add(new LspSignatureHelpFeature(this._connection));
+ store.add(new LspDefinitionFeature(this._connection));
+ store.add(new LspDeclarationFeature(this._connection));
+ store.add(new LspTypeDefinitionFeature(this._connection));
+ store.add(new LspImplementationFeature(this._connection));
+ store.add(new LspReferencesFeature(this._connection));
+ store.add(new LspDocumentHighlightFeature(this._connection));
+ store.add(new LspDocumentSymbolFeature(this._connection));
+ store.add(new LspRenameFeature(this._connection));
+ store.add(new LspCodeActionFeature(this._connection));
+ store.add(new LspCodeLensFeature(this._connection));
+ store.add(new LspDocumentLinkFeature(this._connection));
+ store.add(new LspFormattingFeature(this._connection));
+ store.add(new LspRangeFormattingFeature(this._connection));
+ store.add(new LspOnTypeFormattingFeature(this._connection));
+ store.add(new LspFoldingRangeFeature(this._connection));
+ store.add(new LspSelectionRangeFeature(this._connection));
+ store.add(new LspInlayHintsFeature(this._connection));
+ store.add(new LspSemanticTokensFeature(this._connection));
+ store.add(new LspDiagnosticsFeature(this._connection));
+
+ return store;
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/LspConnection.ts b/monaco-lsp-client/src/adapters/LspConnection.ts
new file mode 100644
index 00000000..b9f619a2
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/LspConnection.ts
@@ -0,0 +1,13 @@
+import { TypedChannel } from '@hediet/json-rpc';
+import { api } from '../../src/types';
+import { ITextModelBridge } from './ITextModelBridge';
+import { LspCapabilitiesRegistry } from './LspCapabilitiesRegistry';
+
+export class LspConnection {
+ constructor(
+ public readonly server: typeof api.TServerInterface,
+ public readonly bridge: ITextModelBridge,
+ public readonly capabilities: LspCapabilitiesRegistry,
+ public readonly connection: TypedChannel,
+ ) { }
+}
diff --git a/monaco-lsp-client/src/adapters/TextDocumentSynchronizer.ts b/monaco-lsp-client/src/adapters/TextDocumentSynchronizer.ts
new file mode 100644
index 00000000..c2b3620c
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/TextDocumentSynchronizer.ts
@@ -0,0 +1,183 @@
+import * as monaco from 'monaco-editor-core';
+import { api, capabilities, Position, Range, TextDocumentContentChangeEvent, TextDocumentIdentifier } from '../../src/types';
+import { Disposable } from '../utils';
+import { ITextModelBridge } from './ITextModelBridge';
+import { ILspCapabilitiesRegistry } from './LspCapabilitiesRegistry';
+
+export class TextDocumentSynchronizer extends Disposable implements ITextModelBridge {
+ private readonly _managedModels = new Map();
+ private readonly _managedModelsReverse = new Map* uri */ string, monaco.editor.ITextModel>();
+
+ private _started = false;
+
+ constructor(
+ private readonly _server: typeof api.TServerInterface,
+ private readonly _capabilities: ILspCapabilitiesRegistry,
+ ) {
+ super();
+
+ this._register(this._capabilities.addStaticClientCapabilities({
+ textDocument: {
+ synchronization: {
+ dynamicRegistration: true,
+ willSave: false,
+ willSaveWaitUntil: false,
+ didSave: false,
+ }
+ }
+ }));
+
+ this._register(_capabilities.registerCapabilityHandler(capabilities.textDocumentDidChange, true, e => {
+ if (this._started) {
+ return {
+ dispose: () => {
+ }
+ }
+ }
+ this._started = true;
+ this._register(monaco.editor.onDidCreateModel(m => {
+ this._getOrCreateManagedModel(m);
+ }));
+ for (const m of monaco.editor.getModels()) {
+ this._getOrCreateManagedModel(m);
+ }
+ return {
+ dispose: () => {
+ }
+ }
+ }));
+ }
+
+ private _getOrCreateManagedModel(m: monaco.editor.ITextModel) {
+ if (!this._started) {
+ throw new Error('Not started');
+ }
+
+ const uriStr = m.uri.toString(true).toLowerCase();
+ let mm = this._managedModels.get(m);
+ if (!mm) {
+ mm = new ManagedModel(m, this._server);
+ this._managedModels.set(m, mm);
+ this._managedModelsReverse.set(uriStr, m);
+ }
+ m.onWillDispose(() => {
+ mm!.dispose();
+ this._managedModels.delete(m);
+ this._managedModelsReverse.delete(uriStr);
+ });
+ return mm;
+ }
+
+ translateBack(textDocument: TextDocumentIdentifier, position: Position): { textModel: monaco.editor.ITextModel; position: monaco.Position; } {
+ const uri = textDocument.uri.toLowerCase();
+ const textModel = this._managedModelsReverse.get(uri);
+ if (!textModel) {
+ throw new Error(`No text model for uri ${uri}`);
+ }
+ const monacoPosition = new monaco.Position(position.line + 1, position.character + 1);
+ return { textModel, position: monacoPosition };
+ }
+
+ translateBackRange(textDocument: TextDocumentIdentifier, range: Range): { textModel: monaco.editor.ITextModel; range: monaco.Range; } {
+ const uri = textDocument.uri.toLowerCase();
+ const textModel = this._managedModelsReverse.get(uri);
+ if (!textModel) {
+ throw new Error(`No text model for uri ${uri}`);
+ }
+ const monacoRange = new monaco.Range(
+ range.start.line + 1,
+ range.start.character + 1,
+ range.end.line + 1,
+ range.end.character + 1
+ );
+ return { textModel, range: monacoRange };
+ }
+
+ translate(textModel: monaco.editor.ITextModel, monacoPos: monaco.Position): { textDocument: TextDocumentIdentifier; position: Position; } {
+ return {
+ textDocument: {
+ uri: textModel.uri.toString(true),
+ },
+ position: {
+ line: monacoPos.lineNumber - 1,
+ character: monacoPos.column - 1,
+ }
+ };
+ }
+
+ translateRange(textModel: monaco.editor.ITextModel, monacoRange: monaco.Range): Range {
+ return {
+ start: {
+ line: monacoRange.startLineNumber - 1,
+ character: monacoRange.startColumn - 1,
+ },
+ end: {
+ line: monacoRange.endLineNumber - 1,
+ character: monacoRange.endColumn - 1,
+ }
+ };
+ }
+}
+
+class ManagedModel extends Disposable {
+ constructor(
+ private readonly _textModel: monaco.editor.ITextModel,
+ private readonly _api: typeof api.TServerInterface
+ ) {
+ super();
+
+ const uri = _textModel.uri.toString(true).toLowerCase();
+
+ this._api.textDocumentDidOpen({
+ textDocument: {
+ languageId: _textModel.getLanguageId(),
+ uri: uri,
+ version: _textModel.getVersionId(),
+ text: _textModel.getValue(),
+ }
+ });
+
+ this._register(_textModel.onDidChangeContent(e => {
+ const contentChanges = e.changes.map(c => toLspTextDocumentContentChangeEvent(c));
+
+ this._api.textDocumentDidChange({
+ textDocument: {
+ uri: uri,
+ version: _textModel.getVersionId(),
+ },
+ contentChanges: contentChanges
+ });
+ }));
+
+ this._register({
+ dispose: () => {
+ this._api.textDocumentDidClose({
+ textDocument: {
+ uri: uri,
+ }
+ });
+ }
+ });
+ }
+}
+
+function toLspTextDocumentContentChangeEvent(change: monaco.editor.IModelContentChange): TextDocumentContentChangeEvent {
+ return {
+ range: toLspRange(change.range),
+ rangeLength: change.rangeLength,
+ text: change.text,
+ };
+}
+
+function toLspRange(range: monaco.IRange): Range {
+ return {
+ start: {
+ line: range.startLineNumber - 1,
+ character: range.startColumn - 1,
+ },
+ end: {
+ line: range.endLineNumber - 1,
+ character: range.endColumn - 1,
+ }
+ };
+}
\ No newline at end of file
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspCodeActionFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspCodeActionFeature.ts
new file mode 100644
index 00000000..aed4e0dd
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspCodeActionFeature.ts
@@ -0,0 +1,169 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, CodeActionRegistrationOptions, Command, WorkspaceEdit, CodeAction } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+import { lspCodeActionKindToMonacoCodeActionKind, toMonacoCodeActionKind, toLspDiagnosticSeverity, toLspCodeActionTriggerKind, toMonacoCommand } from './common';
+
+export class LspCodeActionFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ codeAction: {
+ dynamicRegistration: true,
+ codeActionLiteralSupport: {
+ codeActionKind: {
+ valueSet: Array.from(lspCodeActionKindToMonacoCodeActionKind.keys()),
+ }
+ },
+ isPreferredSupport: true,
+ disabledSupport: true,
+ dataSupport: true,
+ resolveSupport: {
+ properties: ['edit'],
+ },
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentCodeAction, true, capability => {
+ return monaco.languages.registerCodeActionProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspCodeActionProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+interface ExtendedCodeAction extends monaco.languages.CodeAction {
+ _lspAction?: CodeAction;
+}
+
+class LspCodeActionProvider implements monaco.languages.CodeActionProvider {
+ public readonly resolveCodeAction;
+
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: CodeActionRegistrationOptions,
+ ) {
+ if (_capabilities.resolveProvider) {
+ this.resolveCodeAction = async (codeAction: ExtendedCodeAction, token: monaco.CancellationToken): Promise => {
+ if (codeAction._lspAction) {
+ const resolved = await this._client.server.codeActionResolve(codeAction._lspAction);
+ if (resolved.edit) {
+ codeAction.edit = toMonacoWorkspaceEdit(resolved.edit, this._client);
+ }
+ if (resolved.command) {
+ codeAction.command = toMonacoCommand(resolved.command);
+ }
+ }
+ return codeAction;
+ };
+ }
+ }
+
+ async provideCodeActions(
+ model: monaco.editor.ITextModel,
+ range: monaco.Range,
+ context: monaco.languages.CodeActionContext,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, range.getStartPosition());
+
+ const result = await this._client.server.textDocumentCodeAction({
+ textDocument: translated.textDocument,
+ range: this._client.bridge.translateRange(model, range),
+ context: {
+ diagnostics: context.markers.map(marker => ({
+ range: this._client.bridge.translateRange(model, monaco.Range.lift(marker)),
+ message: marker.message,
+ severity: toLspDiagnosticSeverity(marker.severity),
+ })),
+ triggerKind: toLspCodeActionTriggerKind(context.trigger),
+ },
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ const actions = Array.isArray(result) ? result : [result];
+
+ return {
+ actions: actions.map(action => {
+ if ('title' in action && !('kind' in action)) {
+ // Command
+ const cmd = action as Command;
+ const monacoAction: ExtendedCodeAction = {
+ title: cmd.title,
+ command: toMonacoCommand(cmd),
+ };
+ return monacoAction;
+ } else {
+ // CodeAction
+ const codeAction = action as CodeAction;
+ const monacoAction: ExtendedCodeAction = {
+ title: codeAction.title,
+ kind: toMonacoCodeActionKind(codeAction.kind),
+ isPreferred: codeAction.isPreferred,
+ disabled: codeAction.disabled?.reason,
+ edit: codeAction.edit ? toMonacoWorkspaceEdit(codeAction.edit, this._client) : undefined,
+ command: toMonacoCommand(codeAction.command),
+ _lspAction: codeAction,
+ };
+ return monacoAction;
+ }
+ }),
+ dispose: () => { },
+ };
+ }
+}
+
+function toMonacoWorkspaceEdit(
+ edit: WorkspaceEdit,
+ client: LspConnection
+): monaco.languages.WorkspaceEdit {
+ const edits: monaco.languages.IWorkspaceTextEdit[] = [];
+
+ if (edit.changes) {
+ for (const uri in edit.changes) {
+ const textEdits = edit.changes[uri];
+ for (const textEdit of textEdits) {
+ const translated = client.bridge.translateBackRange({ uri }, textEdit.range);
+ edits.push({
+ resource: translated.textModel.uri,
+ versionId: undefined,
+ textEdit: {
+ range: translated.range,
+ text: textEdit.newText,
+ },
+ });
+ }
+ }
+ }
+
+ if (edit.documentChanges) {
+ for (const change of edit.documentChanges) {
+ if ('textDocument' in change) {
+ const uri = change.textDocument.uri;
+ for (const textEdit of change.edits) {
+ const translated = client.bridge.translateBackRange({ uri }, textEdit.range);
+ edits.push({
+ resource: translated.textModel.uri,
+ versionId: change.textDocument.version ?? undefined,
+ textEdit: {
+ range: translated.range,
+ text: textEdit.newText,
+ },
+ });
+ }
+ }
+ }
+ }
+
+ return { edits };
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspCodeLensFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspCodeLensFeature.ts
new file mode 100644
index 00000000..f11fdf71
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspCodeLensFeature.ts
@@ -0,0 +1,90 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, CodeLensRegistrationOptions, CodeLens } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+import { assertTargetTextModel } from '../ITextModelBridge';
+import { toMonacoCommand } from './common';
+
+export class LspCodeLensFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ codeLens: {
+ dynamicRegistration: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentCodeLens, true, capability => {
+ return monaco.languages.registerCodeLensProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspCodeLensProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+interface ExtendedCodeLens extends monaco.languages.CodeLens {
+ _lspCodeLens?: CodeLens;
+}
+
+class LspCodeLensProvider implements monaco.languages.CodeLensProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: CodeLensRegistrationOptions,
+ ) { }
+
+ async provideCodeLenses(
+ model: monaco.editor.ITextModel,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, new monaco.Position(1, 1));
+
+ const result = await this._client.server.textDocumentCodeLens({
+ textDocument: translated.textDocument,
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ return {
+ lenses: result.map(lens => {
+ const monacoLens: ExtendedCodeLens = {
+ range: assertTargetTextModel(this._client.bridge.translateBackRange(translated.textDocument, lens.range), model).range,
+ command: toMonacoCommand(lens.command),
+ _lspCodeLens: lens,
+ };
+ return monacoLens;
+ }),
+ dispose: () => { },
+ };
+ }
+
+ async resolveCodeLens(
+ model: monaco.editor.ITextModel,
+ codeLens: ExtendedCodeLens,
+ token: monaco.CancellationToken
+ ): Promise {
+ if (!this._capabilities.resolveProvider || !codeLens._lspCodeLens) {
+ return codeLens;
+ }
+
+ const resolved = await this._client.server.codeLensResolve(codeLens._lspCodeLens);
+
+ if (resolved.command) {
+ codeLens.command = {
+ id: resolved.command.command,
+ title: resolved.command.title,
+ arguments: resolved.command.arguments,
+ };
+ }
+
+ return codeLens;
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspCompletionFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspCompletionFeature.ts
new file mode 100644
index 00000000..2c11ea1a
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspCompletionFeature.ts
@@ -0,0 +1,202 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, CompletionRegistrationOptions, MarkupContent, CompletionItem, TextDocumentPositionParams } from '../../../src/types';
+import { assertTargetTextModel, ITextModelBridge } from '../ITextModelBridge';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+import {
+ lspCompletionItemKindToMonacoCompletionItemKind,
+ lspCompletionItemTagToMonacoCompletionItemTag,
+ toMonacoCompletionItemKind,
+ toMonacoCompletionItemTag,
+ toLspCompletionTriggerKind,
+ toMonacoInsertTextRules,
+ toMonacoCommand,
+} from './common';
+
+export class LspCompletionFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ completion: {
+ dynamicRegistration: true,
+ contextSupport: true,
+ completionItemKind: {
+ valueSet: Array.from(lspCompletionItemKindToMonacoCompletionItemKind.keys()),
+ },
+ completionItem: {
+ tagSupport: {
+ valueSet: Array.from(lspCompletionItemTagToMonacoCompletionItemTag.keys()),
+ },
+ commitCharactersSupport: true,
+ deprecatedSupport: true,
+ preselectSupport: true,
+ }
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentCompletion, true, capability => {
+ return monaco.languages.registerCompletionItemProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspCompletionProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+interface ExtendedCompletionItem extends monaco.languages.CompletionItem {
+ _lspItem: CompletionItem;
+ _translated: TextDocumentPositionParams;
+ _model: monaco.editor.ITextModel;
+}
+
+class LspCompletionProvider implements monaco.languages.CompletionItemProvider {
+ public readonly resolveCompletionItem;
+
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: CompletionRegistrationOptions,
+ ) {
+ if (_capabilities.resolveProvider) {
+ this.resolveCompletionItem = async (item: ExtendedCompletionItem, token: monaco.CancellationToken): Promise => {
+ const resolved = await this._client.server.completionItemResolve(item._lspItem);
+ applyLspCompletionItemProperties(item, resolved, this._client.bridge, item._translated, item._model);
+ return item;
+ }
+ }
+ }
+
+ get triggerCharacters(): string[] | undefined {
+ return this._capabilities.triggerCharacters;
+ }
+
+ async provideCompletionItems(
+ model: monaco.editor.ITextModel,
+ position: monaco.Position,
+ context: monaco.languages.CompletionContext,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, position);
+
+ const result = await this._client.server.textDocumentCompletion({
+ textDocument: translated.textDocument,
+ position: translated.position,
+ context: context.triggerCharacter ? {
+ triggerKind: toLspCompletionTriggerKind(context.triggerKind),
+ triggerCharacter: context.triggerCharacter,
+ } : undefined,
+ });
+ if (!result) {
+ return { suggestions: [] };
+ }
+
+ const items = Array.isArray(result) ? result : result.items;
+
+ return {
+ suggestions: items.map(i => {
+ const item: ExtendedCompletionItem = {
+ ...convertLspToMonacoCompletionItem(
+ i,
+ this._client.bridge,
+ translated,
+ model,
+ position
+ ),
+ _lspItem: i,
+ _translated: translated,
+ _model: model,
+ };
+
+ return item;
+ })
+ };
+ }
+}
+
+function convertLspToMonacoCompletionItem(
+ lspItem: CompletionItem,
+ bridge: ITextModelBridge,
+ translated: TextDocumentPositionParams,
+ model: monaco.editor.ITextModel,
+ position: monaco.Position
+): monaco.languages.CompletionItem {
+ let insertText = lspItem.insertText || lspItem.label;
+ let range: monaco.IRange | monaco.languages.CompletionItemRanges | undefined = undefined;
+
+ if (lspItem.textEdit) {
+ if ('range' in lspItem.textEdit) {
+ insertText = lspItem.textEdit.newText;
+ range = assertTargetTextModel(bridge.translateBackRange(translated.textDocument, lspItem.textEdit.range), model).range;
+ } else {
+ insertText = lspItem.textEdit.newText;
+ range = {
+ insert: assertTargetTextModel(bridge.translateBackRange(translated.textDocument, lspItem.textEdit.insert), model).range,
+ replace: assertTargetTextModel(bridge.translateBackRange(translated.textDocument, lspItem.textEdit.replace), model).range,
+ };
+ }
+ }
+
+ if (!range) {
+ range = monaco.Range.fromPositions(position, position);
+ }
+
+ const item: monaco.languages.CompletionItem = {
+ label: lspItem.label,
+ kind: toMonacoCompletionItemKind(lspItem.kind),
+ insertText,
+ sortText: lspItem.sortText,
+ filterText: lspItem.filterText,
+ preselect: lspItem.preselect,
+ commitCharacters: lspItem.commitCharacters,
+ range: range,
+ };
+
+ applyLspCompletionItemProperties(item, lspItem, bridge, translated, model);
+
+ return item;
+}
+
+function applyLspCompletionItemProperties(
+ monacoItem: monaco.languages.CompletionItem,
+ lspItem: CompletionItem,
+ bridge: ITextModelBridge,
+ translated: TextDocumentPositionParams,
+ targetModel: monaco.editor.ITextModel
+): void {
+ if (lspItem.detail !== undefined) {
+ monacoItem.detail = lspItem.detail;
+ }
+ if (lspItem.documentation !== undefined) {
+ monacoItem.documentation = toMonacoDocumentation(lspItem.documentation);
+ }
+ if (lspItem.insertTextFormat !== undefined) {
+ const insertTextRules = toMonacoInsertTextRules(lspItem.insertTextFormat);
+ monacoItem.insertTextRules = insertTextRules;
+ }
+ if (lspItem.tags && lspItem.tags.length > 0) {
+ monacoItem.tags = lspItem.tags.map(toMonacoCompletionItemTag).filter((tag): tag is monaco.languages.CompletionItemTag => tag !== undefined);
+ }
+ if (lspItem.additionalTextEdits && lspItem.additionalTextEdits.length > 0) {
+ monacoItem.additionalTextEdits = lspItem.additionalTextEdits.map(edit => ({
+ range: assertTargetTextModel(bridge.translateBackRange(translated.textDocument, edit.range), targetModel).range,
+ text: edit.newText,
+ }));
+ }
+ if (lspItem.command) {
+ monacoItem.command = toMonacoCommand(lspItem.command);
+ }
+}
+
+function toMonacoDocumentation(doc: string | MarkupContent | undefined): string | monaco.IMarkdownString | undefined {
+ if (!doc) return undefined;
+ if (typeof doc === 'string') return doc;
+ return {
+ value: doc.value,
+ isTrusted: true,
+ };
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspDeclarationFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspDeclarationFeature.ts
new file mode 100644
index 00000000..ab306047
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspDeclarationFeature.ts
@@ -0,0 +1,60 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, DeclarationRegistrationOptions } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+import { toMonacoLocation } from "./common";
+
+export class LspDeclarationFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ declaration: {
+ dynamicRegistration: true,
+ linkSupport: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentDeclaration, true, capability => {
+ return monaco.languages.registerDeclarationProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspDeclarationProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspDeclarationProvider implements monaco.languages.DeclarationProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: DeclarationRegistrationOptions,
+ ) { }
+
+ async provideDeclaration(
+ model: monaco.editor.ITextModel,
+ position: monaco.Position,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, position);
+
+ const result = await this._client.server.textDocumentDeclaration({
+ textDocument: translated.textDocument,
+ position: translated.position,
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ if (Array.isArray(result)) {
+ return result.map(loc => toMonacoLocation(loc, this._client));
+ }
+
+ return toMonacoLocation(result, this._client);
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspDefinitionFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspDefinitionFeature.ts
new file mode 100644
index 00000000..bf87f896
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspDefinitionFeature.ts
@@ -0,0 +1,60 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, DefinitionRegistrationOptions } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+import { toMonacoLocation } from "./common";
+
+export class LspDefinitionFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ definition: {
+ dynamicRegistration: true,
+ linkSupport: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentDefinition, true, capability => {
+ return monaco.languages.registerDefinitionProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspDefinitionProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspDefinitionProvider implements monaco.languages.DefinitionProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: DefinitionRegistrationOptions,
+ ) { }
+
+ async provideDefinition(
+ model: monaco.editor.ITextModel,
+ position: monaco.Position,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, position);
+
+ const result = await this._client.server.textDocumentDefinition({
+ textDocument: translated.textDocument,
+ position: translated.position,
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ if (Array.isArray(result)) {
+ return result.map(loc => toMonacoLocation(loc, this._client));
+ }
+
+ return toMonacoLocation(result, this._client);
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspDiagnosticsFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspDiagnosticsFeature.ts
new file mode 100644
index 00000000..2ba7bdea
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspDiagnosticsFeature.ts
@@ -0,0 +1,208 @@
+import * as monaco from 'monaco-editor-core';
+import { api, capabilities, Diagnostic, DiagnosticRegistrationOptions, DocumentDiagnosticReport, PublishDiagnosticsParams } from '../../../src/types';
+import { Disposable, DisposableStore } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { lspDiagnosticTagToMonacoMarkerTag, matchesDocumentSelector, toDiagnosticMarker } from './common';
+
+export class LspDiagnosticsFeature extends Disposable {
+ private readonly _diagnosticsMarkerOwner = 'lsp';
+ private readonly _pullDiagnosticProviders = new Map();
+
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ publishDiagnostics: {
+ relatedInformation: true,
+ tagSupport: {
+ valueSet: [...lspDiagnosticTagToMonacoMarkerTag.keys()],
+ },
+ versionSupport: true,
+ codeDescriptionSupport: true,
+ dataSupport: true,
+ },
+ diagnostic: {
+ dynamicRegistration: true,
+ relatedDocumentSupport: true,
+ }
+ }
+ }));
+
+ debugger;
+ this._register(this._connection.connection.registerNotificationHandler(
+ api.client.textDocumentPublishDiagnostics,
+ (params) => this._handlePublishDiagnostics(params)
+ ));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(
+ capabilities.textDocumentDiagnostic,
+ true,
+ (capability) => {
+ const disposables = new DisposableStore();
+ for (const model of monaco.editor.getModels()) {
+ this._addPullDiagnosticProvider(model, capability, disposables);
+ }
+ disposables.add(monaco.editor.onDidCreateModel(model => {
+ this._addPullDiagnosticProvider(model, capability, disposables);
+ }));
+ return disposables;
+ }
+ ));
+ }
+
+ private _addPullDiagnosticProvider(
+ model: monaco.editor.ITextModel,
+ capability: DiagnosticRegistrationOptions,
+ disposables: DisposableStore
+ ): void {
+ // Check if model matches the document selector
+ const languageId = model.getLanguageId();
+
+ if (!matchesDocumentSelector(model, capability.documentSelector)) {
+ return;
+ }
+
+ const provider = new ModelDiagnosticProvider(
+ model,
+ this._connection,
+ this._diagnosticsMarkerOwner,
+ capability
+ );
+
+ this._pullDiagnosticProviders.set(model, provider);
+ disposables.add(provider);
+
+ disposables.add(model.onWillDispose(() => {
+ this._pullDiagnosticProviders.delete(model);
+ }));
+ }
+
+ private _handlePublishDiagnostics(params: PublishDiagnosticsParams): void {
+ const uri = params.uri;
+
+ try {
+ const translated = this._connection.bridge.translateBack({ uri }, { line: 0, character: 0 });
+ const model = translated.textModel;
+
+ if (!model || model.isDisposed()) {
+ return;
+ }
+
+ const markers = params.diagnostics.map(diagnostic =>
+ toDiagnosticMarker(diagnostic)
+ );
+
+ monaco.editor.setModelMarkers(model, this._diagnosticsMarkerOwner, markers);
+ } catch (error) {
+ // Model not found or already disposed - this is normal when files are closed
+ console.debug(`Could not set diagnostics for ${uri}:`, error);
+ }
+ }
+}
+
+/**
+ * Manages pull diagnostics for a single text model
+ */
+class ModelDiagnosticProvider extends Disposable {
+ private _updateHandle: number | undefined;
+ private _previousResultId: string | undefined;
+
+ constructor(
+ private readonly _model: monaco.editor.ITextModel,
+ private readonly _connection: LspConnection,
+ private readonly _markerOwner: string,
+ private readonly _capability: DiagnosticRegistrationOptions,
+ ) {
+ super();
+ this._register(this._model.onDidChangeContent(() => {
+ this._scheduleDiagnosticUpdate();
+ }));
+ this._scheduleDiagnosticUpdate();
+ }
+
+ private _scheduleDiagnosticUpdate(): void {
+ if (this._updateHandle !== undefined) {
+ clearTimeout(this._updateHandle);
+ }
+
+ this._updateHandle = window.setTimeout(() => {
+ this._updateHandle = undefined;
+ this._requestDiagnostics();
+ }, 500);
+ }
+
+ private async _requestDiagnostics(): Promise {
+ if (this._model.isDisposed()) {
+ return;
+ }
+
+ try {
+ const translated = this._connection.bridge.translate(this._model, new monaco.Position(1, 1));
+
+ const result = await this._connection.server.textDocumentDiagnostic({
+ textDocument: translated.textDocument,
+ identifier: this._capability.identifier,
+ previousResultId: this._previousResultId,
+ });
+
+ if (this._model.isDisposed()) {
+ return;
+ }
+
+ this._handleDiagnosticReport(result);
+ } catch (error) {
+ console.error('Error requesting diagnostics:', error);
+ }
+ }
+
+ private _handleDiagnosticReport(report: DocumentDiagnosticReport): void {
+ if (report.kind === 'full') {
+ // Full diagnostic report
+ this._previousResultId = report.resultId;
+
+ const markers = report.items.map(diagnostic => toDiagnosticMarker(diagnostic));
+ monaco.editor.setModelMarkers(this._model, this._markerOwner, markers);
+
+ // Handle related documents if present
+ if ('relatedDocuments' in report && report.relatedDocuments) {
+ this._handleRelatedDocuments(report.relatedDocuments);
+ }
+ } else if (report.kind === 'unchanged') {
+ // Unchanged report - diagnostics are still valid
+ this._previousResultId = report.resultId;
+ // No need to update markers
+ }
+ }
+
+ private _handleRelatedDocuments(relatedDocuments: { [key: string]: any }): void {
+ for (const [uri, report] of Object.entries(relatedDocuments)) {
+ try {
+ const translated = this._connection.bridge.translateBack({ uri }, { line: 0, character: 0 });
+ const model = translated.textModel;
+
+ if (!model || model.isDisposed()) {
+ continue;
+ }
+
+ if (report.kind === 'full') {
+ const markers = report.items.map((diagnostic: Diagnostic) => toDiagnosticMarker(diagnostic));
+ monaco.editor.setModelMarkers(model, this._markerOwner, markers);
+ }
+ } catch (error) {
+ // Model not found - this is normal
+ console.debug(`Could not set related diagnostics for ${uri}:`, error);
+ }
+ }
+ }
+
+ override dispose(): void {
+ if (this._updateHandle !== undefined) {
+ clearTimeout(this._updateHandle);
+ this._updateHandle = undefined;
+ }
+ super.dispose();
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentHighlightFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentHighlightFeature.ts
new file mode 100644
index 00000000..b07aad78
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentHighlightFeature.ts
@@ -0,0 +1,58 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, DocumentHighlightRegistrationOptions } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+import { toMonacoDocumentHighlightKind } from './common';
+
+export class LspDocumentHighlightFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ documentHighlight: {
+ dynamicRegistration: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentDocumentHighlight, true, capability => {
+ return monaco.languages.registerDocumentHighlightProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspDocumentHighlightProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspDocumentHighlightProvider implements monaco.languages.DocumentHighlightProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: DocumentHighlightRegistrationOptions,
+ ) { }
+
+ async provideDocumentHighlights(
+ model: monaco.editor.ITextModel,
+ position: monaco.Position,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, position);
+
+ const result = await this._client.server.textDocumentDocumentHighlight({
+ textDocument: translated.textDocument,
+ position: translated.position,
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ return result.map(highlight => ({
+ range: this._client.bridge.translateBackRange(translated.textDocument, highlight.range).range,
+ kind: toMonacoDocumentHighlightKind(highlight.kind),
+ }));
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentLinkFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentLinkFeature.ts
new file mode 100644
index 00000000..8825b10f
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentLinkFeature.ts
@@ -0,0 +1,71 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, DocumentLinkRegistrationOptions } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+
+export class LspDocumentLinkFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ documentLink: {
+ dynamicRegistration: true,
+ tooltipSupport: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentDocumentLink, true, capability => {
+ return monaco.languages.registerLinkProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspDocumentLinkProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspDocumentLinkProvider implements monaco.languages.LinkProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: DocumentLinkRegistrationOptions,
+ ) { }
+
+ async provideLinks(
+ model: monaco.editor.ITextModel,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, new monaco.Position(1, 1));
+
+ const result = await this._client.server.textDocumentDocumentLink({
+ textDocument: translated.textDocument,
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ return {
+ links: result.map(link => ({
+ range: this._client.bridge.translateBackRange(translated.textDocument, link.range).range,
+ url: link.target,
+ tooltip: link.tooltip,
+ })),
+ };
+ }
+
+ async resolveLink(
+ link: monaco.languages.ILink,
+ token: monaco.CancellationToken
+ ): Promise {
+ if (!this._capabilities.resolveProvider) {
+ return link;
+ }
+
+ // TODO: Implement resolve
+ return link;
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentSymbolFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentSymbolFeature.ts
new file mode 100644
index 00000000..4f3b4a35
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentSymbolFeature.ts
@@ -0,0 +1,101 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, DocumentSymbolRegistrationOptions, DocumentSymbol, SymbolInformation, SymbolTag } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+import { lspSymbolKindToMonacoSymbolKind, toMonacoSymbolKind, toMonacoSymbolTag } from './common';
+
+export class LspDocumentSymbolFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ documentSymbol: {
+ dynamicRegistration: true,
+ hierarchicalDocumentSymbolSupport: true,
+ symbolKind: {
+ valueSet: Array.from(lspSymbolKindToMonacoSymbolKind.keys()),
+ },
+ tagSupport: {
+ valueSet: [SymbolTag.Deprecated],
+ },
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentDocumentSymbol, true, capability => {
+ return monaco.languages.registerDocumentSymbolProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspDocumentSymbolProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspDocumentSymbolProvider implements monaco.languages.DocumentSymbolProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: DocumentSymbolRegistrationOptions,
+ ) { }
+
+ async provideDocumentSymbols(
+ model: monaco.editor.ITextModel,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, new monaco.Position(1, 1));
+
+ const result = await this._client.server.textDocumentDocumentSymbol({
+ textDocument: translated.textDocument,
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ if (Array.isArray(result) && result.length > 0) {
+ if ('location' in result[0]) {
+ // SymbolInformation[]
+ return (result as SymbolInformation[]).map(symbol => toMonacoSymbolInformation(symbol, this._client));
+ } else {
+ // DocumentSymbol[]
+ return (result as DocumentSymbol[]).map(symbol => toMonacoDocumentSymbol(symbol, this._client, translated.textDocument));
+ }
+ }
+
+ return [];
+ }
+}
+
+function toMonacoDocumentSymbol(
+ symbol: DocumentSymbol,
+ client: LspConnection,
+ textDocument: { uri: string }
+): monaco.languages.DocumentSymbol {
+ return {
+ name: symbol.name,
+ detail: symbol.detail || '',
+ kind: toMonacoSymbolKind(symbol.kind),
+ tags: symbol.tags?.map(tag => toMonacoSymbolTag(tag)).filter((t): t is monaco.languages.SymbolTag => t !== undefined) || [],
+ range: client.bridge.translateBackRange(textDocument, symbol.range).range,
+ selectionRange: client.bridge.translateBackRange(textDocument, symbol.selectionRange).range,
+ children: symbol.children?.map(child => toMonacoDocumentSymbol(child, client, textDocument)) || [],
+ };
+}
+
+function toMonacoSymbolInformation(
+ symbol: SymbolInformation,
+ client: LspConnection
+): monaco.languages.DocumentSymbol {
+ return {
+ name: symbol.name,
+ detail: '',
+ kind: toMonacoSymbolKind(symbol.kind),
+ tags: symbol.tags?.map(tag => toMonacoSymbolTag(tag)).filter((t): t is monaco.languages.SymbolTag => t !== undefined) || [],
+ range: client.bridge.translateBackRange({ uri: symbol.location.uri }, symbol.location.range).range,
+ selectionRange: client.bridge.translateBackRange({ uri: symbol.location.uri }, symbol.location.range).range,
+ children: [],
+ };
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspFoldingRangeFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspFoldingRangeFeature.ts
new file mode 100644
index 00000000..36218023
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspFoldingRangeFeature.ts
@@ -0,0 +1,63 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, FoldingRangeRegistrationOptions, FoldingRangeKind } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+import { toMonacoFoldingRangeKind } from './common';
+
+export class LspFoldingRangeFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ foldingRange: {
+ dynamicRegistration: true,
+ rangeLimit: 5000,
+ lineFoldingOnly: false,
+ foldingRangeKind: {
+ valueSet: [FoldingRangeKind.Comment, FoldingRangeKind.Imports, FoldingRangeKind.Region],
+ },
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentFoldingRange, true, capability => {
+ return monaco.languages.registerFoldingRangeProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspFoldingRangeProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspFoldingRangeProvider implements monaco.languages.FoldingRangeProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: FoldingRangeRegistrationOptions,
+ ) { }
+
+ async provideFoldingRanges(
+ model: monaco.editor.ITextModel,
+ context: monaco.languages.FoldingContext,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, new monaco.Position(1, 1));
+
+ const result = await this._client.server.textDocumentFoldingRange({
+ textDocument: translated.textDocument,
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ return result.map(range => ({
+ start: range.startLine + 1,
+ end: range.endLine + 1,
+ kind: toMonacoFoldingRangeKind(range.kind),
+ }));
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspFormattingFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspFormattingFeature.ts
new file mode 100644
index 00000000..6a3bdc69
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspFormattingFeature.ts
@@ -0,0 +1,60 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, DocumentFormattingRegistrationOptions } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+
+export class LspFormattingFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ formatting: {
+ dynamicRegistration: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentFormatting, true, capability => {
+ return monaco.languages.registerDocumentFormattingEditProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspDocumentFormattingProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspDocumentFormattingProvider implements monaco.languages.DocumentFormattingEditProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: DocumentFormattingRegistrationOptions,
+ ) { }
+
+ async provideDocumentFormattingEdits(
+ model: monaco.editor.ITextModel,
+ options: monaco.languages.FormattingOptions,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, new monaco.Position(1, 1));
+
+ const result = await this._client.server.textDocumentFormatting({
+ textDocument: translated.textDocument,
+ options: {
+ tabSize: options.tabSize,
+ insertSpaces: options.insertSpaces,
+ },
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ return result.map(edit => ({
+ range: this._client.bridge.translateBackRange(translated.textDocument, edit.range).range,
+ text: edit.newText,
+ }));
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspHoverFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspHoverFeature.ts
new file mode 100644
index 00000000..6a8fda53
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspHoverFeature.ts
@@ -0,0 +1,79 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, HoverRegistrationOptions, MarkupContent, MarkedString, MarkupKind } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+
+export class LspHoverFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ hover: {
+ dynamicRegistration: true,
+ contentFormat: [MarkupKind.Markdown, MarkupKind.PlainText],
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentHover, true, capability => {
+ return monaco.languages.registerHoverProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspHoverProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspHoverProvider implements monaco.languages.HoverProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: HoverRegistrationOptions,
+ ) { }
+
+ async provideHover(
+ model: monaco.editor.ITextModel,
+ position: monaco.Position,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, position);
+
+ const result = await this._client.server.textDocumentHover({
+ textDocument: translated.textDocument,
+ position: translated.position,
+ });
+
+ if (!result || !result.contents) {
+ return null;
+ }
+
+ return {
+ contents: toMonacoMarkdownString(result.contents),
+ range: result.range ? this._client.bridge.translateBackRange(translated.textDocument, result.range).range : undefined,
+ };
+ }
+}
+
+function toMonacoMarkdownString(
+ contents: MarkupContent | MarkedString | MarkedString[]
+): monaco.IMarkdownString[] {
+ if (Array.isArray(contents)) {
+ return contents.map(c => toSingleMarkdownString(c));
+ }
+ return [toSingleMarkdownString(contents)];
+}
+
+function toSingleMarkdownString(content: MarkupContent | MarkedString): monaco.IMarkdownString {
+ if (typeof content === 'string') {
+ return { value: content, isTrusted: true };
+ }
+ if ('kind' in content) {
+ // MarkupContent
+ return { value: content.value, isTrusted: true };
+ }
+ // MarkedString with language
+ return { value: `\`\`\`${content.language}\n${content.value}\n\`\`\``, isTrusted: true };
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspImplementationFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspImplementationFeature.ts
new file mode 100644
index 00000000..9dd2d06e
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspImplementationFeature.ts
@@ -0,0 +1,60 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, ImplementationRegistrationOptions } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+import { toMonacoLocation } from "./common";
+
+export class LspImplementationFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ implementation: {
+ dynamicRegistration: true,
+ linkSupport: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentImplementation, true, capability => {
+ return monaco.languages.registerImplementationProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspImplementationProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspImplementationProvider implements monaco.languages.ImplementationProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: ImplementationRegistrationOptions,
+ ) { }
+
+ async provideImplementation(
+ model: monaco.editor.ITextModel,
+ position: monaco.Position,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, position);
+
+ const result = await this._client.server.textDocumentImplementation({
+ textDocument: translated.textDocument,
+ position: translated.position,
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ if (Array.isArray(result)) {
+ return result.map(loc => toMonacoLocation(loc, this._client));
+ }
+
+ return toMonacoLocation(result, this._client);
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspInlayHintsFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspInlayHintsFeature.ts
new file mode 100644
index 00000000..2ef9e63d
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspInlayHintsFeature.ts
@@ -0,0 +1,212 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, InlayHintRegistrationOptions, InlayHint, MarkupContent, api } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+import { assertTargetTextModel } from '../ITextModelBridge';
+import { toMonacoCommand, toMonacoInlayHintKind } from './common';
+
+export class LspInlayHintsFeature extends Disposable {
+ private readonly _providers = new Set();
+
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ inlayHint: {
+ dynamicRegistration: true,
+ resolveSupport: {
+ properties: ['tooltip', 'textEdits', 'label.tooltip', 'label.location', 'label.command'],
+ },
+ }
+ },
+ workspace: {
+ inlayHint: {
+ refreshSupport: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.connection.registerRequestHandler(api.client.workspaceInlayHintRefresh, async () => {
+ // Fire onDidChangeInlayHints for all providers
+ for (const provider of this._providers) {
+ provider.refresh();
+ }
+ return { ok: null };
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentInlayHint, true, capability => {
+ const provider = new LspInlayHintsProvider(this._connection, capability);
+ this._providers.add(provider);
+
+ const disposable = monaco.languages.registerInlayHintsProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ provider,
+ );
+
+ return {
+ dispose: () => {
+ this._providers.delete(provider);
+ disposable.dispose();
+ }
+ };
+ }));
+ }
+}
+
+interface ExtendedInlayHint extends monaco.languages.InlayHint {
+ _lspInlayHint: InlayHint;
+ _targetUri: string;
+}
+
+class LspInlayHintsProvider implements monaco.languages.InlayHintsProvider {
+ private readonly _onDidChangeInlayHints = new monaco.Emitter();
+ public readonly onDidChangeInlayHints = this._onDidChangeInlayHints.event;
+
+ public readonly resolveInlayHint;
+
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: InlayHintRegistrationOptions,
+ ) {
+ if (_capabilities.resolveProvider) {
+ this.resolveInlayHint = async (hint: ExtendedInlayHint, token: monaco.CancellationToken): Promise => {
+
+ const resolved = await this._client.server.inlayHintResolve(hint._lspInlayHint);
+
+ if (resolved.tooltip) {
+ hint.tooltip = toMonacoTooltip(resolved.tooltip);
+ }
+
+ if (resolved.label !== hint._lspInlayHint.label) {
+ hint.label = toLspInlayHintLabel(resolved.label);
+ }
+
+ if (resolved.textEdits) {
+ hint.textEdits = resolved.textEdits.map(edit => {
+ const translated = this._client.bridge.translateBackRange(
+ { uri: hint._targetUri },
+ edit.range
+ );
+ return {
+ range: translated.range,
+ text: edit.newText,
+ };
+ });
+ }
+
+ return hint;
+ };
+ }
+ }
+
+ public refresh(): void {
+ this._onDidChangeInlayHints.fire();
+ }
+
+ async provideInlayHints(
+ model: monaco.editor.ITextModel,
+ range: monaco.Range,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, range.getStartPosition());
+
+ const result = await retryOnContentModified(async () =>
+ await this._client.server.textDocumentInlayHint({
+ textDocument: translated.textDocument,
+ range: this._client.bridge.translateRange(model, range),
+ })
+ );
+
+ if (!result) {
+ return null;
+ }
+
+ return {
+ hints: result.map(hint => {
+ const monacoHint: ExtendedInlayHint = {
+ label: toLspInlayHintLabel(hint.label),
+ position: assertTargetTextModel(
+ this._client.bridge.translateBack(translated.textDocument, hint.position),
+ model
+ ).position,
+ kind: toMonacoInlayHintKind(hint.kind),
+ tooltip: toMonacoTooltip(hint.tooltip),
+ paddingLeft: hint.paddingLeft,
+ paddingRight: hint.paddingRight,
+ textEdits: hint.textEdits?.map(edit => ({
+ range: assertTargetTextModel(
+ this._client.bridge.translateBackRange(translated.textDocument, edit.range),
+ model
+ ).range,
+ text: edit.newText,
+ })),
+ _lspInlayHint: hint,
+ _targetUri: translated.textDocument.uri,
+ };
+ return monacoHint;
+ }),
+ dispose: () => { },
+ };
+ }
+}
+
+async function retryOnContentModified(cb: () => Promise): Promise {
+ const nRetries = 3;
+ for (let triesLeft = nRetries; ; triesLeft--) {
+ try {
+ return await cb();
+ } catch (e: any) {
+ if (e.message === 'content modified' && triesLeft > 0) {
+ continue;
+ }
+ throw e;
+ }
+ }
+}
+
+function toLspInlayHintLabel(label: string | any[]): string | monaco.languages.InlayHintLabelPart[] {
+ if (typeof label === 'string') {
+ return label;
+ }
+
+ return label.map(part => {
+ const monacoLabelPart: monaco.languages.InlayHintLabelPart = {
+ label: part.value,
+ tooltip: toMonacoTooltip(part.tooltip),
+ command: toMonacoCommand(part.command),
+ };
+
+ if (part.location) {
+ monacoLabelPart.location = {
+ uri: monaco.Uri.parse(part.location.uri),
+ range: new monaco.Range(
+ part.location.range.start.line + 1,
+ part.location.range.start.character + 1,
+ part.location.range.end.line + 1,
+ part.location.range.end.character + 1
+ ),
+ };
+ }
+
+ return monacoLabelPart;
+ });
+}
+
+function toMonacoTooltip(tooltip: string | MarkupContent | undefined): string | monaco.IMarkdownString | undefined {
+ if (!tooltip) {
+ return undefined;
+ }
+
+ if (typeof tooltip === 'string') {
+ return tooltip;
+ }
+
+ return {
+ value: tooltip.value,
+ isTrusted: true,
+ };
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspOnTypeFormattingFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspOnTypeFormattingFeature.ts
new file mode 100644
index 00000000..77b50223
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspOnTypeFormattingFeature.ts
@@ -0,0 +1,71 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, DocumentOnTypeFormattingRegistrationOptions } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+
+export class LspOnTypeFormattingFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ onTypeFormatting: {
+ dynamicRegistration: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentOnTypeFormatting, true, capability => {
+ return monaco.languages.registerOnTypeFormattingEditProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspOnTypeFormattingProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspOnTypeFormattingProvider implements monaco.languages.OnTypeFormattingEditProvider {
+ public readonly autoFormatTriggerCharacters: string[];
+
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: DocumentOnTypeFormattingRegistrationOptions,
+ ) {
+ this.autoFormatTriggerCharacters = [
+ _capabilities.firstTriggerCharacter,
+ ...(_capabilities.moreTriggerCharacter || [])
+ ];
+ }
+
+ async provideOnTypeFormattingEdits(
+ model: monaco.editor.ITextModel,
+ position: monaco.Position,
+ ch: string,
+ options: monaco.languages.FormattingOptions,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, position);
+
+ const result = await this._client.server.textDocumentOnTypeFormatting({
+ textDocument: translated.textDocument,
+ position: translated.position,
+ ch,
+ options: {
+ tabSize: options.tabSize,
+ insertSpaces: options.insertSpaces,
+ },
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ return result.map(edit => ({
+ range: this._client.bridge.translateBackRange(translated.textDocument, edit.range).range,
+ text: edit.newText,
+ }));
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspRangeFormattingFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspRangeFormattingFeature.ts
new file mode 100644
index 00000000..5cc79ec5
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspRangeFormattingFeature.ts
@@ -0,0 +1,62 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, DocumentRangeFormattingRegistrationOptions } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+
+export class LspRangeFormattingFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ rangeFormatting: {
+ dynamicRegistration: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentRangeFormatting, true, capability => {
+ return monaco.languages.registerDocumentRangeFormattingEditProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspDocumentRangeFormattingProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspDocumentRangeFormattingProvider implements monaco.languages.DocumentRangeFormattingEditProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: DocumentRangeFormattingRegistrationOptions,
+ ) { }
+
+ async provideDocumentRangeFormattingEdits(
+ model: monaco.editor.ITextModel,
+ range: monaco.Range,
+ options: monaco.languages.FormattingOptions,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, range.getStartPosition());
+
+ const result = await this._client.server.textDocumentRangeFormatting({
+ textDocument: translated.textDocument,
+ range: this._client.bridge.translateRange(model, range),
+ options: {
+ tabSize: options.tabSize,
+ insertSpaces: options.insertSpaces,
+ },
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ return result.map(edit => ({
+ range: this._client.bridge.translateBackRange(translated.textDocument, edit.range).range,
+ text: edit.newText,
+ }));
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspReferencesFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspReferencesFeature.ts
new file mode 100644
index 00000000..2beab9b7
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspReferencesFeature.ts
@@ -0,0 +1,64 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, ReferenceRegistrationOptions } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+
+export class LspReferencesFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ references: {
+ dynamicRegistration: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentReferences, true, capability => {
+ return monaco.languages.registerReferenceProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspReferenceProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspReferenceProvider implements monaco.languages.ReferenceProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: ReferenceRegistrationOptions,
+ ) { }
+
+ async provideReferences(
+ model: monaco.editor.ITextModel,
+ position: monaco.Position,
+ context: monaco.languages.ReferenceContext,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, position);
+
+ const result = await this._client.server.textDocumentReferences({
+ textDocument: translated.textDocument,
+ position: translated.position,
+ context: {
+ includeDeclaration: context.includeDeclaration,
+ },
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ return result.map(loc => {
+ const translated = this._client.bridge.translateBackRange({ uri: loc.uri }, loc.range);
+ return {
+ uri: translated.textModel.uri,
+ range: translated.range,
+ };
+ });
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspRenameFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspRenameFeature.ts
new file mode 100644
index 00000000..008abf20
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspRenameFeature.ts
@@ -0,0 +1,142 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, RenameRegistrationOptions } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+
+export class LspRenameFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ rename: {
+ dynamicRegistration: true,
+ prepareSupport: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentRename, true, capability => {
+ return monaco.languages.registerRenameProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspRenameProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspRenameProvider implements monaco.languages.RenameProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: RenameRegistrationOptions,
+ ) { }
+
+ async provideRenameEdits(
+ model: monaco.editor.ITextModel,
+ position: monaco.Position,
+ newName: string,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, position);
+
+ const result = await this._client.server.textDocumentRename({
+ textDocument: translated.textDocument,
+ position: translated.position,
+ newName,
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ return toMonacoWorkspaceEdit(result, this._client);
+ }
+
+ async resolveRenameLocation(
+ model: monaco.editor.ITextModel,
+ position: monaco.Position,
+ token: monaco.CancellationToken
+ ): Promise {
+ if (!this._capabilities.prepareProvider) {
+ return null;
+ }
+
+ const translated = this._client.bridge.translate(model, position);
+
+ const result = await this._client.server.textDocumentPrepareRename({
+ textDocument: translated.textDocument,
+ position: translated.position,
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ if ('range' in result && 'placeholder' in result) {
+ return {
+ range: this._client.bridge.translateBackRange(translated.textDocument, result.range).range,
+ text: result.placeholder,
+ };
+ } else if ('defaultBehavior' in result) {
+ return null;
+ } else if ('start' in result && 'end' in result) {
+ const range = this._client.bridge.translateBackRange(translated.textDocument, result).range;
+ return {
+ range,
+ text: model.getValueInRange(range),
+ };
+ }
+
+ return null;
+ }
+}
+
+function toMonacoWorkspaceEdit(
+ edit: any,
+ client: LspConnection
+): monaco.languages.WorkspaceEdit {
+ const edits: monaco.languages.IWorkspaceTextEdit[] = [];
+
+ if (edit.changes) {
+ for (const uri in edit.changes) {
+ const textEdits = edit.changes[uri];
+ for (const textEdit of textEdits) {
+ const translated = client.bridge.translateBackRange({ uri }, textEdit.range);
+ edits.push({
+ resource: translated.textModel.uri,
+ versionId: undefined,
+ textEdit: {
+ range: translated.range,
+ text: textEdit.newText,
+ },
+ });
+ }
+ }
+ }
+
+ if (edit.documentChanges) {
+ for (const change of edit.documentChanges) {
+ if ('textDocument' in change) {
+ // TextDocumentEdit
+ const uri = change.textDocument.uri;
+ for (const textEdit of change.edits) {
+ const translated = client.bridge.translateBackRange({ uri }, textEdit.range);
+ edits.push({
+ resource: translated.textModel.uri,
+ versionId: change.textDocument.version,
+ textEdit: {
+ range: translated.range,
+ text: textEdit.newText,
+ },
+ });
+ }
+ }
+ // TODO: Handle CreateFile, RenameFile, DeleteFile
+ }
+ }
+
+ return { edits };
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspSelectionRangeFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspSelectionRangeFeature.ts
new file mode 100644
index 00000000..d7f0f73d
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspSelectionRangeFeature.ts
@@ -0,0 +1,71 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, SelectionRangeRegistrationOptions } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+
+export class LspSelectionRangeFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ selectionRange: {
+ dynamicRegistration: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentSelectionRange, true, capability => {
+ return monaco.languages.registerSelectionRangeProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspSelectionRangeProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspSelectionRangeProvider implements monaco.languages.SelectionRangeProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: SelectionRangeRegistrationOptions,
+ ) { }
+
+ async provideSelectionRanges(
+ model: monaco.editor.ITextModel,
+ positions: monaco.Position[],
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, positions[0]);
+
+ const result = await this._client.server.textDocumentSelectionRange({
+ textDocument: translated.textDocument,
+ positions: positions.map(pos => this._client.bridge.translate(model, pos).position),
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ return result.map(selRange => this.convertSelectionRange(selRange, translated.textDocument));
+ }
+
+ private convertSelectionRange(
+ range: any,
+ textDocument: { uri: string }
+ ): monaco.languages.SelectionRange[] {
+ const result: monaco.languages.SelectionRange[] = [];
+ let current = range;
+
+ while (current) {
+ result.push({
+ range: this._client.bridge.translateBackRange(textDocument, current.range).range,
+ });
+ current = current.parent;
+ }
+
+ return result;
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspSemanticTokensFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspSemanticTokensFeature.ts
new file mode 100644
index 00000000..f57ccc13
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspSemanticTokensFeature.ts
@@ -0,0 +1,130 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, SemanticTokensRegistrationOptions, TokenFormat } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+
+export class LspSemanticTokensFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ semanticTokens: {
+ dynamicRegistration: true,
+ requests: {
+ range: true,
+ full: {
+ delta: true,
+ },
+ },
+ tokenTypes: [
+ 'namespace', 'type', 'class', 'enum', 'interface', 'struct',
+ 'typeParameter', 'parameter', 'variable', 'property', 'enumMember',
+ 'event', 'function', 'method', 'macro', 'keyword', 'modifier',
+ 'comment', 'string', 'number', 'regexp', 'operator', 'decorator'
+ ],
+ tokenModifiers: [
+ 'declaration', 'definition', 'readonly', 'static', 'deprecated',
+ 'abstract', 'async', 'modification', 'documentation', 'defaultLibrary'
+ ],
+ formats: [TokenFormat.Relative],
+ overlappingTokenSupport: false,
+ multilineTokenSupport: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentSemanticTokensFull, true, capability => {
+ return monaco.languages.registerDocumentSemanticTokensProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspSemanticTokensProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspSemanticTokensProvider implements monaco.languages.DocumentSemanticTokensProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: SemanticTokensRegistrationOptions,
+ ) { }
+
+ getLegend(): monaco.languages.SemanticTokensLegend {
+ return {
+ tokenTypes: this._capabilities.legend.tokenTypes,
+ tokenModifiers: this._capabilities.legend.tokenModifiers,
+ };
+ }
+
+ releaseDocumentSemanticTokens(resultId: string | undefined): void {
+ // Monaco will call this when it's done with a result
+ // We can potentially notify the server if needed
+ }
+
+ async provideDocumentSemanticTokens(
+ model: monaco.editor.ITextModel,
+ lastResultId: string | null,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, model.getPositionAt(0));
+
+ // Try delta request if we have a previous result and server supports it
+ const full = this._capabilities.full;
+ if (lastResultId && full && typeof full === 'object' && full.delta) {
+ const deltaResult = await this._client.server.textDocumentSemanticTokensFullDelta({
+ textDocument: translated.textDocument,
+ previousResultId: lastResultId,
+ });
+
+ if (!deltaResult) {
+ return null;
+ }
+
+ // Check if it's a delta or full result
+ if ('edits' in deltaResult) {
+ // It's a delta
+ return {
+ resultId: deltaResult.resultId,
+ edits: deltaResult.edits.map(edit => ({
+ start: edit.start,
+ deleteCount: edit.deleteCount,
+ data: edit.data ? new Uint32Array(edit.data) : undefined,
+ })),
+ };
+ } else {
+ // It's a full result
+ return {
+ resultId: deltaResult.resultId,
+ data: new Uint32Array(deltaResult.data),
+ };
+ }
+ }
+
+ // Full request
+ const result = await this._client.server.textDocumentSemanticTokensFull({
+ textDocument: translated.textDocument,
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ return {
+ resultId: result.resultId,
+ data: new Uint32Array(result.data),
+ };
+ }
+
+ async provideDocumentSemanticTokensEdits?(
+ model: monaco.editor.ITextModel,
+ previousResultId: string,
+ token: monaco.CancellationToken
+ ): Promise {
+ // This method is called when Monaco wants to use delta updates
+ // We can delegate to provideDocumentSemanticTokens which handles both
+ return this.provideDocumentSemanticTokens(model, previousResultId, token);
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspSignatureHelpFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspSignatureHelpFeature.ts
new file mode 100644
index 00000000..672cdc53
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspSignatureHelpFeature.ts
@@ -0,0 +1,101 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, SignatureHelpRegistrationOptions, MarkupContent, MarkupKind } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+import { toLspSignatureHelpTriggerKind } from './common';
+
+export class LspSignatureHelpFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ signatureHelp: {
+ dynamicRegistration: true,
+ contextSupport: true,
+ signatureInformation: {
+ documentationFormat: [MarkupKind.Markdown, MarkupKind.PlainText],
+ parameterInformation: {
+ labelOffsetSupport: true,
+ },
+ activeParameterSupport: true,
+ }
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentSignatureHelp, true, capability => {
+ return monaco.languages.registerSignatureHelpProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspSignatureHelpProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspSignatureHelpProvider implements monaco.languages.SignatureHelpProvider {
+ public readonly signatureHelpTriggerCharacters?: readonly string[];
+ public readonly signatureHelpRetriggerCharacters?: readonly string[];
+
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: SignatureHelpRegistrationOptions,
+ ) {
+ this.signatureHelpTriggerCharacters = _capabilities.triggerCharacters;
+ this.signatureHelpRetriggerCharacters = _capabilities.retriggerCharacters;
+ }
+
+ async provideSignatureHelp(
+ model: monaco.editor.ITextModel,
+ position: monaco.Position,
+ token: monaco.CancellationToken,
+ context: monaco.languages.SignatureHelpContext
+ ): Promise {
+ const translated = this._client.bridge.translate(model, position);
+
+ const result = await this._client.server.textDocumentSignatureHelp({
+ textDocument: translated.textDocument,
+ position: translated.position,
+ context: {
+ triggerKind: toLspSignatureHelpTriggerKind(context.triggerKind),
+ triggerCharacter: context.triggerCharacter,
+ isRetrigger: context.isRetrigger,
+ },
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ return {
+ value: {
+ signatures: result.signatures.map(sig => ({
+ label: sig.label,
+ documentation: toMonacoDocumentation(sig.documentation),
+ parameters: sig.parameters?.map(param => ({
+ label: param.label,
+ documentation: toMonacoDocumentation(param.documentation),
+ })) || [],
+ activeParameter: sig.activeParameter,
+ })),
+ activeSignature: result.activeSignature || 0,
+ activeParameter: result.activeParameter || 0,
+ },
+ dispose: () => { },
+ };
+ }
+}
+
+function toMonacoDocumentation(
+ doc: string | MarkupContent | undefined
+): string | monaco.IMarkdownString | undefined {
+ if (!doc) return undefined;
+ if (typeof doc === 'string') return doc;
+ return {
+ value: doc.value,
+ isTrusted: true,
+ };
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspTypeDefinitionFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspTypeDefinitionFeature.ts
new file mode 100644
index 00000000..8736647f
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/LspTypeDefinitionFeature.ts
@@ -0,0 +1,60 @@
+import * as monaco from 'monaco-editor-core';
+import { capabilities, TypeDefinitionRegistrationOptions } from '../../../src/types';
+import { Disposable } from '../../utils';
+import { LspConnection } from '../LspConnection';
+import { toMonacoLanguageSelector } from './common';
+import { toMonacoLocation } from "./common";
+
+export class LspTypeDefinitionFeature extends Disposable {
+ constructor(
+ private readonly _connection: LspConnection,
+ ) {
+ super();
+
+ this._register(this._connection.capabilities.addStaticClientCapabilities({
+ textDocument: {
+ typeDefinition: {
+ dynamicRegistration: true,
+ linkSupport: true,
+ }
+ }
+ }));
+
+ this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentTypeDefinition, true, capability => {
+ return monaco.languages.registerTypeDefinitionProvider(
+ toMonacoLanguageSelector(capability.documentSelector),
+ new LspTypeDefinitionProvider(this._connection, capability),
+ );
+ }));
+ }
+}
+
+class LspTypeDefinitionProvider implements monaco.languages.TypeDefinitionProvider {
+ constructor(
+ private readonly _client: LspConnection,
+ private readonly _capabilities: TypeDefinitionRegistrationOptions,
+ ) { }
+
+ async provideTypeDefinition(
+ model: monaco.editor.ITextModel,
+ position: monaco.Position,
+ token: monaco.CancellationToken
+ ): Promise {
+ const translated = this._client.bridge.translate(model, position);
+
+ const result = await this._client.server.textDocumentTypeDefinition({
+ textDocument: translated.textDocument,
+ position: translated.position,
+ });
+
+ if (!result) {
+ return null;
+ }
+
+ if (Array.isArray(result)) {
+ return result.map(loc => toMonacoLocation(loc, this._client));
+ }
+
+ return toMonacoLocation(result, this._client);
+ }
+}
diff --git a/monaco-lsp-client/src/adapters/languageFeatures/common.ts b/monaco-lsp-client/src/adapters/languageFeatures/common.ts
new file mode 100644
index 00000000..4d648e7d
--- /dev/null
+++ b/monaco-lsp-client/src/adapters/languageFeatures/common.ts
@@ -0,0 +1,401 @@
+import * as monaco from 'monaco-editor-core';
+import {
+ CodeActionKind,
+ CodeActionTriggerKind,
+ Command,
+ CompletionItemKind,
+ CompletionItemTag,
+ CompletionTriggerKind,
+ Diagnostic,
+ DiagnosticSeverity,
+ DiagnosticTag,
+ DocumentHighlightKind,
+ DocumentSelector,
+ FoldingRangeKind,
+ InlayHintKind,
+ InsertTextFormat,
+ Location,
+ LocationLink,
+ SignatureHelpTriggerKind,
+ SymbolKind,
+ SymbolTag,
+} from '../../../src/types';
+import { LspConnection } from '../LspConnection';
+
+// ============================================================================
+// Code Action Kind
+// ============================================================================
+
+export const lspCodeActionKindToMonacoCodeActionKind = new Map([
+ [CodeActionKind.Empty, ''],
+ [CodeActionKind.QuickFix, 'quickfix'],
+ [CodeActionKind.Refactor, 'refactor'],
+ [CodeActionKind.RefactorExtract, 'refactor.extract'],
+ [CodeActionKind.RefactorInline, 'refactor.inline'],
+ [CodeActionKind.RefactorRewrite, 'refactor.rewrite'],
+ [CodeActionKind.Source, 'source'],
+ [CodeActionKind.SourceOrganizeImports, 'source.organizeImports'],
+ [CodeActionKind.SourceFixAll, 'source.fixAll'],
+]);
+
+export function toMonacoCodeActionKind(kind: CodeActionKind | undefined): string | undefined {
+ if (!kind) {
+ return undefined;
+ }
+ return lspCodeActionKindToMonacoCodeActionKind.get(kind) ?? kind;
+}
+
+// ============================================================================
+// Code Action Trigger Kind
+// ============================================================================
+
+export const monacoCodeActionTriggerTypeToLspCodeActionTriggerKind = new Map([
+ [monaco.languages.CodeActionTriggerType.Invoke, CodeActionTriggerKind.Invoked],
+ [monaco.languages.CodeActionTriggerType.Auto, CodeActionTriggerKind.Automatic],
+]);
+
+export function toLspCodeActionTriggerKind(monacoTrigger: monaco.languages.CodeActionTriggerType): CodeActionTriggerKind {
+ return monacoCodeActionTriggerTypeToLspCodeActionTriggerKind.get(monacoTrigger) ?? CodeActionTriggerKind.Invoked;
+}
+
+// ============================================================================
+// Completion Item Kind
+// ============================================================================
+
+export const lspCompletionItemKindToMonacoCompletionItemKind = new Map([
+ [CompletionItemKind.Text, monaco.languages.CompletionItemKind.Text],
+ [CompletionItemKind.Method, monaco.languages.CompletionItemKind.Method],
+ [CompletionItemKind.Function, monaco.languages.CompletionItemKind.Function],
+ [CompletionItemKind.Constructor, monaco.languages.CompletionItemKind.Constructor],
+ [CompletionItemKind.Field, monaco.languages.CompletionItemKind.Field],
+ [CompletionItemKind.Variable, monaco.languages.CompletionItemKind.Variable],
+ [CompletionItemKind.Class, monaco.languages.CompletionItemKind.Class],
+ [CompletionItemKind.Interface, monaco.languages.CompletionItemKind.Interface],
+ [CompletionItemKind.Module, monaco.languages.CompletionItemKind.Module],
+ [CompletionItemKind.Property, monaco.languages.CompletionItemKind.Property],
+ [CompletionItemKind.Unit, monaco.languages.CompletionItemKind.Unit],
+ [CompletionItemKind.Value, monaco.languages.CompletionItemKind.Value],
+ [CompletionItemKind.Enum, monaco.languages.CompletionItemKind.Enum],
+ [CompletionItemKind.Keyword, monaco.languages.CompletionItemKind.Keyword],
+ [CompletionItemKind.Snippet, monaco.languages.CompletionItemKind.Snippet],
+ [CompletionItemKind.Color, monaco.languages.CompletionItemKind.Color],
+ [CompletionItemKind.File, monaco.languages.CompletionItemKind.File],
+ [CompletionItemKind.Reference, monaco.languages.CompletionItemKind.Reference],
+ [CompletionItemKind.Folder, monaco.languages.CompletionItemKind.Folder],
+ [CompletionItemKind.EnumMember, monaco.languages.CompletionItemKind.EnumMember],
+ [CompletionItemKind.Constant, monaco.languages.CompletionItemKind.Constant],
+ [CompletionItemKind.Struct, monaco.languages.CompletionItemKind.Struct],
+ [CompletionItemKind.Event, monaco.languages.CompletionItemKind.Event],
+ [CompletionItemKind.Operator, monaco.languages.CompletionItemKind.Operator],
+ [CompletionItemKind.TypeParameter, monaco.languages.CompletionItemKind.TypeParameter],
+]);
+
+export function toMonacoCompletionItemKind(kind: CompletionItemKind | undefined): monaco.languages.CompletionItemKind {
+ if (!kind) {
+ return monaco.languages.CompletionItemKind.Text;
+ }
+ return lspCompletionItemKindToMonacoCompletionItemKind.get(kind) ?? monaco.languages.CompletionItemKind.Text;
+}
+
+// ============================================================================
+// Completion Item Tag
+// ============================================================================
+
+export const lspCompletionItemTagToMonacoCompletionItemTag = new Map([
+ [CompletionItemTag.Deprecated, monaco.languages.CompletionItemTag.Deprecated],
+]);
+
+export function toMonacoCompletionItemTag(tag: CompletionItemTag): monaco.languages.CompletionItemTag | undefined {
+ return lspCompletionItemTagToMonacoCompletionItemTag.get(tag);
+}
+
+// ============================================================================
+// Completion Trigger Kind
+// ============================================================================
+
+export const monacoCompletionTriggerKindToLspCompletionTriggerKind = new Map([
+ [monaco.languages.CompletionTriggerKind.Invoke, CompletionTriggerKind.Invoked],
+ [monaco.languages.CompletionTriggerKind.TriggerCharacter, CompletionTriggerKind.TriggerCharacter],
+ [monaco.languages.CompletionTriggerKind.TriggerForIncompleteCompletions, CompletionTriggerKind.TriggerForIncompleteCompletions],
+]);
+
+export function toLspCompletionTriggerKind(monacoKind: monaco.languages.CompletionTriggerKind): CompletionTriggerKind {
+ return monacoCompletionTriggerKindToLspCompletionTriggerKind.get(monacoKind) ?? CompletionTriggerKind.Invoked;
+}
+
+// ============================================================================
+// Insert Text Format
+// ============================================================================
+
+export const lspInsertTextFormatToMonacoInsertTextRules = new Map([
+ [InsertTextFormat.Snippet, monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet],
+]);
+
+export function toMonacoInsertTextRules(format: InsertTextFormat | undefined): monaco.languages.CompletionItemInsertTextRule | undefined {
+ if (!format) {
+ return undefined;
+ }
+ return lspInsertTextFormatToMonacoInsertTextRules.get(format);
+}
+
+// ============================================================================
+// Symbol Kind
+// ============================================================================
+
+export const lspSymbolKindToMonacoSymbolKind = new Map([
+ [SymbolKind.File, monaco.languages.SymbolKind.File],
+ [SymbolKind.Module, monaco.languages.SymbolKind.Module],
+ [SymbolKind.Namespace, monaco.languages.SymbolKind.Namespace],
+ [SymbolKind.Package, monaco.languages.SymbolKind.Package],
+ [SymbolKind.Class, monaco.languages.SymbolKind.Class],
+ [SymbolKind.Method, monaco.languages.SymbolKind.Method],
+ [SymbolKind.Property, monaco.languages.SymbolKind.Property],
+ [SymbolKind.Field, monaco.languages.SymbolKind.Field],
+ [SymbolKind.Constructor, monaco.languages.SymbolKind.Constructor],
+ [SymbolKind.Enum, monaco.languages.SymbolKind.Enum],
+ [SymbolKind.Interface, monaco.languages.SymbolKind.Interface],
+ [SymbolKind.Function, monaco.languages.SymbolKind.Function],
+ [SymbolKind.Variable, monaco.languages.SymbolKind.Variable],
+ [SymbolKind.Constant, monaco.languages.SymbolKind.Constant],
+ [SymbolKind.String, monaco.languages.SymbolKind.String],
+ [SymbolKind.Number, monaco.languages.SymbolKind.Number],
+ [SymbolKind.Boolean, monaco.languages.SymbolKind.Boolean],
+ [SymbolKind.Array, monaco.languages.SymbolKind.Array],
+ [SymbolKind.Object, monaco.languages.SymbolKind.Object],
+ [SymbolKind.Key, monaco.languages.SymbolKind.Key],
+ [SymbolKind.Null, monaco.languages.SymbolKind.Null],
+ [SymbolKind.EnumMember, monaco.languages.SymbolKind.EnumMember],
+ [SymbolKind.Struct, monaco.languages.SymbolKind.Struct],
+ [SymbolKind.Event, monaco.languages.SymbolKind.Event],
+ [SymbolKind.Operator, monaco.languages.SymbolKind.Operator],
+ [SymbolKind.TypeParameter, monaco.languages.SymbolKind.TypeParameter],
+]);
+
+export function toMonacoSymbolKind(kind: SymbolKind): monaco.languages.SymbolKind {
+ return lspSymbolKindToMonacoSymbolKind.get(kind) ?? monaco.languages.SymbolKind.File;
+}
+
+// ============================================================================
+// Symbol Tag
+// ============================================================================
+
+export const lspSymbolTagToMonacoSymbolTag = new Map([
+ [SymbolTag.Deprecated, monaco.languages.SymbolTag.Deprecated],
+]);
+
+export function toMonacoSymbolTag(tag: SymbolTag): monaco.languages.SymbolTag | undefined {
+ return lspSymbolTagToMonacoSymbolTag.get(tag);
+}
+
+// ============================================================================
+// Document Highlight Kind
+// ============================================================================
+
+export const lspDocumentHighlightKindToMonacoDocumentHighlightKind = new Map([
+ [DocumentHighlightKind.Text, monaco.languages.DocumentHighlightKind.Text],
+ [DocumentHighlightKind.Read, monaco.languages.DocumentHighlightKind.Read],
+ [DocumentHighlightKind.Write, monaco.languages.DocumentHighlightKind.Write],
+]);
+
+export function toMonacoDocumentHighlightKind(kind: DocumentHighlightKind | undefined): monaco.languages.DocumentHighlightKind {
+ if (!kind) {
+ return monaco.languages.DocumentHighlightKind.Text;
+ }
+ return lspDocumentHighlightKindToMonacoDocumentHighlightKind.get(kind) ?? monaco.languages.DocumentHighlightKind.Text;
+}
+
+// ============================================================================
+// Folding Range Kind
+// ============================================================================
+
+export const lspFoldingRangeKindToMonacoFoldingRangeKind = new Map([
+ [FoldingRangeKind.Comment, monaco.languages.FoldingRangeKind.Comment],
+ [FoldingRangeKind.Imports, monaco.languages.FoldingRangeKind.Imports],
+ [FoldingRangeKind.Region, monaco.languages.FoldingRangeKind.Region],
+]);
+
+export function toMonacoFoldingRangeKind(kind: FoldingRangeKind | undefined): monaco.languages.FoldingRangeKind | undefined {
+ if (!kind) {
+ return undefined;
+ }
+ return lspFoldingRangeKindToMonacoFoldingRangeKind.get(kind);
+}
+
+// ============================================================================
+// Diagnostic Severity
+// ============================================================================
+
+export const monacoMarkerSeverityToLspDiagnosticSeverity = new Map([
+ [monaco.MarkerSeverity.Error, DiagnosticSeverity.Error],
+ [monaco.MarkerSeverity.Warning, DiagnosticSeverity.Warning],
+ [monaco.MarkerSeverity.Info, DiagnosticSeverity.Information],
+ [monaco.MarkerSeverity.Hint, DiagnosticSeverity.Hint],
+]);
+
+export function toLspDiagnosticSeverity(severity: monaco.MarkerSeverity): DiagnosticSeverity {
+ return monacoMarkerSeverityToLspDiagnosticSeverity.get(severity) ?? DiagnosticSeverity.Error;
+}
+
+export const lspDiagnosticSeverityToMonacoMarkerSeverity = new Map([
+ [DiagnosticSeverity.Error, monaco.MarkerSeverity.Error],
+ [DiagnosticSeverity.Warning, monaco.MarkerSeverity.Warning],
+ [DiagnosticSeverity.Information, monaco.MarkerSeverity.Info],
+ [DiagnosticSeverity.Hint, monaco.MarkerSeverity.Hint],
+]);
+
+export function toMonacoDiagnosticSeverity(severity: DiagnosticSeverity | undefined): monaco.MarkerSeverity {
+ if (!severity) {
+ return monaco.MarkerSeverity.Error;
+ }
+ return lspDiagnosticSeverityToMonacoMarkerSeverity.get(severity) ?? monaco.MarkerSeverity.Error;
+}
+
+// ============================================================================
+// Diagnostic Tag
+// ============================================================================
+
+export const lspDiagnosticTagToMonacoMarkerTag = new Map([
+ [DiagnosticTag.Unnecessary, monaco.MarkerTag.Unnecessary],
+ [DiagnosticTag.Deprecated, monaco.MarkerTag.Deprecated],
+]);
+
+export function toMonacoDiagnosticTag(tag: DiagnosticTag): monaco.MarkerTag | undefined {
+ return lspDiagnosticTagToMonacoMarkerTag.get(tag);
+}
+
+// ============================================================================
+// Signature Help Trigger Kind
+// ============================================================================
+
+export const monacoSignatureHelpTriggerKindToLspSignatureHelpTriggerKind = new Map([
+ [monaco.languages.SignatureHelpTriggerKind.Invoke, SignatureHelpTriggerKind.Invoked],
+ [monaco.languages.SignatureHelpTriggerKind.TriggerCharacter, SignatureHelpTriggerKind.TriggerCharacter],
+ [monaco.languages.SignatureHelpTriggerKind.ContentChange, SignatureHelpTriggerKind.ContentChange],
+]);
+
+export function toLspSignatureHelpTriggerKind(monacoKind: monaco.languages.SignatureHelpTriggerKind): SignatureHelpTriggerKind {
+ return monacoSignatureHelpTriggerKindToLspSignatureHelpTriggerKind.get(monacoKind) ?? SignatureHelpTriggerKind.Invoked;
+}
+
+// ============================================================================
+// Command
+// ============================================================================
+
+export function toMonacoCommand(command: Command | undefined): monaco.languages.Command | undefined {
+ if (!command) {
+ return undefined;
+ }
+ return {
+ id: command.command,
+ title: command.title,
+ arguments: command.arguments,
+ };
+}
+
+// ============================================================================
+// Inlay Hint Kind
+// ============================================================================
+
+export const lspInlayHintKindToMonacoInlayHintKind = new Map([
+ [InlayHintKind.Type, monaco.languages.InlayHintKind.Type],
+ [InlayHintKind.Parameter, monaco.languages.InlayHintKind.Parameter],
+]);
+
+export function toMonacoInlayHintKind(kind: InlayHintKind | undefined): monaco.languages.InlayHintKind {
+ if (!kind) {
+ return monaco.languages.InlayHintKind.Type;
+ }
+ return lspInlayHintKindToMonacoInlayHintKind.get(kind) ?? monaco.languages.InlayHintKind.Type;
+} export function toMonacoLocation(
+ location: Location | LocationLink,
+ client: LspConnection
+): monaco.languages.Location | monaco.languages.LocationLink {
+ if ('targetUri' in location) {
+ // LocationLink
+ const translatedRange = client.bridge.translateBackRange({ uri: location.targetUri }, location.targetRange);
+ return {
+ uri: translatedRange.textModel.uri,
+ range: translatedRange.range,
+ originSelectionRange: location.originSelectionRange
+ ? client.bridge.translateBackRange({ uri: location.targetUri }, location.originSelectionRange).range
+ : undefined,
+ targetSelectionRange: location.targetSelectionRange
+ ? client.bridge.translateBackRange({ uri: location.targetUri }, location.targetSelectionRange).range
+ : undefined,
+ };
+ } else {
+ // Location
+ const translatedRange = client.bridge.translateBackRange({ uri: location.uri }, location.range);
+ return {
+ uri: translatedRange.textModel.uri,
+ range: translatedRange.range,
+ };
+ }
+}
+export function toMonacoLanguageSelector(s: DocumentSelector | null): monaco.languages.LanguageSelector {
+ if (!s || s.length === 0) {
+ return { language: '*' };
+ }
+ return s.map(s => {
+ if ('notebook' in s) {
+ if (typeof s.notebook === 'string') {
+ return { notebookType: s.notebook, language: s.language };
+ } else {
+ return { notebookType: s.notebook.notebookType, language: s.language, pattern: s.notebook.pattern, scheme: s.notebook.scheme };
+ }
+ } else {
+ return { language: s.language, pattern: s.pattern, scheme: s.scheme };
+ }
+ });
+
+}
+export function matchesDocumentSelector(model: monaco.editor.ITextModel, selector: DocumentSelector | null): boolean {
+ if (!selector) {
+ return true;
+ }
+ const languageId = model.getLanguageId();
+ const uri = model.uri.toString(true);
+
+ if (!selector || selector.length === 0) {
+ return true;
+ }
+
+ for (const filter of selector) {
+ if (filter.language && filter.language !== '*' && filter.language !== languageId) {
+ continue;
+ }
+ return true;
+ }
+
+ return false;
+}
+export function toDiagnosticMarker(diagnostic: Diagnostic): monaco.editor.IMarkerData {
+ const marker: monaco.editor.IMarkerData = {
+ severity: toMonacoDiagnosticSeverity(diagnostic.severity),
+ startLineNumber: diagnostic.range.start.line + 1,
+ startColumn: diagnostic.range.start.character + 1,
+ endLineNumber: diagnostic.range.end.line + 1,
+ endColumn: diagnostic.range.end.character + 1,
+ message: diagnostic.message,
+ source: diagnostic.source,
+ code: typeof diagnostic.code === 'string' ? diagnostic.code : diagnostic.code?.toString(),
+ };
+
+ if (diagnostic.tags) {
+ marker.tags = diagnostic.tags.map(tag => toMonacoDiagnosticTag(tag)).filter((tag): tag is monaco.MarkerTag => tag !== undefined);
+ }
+
+ if (diagnostic.relatedInformation) {
+ marker.relatedInformation = diagnostic.relatedInformation.map(info => ({
+ resource: monaco.Uri.parse(info.location.uri),
+ startLineNumber: info.location.range.start.line + 1,
+ startColumn: info.location.range.start.character + 1,
+ endLineNumber: info.location.range.end.line + 1,
+ endColumn: info.location.range.end.character + 1,
+ message: info.message,
+ }));
+ }
+
+ return marker;
+}
+
diff --git a/monaco-lsp-client/src/index.ts b/monaco-lsp-client/src/index.ts
new file mode 100644
index 00000000..ade3e55f
--- /dev/null
+++ b/monaco-lsp-client/src/index.ts
@@ -0,0 +1,5 @@
+import { MonacoLspClient } from './adapters/LspClient';
+import { WebSocketTransport } from '@hediet/json-rpc-websocket';
+import { createTransportToWorker, createTransportToIFrame } from '@hediet/json-rpc-browser';
+
+export { MonacoLspClient, WebSocketTransport, createTransportToWorker, createTransportToIFrame };
diff --git a/monaco-lsp-client/src/types.ts b/monaco-lsp-client/src/types.ts
new file mode 100644
index 00000000..c007b2fb
--- /dev/null
+++ b/monaco-lsp-client/src/types.ts
@@ -0,0 +1,7514 @@
+// Generated TypeScript definitions for LSP
+// Protocol version: 3.17.0
+// This file is auto-generated. Do not edit manually.
+
+import {
+ contract, unverifiedRequest,
+ unverifiedNotification
+} from "@hediet/json-rpc";
+
+/**
+ * A set of predefined token types. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0
+ */
+export enum SemanticTokenTypes {
+ namespace = 'namespace',
+ /**
+ * Represents a generic type. Acts as a fallback for types which can't be mapped to
+ * a specific type like class or enum.
+ */
+ type = 'type',
+ class = 'class',
+ enum = 'enum',
+ interface = 'interface',
+ struct = 'struct',
+ typeParameter = 'typeParameter',
+ parameter = 'parameter',
+ variable = 'variable',
+ property = 'property',
+ enumMember = 'enumMember',
+ event = 'event',
+ function = 'function',
+ method = 'method',
+ macro = 'macro',
+ keyword = 'keyword',
+ modifier = 'modifier',
+ comment = 'comment',
+ string = 'string',
+ number = 'number',
+ regexp = 'regexp',
+ operator = 'operator',
+ /**
+ * @since 3.17.0
+ */
+ decorator = 'decorator'
+}
+
+/**
+ * A set of predefined token modifiers. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0
+ */
+export enum SemanticTokenModifiers {
+ declaration = 'declaration',
+ definition = 'definition',
+ readonly = 'readonly',
+ static = 'static',
+ deprecated = 'deprecated',
+ abstract = 'abstract',
+ async = 'async',
+ modification = 'modification',
+ documentation = 'documentation',
+ defaultLibrary = 'defaultLibrary'
+}
+
+/**
+ * The document diagnostic report kinds.
+ *
+ * @since 3.17.0
+ */
+export enum DocumentDiagnosticReportKind {
+ /**
+ * A diagnostic report with a full
+ * set of problems.
+ */
+ Full = 'full',
+ /**
+ * A report indicating that the last
+ * returned report is still accurate.
+ */
+ Unchanged = 'unchanged'
+}
+
+/**
+ * Predefined error codes.
+ */
+export enum ErrorCodes {
+ ParseError = -32700,
+ InvalidRequest = -32600,
+ MethodNotFound = -32601,
+ InvalidParams = -32602,
+ InternalError = -32603,
+ /**
+ * Error code indicating that a server received a notification or
+ * request before the server has received the `initialize` request.
+ */
+ ServerNotInitialized = -32002,
+ UnknownErrorCode = -32001
+}
+
+export enum LSPErrorCodes {
+ /**
+ * A request failed but it was syntactically correct, e.g the
+ * method name was known and the parameters were valid. The error
+ * message should contain human readable information about why
+ * the request failed.
+ *
+ * @since 3.17.0
+ */
+ RequestFailed = -32803,
+ /**
+ * The server cancelled the request. This error code should
+ * only be used for requests that explicitly support being
+ * server cancellable.
+ *
+ * @since 3.17.0
+ */
+ ServerCancelled = -32802,
+ /**
+ * The server detected that the content of a document got
+ * modified outside normal conditions. A server should
+ * NOT send this error code if it detects a content change
+ * in it unprocessed messages. The result even computed
+ * on an older state might still be useful for the client.
+ *
+ * If a client decides that a result is not of any use anymore
+ * the client should cancel the request.
+ */
+ ContentModified = -32801,
+ /**
+ * The client has canceled a request and a server has detected
+ * the cancel.
+ */
+ RequestCancelled = -32800
+}
+
+/**
+ * A set of predefined range kinds.
+ */
+export enum FoldingRangeKind {
+ /**
+ * Folding range for a comment
+ */
+ Comment = 'comment',
+ /**
+ * Folding range for an import or include
+ */
+ Imports = 'imports',
+ /**
+ * Folding range for a region (e.g. `#region`)
+ */
+ Region = 'region'
+}
+
+/**
+ * A symbol kind.
+ */
+export enum SymbolKind {
+ File = 1,
+ Module = 2,
+ Namespace = 3,
+ Package = 4,
+ Class = 5,
+ Method = 6,
+ Property = 7,
+ Field = 8,
+ Constructor = 9,
+ Enum = 10,
+ Interface = 11,
+ Function = 12,
+ Variable = 13,
+ Constant = 14,
+ String = 15,
+ Number = 16,
+ Boolean = 17,
+ Array = 18,
+ Object = 19,
+ Key = 20,
+ Null = 21,
+ EnumMember = 22,
+ Struct = 23,
+ Event = 24,
+ Operator = 25,
+ TypeParameter = 26
+}
+
+/**
+ * Symbol tags are extra annotations that tweak the rendering of a symbol.
+ *
+ * @since 3.16
+ */
+export enum SymbolTag {
+ /**
+ * Render a symbol as obsolete, usually using a strike-out.
+ */
+ Deprecated = 1
+}
+
+/**
+ * Moniker uniqueness level to define scope of the moniker.
+ *
+ * @since 3.16.0
+ */
+export enum UniquenessLevel {
+ /**
+ * The moniker is only unique inside a document
+ */
+ document = 'document',
+ /**
+ * The moniker is unique inside a project for which a dump got created
+ */
+ project = 'project',
+ /**
+ * The moniker is unique inside the group to which a project belongs
+ */
+ group = 'group',
+ /**
+ * The moniker is unique inside the moniker scheme.
+ */
+ scheme = 'scheme',
+ /**
+ * The moniker is globally unique
+ */
+ global = 'global'
+}
+
+/**
+ * The moniker kind.
+ *
+ * @since 3.16.0
+ */
+export enum MonikerKind {
+ /**
+ * The moniker represent a symbol that is imported into a project
+ */
+ import = 'import',
+ /**
+ * The moniker represents a symbol that is exported from a project
+ */
+ export = 'export',
+ /**
+ * The moniker represents a symbol that is local to a project (e.g. a local
+ * variable of a function, a class not visible outside the project, ...)
+ */
+ local = 'local'
+}
+
+/**
+ * Inlay hint kinds.
+ *
+ * @since 3.17.0
+ */
+export enum InlayHintKind {
+ /**
+ * An inlay hint that for a type annotation.
+ */
+ Type = 1,
+ /**
+ * An inlay hint that is for a parameter.
+ */
+ Parameter = 2
+}
+
+/**
+ * The message type
+ */
+export enum MessageType {
+ /**
+ * An error message.
+ */
+ Error = 1,
+ /**
+ * A warning message.
+ */
+ Warning = 2,
+ /**
+ * An information message.
+ */
+ Info = 3,
+ /**
+ * A log message.
+ */
+ Log = 4,
+ /**
+ * A debug message.
+ *
+ * @since 3.18.0
+ */
+ Debug = 5
+}
+
+/**
+ * Defines how the host (editor) should sync
+ * document changes to the language server.
+ */
+export enum TextDocumentSyncKind {
+ /**
+ * Documents should not be synced at all.
+ */
+ None = 0,
+ /**
+ * Documents are synced by always sending the full content
+ * of the document.
+ */
+ Full = 1,
+ /**
+ * Documents are synced by sending the full content on open.
+ * After that only incremental updates to the document are
+ * send.
+ */
+ Incremental = 2
+}
+
+/**
+ * Represents reasons why a text document is saved.
+ */
+export enum TextDocumentSaveReason {
+ /**
+ * Manually triggered, e.g. by the user pressing save, by starting debugging,
+ * or by an API call.
+ */
+ Manual = 1,
+ /**
+ * Automatic after a delay.
+ */
+ AfterDelay = 2,
+ /**
+ * When the editor lost focus.
+ */
+ FocusOut = 3
+}
+
+/**
+ * The kind of a completion entry.
+ */
+export enum CompletionItemKind {
+ Text = 1,
+ Method = 2,
+ Function = 3,
+ Constructor = 4,
+ Field = 5,
+ Variable = 6,
+ Class = 7,
+ Interface = 8,
+ Module = 9,
+ Property = 10,
+ Unit = 11,
+ Value = 12,
+ Enum = 13,
+ Keyword = 14,
+ Snippet = 15,
+ Color = 16,
+ File = 17,
+ Reference = 18,
+ Folder = 19,
+ EnumMember = 20,
+ Constant = 21,
+ Struct = 22,
+ Event = 23,
+ Operator = 24,
+ TypeParameter = 25
+}
+
+/**
+ * Completion item tags are extra annotations that tweak the rendering of a completion
+ * item.
+ *
+ * @since 3.15.0
+ */
+export enum CompletionItemTag {
+ /**
+ * Render a completion as obsolete, usually using a strike-out.
+ */
+ Deprecated = 1
+}
+
+/**
+ * Defines whether the insert text in a completion item should be interpreted as
+ * plain text or a snippet.
+ */
+export enum InsertTextFormat {
+ /**
+ * The primary text to be inserted is treated as a plain string.
+ */
+ PlainText = 1,
+ /**
+ * The primary text to be inserted is treated as a snippet.
+ *
+ * A snippet can define tab stops and placeholders with `$1`, `$2`
+ * and `${3:foo}`. `$0` defines the final tab stop, it defaults to
+ * the end of the snippet. Placeholders with equal identifiers are linked,
+ * that is typing in one will update others too.
+ *
+ * See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#snippet_syntax
+ */
+ Snippet = 2
+}
+
+/**
+ * How whitespace and indentation is handled during completion
+ * item insertion.
+ *
+ * @since 3.16.0
+ */
+export enum InsertTextMode {
+ /**
+ * The insertion or replace strings is taken as it is. If the
+ * value is multi line the lines below the cursor will be
+ * inserted using the indentation defined in the string value.
+ * The client will not apply any kind of adjustments to the
+ * string.
+ */
+ asIs = 1,
+ /**
+ * The editor adjusts leading whitespace of new lines so that
+ * they match the indentation up to the cursor of the line for
+ * which the item is accepted.
+ *
+ * Consider a line like this: <2tabs><3tabs>foo. Accepting a
+ * multi line completion item is indented using 2 tabs and all
+ * following lines inserted will be indented using 2 tabs as well.
+ */
+ adjustIndentation = 2
+}
+
+/**
+ * A document highlight kind.
+ */
+export enum DocumentHighlightKind {
+ /**
+ * A textual occurrence.
+ */
+ Text = 1,
+ /**
+ * Read-access of a symbol, like reading a variable.
+ */
+ Read = 2,
+ /**
+ * Write-access of a symbol, like writing to a variable.
+ */
+ Write = 3
+}
+
+/**
+ * A set of predefined code action kinds
+ */
+export enum CodeActionKind {
+ /**
+ * Empty kind.
+ */
+ Empty = '',
+ /**
+ * Base kind for quickfix actions: 'quickfix'
+ */
+ QuickFix = 'quickfix',
+ /**
+ * Base kind for refactoring actions: 'refactor'
+ */
+ Refactor = 'refactor',
+ /**
+ * Base kind for refactoring extraction actions: 'refactor.extract'
+ *
+ * Example extract actions:
+ *
+ * - Extract method
+ * - Extract function
+ * - Extract variable
+ * - Extract interface from class
+ * - ...
+ */
+ RefactorExtract = 'refactor.extract',
+ /**
+ * Base kind for refactoring inline actions: 'refactor.inline'
+ *
+ * Example inline actions:
+ *
+ * - Inline function
+ * - Inline variable
+ * - Inline constant
+ * - ...
+ */
+ RefactorInline = 'refactor.inline',
+ /**
+ * Base kind for refactoring rewrite actions: 'refactor.rewrite'
+ *
+ * Example rewrite actions:
+ *
+ * - Convert JavaScript function to class
+ * - Add or remove parameter
+ * - Encapsulate field
+ * - Make method static
+ * - Move method to base class
+ * - ...
+ */
+ RefactorRewrite = 'refactor.rewrite',
+ /**
+ * Base kind for source actions: `source`
+ *
+ * Source code actions apply to the entire file.
+ */
+ Source = 'source',
+ /**
+ * Base kind for an organize imports source action: `source.organizeImports`
+ */
+ SourceOrganizeImports = 'source.organizeImports',
+ /**
+ * Base kind for auto-fix source actions: `source.fixAll`.
+ *
+ * Fix all actions automatically fix errors that have a clear fix that do not require user input.
+ * They should not suppress errors or perform unsafe fixes such as generating new types or classes.
+ *
+ * @since 3.15.0
+ */
+ SourceFixAll = 'source.fixAll'
+}
+
+export enum TraceValues {
+ /**
+ * Turn tracing off.
+ */
+ Off = 'off',
+ /**
+ * Trace messages only.
+ */
+ Messages = 'messages',
+ /**
+ * Verbose message tracing.
+ */
+ Verbose = 'verbose'
+}
+
+/**
+ * Describes the content type that a client supports in various
+ * result literals like `Hover`, `ParameterInfo` or `CompletionItem`.
+ *
+ * Please note that `MarkupKinds` must not start with a `$`. This kinds
+ * are reserved for internal usage.
+ */
+export enum MarkupKind {
+ /**
+ * Plain text is supported as a content format
+ */
+ PlainText = 'plaintext',
+ /**
+ * Markdown is supported as a content format
+ */
+ Markdown = 'markdown'
+}
+
+/**
+ * Describes how an {@link InlineCompletionItemProvider inline completion provider} was triggered.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export enum InlineCompletionTriggerKind {
+ /**
+ * Completion was triggered explicitly by a user gesture.
+ */
+ Invoked = 0,
+ /**
+ * Completion was triggered automatically while editing.
+ */
+ Automatic = 1
+}
+
+/**
+ * A set of predefined position encoding kinds.
+ *
+ * @since 3.17.0
+ */
+export enum PositionEncodingKind {
+ /**
+ * Character offsets count UTF-8 code units (e.g. bytes).
+ */
+ UTF8 = 'utf-8',
+ /**
+ * Character offsets count UTF-16 code units.
+ *
+ * This is the default and must always be supported
+ * by servers
+ */
+ UTF16 = 'utf-16',
+ /**
+ * Character offsets count UTF-32 code units.
+ *
+ * Implementation note: these are the same as Unicode codepoints,
+ * so this `PositionEncodingKind` may also be used for an
+ * encoding-agnostic representation of character offsets.
+ */
+ UTF32 = 'utf-32'
+}
+
+/**
+ * The file event type
+ */
+export enum FileChangeType {
+ /**
+ * The file got created.
+ */
+ Created = 1,
+ /**
+ * The file got changed.
+ */
+ Changed = 2,
+ /**
+ * The file got deleted.
+ */
+ Deleted = 3
+}
+
+export enum WatchKind {
+ /**
+ * Interested in create events.
+ */
+ Create = 1,
+ /**
+ * Interested in change events
+ */
+ Change = 2,
+ /**
+ * Interested in delete events
+ */
+ Delete = 4
+}
+
+/**
+ * The diagnostic's severity.
+ */
+export enum DiagnosticSeverity {
+ /**
+ * Reports an error.
+ */
+ Error = 1,
+ /**
+ * Reports a warning.
+ */
+ Warning = 2,
+ /**
+ * Reports an information.
+ */
+ Information = 3,
+ /**
+ * Reports a hint.
+ */
+ Hint = 4
+}
+
+/**
+ * The diagnostic tags.
+ *
+ * @since 3.15.0
+ */
+export enum DiagnosticTag {
+ /**
+ * Unused or unnecessary code.
+ *
+ * Clients are allowed to render diagnostics with this tag faded out instead of having
+ * an error squiggle.
+ */
+ Unnecessary = 1,
+ /**
+ * Deprecated or obsolete code.
+ *
+ * Clients are allowed to rendered diagnostics with this tag strike through.
+ */
+ Deprecated = 2
+}
+
+/**
+ * How a completion was triggered
+ */
+export enum CompletionTriggerKind {
+ /**
+ * Completion was triggered by typing an identifier (24x7 code
+ * complete), manual invocation (e.g Ctrl+Space) or via API.
+ */
+ Invoked = 1,
+ /**
+ * Completion was triggered by a trigger character specified by
+ * the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
+ */
+ TriggerCharacter = 2,
+ /**
+ * Completion was re-triggered as current completion list is incomplete
+ */
+ TriggerForIncompleteCompletions = 3
+}
+
+/**
+ * How a signature help was triggered.
+ *
+ * @since 3.15.0
+ */
+export enum SignatureHelpTriggerKind {
+ /**
+ * Signature help was invoked manually by the user or by a command.
+ */
+ Invoked = 1,
+ /**
+ * Signature help was triggered by a trigger character.
+ */
+ TriggerCharacter = 2,
+ /**
+ * Signature help was triggered by the cursor moving or by the document content changing.
+ */
+ ContentChange = 3
+}
+
+/**
+ * The reason why code actions were requested.
+ *
+ * @since 3.17.0
+ */
+export enum CodeActionTriggerKind {
+ /**
+ * Code actions were explicitly requested by the user or by an extension.
+ */
+ Invoked = 1,
+ /**
+ * Code actions were requested automatically.
+ *
+ * This typically happens when current selection in a file changes, but can
+ * also be triggered when file content changes.
+ */
+ Automatic = 2
+}
+
+/**
+ * A pattern kind describing if a glob pattern matches a file a folder or
+ * both.
+ *
+ * @since 3.16.0
+ */
+export enum FileOperationPatternKind {
+ /**
+ * The pattern matches a file only.
+ */
+ file = 'file',
+ /**
+ * The pattern matches a folder only.
+ */
+ folder = 'folder'
+}
+
+/**
+ * A notebook cell kind.
+ *
+ * @since 3.17.0
+ */
+export enum NotebookCellKind {
+ /**
+ * A markup-cell is formatted source that is used for display.
+ */
+ Markup = 1,
+ /**
+ * A code-cell is source code.
+ */
+ Code = 2
+}
+
+export enum ResourceOperationKind {
+ /**
+ * Supports creating new files and folders.
+ */
+ Create = 'create',
+ /**
+ * Supports renaming existing files and folders.
+ */
+ Rename = 'rename',
+ /**
+ * Supports deleting existing files and folders.
+ */
+ Delete = 'delete'
+}
+
+export enum FailureHandlingKind {
+ /**
+ * Applying the workspace change is simply aborted if one of the changes provided
+ * fails. All operations executed before the failing operation stay executed.
+ */
+ Abort = 'abort',
+ /**
+ * All operations are executed transactional. That means they either all
+ * succeed or no changes at all are applied to the workspace.
+ */
+ Transactional = 'transactional',
+ /**
+ * If the workspace edit contains only textual file changes they are executed transactional.
+ * If resource changes (create, rename or delete file) are part of the change the failure
+ * handling strategy is abort.
+ */
+ TextOnlyTransactional = 'textOnlyTransactional',
+ /**
+ * The client tries to undo the operations already executed. But there is no
+ * guarantee that this is succeeding.
+ */
+ Undo = 'undo'
+}
+
+export enum PrepareSupportDefaultBehavior {
+ /**
+ * The client's default behavior is to select the identifier
+ * according the to language's syntax rule.
+ */
+ Identifier = 1
+}
+
+export enum TokenFormat {
+ Relative = 'relative'
+}
+
+/**
+ * The definition of a symbol represented as one or many {@link Location locations}.
+ * For most programming languages there is only one location at which a symbol is
+ * defined.
+ *
+ * Servers should prefer returning `DefinitionLink` over `Definition` if supported
+ * by the client.
+ */
+export type Definition = Location | (Location)[];
+
+/**
+ * Information about where a symbol is defined.
+ *
+ * Provides additional metadata over normal {@link Location location} definitions, including the range of
+ * the defining symbol
+ */
+export type DefinitionLink = LocationLink;
+
+/**
+ * LSP arrays.
+ * @since 3.17.0
+ */
+export type LSPArray = (LSPAny)[];
+
+/**
+ * The LSP any type.
+ * Please note that strictly speaking a property with the value `undefined`
+ * can't be converted into JSON preserving the property name. However for
+ * convenience it is allowed and assumed that all these properties are
+ * optional as well.
+ * @since 3.17.0
+ */
+export type LSPAny = LSPObject | LSPArray | string | number | number | number | boolean | null;
+
+/**
+ * The declaration of a symbol representation as one or many {@link Location locations}.
+ */
+export type Declaration = Location | (Location)[];
+
+/**
+ * Information about where a symbol is declared.
+ *
+ * Provides additional metadata over normal {@link Location location} declarations, including the range of
+ * the declaring symbol.
+ *
+ * Servers should prefer returning `DeclarationLink` over `Declaration` if supported
+ * by the client.
+ */
+export type DeclarationLink = LocationLink;
+
+/**
+ * Inline value information can be provided by different means:
+ * - directly as a text value (class InlineValueText).
+ * - as a name to use for a variable lookup (class InlineValueVariableLookup)
+ * - as an evaluatable expression (class InlineValueEvaluatableExpression)
+ * The InlineValue types combines all inline value types into one type.
+ *
+ * @since 3.17.0
+ */
+export type InlineValue = InlineValueText | InlineValueVariableLookup | InlineValueEvaluatableExpression;
+
+/**
+ * The result of a document diagnostic pull request. A report can
+ * either be a full report containing all diagnostics for the
+ * requested document or an unchanged report indicating that nothing
+ * has changed in terms of diagnostics in comparison to the last
+ * pull request.
+ *
+ * @since 3.17.0
+ */
+export type DocumentDiagnosticReport = RelatedFullDocumentDiagnosticReport | RelatedUnchangedDocumentDiagnosticReport;
+
+export type PrepareRenameResult = Range | {
+ range: Range;
+ placeholder: string
+} | {
+ defaultBehavior: boolean
+};
+
+/**
+ * A document selector is the combination of one or many document filters.
+ *
+ * @sample `let sel:DocumentSelector = [{ language: 'typescript' }, { language: 'json', pattern: '**∕tsconfig.json' }]`;
+ *
+ * The use of a string as a document filter is deprecated @since 3.16.0.
+ */
+export type DocumentSelector = (DocumentFilter)[];
+
+export type ProgressToken = number | string;
+
+/**
+ * An identifier to refer to a change annotation stored with a workspace edit.
+ */
+export type ChangeAnnotationIdentifier = string;
+
+/**
+ * A workspace diagnostic document report.
+ *
+ * @since 3.17.0
+ */
+export type WorkspaceDocumentDiagnosticReport = WorkspaceFullDocumentDiagnosticReport | WorkspaceUnchangedDocumentDiagnosticReport;
+
+/**
+ * An event describing a change to a text document. If only a text is provided
+ * it is considered to be the full content of the document.
+ */
+export type TextDocumentContentChangeEvent = {
+ range: Range;
+ rangeLength?: number;
+ text: string
+} | {
+ text: string
+};
+
+/**
+ * MarkedString can be used to render human readable text. It is either a markdown string
+ * or a code-block that provides a language and a code snippet. The language identifier
+ * is semantically equal to the optional language identifier in fenced code blocks in GitHub
+ * issues. See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
+ *
+ * The pair of a language and a value is an equivalent to markdown:
+ * ```${language}
+ * ${value}
+ * ```
+ *
+ * Note that markdown strings will be sanitized - that means html will be escaped.
+ * @deprecated use MarkupContent instead.
+ */
+export type MarkedString = string | {
+ language: string;
+ value: string
+};
+
+/**
+ * A document filter describes a top level text document or
+ * a notebook cell document.
+ *
+ * @since 3.17.0 - proposed support for NotebookCellTextDocumentFilter.
+ */
+export type DocumentFilter = TextDocumentFilter | NotebookCellTextDocumentFilter;
+
+/**
+ * LSP object definition.
+ * @since 3.17.0
+ */
+export type LSPObject = { [key: string]: LSPAny };
+
+/**
+ * The glob pattern. Either a string pattern or a relative pattern.
+ *
+ * @since 3.17.0
+ */
+export type GlobPattern = Pattern | RelativePattern;
+
+/**
+ * A document filter denotes a document by different properties like
+ * the {@link TextDocument.languageId language}, the {@link Uri.scheme scheme} of
+ * its resource, or a glob-pattern that is applied to the {@link TextDocument.fileName path}.
+ *
+ * Glob patterns can have the following syntax:
+ * - `*` to match zero or more characters in a path segment
+ * - `?` to match on one character in a path segment
+ * - `**` to match any number of path segments, including none
+ * - `{}` to group sub patterns into an OR expression. (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files)
+ * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
+ * - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
+ *
+ * @sample A language filter that applies to typescript files on disk: `{ language: 'typescript', scheme: 'file' }`
+ * @sample A language filter that applies to all package.json paths: `{ language: 'json', pattern: '**package.json' }`
+ *
+ * @since 3.17.0
+ */
+export type TextDocumentFilter = {
+ language: string;
+ scheme?: string;
+ pattern?: string
+} | {
+ language?: string;
+ scheme: string;
+ pattern?: string
+} | {
+ language?: string;
+ scheme?: string;
+ pattern: string
+};
+
+/**
+ * A notebook document filter denotes a notebook document by
+ * different properties. The properties will be match
+ * against the notebook's URI (same as with documents)
+ *
+ * @since 3.17.0
+ */
+export type NotebookDocumentFilter = {
+ notebookType: string;
+ scheme?: string;
+ pattern?: string
+} | {
+ notebookType?: string;
+ scheme: string;
+ pattern?: string
+} | {
+ notebookType?: string;
+ scheme?: string;
+ pattern: string
+};
+
+/**
+ * The glob pattern to watch relative to the base path. Glob patterns can have the following syntax:
+ * - `*` to match zero or more characters in a path segment
+ * - `?` to match on one character in a path segment
+ * - `**` to match any number of path segments, including none
+ * - `{}` to group conditions (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files)
+ * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
+ * - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
+ *
+ * @since 3.17.0
+ */
+export type Pattern = string;
+
+export interface ImplementationParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+
+/**
+ * Represents a location inside a resource, such as a line
+ * inside a text file.
+ */
+export interface Location {
+ uri: string;
+ range: Range;
+}
+
+export interface ImplementationRegistrationOptions extends TextDocumentRegistrationOptions, ImplementationOptions, StaticRegistrationOptions {
+}
+
+export interface TypeDefinitionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+
+export interface TypeDefinitionRegistrationOptions extends TextDocumentRegistrationOptions, TypeDefinitionOptions, StaticRegistrationOptions {
+}
+
+/**
+ * A workspace folder inside a client.
+ */
+export interface WorkspaceFolder {
+ /**
+ * The associated URI for this workspace folder.
+ */
+ uri: string;
+ /**
+ * The name of the workspace folder. Used to refer to this
+ * workspace folder in the user interface.
+ */
+ name: string;
+}
+
+/**
+ * The parameters of a `workspace/didChangeWorkspaceFolders` notification.
+ */
+export interface DidChangeWorkspaceFoldersParams {
+ /**
+ * The actual workspace folder change event.
+ */
+ event: WorkspaceFoldersChangeEvent;
+}
+
+/**
+ * The parameters of a configuration request.
+ */
+export interface ConfigurationParams {
+ items: (ConfigurationItem)[];
+}
+
+/**
+ * Parameters for a {@link DocumentColorRequest}.
+ */
+export interface DocumentColorParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The text document.
+ */
+ textDocument: TextDocumentIdentifier;
+}
+
+/**
+ * Represents a color range from a document.
+ */
+export interface ColorInformation {
+ /**
+ * The range in the document where this color appears.
+ */
+ range: Range;
+ /**
+ * The actual color value for this color range.
+ */
+ color: Color;
+}
+
+export interface DocumentColorRegistrationOptions extends TextDocumentRegistrationOptions, DocumentColorOptions, StaticRegistrationOptions {
+}
+
+/**
+ * Parameters for a {@link ColorPresentationRequest}.
+ */
+export interface ColorPresentationParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The text document.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The color to request presentations for.
+ */
+ color: Color;
+ /**
+ * The range where the color would be inserted. Serves as a context.
+ */
+ range: Range;
+}
+
+export interface ColorPresentation {
+ /**
+ * The label of this color presentation. It will be shown on the color
+ * picker header. By default this is also the text that is inserted when selecting
+ * this color presentation.
+ */
+ label: string;
+ /**
+ * An {@link TextEdit edit} which is applied to a document when selecting
+ * this presentation for the color. When `falsy` the {@link ColorPresentation.label label}
+ * is used.
+ */
+ textEdit?: TextEdit;
+ /**
+ * An optional array of additional {@link TextEdit text edits} that are applied when
+ * selecting this color presentation. Edits must not overlap with the main {@link ColorPresentation.textEdit edit} nor with themselves.
+ */
+ additionalTextEdits?: (TextEdit)[];
+}
+
+export interface WorkDoneProgressOptions {
+ workDoneProgress?: boolean;
+}
+
+/**
+ * General text document registration options.
+ */
+export interface TextDocumentRegistrationOptions {
+ /**
+ * A document selector to identify the scope of the registration. If set to null
+ * the document selector provided on the client side will be used.
+ */
+ documentSelector: DocumentSelector | null;
+}
+
+/**
+ * Parameters for a {@link FoldingRangeRequest}.
+ */
+export interface FoldingRangeParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The text document.
+ */
+ textDocument: TextDocumentIdentifier;
+}
+
+/**
+ * Represents a folding range. To be valid, start and end line must be bigger than zero and smaller
+ * than the number of lines in the document. Clients are free to ignore invalid ranges.
+ */
+export interface FoldingRange {
+ /**
+ * The zero-based start line of the range to fold. The folded area starts after the line's last character.
+ * To be valid, the end must be zero or larger and smaller than the number of lines in the document.
+ */
+ startLine: number;
+ /**
+ * The zero-based character offset from where the folded range starts. If not defined, defaults to the length of the start line.
+ */
+ startCharacter?: number;
+ /**
+ * The zero-based end line of the range to fold. The folded area ends with the line's last character.
+ * To be valid, the end must be zero or larger and smaller than the number of lines in the document.
+ */
+ endLine: number;
+ /**
+ * The zero-based character offset before the folded range ends. If not defined, defaults to the length of the end line.
+ */
+ endCharacter?: number;
+ /**
+ * Describes the kind of the folding range such as `comment' or 'region'. The kind
+ * is used to categorize folding ranges and used by commands like 'Fold all comments'.
+ * See {@link FoldingRangeKind} for an enumeration of standardized kinds.
+ */
+ kind?: FoldingRangeKind;
+ /**
+ * The text that the client should show when the specified range is
+ * collapsed. If not defined or not supported by the client, a default
+ * will be chosen by the client.
+ *
+ * @since 3.17.0
+ */
+ collapsedText?: string;
+}
+
+export interface FoldingRangeRegistrationOptions extends TextDocumentRegistrationOptions, FoldingRangeOptions, StaticRegistrationOptions {
+}
+
+export interface DeclarationParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+
+export interface DeclarationRegistrationOptions extends DeclarationOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions {
+}
+
+/**
+ * A parameter literal used in selection range requests.
+ */
+export interface SelectionRangeParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The text document.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The positions inside the text document.
+ */
+ positions: (Position)[];
+}
+
+/**
+ * A selection range represents a part of a selection hierarchy. A selection range
+ * may have a parent selection range that contains it.
+ */
+export interface SelectionRange {
+ /**
+ * The {@link Range range} of this selection range.
+ */
+ range: Range;
+ /**
+ * The parent selection range containing this range. Therefore `parent.range` must contain `this.range`.
+ */
+ parent?: SelectionRange;
+}
+
+export interface SelectionRangeRegistrationOptions extends SelectionRangeOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions {
+}
+
+export interface WorkDoneProgressCreateParams {
+ /**
+ * The token to be used to report progress.
+ */
+ token: ProgressToken;
+}
+
+export interface WorkDoneProgressCancelParams {
+ /**
+ * The token to be used to report progress.
+ */
+ token: ProgressToken;
+}
+
+/**
+ * The parameter of a `textDocument/prepareCallHierarchy` request.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyPrepareParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+}
+
+/**
+ * Represents programming constructs like functions or constructors in the context
+ * of call hierarchy.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyItem {
+ /**
+ * The name of this item.
+ */
+ name: string;
+ /**
+ * The kind of this item.
+ */
+ kind: SymbolKind;
+ /**
+ * Tags for this item.
+ */
+ tags?: (SymbolTag)[];
+ /**
+ * More detail for this item, e.g. the signature of a function.
+ */
+ detail?: string;
+ /**
+ * The resource identifier of this item.
+ */
+ uri: string;
+ /**
+ * The range enclosing this symbol not including leading/trailing whitespace but everything else, e.g. comments and code.
+ */
+ range: Range;
+ /**
+ * The range that should be selected and revealed when this symbol is being picked, e.g. the name of a function.
+ * Must be contained by the {@link CallHierarchyItem.range `range`}.
+ */
+ selectionRange: Range;
+ /**
+ * A data entry field that is preserved between a call hierarchy prepare and
+ * incoming calls or outgoing calls requests.
+ */
+ data?: LSPAny;
+}
+
+/**
+ * Call hierarchy options used during static or dynamic registration.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyRegistrationOptions extends TextDocumentRegistrationOptions, CallHierarchyOptions, StaticRegistrationOptions {
+}
+
+/**
+ * The parameter of a `callHierarchy/incomingCalls` request.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyIncomingCallsParams extends WorkDoneProgressParams, PartialResultParams {
+ item: CallHierarchyItem;
+}
+
+/**
+ * Represents an incoming call, e.g. a caller of a method or constructor.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyIncomingCall {
+ /**
+ * The item that makes the call.
+ */
+ from: CallHierarchyItem;
+ /**
+ * The ranges at which the calls appear. This is relative to the caller
+ * denoted by {@link CallHierarchyIncomingCall.from `this.from`}.
+ */
+ fromRanges: (Range)[];
+}
+
+/**
+ * The parameter of a `callHierarchy/outgoingCalls` request.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyOutgoingCallsParams extends WorkDoneProgressParams, PartialResultParams {
+ item: CallHierarchyItem;
+}
+
+/**
+ * Represents an outgoing call, e.g. calling a getter from a method or a method from a constructor etc.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyOutgoingCall {
+ /**
+ * The item that is called.
+ */
+ to: CallHierarchyItem;
+ /**
+ * The range at which this item is called. This is the range relative to the caller, e.g the item
+ * passed to {@link CallHierarchyItemProvider.provideCallHierarchyOutgoingCalls `provideCallHierarchyOutgoingCalls`}
+ * and not {@link CallHierarchyOutgoingCall.to `this.to`}.
+ */
+ fromRanges: (Range)[];
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The text document.
+ */
+ textDocument: TextDocumentIdentifier;
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokens {
+ /**
+ * An optional result id. If provided and clients support delta updating
+ * the client will include the result id in the next semantic token request.
+ * A server can then instead of computing all semantic tokens again simply
+ * send a delta.
+ */
+ resultId?: string;
+ /**
+ * The actual tokens.
+ */
+ data: (number)[];
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensPartialResult {
+ data: (number)[];
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensRegistrationOptions extends TextDocumentRegistrationOptions, SemanticTokensOptions, StaticRegistrationOptions {
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensDeltaParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The text document.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The result id of a previous response. The result Id can either point to a full response
+ * or a delta response depending on what was received last.
+ */
+ previousResultId: string;
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensDelta {
+ resultId?: string;
+ /**
+ * The semantic token edits to transform a previous result into a new result.
+ */
+ edits: (SemanticTokensEdit)[];
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensDeltaPartialResult {
+ edits: (SemanticTokensEdit)[];
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensRangeParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The text document.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The range the semantic tokens are requested for.
+ */
+ range: Range;
+}
+
+/**
+ * Params to show a resource in the UI.
+ *
+ * @since 3.16.0
+ */
+export interface ShowDocumentParams {
+ /**
+ * The uri to show.
+ */
+ uri: string;
+ /**
+ * Indicates to show the resource in an external program.
+ * To show, for example, `https://code.visualstudio.com/`
+ * in the default WEB browser set `external` to `true`.
+ */
+ external?: boolean;
+ /**
+ * An optional property to indicate whether the editor
+ * showing the document should take focus or not.
+ * Clients might ignore this property if an external
+ * program is started.
+ */
+ takeFocus?: boolean;
+ /**
+ * An optional selection range if the document is a text
+ * document. Clients might ignore the property if an
+ * external program is started or the file is not a text
+ * file.
+ */
+ selection?: Range;
+}
+
+/**
+ * The result of a showDocument request.
+ *
+ * @since 3.16.0
+ */
+export interface ShowDocumentResult {
+ /**
+ * A boolean indicating if the show was successful.
+ */
+ success: boolean;
+}
+
+export interface LinkedEditingRangeParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+}
+
+/**
+ * The result of a linked editing range request.
+ *
+ * @since 3.16.0
+ */
+export interface LinkedEditingRanges {
+ /**
+ * A list of ranges that can be edited together. The ranges must have
+ * identical length and contain identical text content. The ranges cannot overlap.
+ */
+ ranges: (Range)[];
+ /**
+ * An optional word pattern (regular expression) that describes valid contents for
+ * the given ranges. If no pattern is provided, the client configuration's word
+ * pattern will be used.
+ */
+ wordPattern?: string;
+}
+
+export interface LinkedEditingRangeRegistrationOptions extends TextDocumentRegistrationOptions, LinkedEditingRangeOptions, StaticRegistrationOptions {
+}
+
+/**
+ * The parameters sent in notifications/requests for user-initiated creation of
+ * files.
+ *
+ * @since 3.16.0
+ */
+export interface CreateFilesParams {
+ /**
+ * An array of all files/folders created in this operation.
+ */
+ files: (FileCreate)[];
+}
+
+/**
+ * A workspace edit represents changes to many resources managed in the workspace. The edit
+ * should either provide `changes` or `documentChanges`. If documentChanges are present
+ * they are preferred over `changes` if the client can handle versioned document edits.
+ *
+ * Since version 3.13.0 a workspace edit can contain resource operations as well. If resource
+ * operations are present clients need to execute the operations in the order in which they
+ * are provided. So a workspace edit for example can consist of the following two changes:
+ * (1) a create file a.txt and (2) a text document edit which insert text into file a.txt.
+ *
+ * An invalid sequence (e.g. (1) delete file a.txt and (2) insert text into file a.txt) will
+ * cause failure of the operation. How the client recovers from the failure is described by
+ * the client capability: `workspace.workspaceEdit.failureHandling`
+ */
+export interface WorkspaceEdit {
+ /**
+ * Holds changes to existing resources.
+ */
+ changes?: { [key: string]: (TextEdit)[] };
+ /**
+ * Depending on the client capability `workspace.workspaceEdit.resourceOperations` document changes
+ * are either an array of `TextDocumentEdit`s to express changes to n different text documents
+ * where each text document edit addresses a specific version of a text document. Or it can contain
+ * above `TextDocumentEdit`s mixed with create, rename and delete file / folder operations.
+ *
+ * Whether a client supports versioned document edits is expressed via
+ * `workspace.workspaceEdit.documentChanges` client capability.
+ *
+ * If a client neither supports `documentChanges` nor `workspace.workspaceEdit.resourceOperations` then
+ * only plain `TextEdit`s using the `changes` property are supported.
+ */
+ documentChanges?: (TextDocumentEdit | CreateFile | RenameFile | DeleteFile)[];
+ /**
+ * A map of change annotations that can be referenced in `AnnotatedTextEdit`s or create, rename and
+ * delete file / folder operations.
+ *
+ * Whether clients honor this property depends on the client capability `workspace.changeAnnotationSupport`.
+ *
+ * @since 3.16.0
+ */
+ changeAnnotations?: { [key: ChangeAnnotationIdentifier]: ChangeAnnotation };
+}
+
+/**
+ * The options to register for file operations.
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationRegistrationOptions {
+ /**
+ * The actual filters.
+ */
+ filters: (FileOperationFilter)[];
+}
+
+/**
+ * The parameters sent in notifications/requests for user-initiated renames of
+ * files.
+ *
+ * @since 3.16.0
+ */
+export interface RenameFilesParams {
+ /**
+ * An array of all files/folders renamed in this operation. When a folder is renamed, only
+ * the folder will be included, and not its children.
+ */
+ files: (FileRename)[];
+}
+
+/**
+ * The parameters sent in notifications/requests for user-initiated deletes of
+ * files.
+ *
+ * @since 3.16.0
+ */
+export interface DeleteFilesParams {
+ /**
+ * An array of all files/folders deleted in this operation.
+ */
+ files: (FileDelete)[];
+}
+
+export interface MonikerParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+
+/**
+ * Moniker definition to match LSIF 0.5 moniker definition.
+ *
+ * @since 3.16.0
+ */
+export interface Moniker {
+ /**
+ * The scheme of the moniker. For example tsc or .Net
+ */
+ scheme: string;
+ /**
+ * The identifier of the moniker. The value is opaque in LSIF however
+ * schema owners are allowed to define the structure if they want.
+ */
+ identifier: string;
+ /**
+ * The scope in which the moniker is unique
+ */
+ unique: UniquenessLevel;
+ /**
+ * The moniker kind if known.
+ */
+ kind?: MonikerKind;
+}
+
+export interface MonikerRegistrationOptions extends TextDocumentRegistrationOptions, MonikerOptions {
+}
+
+/**
+ * The parameter of a `textDocument/prepareTypeHierarchy` request.
+ *
+ * @since 3.17.0
+ */
+export interface TypeHierarchyPrepareParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+}
+
+/**
+ * @since 3.17.0
+ */
+export interface TypeHierarchyItem {
+ /**
+ * The name of this item.
+ */
+ name: string;
+ /**
+ * The kind of this item.
+ */
+ kind: SymbolKind;
+ /**
+ * Tags for this item.
+ */
+ tags?: (SymbolTag)[];
+ /**
+ * More detail for this item, e.g. the signature of a function.
+ */
+ detail?: string;
+ /**
+ * The resource identifier of this item.
+ */
+ uri: string;
+ /**
+ * The range enclosing this symbol not including leading/trailing whitespace
+ * but everything else, e.g. comments and code.
+ */
+ range: Range;
+ /**
+ * The range that should be selected and revealed when this symbol is being
+ * picked, e.g. the name of a function. Must be contained by the
+ * {@link TypeHierarchyItem.range `range`}.
+ */
+ selectionRange: Range;
+ /**
+ * A data entry field that is preserved between a type hierarchy prepare and
+ * supertypes or subtypes requests. It could also be used to identify the
+ * type hierarchy in the server, helping improve the performance on
+ * resolving supertypes and subtypes.
+ */
+ data?: LSPAny;
+}
+
+/**
+ * Type hierarchy options used during static or dynamic registration.
+ *
+ * @since 3.17.0
+ */
+export interface TypeHierarchyRegistrationOptions extends TextDocumentRegistrationOptions, TypeHierarchyOptions, StaticRegistrationOptions {
+}
+
+/**
+ * The parameter of a `typeHierarchy/supertypes` request.
+ *
+ * @since 3.17.0
+ */
+export interface TypeHierarchySupertypesParams extends WorkDoneProgressParams, PartialResultParams {
+ item: TypeHierarchyItem;
+}
+
+/**
+ * The parameter of a `typeHierarchy/subtypes` request.
+ *
+ * @since 3.17.0
+ */
+export interface TypeHierarchySubtypesParams extends WorkDoneProgressParams, PartialResultParams {
+ item: TypeHierarchyItem;
+}
+
+/**
+ * A parameter literal used in inline value requests.
+ *
+ * @since 3.17.0
+ */
+export interface InlineValueParams extends WorkDoneProgressParams {
+ /**
+ * The text document.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The document range for which inline values should be computed.
+ */
+ range: Range;
+ /**
+ * Additional information about the context in which inline values were
+ * requested.
+ */
+ context: InlineValueContext;
+}
+
+/**
+ * Inline value options used during static or dynamic registration.
+ *
+ * @since 3.17.0
+ */
+export interface InlineValueRegistrationOptions extends InlineValueOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions {
+}
+
+/**
+ * A parameter literal used in inlay hint requests.
+ *
+ * @since 3.17.0
+ */
+export interface InlayHintParams extends WorkDoneProgressParams {
+ /**
+ * The text document.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The document range for which inlay hints should be computed.
+ */
+ range: Range;
+}
+
+/**
+ * Inlay hint information.
+ *
+ * @since 3.17.0
+ */
+export interface InlayHint {
+ /**
+ * The position of this hint.
+ *
+ * If multiple hints have the same position, they will be shown in the order
+ * they appear in the response.
+ */
+ position: Position;
+ /**
+ * The label of this hint. A human readable string or an array of
+ * InlayHintLabelPart label parts.
+ *
+ * *Note* that neither the string nor the label part can be empty.
+ */
+ label: string | (InlayHintLabelPart)[];
+ /**
+ * The kind of this hint. Can be omitted in which case the client
+ * should fall back to a reasonable default.
+ */
+ kind?: InlayHintKind;
+ /**
+ * Optional text edits that are performed when accepting this inlay hint.
+ *
+ * *Note* that edits are expected to change the document so that the inlay
+ * hint (or its nearest variant) is now part of the document and the inlay
+ * hint itself is now obsolete.
+ */
+ textEdits?: (TextEdit)[];
+ /**
+ * The tooltip text when you hover over this item.
+ */
+ tooltip?: string | MarkupContent;
+ /**
+ * Render padding before the hint.
+ *
+ * Note: Padding should use the editor's background color, not the
+ * background color of the hint itself. That means padding can be used
+ * to visually align/separate an inlay hint.
+ */
+ paddingLeft?: boolean;
+ /**
+ * Render padding after the hint.
+ *
+ * Note: Padding should use the editor's background color, not the
+ * background color of the hint itself. That means padding can be used
+ * to visually align/separate an inlay hint.
+ */
+ paddingRight?: boolean;
+ /**
+ * A data entry field that is preserved on an inlay hint between
+ * a `textDocument/inlayHint` and a `inlayHint/resolve` request.
+ */
+ data?: LSPAny;
+}
+
+/**
+ * Inlay hint options used during static or dynamic registration.
+ *
+ * @since 3.17.0
+ */
+export interface InlayHintRegistrationOptions extends InlayHintOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions {
+}
+
+/**
+ * Parameters of the document diagnostic request.
+ *
+ * @since 3.17.0
+ */
+export interface DocumentDiagnosticParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The text document.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The additional identifier provided during registration.
+ */
+ identifier?: string;
+ /**
+ * The result id of a previous response if provided.
+ */
+ previousResultId?: string;
+}
+
+/**
+ * A partial result for a document diagnostic report.
+ *
+ * @since 3.17.0
+ */
+export interface DocumentDiagnosticReportPartialResult {
+ relatedDocuments: { [key: string]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport };
+}
+
+/**
+ * Cancellation data returned from a diagnostic request.
+ *
+ * @since 3.17.0
+ */
+export interface DiagnosticServerCancellationData {
+ retriggerRequest: boolean;
+}
+
+/**
+ * Diagnostic registration options.
+ *
+ * @since 3.17.0
+ */
+export interface DiagnosticRegistrationOptions extends TextDocumentRegistrationOptions, DiagnosticOptions, StaticRegistrationOptions {
+}
+
+/**
+ * Parameters of the workspace diagnostic request.
+ *
+ * @since 3.17.0
+ */
+export interface WorkspaceDiagnosticParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The additional identifier provided during registration.
+ */
+ identifier?: string;
+ /**
+ * The currently known diagnostic reports with their
+ * previous result ids.
+ */
+ previousResultIds: (PreviousResultId)[];
+}
+
+/**
+ * A workspace diagnostic report.
+ *
+ * @since 3.17.0
+ */
+export interface WorkspaceDiagnosticReport {
+ items: (WorkspaceDocumentDiagnosticReport)[];
+}
+
+/**
+ * A partial result for a workspace diagnostic report.
+ *
+ * @since 3.17.0
+ */
+export interface WorkspaceDiagnosticReportPartialResult {
+ items: (WorkspaceDocumentDiagnosticReport)[];
+}
+
+/**
+ * The params sent in an open notebook document notification.
+ *
+ * @since 3.17.0
+ */
+export interface DidOpenNotebookDocumentParams {
+ /**
+ * The notebook document that got opened.
+ */
+ notebookDocument: NotebookDocument;
+ /**
+ * The text documents that represent the content
+ * of a notebook cell.
+ */
+ cellTextDocuments: (TextDocumentItem)[];
+}
+
+/**
+ * The params sent in a change notebook document notification.
+ *
+ * @since 3.17.0
+ */
+export interface DidChangeNotebookDocumentParams {
+ /**
+ * The notebook document that did change. The version number points
+ * to the version after all provided changes have been applied. If
+ * only the text document content of a cell changes the notebook version
+ * doesn't necessarily have to change.
+ */
+ notebookDocument: VersionedNotebookDocumentIdentifier;
+ /**
+ * The actual changes to the notebook document.
+ *
+ * The changes describe single state changes to the notebook document.
+ * So if there are two changes c1 (at array index 0) and c2 (at array
+ * index 1) for a notebook in state S then c1 moves the notebook from
+ * S to S' and c2 from S' to S''. So c1 is computed on the state S and
+ * c2 is computed on the state S'.
+ *
+ * To mirror the content of a notebook using change events use the following approach:
+ * - start with the same initial content
+ * - apply the 'notebookDocument/didChange' notifications in the order you receive them.
+ * - apply the `NotebookChangeEvent`s in a single notification in the order
+ * you receive them.
+ */
+ change: NotebookDocumentChangeEvent;
+}
+
+/**
+ * The params sent in a save notebook document notification.
+ *
+ * @since 3.17.0
+ */
+export interface DidSaveNotebookDocumentParams {
+ /**
+ * The notebook document that got saved.
+ */
+ notebookDocument: NotebookDocumentIdentifier;
+}
+
+/**
+ * The params sent in a close notebook document notification.
+ *
+ * @since 3.17.0
+ */
+export interface DidCloseNotebookDocumentParams {
+ /**
+ * The notebook document that got closed.
+ */
+ notebookDocument: NotebookDocumentIdentifier;
+ /**
+ * The text documents that represent the content
+ * of a notebook cell that got closed.
+ */
+ cellTextDocuments: (TextDocumentIdentifier)[];
+}
+
+/**
+ * A parameter literal used in inline completion requests.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export interface InlineCompletionParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+ /**
+ * Additional information about the context in which inline completions were
+ * requested.
+ */
+ context: InlineCompletionContext;
+}
+
+/**
+ * Represents a collection of {@link InlineCompletionItem inline completion items} to be presented in the editor.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export interface InlineCompletionList {
+ /**
+ * The inline completion items
+ */
+ items: (InlineCompletionItem)[];
+}
+
+/**
+ * An inline completion item represents a text snippet that is proposed inline to complete text that is being typed.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export interface InlineCompletionItem {
+ /**
+ * The text to replace the range with. Must be set.
+ */
+ insertText: string | StringValue;
+ /**
+ * A text that is used to decide if this inline completion should be shown. When `falsy` the {@link InlineCompletionItem.insertText} is used.
+ */
+ filterText?: string;
+ /**
+ * The range to replace. Must begin and end on the same line.
+ */
+ range?: Range;
+ /**
+ * An optional {@link Command} that is executed *after* inserting this completion.
+ */
+ command?: Command;
+}
+
+/**
+ * Inline completion options used during static or dynamic registration.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export interface InlineCompletionRegistrationOptions extends InlineCompletionOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions {
+}
+
+export interface RegistrationParams {
+ registrations: (Registration)[];
+}
+
+export interface UnregistrationParams {
+ unregisterations: (Unregistration)[];
+}
+
+export interface InitializeParams extends _InitializeParams, WorkspaceFoldersInitializeParams {
+}
+
+/**
+ * The result returned from an initialize request.
+ */
+export interface InitializeResult {
+ /**
+ * The capabilities the language server provides.
+ */
+ capabilities: ServerCapabilities;
+ /**
+ * Information about the server.
+ *
+ * @since 3.15.0
+ */
+ serverInfo?: {
+ name: string;
+ version?: string
+ };
+}
+
+/**
+ * The data type of the ResponseError if the
+ * initialize request fails.
+ */
+export interface InitializeError {
+ /**
+ * Indicates whether the client execute the following retry logic:
+ * (1) show the message provided by the ResponseError to the user
+ * (2) user selects retry or cancel
+ * (3) if user selected retry the initialize method is sent again.
+ */
+ retry: boolean;
+}
+
+export interface InitializedParams {
+}
+
+/**
+ * The parameters of a change configuration notification.
+ */
+export interface DidChangeConfigurationParams {
+ /**
+ * The actual changed settings
+ */
+ settings: LSPAny;
+}
+
+export interface DidChangeConfigurationRegistrationOptions {
+ section?: string | (string)[];
+}
+
+/**
+ * The parameters of a notification message.
+ */
+export interface ShowMessageParams {
+ /**
+ * The message type. See {@link MessageType}
+ */
+ type: MessageType;
+ /**
+ * The actual message.
+ */
+ message: string;
+}
+
+export interface ShowMessageRequestParams {
+ /**
+ * The message type. See {@link MessageType}
+ */
+ type: MessageType;
+ /**
+ * The actual message.
+ */
+ message: string;
+ /**
+ * The message action items to present.
+ */
+ actions?: (MessageActionItem)[];
+}
+
+export interface MessageActionItem {
+ /**
+ * A short title like 'Retry', 'Open Log' etc.
+ */
+ title: string;
+}
+
+/**
+ * The log message parameters.
+ */
+export interface LogMessageParams {
+ /**
+ * The message type. See {@link MessageType}
+ */
+ type: MessageType;
+ /**
+ * The actual message.
+ */
+ message: string;
+}
+
+/**
+ * The parameters sent in an open text document notification
+ */
+export interface DidOpenTextDocumentParams {
+ /**
+ * The document that was opened.
+ */
+ textDocument: TextDocumentItem;
+}
+
+/**
+ * The change text document notification's parameters.
+ */
+export interface DidChangeTextDocumentParams {
+ /**
+ * The document that did change. The version number points
+ * to the version after all provided content changes have
+ * been applied.
+ */
+ textDocument: VersionedTextDocumentIdentifier;
+ /**
+ * The actual content changes. The content changes describe single state changes
+ * to the document. So if there are two content changes c1 (at array index 0) and
+ * c2 (at array index 1) for a document in state S then c1 moves the document from
+ * S to S' and c2 from S' to S''. So c1 is computed on the state S and c2 is computed
+ * on the state S'.
+ *
+ * To mirror the content of a document using change events use the following approach:
+ * - start with the same initial content
+ * - apply the 'textDocument/didChange' notifications in the order you receive them.
+ * - apply the `TextDocumentContentChangeEvent`s in a single notification in the order
+ * you receive them.
+ */
+ contentChanges: (TextDocumentContentChangeEvent)[];
+}
+
+/**
+ * Describe options to be used when registered for text document change events.
+ */
+export interface TextDocumentChangeRegistrationOptions extends TextDocumentRegistrationOptions {
+ /**
+ * How documents are synced to the server.
+ */
+ syncKind: TextDocumentSyncKind;
+}
+
+/**
+ * The parameters sent in a close text document notification
+ */
+export interface DidCloseTextDocumentParams {
+ /**
+ * The document that was closed.
+ */
+ textDocument: TextDocumentIdentifier;
+}
+
+/**
+ * The parameters sent in a save text document notification
+ */
+export interface DidSaveTextDocumentParams {
+ /**
+ * The document that was saved.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * Optional the content when saved. Depends on the includeText value
+ * when the save notification was requested.
+ */
+ text?: string;
+}
+
+/**
+ * Save registration options.
+ */
+export interface TextDocumentSaveRegistrationOptions extends TextDocumentRegistrationOptions, SaveOptions {
+}
+
+/**
+ * The parameters sent in a will save text document notification.
+ */
+export interface WillSaveTextDocumentParams {
+ /**
+ * The document that will be saved.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The 'TextDocumentSaveReason'.
+ */
+ reason: TextDocumentSaveReason;
+}
+
+/**
+ * A text edit applicable to a text document.
+ */
+export interface TextEdit {
+ /**
+ * The range of the text document to be manipulated. To insert
+ * text into a document create a range where start === end.
+ */
+ range: Range;
+ /**
+ * The string to be inserted. For delete operations use an
+ * empty string.
+ */
+ newText: string;
+}
+
+/**
+ * The watched files change notification's parameters.
+ */
+export interface DidChangeWatchedFilesParams {
+ /**
+ * The actual file events.
+ */
+ changes: (FileEvent)[];
+}
+
+/**
+ * Describe options to be used when registered for text document change events.
+ */
+export interface DidChangeWatchedFilesRegistrationOptions {
+ /**
+ * The watchers to register.
+ */
+ watchers: (FileSystemWatcher)[];
+}
+
+/**
+ * The publish diagnostic notification's parameters.
+ */
+export interface PublishDiagnosticsParams {
+ /**
+ * The URI for which diagnostic information is reported.
+ */
+ uri: string;
+ /**
+ * Optional the version number of the document the diagnostics are published for.
+ *
+ * @since 3.15.0
+ */
+ version?: number;
+ /**
+ * An array of diagnostic information items.
+ */
+ diagnostics: (Diagnostic)[];
+}
+
+/**
+ * Completion parameters
+ */
+export interface CompletionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The completion context. This is only available if the client specifies
+ * to send this using the client capability `textDocument.completion.contextSupport === true`
+ */
+ context?: CompletionContext;
+}
+
+/**
+ * A completion item represents a text snippet that is
+ * proposed to complete text that is being typed.
+ */
+export interface CompletionItem {
+ /**
+ * The label of this completion item.
+ *
+ * The label property is also by default the text that
+ * is inserted when selecting this completion.
+ *
+ * If label details are provided the label itself should
+ * be an unqualified name of the completion item.
+ */
+ label: string;
+ /**
+ * Additional details for the label
+ *
+ * @since 3.17.0
+ */
+ labelDetails?: CompletionItemLabelDetails;
+ /**
+ * The kind of this completion item. Based of the kind
+ * an icon is chosen by the editor.
+ */
+ kind?: CompletionItemKind;
+ /**
+ * Tags for this completion item.
+ *
+ * @since 3.15.0
+ */
+ tags?: (CompletionItemTag)[];
+ /**
+ * A human-readable string with additional information
+ * about this item, like type or symbol information.
+ */
+ detail?: string;
+ /**
+ * A human-readable string that represents a doc-comment.
+ */
+ documentation?: string | MarkupContent;
+ /**
+ * Indicates if this item is deprecated.
+ * @deprecated Use `tags` instead.
+ */
+ deprecated?: boolean;
+ /**
+ * Select this item when showing.
+ *
+ * *Note* that only one completion item can be selected and that the
+ * tool / client decides which item that is. The rule is that the *first*
+ * item of those that match best is selected.
+ */
+ preselect?: boolean;
+ /**
+ * A string that should be used when comparing this item
+ * with other items. When `falsy` the {@link CompletionItem.label label}
+ * is used.
+ */
+ sortText?: string;
+ /**
+ * A string that should be used when filtering a set of
+ * completion items. When `falsy` the {@link CompletionItem.label label}
+ * is used.
+ */
+ filterText?: string;
+ /**
+ * A string that should be inserted into a document when selecting
+ * this completion. When `falsy` the {@link CompletionItem.label label}
+ * is used.
+ *
+ * The `insertText` is subject to interpretation by the client side.
+ * Some tools might not take the string literally. For example
+ * VS Code when code complete is requested in this example
+ * `con` and a completion item with an `insertText` of
+ * `console` is provided it will only insert `sole`. Therefore it is
+ * recommended to use `textEdit` instead since it avoids additional client
+ * side interpretation.
+ */
+ insertText?: string;
+ /**
+ * The format of the insert text. The format applies to both the
+ * `insertText` property and the `newText` property of a provided
+ * `textEdit`. If omitted defaults to `InsertTextFormat.PlainText`.
+ *
+ * Please note that the insertTextFormat doesn't apply to
+ * `additionalTextEdits`.
+ */
+ insertTextFormat?: InsertTextFormat;
+ /**
+ * How whitespace and indentation is handled during completion
+ * item insertion. If not provided the clients default value depends on
+ * the `textDocument.completion.insertTextMode` client capability.
+ *
+ * @since 3.16.0
+ */
+ insertTextMode?: InsertTextMode;
+ /**
+ * An {@link TextEdit edit} which is applied to a document when selecting
+ * this completion. When an edit is provided the value of
+ * {@link CompletionItem.insertText insertText} is ignored.
+ *
+ * Most editors support two different operations when accepting a completion
+ * item. One is to insert a completion text and the other is to replace an
+ * existing text with a completion text. Since this can usually not be
+ * predetermined by a server it can report both ranges. Clients need to
+ * signal support for `InsertReplaceEdits` via the
+ * `textDocument.completion.insertReplaceSupport` client capability
+ * property.
+ *
+ * *Note 1:* The text edit's range as well as both ranges from an insert
+ * replace edit must be a [single line] and they must contain the position
+ * at which completion has been requested.
+ * *Note 2:* If an `InsertReplaceEdit` is returned the edit's insert range
+ * must be a prefix of the edit's replace range, that means it must be
+ * contained and starting at the same position.
+ *
+ * @since 3.16.0 additional type `InsertReplaceEdit`
+ */
+ textEdit?: TextEdit | InsertReplaceEdit;
+ /**
+ * The edit text used if the completion item is part of a CompletionList and
+ * CompletionList defines an item default for the text edit range.
+ *
+ * Clients will only honor this property if they opt into completion list
+ * item defaults using the capability `completionList.itemDefaults`.
+ *
+ * If not provided and a list's default range is provided the label
+ * property is used as a text.
+ *
+ * @since 3.17.0
+ */
+ textEditText?: string;
+ /**
+ * An optional array of additional {@link TextEdit text edits} that are applied when
+ * selecting this completion. Edits must not overlap (including the same insert position)
+ * with the main {@link CompletionItem.textEdit edit} nor with themselves.
+ *
+ * Additional text edits should be used to change text unrelated to the current cursor position
+ * (for example adding an import statement at the top of the file if the completion item will
+ * insert an unqualified type).
+ */
+ additionalTextEdits?: (TextEdit)[];
+ /**
+ * An optional set of characters that when pressed while this completion is active will accept it first and
+ * then type that character. *Note* that all commit characters should have `length=1` and that superfluous
+ * characters will be ignored.
+ */
+ commitCharacters?: (string)[];
+ /**
+ * An optional {@link Command command} that is executed *after* inserting this completion. *Note* that
+ * additional modifications to the current document should be described with the
+ * {@link CompletionItem.additionalTextEdits additionalTextEdits}-property.
+ */
+ command?: Command;
+ /**
+ * A data entry field that is preserved on a completion item between a
+ * {@link CompletionRequest} and a {@link CompletionResolveRequest}.
+ */
+ data?: LSPAny;
+}
+
+/**
+ * Represents a collection of {@link CompletionItem completion items} to be presented
+ * in the editor.
+ */
+export interface CompletionList {
+ /**
+ * This list it not complete. Further typing results in recomputing this list.
+ *
+ * Recomputed lists have all their items replaced (not appended) in the
+ * incomplete completion sessions.
+ */
+ isIncomplete: boolean;
+ /**
+ * In many cases the items of an actual completion result share the same
+ * value for properties like `commitCharacters` or the range of a text
+ * edit. A completion list can therefore define item defaults which will
+ * be used if a completion item itself doesn't specify the value.
+ *
+ * If a completion list specifies a default value and a completion item
+ * also specifies a corresponding value the one from the item is used.
+ *
+ * Servers are only allowed to return default values if the client
+ * signals support for this via the `completionList.itemDefaults`
+ * capability.
+ *
+ * @since 3.17.0
+ */
+ itemDefaults?: {
+ commitCharacters?: (string)[];
+ editRange?: Range | {
+ insert: Range;
+ replace: Range
+ };
+ insertTextFormat?: InsertTextFormat;
+ insertTextMode?: InsertTextMode;
+ data?: LSPAny
+ };
+ /**
+ * The completion items.
+ */
+ items: (CompletionItem)[];
+}
+
+/**
+ * Registration options for a {@link CompletionRequest}.
+ */
+export interface CompletionRegistrationOptions extends TextDocumentRegistrationOptions, CompletionOptions {
+}
+
+/**
+ * Parameters for a {@link HoverRequest}.
+ */
+export interface HoverParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+}
+
+/**
+ * The result of a hover request.
+ */
+export interface Hover {
+ /**
+ * The hover's content
+ */
+ contents: MarkupContent | MarkedString | (MarkedString)[];
+ /**
+ * An optional range inside the text document that is used to
+ * visualize the hover, e.g. by changing the background color.
+ */
+ range?: Range;
+}
+
+/**
+ * Registration options for a {@link HoverRequest}.
+ */
+export interface HoverRegistrationOptions extends TextDocumentRegistrationOptions, HoverOptions {
+}
+
+/**
+ * Parameters for a {@link SignatureHelpRequest}.
+ */
+export interface SignatureHelpParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+ /**
+ * The signature help context. This is only available if the client specifies
+ * to send this using the client capability `textDocument.signatureHelp.contextSupport === true`
+ *
+ * @since 3.15.0
+ */
+ context?: SignatureHelpContext;
+}
+
+/**
+ * Signature help represents the signature of something
+ * callable. There can be multiple signature but only one
+ * active and only one active parameter.
+ */
+export interface SignatureHelp {
+ /**
+ * One or more signatures.
+ */
+ signatures: (SignatureInformation)[];
+ /**
+ * The active signature. If omitted or the value lies outside the
+ * range of `signatures` the value defaults to zero or is ignored if
+ * the `SignatureHelp` has no signatures.
+ *
+ * Whenever possible implementors should make an active decision about
+ * the active signature and shouldn't rely on a default value.
+ *
+ * In future version of the protocol this property might become
+ * mandatory to better express this.
+ */
+ activeSignature?: number;
+ /**
+ * The active parameter of the active signature. If omitted or the value
+ * lies outside the range of `signatures[activeSignature].parameters`
+ * defaults to 0 if the active signature has parameters. If
+ * the active signature has no parameters it is ignored.
+ * In future version of the protocol this property might become
+ * mandatory to better express the active parameter if the
+ * active signature does have any.
+ */
+ activeParameter?: number;
+}
+
+/**
+ * Registration options for a {@link SignatureHelpRequest}.
+ */
+export interface SignatureHelpRegistrationOptions extends TextDocumentRegistrationOptions, SignatureHelpOptions {
+}
+
+/**
+ * Parameters for a {@link DefinitionRequest}.
+ */
+export interface DefinitionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+
+/**
+ * Registration options for a {@link DefinitionRequest}.
+ */
+export interface DefinitionRegistrationOptions extends TextDocumentRegistrationOptions, DefinitionOptions {
+}
+
+/**
+ * Parameters for a {@link ReferencesRequest}.
+ */
+export interface ReferenceParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+ context: ReferenceContext;
+}
+
+/**
+ * Registration options for a {@link ReferencesRequest}.
+ */
+export interface ReferenceRegistrationOptions extends TextDocumentRegistrationOptions, ReferenceOptions {
+}
+
+/**
+ * Parameters for a {@link DocumentHighlightRequest}.
+ */
+export interface DocumentHighlightParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+
+/**
+ * A document highlight is a range inside a text document which deserves
+ * special attention. Usually a document highlight is visualized by changing
+ * the background color of its range.
+ */
+export interface DocumentHighlight {
+ /**
+ * The range this highlight applies to.
+ */
+ range: Range;
+ /**
+ * The highlight kind, default is {@link DocumentHighlightKind.Text text}.
+ */
+ kind?: DocumentHighlightKind;
+}
+
+/**
+ * Registration options for a {@link DocumentHighlightRequest}.
+ */
+export interface DocumentHighlightRegistrationOptions extends TextDocumentRegistrationOptions, DocumentHighlightOptions {
+}
+
+/**
+ * Parameters for a {@link DocumentSymbolRequest}.
+ */
+export interface DocumentSymbolParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The text document.
+ */
+ textDocument: TextDocumentIdentifier;
+}
+
+/**
+ * Represents information about programming constructs like variables, classes,
+ * interfaces etc.
+ */
+export interface SymbolInformation extends BaseSymbolInformation {
+ /**
+ * Indicates if this symbol is deprecated.
+ *
+ * @deprecated Use tags instead
+ */
+ deprecated?: boolean;
+ /**
+ * The location of this symbol. The location's range is used by a tool
+ * to reveal the location in the editor. If the symbol is selected in the
+ * tool the range's start information is used to position the cursor. So
+ * the range usually spans more than the actual symbol's name and does
+ * normally include things like visibility modifiers.
+ *
+ * The range doesn't have to denote a node range in the sense of an abstract
+ * syntax tree. It can therefore not be used to re-construct a hierarchy of
+ * the symbols.
+ */
+ location: Location;
+}
+
+/**
+ * Represents programming constructs like variables, classes, interfaces etc.
+ * that appear in a document. Document symbols can be hierarchical and they
+ * have two ranges: one that encloses its definition and one that points to
+ * its most interesting range, e.g. the range of an identifier.
+ */
+export interface DocumentSymbol {
+ /**
+ * The name of this symbol. Will be displayed in the user interface and therefore must not be
+ * an empty string or a string only consisting of white spaces.
+ */
+ name: string;
+ /**
+ * More detail for this symbol, e.g the signature of a function.
+ */
+ detail?: string;
+ /**
+ * The kind of this symbol.
+ */
+ kind: SymbolKind;
+ /**
+ * Tags for this document symbol.
+ *
+ * @since 3.16.0
+ */
+ tags?: (SymbolTag)[];
+ /**
+ * Indicates if this symbol is deprecated.
+ *
+ * @deprecated Use tags instead
+ */
+ deprecated?: boolean;
+ /**
+ * The range enclosing this symbol not including leading/trailing whitespace but everything else
+ * like comments. This information is typically used to determine if the clients cursor is
+ * inside the symbol to reveal in the symbol in the UI.
+ */
+ range: Range;
+ /**
+ * The range that should be selected and revealed when this symbol is being picked, e.g the name of a function.
+ * Must be contained by the `range`.
+ */
+ selectionRange: Range;
+ /**
+ * Children of this symbol, e.g. properties of a class.
+ */
+ children?: (DocumentSymbol)[];
+}
+
+/**
+ * Registration options for a {@link DocumentSymbolRequest}.
+ */
+export interface DocumentSymbolRegistrationOptions extends TextDocumentRegistrationOptions, DocumentSymbolOptions {
+}
+
+/**
+ * The parameters of a {@link CodeActionRequest}.
+ */
+export interface CodeActionParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The document in which the command was invoked.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The range for which the command was invoked.
+ */
+ range: Range;
+ /**
+ * Context carrying additional information.
+ */
+ context: CodeActionContext;
+}
+
+/**
+ * Represents a reference to a command. Provides a title which
+ * will be used to represent a command in the UI and, optionally,
+ * an array of arguments which will be passed to the command handler
+ * function when invoked.
+ */
+export interface Command {
+ /**
+ * Title of the command, like `save`.
+ */
+ title: string;
+ /**
+ * The identifier of the actual command handler.
+ */
+ command: string;
+ /**
+ * Arguments that the command handler should be
+ * invoked with.
+ */
+ arguments?: (LSPAny)[];
+}
+
+/**
+ * A code action represents a change that can be performed in code, e.g. to fix a problem or
+ * to refactor code.
+ *
+ * A CodeAction must set either `edit` and/or a `command`. If both are supplied, the `edit` is applied first, then the `command` is executed.
+ */
+export interface CodeAction {
+ /**
+ * A short, human-readable, title for this code action.
+ */
+ title: string;
+ /**
+ * The kind of the code action.
+ *
+ * Used to filter code actions.
+ */
+ kind?: CodeActionKind;
+ /**
+ * The diagnostics that this code action resolves.
+ */
+ diagnostics?: (Diagnostic)[];
+ /**
+ * Marks this as a preferred action. Preferred actions are used by the `auto fix` command and can be targeted
+ * by keybindings.
+ *
+ * A quick fix should be marked preferred if it properly addresses the underlying error.
+ * A refactoring should be marked preferred if it is the most reasonable choice of actions to take.
+ *
+ * @since 3.15.0
+ */
+ isPreferred?: boolean;
+ /**
+ * Marks that the code action cannot currently be applied.
+ *
+ * Clients should follow the following guidelines regarding disabled code actions:
+ *
+ * - Disabled code actions are not shown in automatic [lightbulbs](https://code.visualstudio.com/docs/editor/editingevolved#_code-action)
+ * code action menus.
+ *
+ * - Disabled actions are shown as faded out in the code action menu when the user requests a more specific type
+ * of code action, such as refactorings.
+ *
+ * - If the user has a [keybinding](https://code.visualstudio.com/docs/editor/refactoring#_keybindings-for-code-actions)
+ * that auto applies a code action and only disabled code actions are returned, the client should show the user an
+ * error message with `reason` in the editor.
+ *
+ * @since 3.16.0
+ */
+ disabled?: {
+ reason: string
+ };
+ /**
+ * The workspace edit this code action performs.
+ */
+ edit?: WorkspaceEdit;
+ /**
+ * A command this code action executes. If a code action
+ * provides an edit and a command, first the edit is
+ * executed and then the command.
+ */
+ command?: Command;
+ /**
+ * A data entry field that is preserved on a code action between
+ * a `textDocument/codeAction` and a `codeAction/resolve` request.
+ *
+ * @since 3.16.0
+ */
+ data?: LSPAny;
+}
+
+/**
+ * Registration options for a {@link CodeActionRequest}.
+ */
+export interface CodeActionRegistrationOptions extends TextDocumentRegistrationOptions, CodeActionOptions {
+}
+
+/**
+ * The parameters of a {@link WorkspaceSymbolRequest}.
+ */
+export interface WorkspaceSymbolParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * A query string to filter symbols by. Clients may send an empty
+ * string here to request all symbols.
+ */
+ query: string;
+}
+
+/**
+ * A special workspace symbol that supports locations without a range.
+ *
+ * See also SymbolInformation.
+ *
+ * @since 3.17.0
+ */
+export interface WorkspaceSymbol extends BaseSymbolInformation {
+ /**
+ * The location of the symbol. Whether a server is allowed to
+ * return a location without a range depends on the client
+ * capability `workspace.symbol.resolveSupport`.
+ *
+ * See SymbolInformation#location for more details.
+ */
+ location: Location | {
+ uri: string
+ };
+ /**
+ * A data entry field that is preserved on a workspace symbol between a
+ * workspace symbol request and a workspace symbol resolve request.
+ */
+ data?: LSPAny;
+}
+
+/**
+ * Registration options for a {@link WorkspaceSymbolRequest}.
+ */
+export interface WorkspaceSymbolRegistrationOptions extends WorkspaceSymbolOptions {
+}
+
+/**
+ * The parameters of a {@link CodeLensRequest}.
+ */
+export interface CodeLensParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The document to request code lens for.
+ */
+ textDocument: TextDocumentIdentifier;
+}
+
+/**
+ * A code lens represents a {@link Command command} that should be shown along with
+ * source text, like the number of references, a way to run tests, etc.
+ *
+ * A code lens is _unresolved_ when no command is associated to it. For performance
+ * reasons the creation of a code lens and resolving should be done in two stages.
+ */
+export interface CodeLens {
+ /**
+ * The range in which this code lens is valid. Should only span a single line.
+ */
+ range: Range;
+ /**
+ * The command this code lens represents.
+ */
+ command?: Command;
+ /**
+ * A data entry field that is preserved on a code lens item between
+ * a {@link CodeLensRequest} and a {@link CodeLensResolveRequest}
+ */
+ data?: LSPAny;
+}
+
+/**
+ * Registration options for a {@link CodeLensRequest}.
+ */
+export interface CodeLensRegistrationOptions extends TextDocumentRegistrationOptions, CodeLensOptions {
+}
+
+/**
+ * The parameters of a {@link DocumentLinkRequest}.
+ */
+export interface DocumentLinkParams extends WorkDoneProgressParams, PartialResultParams {
+ /**
+ * The document to provide document links for.
+ */
+ textDocument: TextDocumentIdentifier;
+}
+
+/**
+ * A document link is a range in a text document that links to an internal or external resource, like another
+ * text document or a web site.
+ */
+export interface DocumentLink {
+ /**
+ * The range this link applies to.
+ */
+ range: Range;
+ /**
+ * The uri this link points to. If missing a resolve request is sent later.
+ */
+ target?: string;
+ /**
+ * The tooltip text when you hover over this link.
+ *
+ * If a tooltip is provided, is will be displayed in a string that includes instructions on how to
+ * trigger the link, such as `{0} (ctrl + click)`. The specific instructions vary depending on OS,
+ * user settings, and localization.
+ *
+ * @since 3.15.0
+ */
+ tooltip?: string;
+ /**
+ * A data entry field that is preserved on a document link between a
+ * DocumentLinkRequest and a DocumentLinkResolveRequest.
+ */
+ data?: LSPAny;
+}
+
+/**
+ * Registration options for a {@link DocumentLinkRequest}.
+ */
+export interface DocumentLinkRegistrationOptions extends TextDocumentRegistrationOptions, DocumentLinkOptions {
+}
+
+/**
+ * The parameters of a {@link DocumentFormattingRequest}.
+ */
+export interface DocumentFormattingParams extends WorkDoneProgressParams {
+ /**
+ * The document to format.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The format options.
+ */
+ options: FormattingOptions;
+}
+
+/**
+ * Registration options for a {@link DocumentFormattingRequest}.
+ */
+export interface DocumentFormattingRegistrationOptions extends TextDocumentRegistrationOptions, DocumentFormattingOptions {
+}
+
+/**
+ * The parameters of a {@link DocumentRangeFormattingRequest}.
+ */
+export interface DocumentRangeFormattingParams extends WorkDoneProgressParams {
+ /**
+ * The document to format.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The range to format
+ */
+ range: Range;
+ /**
+ * The format options
+ */
+ options: FormattingOptions;
+}
+
+/**
+ * Registration options for a {@link DocumentRangeFormattingRequest}.
+ */
+export interface DocumentRangeFormattingRegistrationOptions extends TextDocumentRegistrationOptions, DocumentRangeFormattingOptions {
+}
+
+/**
+ * The parameters of a {@link DocumentRangesFormattingRequest}.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export interface DocumentRangesFormattingParams extends WorkDoneProgressParams {
+ /**
+ * The document to format.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The ranges to format
+ */
+ ranges: (Range)[];
+ /**
+ * The format options
+ */
+ options: FormattingOptions;
+}
+
+/**
+ * The parameters of a {@link DocumentOnTypeFormattingRequest}.
+ */
+export interface DocumentOnTypeFormattingParams {
+ /**
+ * The document to format.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The position around which the on type formatting should happen.
+ * This is not necessarily the exact position where the character denoted
+ * by the property `ch` got typed.
+ */
+ position: Position;
+ /**
+ * The character that has been typed that triggered the formatting
+ * on type request. That is not necessarily the last character that
+ * got inserted into the document since the client could auto insert
+ * characters as well (e.g. like automatic brace completion).
+ */
+ ch: string;
+ /**
+ * The formatting options.
+ */
+ options: FormattingOptions;
+}
+
+/**
+ * Registration options for a {@link DocumentOnTypeFormattingRequest}.
+ */
+export interface DocumentOnTypeFormattingRegistrationOptions extends TextDocumentRegistrationOptions, DocumentOnTypeFormattingOptions {
+}
+
+/**
+ * The parameters of a {@link RenameRequest}.
+ */
+export interface RenameParams extends WorkDoneProgressParams {
+ /**
+ * The document to rename.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The position at which this request was sent.
+ */
+ position: Position;
+ /**
+ * The new name of the symbol. If the given name is not valid the
+ * request must return a {@link ResponseError} with an
+ * appropriate message set.
+ */
+ newName: string;
+}
+
+/**
+ * Registration options for a {@link RenameRequest}.
+ */
+export interface RenameRegistrationOptions extends TextDocumentRegistrationOptions, RenameOptions {
+}
+
+export interface PrepareRenameParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+}
+
+/**
+ * The parameters of a {@link ExecuteCommandRequest}.
+ */
+export interface ExecuteCommandParams extends WorkDoneProgressParams {
+ /**
+ * The identifier of the actual command handler.
+ */
+ command: string;
+ /**
+ * Arguments that the command should be invoked with.
+ */
+ arguments?: (LSPAny)[];
+}
+
+/**
+ * Registration options for a {@link ExecuteCommandRequest}.
+ */
+export interface ExecuteCommandRegistrationOptions extends ExecuteCommandOptions {
+}
+
+/**
+ * The parameters passed via an apply workspace edit request.
+ */
+export interface ApplyWorkspaceEditParams {
+ /**
+ * An optional label of the workspace edit. This label is
+ * presented in the user interface for example on an undo
+ * stack to undo the workspace edit.
+ */
+ label?: string;
+ /**
+ * The edits to apply.
+ */
+ edit: WorkspaceEdit;
+}
+
+/**
+ * The result returned from the apply workspace edit request.
+ *
+ * @since 3.17 renamed from ApplyWorkspaceEditResponse
+ */
+export interface ApplyWorkspaceEditResult {
+ /**
+ * Indicates whether the edit was applied or not.
+ */
+ applied: boolean;
+ /**
+ * An optional textual description for why the edit was not applied.
+ * This may be used by the server for diagnostic logging or to provide
+ * a suitable error for a request that triggered the edit.
+ */
+ failureReason?: string;
+ /**
+ * Depending on the client's failure handling strategy `failedChange` might
+ * contain the index of the change that failed. This property is only available
+ * if the client signals a `failureHandlingStrategy` in its client capabilities.
+ */
+ failedChange?: number;
+}
+
+export interface WorkDoneProgressBegin {
+ kind: 'begin';
+ /**
+ * Mandatory title of the progress operation. Used to briefly inform about
+ * the kind of operation being performed.
+ *
+ * Examples: "Indexing" or "Linking dependencies".
+ */
+ title: string;
+ /**
+ * Controls if a cancel button should show to allow the user to cancel the
+ * long running operation. Clients that don't support cancellation are allowed
+ * to ignore the setting.
+ */
+ cancellable?: boolean;
+ /**
+ * Optional, more detailed associated progress message. Contains
+ * complementary information to the `title`.
+ *
+ * Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
+ * If unset, the previous progress message (if any) is still valid.
+ */
+ message?: string;
+ /**
+ * Optional progress percentage to display (value 100 is considered 100%).
+ * If not provided infinite progress is assumed and clients are allowed
+ * to ignore the `percentage` value in subsequent report notifications.
+ *
+ * The value should be steadily rising. Clients are free to ignore values
+ * that are not following this rule. The value range is [0, 100].
+ */
+ percentage?: number;
+}
+
+export interface WorkDoneProgressReport {
+ kind: 'report';
+ /**
+ * Controls enablement state of a cancel button.
+ *
+ * Clients that don't support cancellation or don't support controlling the button's
+ * enablement state are allowed to ignore the property.
+ */
+ cancellable?: boolean;
+ /**
+ * Optional, more detailed associated progress message. Contains
+ * complementary information to the `title`.
+ *
+ * Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
+ * If unset, the previous progress message (if any) is still valid.
+ */
+ message?: string;
+ /**
+ * Optional progress percentage to display (value 100 is considered 100%).
+ * If not provided infinite progress is assumed and clients are allowed
+ * to ignore the `percentage` value in subsequent report notifications.
+ *
+ * The value should be steadily rising. Clients are free to ignore values
+ * that are not following this rule. The value range is [0, 100].
+ */
+ percentage?: number;
+}
+
+export interface WorkDoneProgressEnd {
+ kind: 'end';
+ /**
+ * Optional, a final message indicating to for example indicate the outcome
+ * of the operation.
+ */
+ message?: string;
+}
+
+export interface SetTraceParams {
+ value: TraceValues;
+}
+
+export interface LogTraceParams {
+ message: string;
+ verbose?: string;
+}
+
+export interface CancelParams {
+ /**
+ * The request id to cancel.
+ */
+ id: number | string;
+}
+
+export interface ProgressParams {
+ /**
+ * The progress token provided by the client or server.
+ */
+ token: ProgressToken;
+ /**
+ * The progress data.
+ */
+ value: LSPAny;
+}
+
+/**
+ * A parameter literal used in requests to pass a text document and a position inside that
+ * document.
+ */
+export interface TextDocumentPositionParams {
+ /**
+ * The text document.
+ */
+ textDocument: TextDocumentIdentifier;
+ /**
+ * The position inside the text document.
+ */
+ position: Position;
+}
+
+export interface WorkDoneProgressParams {
+ /**
+ * An optional token that a server can use to report work done progress.
+ */
+ workDoneToken?: ProgressToken;
+}
+
+export interface PartialResultParams {
+ /**
+ * An optional token that a server can use to report partial results (e.g. streaming) to
+ * the client.
+ */
+ partialResultToken?: ProgressToken;
+}
+
+/**
+ * Represents the connection of two locations. Provides additional metadata over normal {@link Location locations},
+ * including an origin range.
+ */
+export interface LocationLink {
+ /**
+ * Span of the origin of this link.
+ *
+ * Used as the underlined span for mouse interaction. Defaults to the word range at
+ * the definition position.
+ */
+ originSelectionRange?: Range;
+ /**
+ * The target resource identifier of this link.
+ */
+ targetUri: string;
+ /**
+ * The full target range of this link. If the target for example is a symbol then target range is the
+ * range enclosing this symbol not including leading/trailing whitespace but everything else
+ * like comments. This information is typically used to highlight the range in the editor.
+ */
+ targetRange: Range;
+ /**
+ * The range that should be selected and revealed when this link is being followed, e.g the name of a function.
+ * Must be contained by the `targetRange`. See also `DocumentSymbol#range`
+ */
+ targetSelectionRange: Range;
+}
+
+/**
+ * A range in a text document expressed as (zero-based) start and end positions.
+ *
+ * If you want to specify a range that contains a line including the line ending
+ * character(s) then use an end position denoting the start of the next line.
+ * For example:
+ * ```ts
+ * {
+ * start: { line: 5, character: 23 }
+ * end : { line 6, character : 0 }
+ * }
+ * ```
+ */
+export interface Range {
+ /**
+ * The range's start position.
+ */
+ start: Position;
+ /**
+ * The range's end position.
+ */
+ end: Position;
+}
+
+export interface ImplementationOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * Static registration options to be returned in the initialize
+ * request.
+ */
+export interface StaticRegistrationOptions {
+ /**
+ * The id used to register the request. The id can be used to deregister
+ * the request again. See also Registration#id.
+ */
+ id?: string;
+}
+
+export interface TypeDefinitionOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * The workspace folder change event.
+ */
+export interface WorkspaceFoldersChangeEvent {
+ /**
+ * The array of added workspace folders
+ */
+ added: (WorkspaceFolder)[];
+ /**
+ * The array of the removed workspace folders
+ */
+ removed: (WorkspaceFolder)[];
+}
+
+export interface ConfigurationItem {
+ /**
+ * The scope to get the configuration section for.
+ */
+ scopeUri?: string;
+ /**
+ * The configuration section asked for.
+ */
+ section?: string;
+}
+
+/**
+ * A literal to identify a text document in the client.
+ */
+export interface TextDocumentIdentifier {
+ /**
+ * The text document's uri.
+ */
+ uri: string;
+}
+
+/**
+ * Represents a color in RGBA space.
+ */
+export interface Color {
+ /**
+ * The red component of this color in the range [0-1].
+ */
+ red: number;
+ /**
+ * The green component of this color in the range [0-1].
+ */
+ green: number;
+ /**
+ * The blue component of this color in the range [0-1].
+ */
+ blue: number;
+ /**
+ * The alpha component of this color in the range [0-1].
+ */
+ alpha: number;
+}
+
+export interface DocumentColorOptions extends WorkDoneProgressOptions {
+}
+
+export interface FoldingRangeOptions extends WorkDoneProgressOptions {
+}
+
+export interface DeclarationOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * Position in a text document expressed as zero-based line and character
+ * offset. Prior to 3.17 the offsets were always based on a UTF-16 string
+ * representation. So a string of the form `a𐐀b` the character offset of the
+ * character `a` is 0, the character offset of `𐐀` is 1 and the character
+ * offset of b is 3 since `𐐀` is represented using two code units in UTF-16.
+ * Since 3.17 clients and servers can agree on a different string encoding
+ * representation (e.g. UTF-8). The client announces it's supported encoding
+ * via the client capability [`general.positionEncodings`](https://microsoft.github.io/language-server-protocol/specifications/specification-current/#clientCapabilities).
+ * The value is an array of position encodings the client supports, with
+ * decreasing preference (e.g. the encoding at index `0` is the most preferred
+ * one). To stay backwards compatible the only mandatory encoding is UTF-16
+ * represented via the string `utf-16`. The server can pick one of the
+ * encodings offered by the client and signals that encoding back to the
+ * client via the initialize result's property
+ * [`capabilities.positionEncoding`](https://microsoft.github.io/language-server-protocol/specifications/specification-current/#serverCapabilities). If the string value
+ * `utf-16` is missing from the client's capability `general.positionEncodings`
+ * servers can safely assume that the client supports UTF-16. If the server
+ * omits the position encoding in its initialize result the encoding defaults
+ * to the string value `utf-16`. Implementation considerations: since the
+ * conversion from one encoding into another requires the content of the
+ * file / line the conversion is best done where the file is read which is
+ * usually on the server side.
+ *
+ * Positions are line end character agnostic. So you can not specify a position
+ * that denotes `\r|\n` or `\n|` where `|` represents the character offset.
+ *
+ * @since 3.17.0 - support for negotiated position encoding.
+ */
+export interface Position {
+ /**
+ * Line position in a document (zero-based).
+ *
+ * If a line number is greater than the number of lines in a document, it defaults back to the number of lines in the document.
+ * If a line number is negative, it defaults to 0.
+ */
+ line: number;
+ /**
+ * Character offset on a line in a document (zero-based).
+ *
+ * The meaning of this offset is determined by the negotiated
+ * `PositionEncodingKind`.
+ *
+ * If the character value is greater than the line length it defaults back to the
+ * line length.
+ */
+ character: number;
+}
+
+export interface SelectionRangeOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * Call hierarchy options used during static registration.
+ *
+ * @since 3.16.0
+ */
+export interface CallHierarchyOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensOptions extends WorkDoneProgressOptions {
+ /**
+ * The legend used by the server
+ */
+ legend: SemanticTokensLegend;
+ /**
+ * Server supports providing semantic tokens for a specific range
+ * of a document.
+ */
+ range?: boolean | {
+
+ };
+ /**
+ * Server supports providing semantic tokens for a full document.
+ */
+ full?: boolean | {
+ delta?: boolean
+ };
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensEdit {
+ /**
+ * The start offset of the edit.
+ */
+ start: number;
+ /**
+ * The count of elements to remove.
+ */
+ deleteCount: number;
+ /**
+ * The elements to insert.
+ */
+ data?: (number)[];
+}
+
+export interface LinkedEditingRangeOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * Represents information on a file/folder create.
+ *
+ * @since 3.16.0
+ */
+export interface FileCreate {
+ /**
+ * A file:// URI for the location of the file/folder being created.
+ */
+ uri: string;
+}
+
+/**
+ * Describes textual changes on a text document. A TextDocumentEdit describes all changes
+ * on a document version Si and after they are applied move the document to version Si+1.
+ * So the creator of a TextDocumentEdit doesn't need to sort the array of edits or do any
+ * kind of ordering. However the edits must be non overlapping.
+ */
+export interface TextDocumentEdit {
+ /**
+ * The text document to change.
+ */
+ textDocument: OptionalVersionedTextDocumentIdentifier;
+ /**
+ * The edits to be applied.
+ *
+ * @since 3.16.0 - support for AnnotatedTextEdit. This is guarded using a
+ * client capability.
+ */
+ edits: (TextEdit | AnnotatedTextEdit)[];
+}
+
+/**
+ * Create file operation.
+ */
+export interface CreateFile extends ResourceOperation {
+ /**
+ * A create
+ */
+ kind: 'create';
+ /**
+ * The resource to create.
+ */
+ uri: string;
+ /**
+ * Additional options
+ */
+ options?: CreateFileOptions;
+}
+
+/**
+ * Rename file operation
+ */
+export interface RenameFile extends ResourceOperation {
+ /**
+ * A rename
+ */
+ kind: 'rename';
+ /**
+ * The old (existing) location.
+ */
+ oldUri: string;
+ /**
+ * The new location.
+ */
+ newUri: string;
+ /**
+ * Rename options.
+ */
+ options?: RenameFileOptions;
+}
+
+/**
+ * Delete file operation
+ */
+export interface DeleteFile extends ResourceOperation {
+ /**
+ * A delete
+ */
+ kind: 'delete';
+ /**
+ * The file to delete.
+ */
+ uri: string;
+ /**
+ * Delete options.
+ */
+ options?: DeleteFileOptions;
+}
+
+/**
+ * Additional information that describes document changes.
+ *
+ * @since 3.16.0
+ */
+export interface ChangeAnnotation {
+ /**
+ * A human-readable string describing the actual change. The string
+ * is rendered prominent in the user interface.
+ */
+ label: string;
+ /**
+ * A flag which indicates that user confirmation is needed
+ * before applying the change.
+ */
+ needsConfirmation?: boolean;
+ /**
+ * A human-readable string which is rendered less prominent in
+ * the user interface.
+ */
+ description?: string;
+}
+
+/**
+ * A filter to describe in which file operation requests or notifications
+ * the server is interested in receiving.
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationFilter {
+ /**
+ * A Uri scheme like `file` or `untitled`.
+ */
+ scheme?: string;
+ /**
+ * The actual file operation pattern.
+ */
+ pattern: FileOperationPattern;
+}
+
+/**
+ * Represents information on a file/folder rename.
+ *
+ * @since 3.16.0
+ */
+export interface FileRename {
+ /**
+ * A file:// URI for the original location of the file/folder being renamed.
+ */
+ oldUri: string;
+ /**
+ * A file:// URI for the new location of the file/folder being renamed.
+ */
+ newUri: string;
+}
+
+/**
+ * Represents information on a file/folder delete.
+ *
+ * @since 3.16.0
+ */
+export interface FileDelete {
+ /**
+ * A file:// URI for the location of the file/folder being deleted.
+ */
+ uri: string;
+}
+
+export interface MonikerOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * Type hierarchy options used during static registration.
+ *
+ * @since 3.17.0
+ */
+export interface TypeHierarchyOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * @since 3.17.0
+ */
+export interface InlineValueContext {
+ /**
+ * The stack frame (as a DAP Id) where the execution has stopped.
+ */
+ frameId: number;
+ /**
+ * The document range where execution has stopped.
+ * Typically the end position of the range denotes the line where the inline values are shown.
+ */
+ stoppedLocation: Range;
+}
+
+/**
+ * Provide inline value as text.
+ *
+ * @since 3.17.0
+ */
+export interface InlineValueText {
+ /**
+ * The document range for which the inline value applies.
+ */
+ range: Range;
+ /**
+ * The text of the inline value.
+ */
+ text: string;
+}
+
+/**
+ * Provide inline value through a variable lookup.
+ * If only a range is specified, the variable name will be extracted from the underlying document.
+ * An optional variable name can be used to override the extracted name.
+ *
+ * @since 3.17.0
+ */
+export interface InlineValueVariableLookup {
+ /**
+ * The document range for which the inline value applies.
+ * The range is used to extract the variable name from the underlying document.
+ */
+ range: Range;
+ /**
+ * If specified the name of the variable to look up.
+ */
+ variableName?: string;
+ /**
+ * How to perform the lookup.
+ */
+ caseSensitiveLookup: boolean;
+}
+
+/**
+ * Provide an inline value through an expression evaluation.
+ * If only a range is specified, the expression will be extracted from the underlying document.
+ * An optional expression can be used to override the extracted expression.
+ *
+ * @since 3.17.0
+ */
+export interface InlineValueEvaluatableExpression {
+ /**
+ * The document range for which the inline value applies.
+ * The range is used to extract the evaluatable expression from the underlying document.
+ */
+ range: Range;
+ /**
+ * If specified the expression overrides the extracted expression.
+ */
+ expression?: string;
+}
+
+/**
+ * Inline value options used during static registration.
+ *
+ * @since 3.17.0
+ */
+export interface InlineValueOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * An inlay hint label part allows for interactive and composite labels
+ * of inlay hints.
+ *
+ * @since 3.17.0
+ */
+export interface InlayHintLabelPart {
+ /**
+ * The value of this label part.
+ */
+ value: string;
+ /**
+ * The tooltip text when you hover over this label part. Depending on
+ * the client capability `inlayHint.resolveSupport` clients might resolve
+ * this property late using the resolve request.
+ */
+ tooltip?: string | MarkupContent;
+ /**
+ * An optional source code location that represents this
+ * label part.
+ *
+ * The editor will use this location for the hover and for code navigation
+ * features: This part will become a clickable link that resolves to the
+ * definition of the symbol at the given location (not necessarily the
+ * location itself), it shows the hover that shows at the given location,
+ * and it shows a context menu with further code navigation commands.
+ *
+ * Depending on the client capability `inlayHint.resolveSupport` clients
+ * might resolve this property late using the resolve request.
+ */
+ location?: Location;
+ /**
+ * An optional command for this label part.
+ *
+ * Depending on the client capability `inlayHint.resolveSupport` clients
+ * might resolve this property late using the resolve request.
+ */
+ command?: Command;
+}
+
+/**
+ * A `MarkupContent` literal represents a string value which content is interpreted base on its
+ * kind flag. Currently the protocol supports `plaintext` and `markdown` as markup kinds.
+ *
+ * If the kind is `markdown` then the value can contain fenced code blocks like in GitHub issues.
+ * See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
+ *
+ * Here is an example how such a string can be constructed using JavaScript / TypeScript:
+ * ```ts
+ * let markdown: MarkdownContent = {
+ * kind: MarkupKind.Markdown,
+ * value: [
+ * '# Header',
+ * 'Some text',
+ * '```typescript',
+ * 'someCode();',
+ * '```'
+ * ].join('\n')
+ * };
+ * ```
+ *
+ * *Please Note* that clients might sanitize the return markdown. A client could decide to
+ * remove HTML from the markdown to avoid script execution.
+ */
+export interface MarkupContent {
+ /**
+ * The type of the Markup
+ */
+ kind: MarkupKind;
+ /**
+ * The content itself
+ */
+ value: string;
+}
+
+/**
+ * Inlay hint options used during static registration.
+ *
+ * @since 3.17.0
+ */
+export interface InlayHintOptions extends WorkDoneProgressOptions {
+ /**
+ * The server provides support to resolve additional
+ * information for an inlay hint item.
+ */
+ resolveProvider?: boolean;
+}
+
+/**
+ * A full diagnostic report with a set of related documents.
+ *
+ * @since 3.17.0
+ */
+export interface RelatedFullDocumentDiagnosticReport extends FullDocumentDiagnosticReport {
+ /**
+ * Diagnostics of related documents. This information is useful
+ * in programming languages where code in a file A can generate
+ * diagnostics in a file B which A depends on. An example of
+ * such a language is C/C++ where marco definitions in a file
+ * a.cpp and result in errors in a header file b.hpp.
+ *
+ * @since 3.17.0
+ */
+ relatedDocuments?: { [key: string]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport };
+}
+
+/**
+ * An unchanged diagnostic report with a set of related documents.
+ *
+ * @since 3.17.0
+ */
+export interface RelatedUnchangedDocumentDiagnosticReport extends UnchangedDocumentDiagnosticReport {
+ /**
+ * Diagnostics of related documents. This information is useful
+ * in programming languages where code in a file A can generate
+ * diagnostics in a file B which A depends on. An example of
+ * such a language is C/C++ where marco definitions in a file
+ * a.cpp and result in errors in a header file b.hpp.
+ *
+ * @since 3.17.0
+ */
+ relatedDocuments?: { [key: string]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport };
+}
+
+/**
+ * A diagnostic report with a full set of problems.
+ *
+ * @since 3.17.0
+ */
+export interface FullDocumentDiagnosticReport {
+ /**
+ * A full document diagnostic report.
+ */
+ kind: 'full';
+ /**
+ * An optional result id. If provided it will
+ * be sent on the next diagnostic request for the
+ * same document.
+ */
+ resultId?: string;
+ /**
+ * The actual items.
+ */
+ items: (Diagnostic)[];
+}
+
+/**
+ * A diagnostic report indicating that the last returned
+ * report is still accurate.
+ *
+ * @since 3.17.0
+ */
+export interface UnchangedDocumentDiagnosticReport {
+ /**
+ * A document diagnostic report indicating
+ * no changes to the last result. A server can
+ * only return `unchanged` if result ids are
+ * provided.
+ */
+ kind: 'unchanged';
+ /**
+ * A result id which will be sent on the next
+ * diagnostic request for the same document.
+ */
+ resultId: string;
+}
+
+/**
+ * Diagnostic options.
+ *
+ * @since 3.17.0
+ */
+export interface DiagnosticOptions extends WorkDoneProgressOptions {
+ /**
+ * An optional identifier under which the diagnostics are
+ * managed by the client.
+ */
+ identifier?: string;
+ /**
+ * Whether the language has inter file dependencies meaning that
+ * editing code in one file can result in a different diagnostic
+ * set in another file. Inter file dependencies are common for
+ * most programming languages and typically uncommon for linters.
+ */
+ interFileDependencies: boolean;
+ /**
+ * The server provides support for workspace diagnostics as well.
+ */
+ workspaceDiagnostics: boolean;
+}
+
+/**
+ * A previous result id in a workspace pull request.
+ *
+ * @since 3.17.0
+ */
+export interface PreviousResultId {
+ /**
+ * The URI for which the client knowns a
+ * result id.
+ */
+ uri: string;
+ /**
+ * The value of the previous result id.
+ */
+ value: string;
+}
+
+/**
+ * A notebook document.
+ *
+ * @since 3.17.0
+ */
+export interface NotebookDocument {
+ /**
+ * The notebook document's uri.
+ */
+ uri: string;
+ /**
+ * The type of the notebook.
+ */
+ notebookType: string;
+ /**
+ * The version number of this document (it will increase after each
+ * change, including undo/redo).
+ */
+ version: number;
+ /**
+ * Additional metadata stored with the notebook
+ * document.
+ *
+ * Note: should always be an object literal (e.g. LSPObject)
+ */
+ metadata?: LSPObject;
+ /**
+ * The cells of a notebook.
+ */
+ cells: (NotebookCell)[];
+}
+
+/**
+ * An item to transfer a text document from the client to the
+ * server.
+ */
+export interface TextDocumentItem {
+ /**
+ * The text document's uri.
+ */
+ uri: string;
+ /**
+ * The text document's language identifier.
+ */
+ languageId: string;
+ /**
+ * The version number of this document (it will increase after each
+ * change, including undo/redo).
+ */
+ version: number;
+ /**
+ * The content of the opened text document.
+ */
+ text: string;
+}
+
+/**
+ * A versioned notebook document identifier.
+ *
+ * @since 3.17.0
+ */
+export interface VersionedNotebookDocumentIdentifier {
+ /**
+ * The version number of this notebook document.
+ */
+ version: number;
+ /**
+ * The notebook document's uri.
+ */
+ uri: string;
+}
+
+/**
+ * A change event for a notebook document.
+ *
+ * @since 3.17.0
+ */
+export interface NotebookDocumentChangeEvent {
+ /**
+ * The changed meta data if any.
+ *
+ * Note: should always be an object literal (e.g. LSPObject)
+ */
+ metadata?: LSPObject;
+ /**
+ * Changes to cells
+ */
+ cells?: {
+ structure?: {
+ array: NotebookCellArrayChange;
+ didOpen?: (TextDocumentItem)[];
+ didClose?: (TextDocumentIdentifier)[]
+ };
+ data?: (NotebookCell)[];
+ textContent?: ({
+ document: VersionedTextDocumentIdentifier;
+ changes: (TextDocumentContentChangeEvent)[]
+ })[]
+ };
+}
+
+/**
+ * A literal to identify a notebook document in the client.
+ *
+ * @since 3.17.0
+ */
+export interface NotebookDocumentIdentifier {
+ /**
+ * The notebook document's uri.
+ */
+ uri: string;
+}
+
+/**
+ * Provides information about the context in which an inline completion was requested.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export interface InlineCompletionContext {
+ /**
+ * Describes how the inline completion was triggered.
+ */
+ triggerKind: InlineCompletionTriggerKind;
+ /**
+ * Provides information about the currently selected item in the autocomplete widget if it is visible.
+ */
+ selectedCompletionInfo?: SelectedCompletionInfo;
+}
+
+/**
+ * A string value used as a snippet is a template which allows to insert text
+ * and to control the editor cursor when insertion happens.
+ *
+ * A snippet can define tab stops and placeholders with `$1`, `$2`
+ * and `${3:foo}`. `$0` defines the final tab stop, it defaults to
+ * the end of the snippet. Variables are defined with `$name` and
+ * `${name:default value}`.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export interface StringValue {
+ /**
+ * The kind of string value.
+ */
+ kind: 'snippet';
+ /**
+ * The snippet string.
+ */
+ value: string;
+}
+
+/**
+ * Inline completion options used during static registration.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export interface InlineCompletionOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * General parameters to register for a notification or to register a provider.
+ */
+export interface Registration {
+ /**
+ * The id used to register the request. The id can be used to deregister
+ * the request again.
+ */
+ id: string;
+ /**
+ * The method / capability to register for.
+ */
+ method: string;
+ /**
+ * Options necessary for the registration.
+ */
+ registerOptions?: LSPAny;
+}
+
+/**
+ * General parameters to unregister a request or notification.
+ */
+export interface Unregistration {
+ /**
+ * The id used to unregister the request or notification. Usually an id
+ * provided during the register request.
+ */
+ id: string;
+ /**
+ * The method to unregister for.
+ */
+ method: string;
+}
+
+/**
+ * The initialize parameters
+ */
+export interface _InitializeParams extends WorkDoneProgressParams {
+ /**
+ * The process Id of the parent process that started
+ * the server.
+ *
+ * Is `null` if the process has not been started by another process.
+ * If the parent process is not alive then the server should exit.
+ */
+ processId: number | null;
+ /**
+ * Information about the client
+ *
+ * @since 3.15.0
+ */
+ clientInfo?: {
+ name: string;
+ version?: string
+ };
+ /**
+ * The locale the client is currently showing the user interface
+ * in. This must not necessarily be the locale of the operating
+ * system.
+ *
+ * Uses IETF language tags as the value's syntax
+ * (See https://en.wikipedia.org/wiki/IETF_language_tag)
+ *
+ * @since 3.16.0
+ */
+ locale?: string;
+ /**
+ * The rootPath of the workspace. Is null
+ * if no folder is open.
+ *
+ * @deprecated in favour of rootUri.
+ */
+ rootPath?: string | null;
+ /**
+ * The rootUri of the workspace. Is null if no
+ * folder is open. If both `rootPath` and `rootUri` are set
+ * `rootUri` wins.
+ *
+ * @deprecated in favour of workspaceFolders.
+ */
+ rootUri: string | null;
+ /**
+ * The capabilities provided by the client (editor or tool)
+ */
+ capabilities: ClientCapabilities;
+ /**
+ * User provided initialization options.
+ */
+ initializationOptions?: LSPAny;
+ /**
+ * The initial trace setting. If omitted trace is disabled ('off').
+ */
+ trace?: TraceValues;
+}
+
+export interface WorkspaceFoldersInitializeParams {
+ /**
+ * The workspace folders configured in the client when the server starts.
+ *
+ * This property is only available if the client supports workspace folders.
+ * It can be `null` if the client supports workspace folders but none are
+ * configured.
+ *
+ * @since 3.6.0
+ */
+ workspaceFolders?: (WorkspaceFolder)[] | null;
+}
+
+/**
+ * Defines the capabilities provided by a language
+ * server.
+ */
+export interface ServerCapabilities {
+ /**
+ * The position encoding the server picked from the encodings offered
+ * by the client via the client capability `general.positionEncodings`.
+ *
+ * If the client didn't provide any position encodings the only valid
+ * value that a server can return is 'utf-16'.
+ *
+ * If omitted it defaults to 'utf-16'.
+ *
+ * @since 3.17.0
+ */
+ positionEncoding?: PositionEncodingKind;
+ /**
+ * Defines how text documents are synced. Is either a detailed structure
+ * defining each notification or for backwards compatibility the
+ * TextDocumentSyncKind number.
+ */
+ textDocumentSync?: TextDocumentSyncOptions | TextDocumentSyncKind;
+ /**
+ * Defines how notebook documents are synced.
+ *
+ * @since 3.17.0
+ */
+ notebookDocumentSync?: NotebookDocumentSyncOptions | NotebookDocumentSyncRegistrationOptions;
+ /**
+ * The server provides completion support.
+ */
+ completionProvider?: CompletionOptions;
+ /**
+ * The server provides hover support.
+ */
+ hoverProvider?: boolean | HoverOptions;
+ /**
+ * The server provides signature help support.
+ */
+ signatureHelpProvider?: SignatureHelpOptions;
+ /**
+ * The server provides Goto Declaration support.
+ */
+ declarationProvider?: boolean | DeclarationOptions | DeclarationRegistrationOptions;
+ /**
+ * The server provides goto definition support.
+ */
+ definitionProvider?: boolean | DefinitionOptions;
+ /**
+ * The server provides Goto Type Definition support.
+ */
+ typeDefinitionProvider?: boolean | TypeDefinitionOptions | TypeDefinitionRegistrationOptions;
+ /**
+ * The server provides Goto Implementation support.
+ */
+ implementationProvider?: boolean | ImplementationOptions | ImplementationRegistrationOptions;
+ /**
+ * The server provides find references support.
+ */
+ referencesProvider?: boolean | ReferenceOptions;
+ /**
+ * The server provides document highlight support.
+ */
+ documentHighlightProvider?: boolean | DocumentHighlightOptions;
+ /**
+ * The server provides document symbol support.
+ */
+ documentSymbolProvider?: boolean | DocumentSymbolOptions;
+ /**
+ * The server provides code actions. CodeActionOptions may only be
+ * specified if the client states that it supports
+ * `codeActionLiteralSupport` in its initial `initialize` request.
+ */
+ codeActionProvider?: boolean | CodeActionOptions;
+ /**
+ * The server provides code lens.
+ */
+ codeLensProvider?: CodeLensOptions;
+ /**
+ * The server provides document link support.
+ */
+ documentLinkProvider?: DocumentLinkOptions;
+ /**
+ * The server provides color provider support.
+ */
+ colorProvider?: boolean | DocumentColorOptions | DocumentColorRegistrationOptions;
+ /**
+ * The server provides workspace symbol support.
+ */
+ workspaceSymbolProvider?: boolean | WorkspaceSymbolOptions;
+ /**
+ * The server provides document formatting.
+ */
+ documentFormattingProvider?: boolean | DocumentFormattingOptions;
+ /**
+ * The server provides document range formatting.
+ */
+ documentRangeFormattingProvider?: boolean | DocumentRangeFormattingOptions;
+ /**
+ * The server provides document formatting on typing.
+ */
+ documentOnTypeFormattingProvider?: DocumentOnTypeFormattingOptions;
+ /**
+ * The server provides rename support. RenameOptions may only be
+ * specified if the client states that it supports
+ * `prepareSupport` in its initial `initialize` request.
+ */
+ renameProvider?: boolean | RenameOptions;
+ /**
+ * The server provides folding provider support.
+ */
+ foldingRangeProvider?: boolean | FoldingRangeOptions | FoldingRangeRegistrationOptions;
+ /**
+ * The server provides selection range support.
+ */
+ selectionRangeProvider?: boolean | SelectionRangeOptions | SelectionRangeRegistrationOptions;
+ /**
+ * The server provides execute command support.
+ */
+ executeCommandProvider?: ExecuteCommandOptions;
+ /**
+ * The server provides call hierarchy support.
+ *
+ * @since 3.16.0
+ */
+ callHierarchyProvider?: boolean | CallHierarchyOptions | CallHierarchyRegistrationOptions;
+ /**
+ * The server provides linked editing range support.
+ *
+ * @since 3.16.0
+ */
+ linkedEditingRangeProvider?: boolean | LinkedEditingRangeOptions | LinkedEditingRangeRegistrationOptions;
+ /**
+ * The server provides semantic tokens support.
+ *
+ * @since 3.16.0
+ */
+ semanticTokensProvider?: SemanticTokensOptions | SemanticTokensRegistrationOptions;
+ /**
+ * The server provides moniker support.
+ *
+ * @since 3.16.0
+ */
+ monikerProvider?: boolean | MonikerOptions | MonikerRegistrationOptions;
+ /**
+ * The server provides type hierarchy support.
+ *
+ * @since 3.17.0
+ */
+ typeHierarchyProvider?: boolean | TypeHierarchyOptions | TypeHierarchyRegistrationOptions;
+ /**
+ * The server provides inline values.
+ *
+ * @since 3.17.0
+ */
+ inlineValueProvider?: boolean | InlineValueOptions | InlineValueRegistrationOptions;
+ /**
+ * The server provides inlay hints.
+ *
+ * @since 3.17.0
+ */
+ inlayHintProvider?: boolean | InlayHintOptions | InlayHintRegistrationOptions;
+ /**
+ * The server has support for pull model diagnostics.
+ *
+ * @since 3.17.0
+ */
+ diagnosticProvider?: DiagnosticOptions | DiagnosticRegistrationOptions;
+ /**
+ * Inline completion options used during static registration.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+ inlineCompletionProvider?: boolean | InlineCompletionOptions;
+ /**
+ * Workspace specific server capabilities.
+ */
+ workspace?: {
+ workspaceFolders?: WorkspaceFoldersServerCapabilities;
+ fileOperations?: FileOperationOptions
+ };
+ /**
+ * Experimental server capabilities.
+ */
+ experimental?: LSPAny;
+}
+
+/**
+ * A text document identifier to denote a specific version of a text document.
+ */
+export interface VersionedTextDocumentIdentifier extends TextDocumentIdentifier {
+ /**
+ * The version number of this document.
+ */
+ version: number;
+}
+
+/**
+ * Save options.
+ */
+export interface SaveOptions {
+ /**
+ * The client is supposed to include the content on save.
+ */
+ includeText?: boolean;
+}
+
+/**
+ * An event describing a file change.
+ */
+export interface FileEvent {
+ /**
+ * The file's uri.
+ */
+ uri: string;
+ /**
+ * The change type.
+ */
+ type: FileChangeType;
+}
+
+export interface FileSystemWatcher {
+ /**
+ * The glob pattern to watch. See {@link GlobPattern glob pattern} for more detail.
+ *
+ * @since 3.17.0 support for relative patterns.
+ */
+ globPattern: GlobPattern;
+ /**
+ * The kind of events of interest. If omitted it defaults
+ * to WatchKind.Create | WatchKind.Change | WatchKind.Delete
+ * which is 7.
+ */
+ kind?: WatchKind;
+}
+
+/**
+ * Represents a diagnostic, such as a compiler error or warning. Diagnostic objects
+ * are only valid in the scope of a resource.
+ */
+export interface Diagnostic {
+ /**
+ * The range at which the message applies
+ */
+ range: Range;
+ /**
+ * The diagnostic's severity. Can be omitted. If omitted it is up to the
+ * client to interpret diagnostics as error, warning, info or hint.
+ */
+ severity?: DiagnosticSeverity;
+ /**
+ * The diagnostic's code, which usually appear in the user interface.
+ */
+ code?: number | string;
+ /**
+ * An optional property to describe the error code.
+ * Requires the code field (above) to be present/not null.
+ *
+ * @since 3.16.0
+ */
+ codeDescription?: CodeDescription;
+ /**
+ * A human-readable string describing the source of this
+ * diagnostic, e.g. 'typescript' or 'super lint'. It usually
+ * appears in the user interface.
+ */
+ source?: string;
+ /**
+ * The diagnostic's message. It usually appears in the user interface
+ */
+ message: string;
+ /**
+ * Additional metadata about the diagnostic.
+ *
+ * @since 3.15.0
+ */
+ tags?: (DiagnosticTag)[];
+ /**
+ * An array of related diagnostic information, e.g. when symbol-names within
+ * a scope collide all definitions can be marked via this property.
+ */
+ relatedInformation?: (DiagnosticRelatedInformation)[];
+ /**
+ * A data entry field that is preserved between a `textDocument/publishDiagnostics`
+ * notification and `textDocument/codeAction` request.
+ *
+ * @since 3.16.0
+ */
+ data?: LSPAny;
+}
+
+/**
+ * Contains additional information about the context in which a completion request is triggered.
+ */
+export interface CompletionContext {
+ /**
+ * How the completion was triggered.
+ */
+ triggerKind: CompletionTriggerKind;
+ /**
+ * The trigger character (a single character) that has trigger code complete.
+ * Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter`
+ */
+ triggerCharacter?: string;
+}
+
+/**
+ * Additional details for a completion item label.
+ *
+ * @since 3.17.0
+ */
+export interface CompletionItemLabelDetails {
+ /**
+ * An optional string which is rendered less prominently directly after {@link CompletionItem.label label},
+ * without any spacing. Should be used for function signatures and type annotations.
+ */
+ detail?: string;
+ /**
+ * An optional string which is rendered less prominently after {@link CompletionItem.detail}. Should be used
+ * for fully qualified names and file paths.
+ */
+ description?: string;
+}
+
+/**
+ * A special text edit to provide an insert and a replace operation.
+ *
+ * @since 3.16.0
+ */
+export interface InsertReplaceEdit {
+ /**
+ * The string to be inserted.
+ */
+ newText: string;
+ /**
+ * The range if the insert is requested
+ */
+ insert: Range;
+ /**
+ * The range if the replace is requested.
+ */
+ replace: Range;
+}
+
+/**
+ * Completion options.
+ */
+export interface CompletionOptions extends WorkDoneProgressOptions {
+ /**
+ * Most tools trigger completion request automatically without explicitly requesting
+ * it using a keyboard shortcut (e.g. Ctrl+Space). Typically they do so when the user
+ * starts to type an identifier. For example if the user types `c` in a JavaScript file
+ * code complete will automatically pop up present `console` besides others as a
+ * completion item. Characters that make up identifiers don't need to be listed here.
+ *
+ * If code complete should automatically be trigger on characters not being valid inside
+ * an identifier (for example `.` in JavaScript) list them in `triggerCharacters`.
+ */
+ triggerCharacters?: (string)[];
+ /**
+ * The list of all possible characters that commit a completion. This field can be used
+ * if clients don't support individual commit characters per completion item. See
+ * `ClientCapabilities.textDocument.completion.completionItem.commitCharactersSupport`
+ *
+ * If a server provides both `allCommitCharacters` and commit characters on an individual
+ * completion item the ones on the completion item win.
+ *
+ * @since 3.2.0
+ */
+ allCommitCharacters?: (string)[];
+ /**
+ * The server provides support to resolve additional
+ * information for a completion item.
+ */
+ resolveProvider?: boolean;
+ /**
+ * The server supports the following `CompletionItem` specific
+ * capabilities.
+ *
+ * @since 3.17.0
+ */
+ completionItem?: {
+ labelDetailsSupport?: boolean
+ };
+}
+
+/**
+ * Hover options.
+ */
+export interface HoverOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * Additional information about the context in which a signature help request was triggered.
+ *
+ * @since 3.15.0
+ */
+export interface SignatureHelpContext {
+ /**
+ * Action that caused signature help to be triggered.
+ */
+ triggerKind: SignatureHelpTriggerKind;
+ /**
+ * Character that caused signature help to be triggered.
+ *
+ * This is undefined when `triggerKind !== SignatureHelpTriggerKind.TriggerCharacter`
+ */
+ triggerCharacter?: string;
+ /**
+ * `true` if signature help was already showing when it was triggered.
+ *
+ * Retriggers occurs when the signature help is already active and can be caused by actions such as
+ * typing a trigger character, a cursor move, or document content changes.
+ */
+ isRetrigger: boolean;
+ /**
+ * The currently active `SignatureHelp`.
+ *
+ * The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field updated based on
+ * the user navigating through available signatures.
+ */
+ activeSignatureHelp?: SignatureHelp;
+}
+
+/**
+ * Represents the signature of something callable. A signature
+ * can have a label, like a function-name, a doc-comment, and
+ * a set of parameters.
+ */
+export interface SignatureInformation {
+ /**
+ * The label of this signature. Will be shown in
+ * the UI.
+ */
+ label: string;
+ /**
+ * The human-readable doc-comment of this signature. Will be shown
+ * in the UI but can be omitted.
+ */
+ documentation?: string | MarkupContent;
+ /**
+ * The parameters of this signature.
+ */
+ parameters?: (ParameterInformation)[];
+ /**
+ * The index of the active parameter.
+ *
+ * If provided, this is used in place of `SignatureHelp.activeParameter`.
+ *
+ * @since 3.16.0
+ */
+ activeParameter?: number;
+}
+
+/**
+ * Server Capabilities for a {@link SignatureHelpRequest}.
+ */
+export interface SignatureHelpOptions extends WorkDoneProgressOptions {
+ /**
+ * List of characters that trigger signature help automatically.
+ */
+ triggerCharacters?: (string)[];
+ /**
+ * List of characters that re-trigger signature help.
+ *
+ * These trigger characters are only active when signature help is already showing. All trigger characters
+ * are also counted as re-trigger characters.
+ *
+ * @since 3.15.0
+ */
+ retriggerCharacters?: (string)[];
+}
+
+/**
+ * Server Capabilities for a {@link DefinitionRequest}.
+ */
+export interface DefinitionOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * Value-object that contains additional information when
+ * requesting references.
+ */
+export interface ReferenceContext {
+ /**
+ * Include the declaration of the current symbol.
+ */
+ includeDeclaration: boolean;
+}
+
+/**
+ * Reference options.
+ */
+export interface ReferenceOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * Provider options for a {@link DocumentHighlightRequest}.
+ */
+export interface DocumentHighlightOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * A base for all symbol information.
+ */
+export interface BaseSymbolInformation {
+ /**
+ * The name of this symbol.
+ */
+ name: string;
+ /**
+ * The kind of this symbol.
+ */
+ kind: SymbolKind;
+ /**
+ * Tags for this symbol.
+ *
+ * @since 3.16.0
+ */
+ tags?: (SymbolTag)[];
+ /**
+ * The name of the symbol containing this symbol. This information is for
+ * user interface purposes (e.g. to render a qualifier in the user interface
+ * if necessary). It can't be used to re-infer a hierarchy for the document
+ * symbols.
+ */
+ containerName?: string;
+}
+
+/**
+ * Provider options for a {@link DocumentSymbolRequest}.
+ */
+export interface DocumentSymbolOptions extends WorkDoneProgressOptions {
+ /**
+ * A human-readable string that is shown when multiple outlines trees
+ * are shown for the same document.
+ *
+ * @since 3.16.0
+ */
+ label?: string;
+}
+
+/**
+ * Contains additional diagnostic information about the context in which
+ * a {@link CodeActionProvider.provideCodeActions code action} is run.
+ */
+export interface CodeActionContext {
+ /**
+ * An array of diagnostics known on the client side overlapping the range provided to the
+ * `textDocument/codeAction` request. They are provided so that the server knows which
+ * errors are currently presented to the user for the given range. There is no guarantee
+ * that these accurately reflect the error state of the resource. The primary parameter
+ * to compute code actions is the provided range.
+ */
+ diagnostics: (Diagnostic)[];
+ /**
+ * Requested kind of actions to return.
+ *
+ * Actions not of this kind are filtered out by the client before being shown. So servers
+ * can omit computing them.
+ */
+ only?: (CodeActionKind)[];
+ /**
+ * The reason why code actions were requested.
+ *
+ * @since 3.17.0
+ */
+ triggerKind?: CodeActionTriggerKind;
+}
+
+/**
+ * Provider options for a {@link CodeActionRequest}.
+ */
+export interface CodeActionOptions extends WorkDoneProgressOptions {
+ /**
+ * CodeActionKinds that this server may return.
+ *
+ * The list of kinds may be generic, such as `CodeActionKind.Refactor`, or the server
+ * may list out every specific kind they provide.
+ */
+ codeActionKinds?: (CodeActionKind)[];
+ /**
+ * The server provides support to resolve additional
+ * information for a code action.
+ *
+ * @since 3.16.0
+ */
+ resolveProvider?: boolean;
+}
+
+/**
+ * Server capabilities for a {@link WorkspaceSymbolRequest}.
+ */
+export interface WorkspaceSymbolOptions extends WorkDoneProgressOptions {
+ /**
+ * The server provides support to resolve additional
+ * information for a workspace symbol.
+ *
+ * @since 3.17.0
+ */
+ resolveProvider?: boolean;
+}
+
+/**
+ * Code Lens provider options of a {@link CodeLensRequest}.
+ */
+export interface CodeLensOptions extends WorkDoneProgressOptions {
+ /**
+ * Code lens has a resolve provider as well.
+ */
+ resolveProvider?: boolean;
+}
+
+/**
+ * Provider options for a {@link DocumentLinkRequest}.
+ */
+export interface DocumentLinkOptions extends WorkDoneProgressOptions {
+ /**
+ * Document links have a resolve provider as well.
+ */
+ resolveProvider?: boolean;
+}
+
+/**
+ * Value-object describing what options formatting should use.
+ */
+export interface FormattingOptions {
+ /**
+ * Size of a tab in spaces.
+ */
+ tabSize: number;
+ /**
+ * Prefer spaces over tabs.
+ */
+ insertSpaces: boolean;
+ /**
+ * Trim trailing whitespace on a line.
+ *
+ * @since 3.15.0
+ */
+ trimTrailingWhitespace?: boolean;
+ /**
+ * Insert a newline character at the end of the file if one does not exist.
+ *
+ * @since 3.15.0
+ */
+ insertFinalNewline?: boolean;
+ /**
+ * Trim all newlines after the final newline at the end of the file.
+ *
+ * @since 3.15.0
+ */
+ trimFinalNewlines?: boolean;
+}
+
+/**
+ * Provider options for a {@link DocumentFormattingRequest}.
+ */
+export interface DocumentFormattingOptions extends WorkDoneProgressOptions {
+}
+
+/**
+ * Provider options for a {@link DocumentRangeFormattingRequest}.
+ */
+export interface DocumentRangeFormattingOptions extends WorkDoneProgressOptions {
+ /**
+ * Whether the server supports formatting multiple ranges at once.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+ rangesSupport?: boolean;
+}
+
+/**
+ * Provider options for a {@link DocumentOnTypeFormattingRequest}.
+ */
+export interface DocumentOnTypeFormattingOptions {
+ /**
+ * A character on which formatting should be triggered, like `{`.
+ */
+ firstTriggerCharacter: string;
+ /**
+ * More trigger characters.
+ */
+ moreTriggerCharacter?: (string)[];
+}
+
+/**
+ * Provider options for a {@link RenameRequest}.
+ */
+export interface RenameOptions extends WorkDoneProgressOptions {
+ /**
+ * Renames should be checked and tested before being executed.
+ *
+ * @since version 3.12.0
+ */
+ prepareProvider?: boolean;
+}
+
+/**
+ * The server capabilities of a {@link ExecuteCommandRequest}.
+ */
+export interface ExecuteCommandOptions extends WorkDoneProgressOptions {
+ /**
+ * The commands to be executed on the server
+ */
+ commands: (string)[];
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensLegend {
+ /**
+ * The token types a server uses.
+ */
+ tokenTypes: (string)[];
+ /**
+ * The token modifiers a server uses.
+ */
+ tokenModifiers: (string)[];
+}
+
+/**
+ * A text document identifier to optionally denote a specific version of a text document.
+ */
+export interface OptionalVersionedTextDocumentIdentifier extends TextDocumentIdentifier {
+ /**
+ * The version number of this document. If a versioned text document identifier
+ * is sent from the server to the client and the file is not open in the editor
+ * (the server has not received an open notification before) the server can send
+ * `null` to indicate that the version is unknown and the content on disk is the
+ * truth (as specified with document content ownership).
+ */
+ version: number | null;
+}
+
+/**
+ * A special text edit with an additional change annotation.
+ *
+ * @since 3.16.0.
+ */
+export interface AnnotatedTextEdit extends TextEdit {
+ /**
+ * The actual identifier of the change annotation
+ */
+ annotationId: ChangeAnnotationIdentifier;
+}
+
+/**
+ * A generic resource operation.
+ */
+export interface ResourceOperation {
+ /**
+ * The resource operation kind.
+ */
+ kind: string;
+ /**
+ * An optional annotation identifier describing the operation.
+ *
+ * @since 3.16.0
+ */
+ annotationId?: ChangeAnnotationIdentifier;
+}
+
+/**
+ * Options to create a file.
+ */
+export interface CreateFileOptions {
+ /**
+ * Overwrite existing file. Overwrite wins over `ignoreIfExists`
+ */
+ overwrite?: boolean;
+ /**
+ * Ignore if exists.
+ */
+ ignoreIfExists?: boolean;
+}
+
+/**
+ * Rename file options
+ */
+export interface RenameFileOptions {
+ /**
+ * Overwrite target if existing. Overwrite wins over `ignoreIfExists`
+ */
+ overwrite?: boolean;
+ /**
+ * Ignores if target exists.
+ */
+ ignoreIfExists?: boolean;
+}
+
+/**
+ * Delete file options
+ */
+export interface DeleteFileOptions {
+ /**
+ * Delete the content recursively if a folder is denoted.
+ */
+ recursive?: boolean;
+ /**
+ * Ignore the operation if the file doesn't exist.
+ */
+ ignoreIfNotExists?: boolean;
+}
+
+/**
+ * A pattern to describe in which file operation requests or notifications
+ * the server is interested in receiving.
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationPattern {
+ /**
+ * The glob pattern to match. Glob patterns can have the following syntax:
+ * - `*` to match zero or more characters in a path segment
+ * - `?` to match on one character in a path segment
+ * - `**` to match any number of path segments, including none
+ * - `{}` to group sub patterns into an OR expression. (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files)
+ * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
+ * - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
+ */
+ glob: string;
+ /**
+ * Whether to match files or folders with this pattern.
+ *
+ * Matches both if undefined.
+ */
+ matches?: FileOperationPatternKind;
+ /**
+ * Additional options used during matching.
+ */
+ options?: FileOperationPatternOptions;
+}
+
+/**
+ * A full document diagnostic report for a workspace diagnostic result.
+ *
+ * @since 3.17.0
+ */
+export interface WorkspaceFullDocumentDiagnosticReport extends FullDocumentDiagnosticReport {
+ /**
+ * The URI for which diagnostic information is reported.
+ */
+ uri: string;
+ /**
+ * The version number for which the diagnostics are reported.
+ * If the document is not marked as open `null` can be provided.
+ */
+ version: number | null;
+}
+
+/**
+ * An unchanged document diagnostic report for a workspace diagnostic result.
+ *
+ * @since 3.17.0
+ */
+export interface WorkspaceUnchangedDocumentDiagnosticReport extends UnchangedDocumentDiagnosticReport {
+ /**
+ * The URI for which diagnostic information is reported.
+ */
+ uri: string;
+ /**
+ * The version number for which the diagnostics are reported.
+ * If the document is not marked as open `null` can be provided.
+ */
+ version: number | null;
+}
+
+/**
+ * A notebook cell.
+ *
+ * A cell's document URI must be unique across ALL notebook
+ * cells and can therefore be used to uniquely identify a
+ * notebook cell or the cell's text document.
+ *
+ * @since 3.17.0
+ */
+export interface NotebookCell {
+ /**
+ * The cell's kind
+ */
+ kind: NotebookCellKind;
+ /**
+ * The URI of the cell's text document
+ * content.
+ */
+ document: string;
+ /**
+ * Additional metadata stored with the cell.
+ *
+ * Note: should always be an object literal (e.g. LSPObject)
+ */
+ metadata?: LSPObject;
+ /**
+ * Additional execution summary information
+ * if supported by the client.
+ */
+ executionSummary?: ExecutionSummary;
+}
+
+/**
+ * A change describing how to move a `NotebookCell`
+ * array from state S to S'.
+ *
+ * @since 3.17.0
+ */
+export interface NotebookCellArrayChange {
+ /**
+ * The start oftest of the cell that changed.
+ */
+ start: number;
+ /**
+ * The deleted cells
+ */
+ deleteCount: number;
+ /**
+ * The new cells, if any
+ */
+ cells?: (NotebookCell)[];
+}
+
+/**
+ * Describes the currently selected completion item.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export interface SelectedCompletionInfo {
+ /**
+ * The range that will be replaced if this completion item is accepted.
+ */
+ range: Range;
+ /**
+ * The text the range will be replaced with if this completion is accepted.
+ */
+ text: string;
+}
+
+/**
+ * Defines the capabilities provided by the client.
+ */
+export interface ClientCapabilities {
+ /**
+ * Workspace specific client capabilities.
+ */
+ workspace?: WorkspaceClientCapabilities;
+ /**
+ * Text document specific client capabilities.
+ */
+ textDocument?: TextDocumentClientCapabilities;
+ /**
+ * Capabilities specific to the notebook document support.
+ *
+ * @since 3.17.0
+ */
+ notebookDocument?: NotebookDocumentClientCapabilities;
+ /**
+ * Window specific client capabilities.
+ */
+ window?: WindowClientCapabilities;
+ /**
+ * General client capabilities.
+ *
+ * @since 3.16.0
+ */
+ general?: GeneralClientCapabilities;
+ /**
+ * Experimental client capabilities.
+ */
+ experimental?: LSPAny;
+}
+
+export interface TextDocumentSyncOptions {
+ /**
+ * Open and close notifications are sent to the server. If omitted open close notification should not
+ * be sent.
+ */
+ openClose?: boolean;
+ /**
+ * Change notifications are sent to the server. See TextDocumentSyncKind.None, TextDocumentSyncKind.Full
+ * and TextDocumentSyncKind.Incremental. If omitted it defaults to TextDocumentSyncKind.None.
+ */
+ change?: TextDocumentSyncKind;
+ /**
+ * If present will save notifications are sent to the server. If omitted the notification should not be
+ * sent.
+ */
+ willSave?: boolean;
+ /**
+ * If present will save wait until requests are sent to the server. If omitted the request should not be
+ * sent.
+ */
+ willSaveWaitUntil?: boolean;
+ /**
+ * If present save notifications are sent to the server. If omitted the notification should not be
+ * sent.
+ */
+ save?: boolean | SaveOptions;
+}
+
+/**
+ * Options specific to a notebook plus its cells
+ * to be synced to the server.
+ *
+ * If a selector provides a notebook document
+ * filter but no cell selector all cells of a
+ * matching notebook document will be synced.
+ *
+ * If a selector provides no notebook document
+ * filter but only a cell selector all notebook
+ * document that contain at least one matching
+ * cell will be synced.
+ *
+ * @since 3.17.0
+ */
+export interface NotebookDocumentSyncOptions {
+ /**
+ * The notebooks to be synced
+ */
+ notebookSelector: ({
+ notebook: string | NotebookDocumentFilter;
+ cells?: ({
+ language: string
+ })[]
+ } | {
+ notebook?: string | NotebookDocumentFilter;
+ cells: ({
+ language: string
+ })[]
+ })[];
+ /**
+ * Whether save notification should be forwarded to
+ * the server. Will only be honored if mode === `notebook`.
+ */
+ save?: boolean;
+}
+
+/**
+ * Registration options specific to a notebook.
+ *
+ * @since 3.17.0
+ */
+export interface NotebookDocumentSyncRegistrationOptions extends NotebookDocumentSyncOptions, StaticRegistrationOptions {
+}
+
+export interface WorkspaceFoldersServerCapabilities {
+ /**
+ * The server has support for workspace folders
+ */
+ supported?: boolean;
+ /**
+ * Whether the server wants to receive workspace folder
+ * change notifications.
+ *
+ * If a string is provided the string is treated as an ID
+ * under which the notification is registered on the client
+ * side. The ID can be used to unregister for these events
+ * using the `client/unregisterCapability` request.
+ */
+ changeNotifications?: string | boolean;
+}
+
+/**
+ * Options for notifications/requests for user operations on files.
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationOptions {
+ /**
+ * The server is interested in receiving didCreateFiles notifications.
+ */
+ didCreate?: FileOperationRegistrationOptions;
+ /**
+ * The server is interested in receiving willCreateFiles requests.
+ */
+ willCreate?: FileOperationRegistrationOptions;
+ /**
+ * The server is interested in receiving didRenameFiles notifications.
+ */
+ didRename?: FileOperationRegistrationOptions;
+ /**
+ * The server is interested in receiving willRenameFiles requests.
+ */
+ willRename?: FileOperationRegistrationOptions;
+ /**
+ * The server is interested in receiving didDeleteFiles file notifications.
+ */
+ didDelete?: FileOperationRegistrationOptions;
+ /**
+ * The server is interested in receiving willDeleteFiles file requests.
+ */
+ willDelete?: FileOperationRegistrationOptions;
+}
+
+/**
+ * Structure to capture a description for an error code.
+ *
+ * @since 3.16.0
+ */
+export interface CodeDescription {
+ /**
+ * An URI to open with more information about the diagnostic error.
+ */
+ href: string;
+}
+
+/**
+ * Represents a related message and source code location for a diagnostic. This should be
+ * used to point to code locations that cause or related to a diagnostics, e.g when duplicating
+ * a symbol in a scope.
+ */
+export interface DiagnosticRelatedInformation {
+ /**
+ * The location of this related diagnostic information.
+ */
+ location: Location;
+ /**
+ * The message of this related diagnostic information.
+ */
+ message: string;
+}
+
+/**
+ * Represents a parameter of a callable-signature. A parameter can
+ * have a label and a doc-comment.
+ */
+export interface ParameterInformation {
+ /**
+ * The label of this parameter information.
+ *
+ * Either a string or an inclusive start and exclusive end offsets within its containing
+ * signature label. (see SignatureInformation.label). The offsets are based on a UTF-16
+ * string representation as `Position` and `Range` does.
+ *
+ * *Note*: a label of type string should be a substring of its containing signature label.
+ * Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`.
+ */
+ label: string | [number, number];
+ /**
+ * The human-readable doc-comment of this parameter. Will be shown
+ * in the UI but can be omitted.
+ */
+ documentation?: string | MarkupContent;
+}
+
+/**
+ * A notebook cell text document filter denotes a cell text
+ * document by different properties.
+ *
+ * @since 3.17.0
+ */
+export interface NotebookCellTextDocumentFilter {
+ /**
+ * A filter that matches against the notebook
+ * containing the notebook cell. If a string
+ * value is provided it matches against the
+ * notebook type. '*' matches every notebook.
+ */
+ notebook: string | NotebookDocumentFilter;
+ /**
+ * A language id like `python`.
+ *
+ * Will be matched against the language id of the
+ * notebook cell document. '*' matches every language.
+ */
+ language?: string;
+}
+
+/**
+ * Matching options for the file operation pattern.
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationPatternOptions {
+ /**
+ * The pattern should be matched ignoring casing.
+ */
+ ignoreCase?: boolean;
+}
+
+export interface ExecutionSummary {
+ /**
+ * A strict monotonically increasing value
+ * indicating the execution order of a cell
+ * inside a notebook.
+ */
+ executionOrder: number;
+ /**
+ * Whether the execution was successful or
+ * not if known by the client.
+ */
+ success?: boolean;
+}
+
+/**
+ * Workspace specific client capabilities.
+ */
+export interface WorkspaceClientCapabilities {
+ /**
+ * The client supports applying batch edits
+ * to the workspace by supporting the request
+ * 'workspace/applyEdit'
+ */
+ applyEdit?: boolean;
+ /**
+ * Capabilities specific to `WorkspaceEdit`s.
+ */
+ workspaceEdit?: WorkspaceEditClientCapabilities;
+ /**
+ * Capabilities specific to the `workspace/didChangeConfiguration` notification.
+ */
+ didChangeConfiguration?: DidChangeConfigurationClientCapabilities;
+ /**
+ * Capabilities specific to the `workspace/didChangeWatchedFiles` notification.
+ */
+ didChangeWatchedFiles?: DidChangeWatchedFilesClientCapabilities;
+ /**
+ * Capabilities specific to the `workspace/symbol` request.
+ */
+ symbol?: WorkspaceSymbolClientCapabilities;
+ /**
+ * Capabilities specific to the `workspace/executeCommand` request.
+ */
+ executeCommand?: ExecuteCommandClientCapabilities;
+ /**
+ * The client has support for workspace folders.
+ *
+ * @since 3.6.0
+ */
+ workspaceFolders?: boolean;
+ /**
+ * The client supports `workspace/configuration` requests.
+ *
+ * @since 3.6.0
+ */
+ configuration?: boolean;
+ /**
+ * Capabilities specific to the semantic token requests scoped to the
+ * workspace.
+ *
+ * @since 3.16.0.
+ */
+ semanticTokens?: SemanticTokensWorkspaceClientCapabilities;
+ /**
+ * Capabilities specific to the code lens requests scoped to the
+ * workspace.
+ *
+ * @since 3.16.0.
+ */
+ codeLens?: CodeLensWorkspaceClientCapabilities;
+ /**
+ * The client has support for file notifications/requests for user operations on files.
+ *
+ * Since 3.16.0
+ */
+ fileOperations?: FileOperationClientCapabilities;
+ /**
+ * Capabilities specific to the inline values requests scoped to the
+ * workspace.
+ *
+ * @since 3.17.0.
+ */
+ inlineValue?: InlineValueWorkspaceClientCapabilities;
+ /**
+ * Capabilities specific to the inlay hint requests scoped to the
+ * workspace.
+ *
+ * @since 3.17.0.
+ */
+ inlayHint?: InlayHintWorkspaceClientCapabilities;
+ /**
+ * Capabilities specific to the diagnostic requests scoped to the
+ * workspace.
+ *
+ * @since 3.17.0.
+ */
+ diagnostics?: DiagnosticWorkspaceClientCapabilities;
+ /**
+ * Capabilities specific to the folding range requests scoped to the workspace.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+ foldingRange?: FoldingRangeWorkspaceClientCapabilities;
+}
+
+/**
+ * Text document specific client capabilities.
+ */
+export interface TextDocumentClientCapabilities {
+ /**
+ * Defines which synchronization capabilities the client supports.
+ */
+ synchronization?: TextDocumentSyncClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/completion` request.
+ */
+ completion?: CompletionClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/hover` request.
+ */
+ hover?: HoverClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/signatureHelp` request.
+ */
+ signatureHelp?: SignatureHelpClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/declaration` request.
+ *
+ * @since 3.14.0
+ */
+ declaration?: DeclarationClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/definition` request.
+ */
+ definition?: DefinitionClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/typeDefinition` request.
+ *
+ * @since 3.6.0
+ */
+ typeDefinition?: TypeDefinitionClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/implementation` request.
+ *
+ * @since 3.6.0
+ */
+ implementation?: ImplementationClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/references` request.
+ */
+ references?: ReferenceClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/documentHighlight` request.
+ */
+ documentHighlight?: DocumentHighlightClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/documentSymbol` request.
+ */
+ documentSymbol?: DocumentSymbolClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/codeAction` request.
+ */
+ codeAction?: CodeActionClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/codeLens` request.
+ */
+ codeLens?: CodeLensClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/documentLink` request.
+ */
+ documentLink?: DocumentLinkClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/documentColor` and the
+ * `textDocument/colorPresentation` request.
+ *
+ * @since 3.6.0
+ */
+ colorProvider?: DocumentColorClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/formatting` request.
+ */
+ formatting?: DocumentFormattingClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/rangeFormatting` request.
+ */
+ rangeFormatting?: DocumentRangeFormattingClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/onTypeFormatting` request.
+ */
+ onTypeFormatting?: DocumentOnTypeFormattingClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/rename` request.
+ */
+ rename?: RenameClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/foldingRange` request.
+ *
+ * @since 3.10.0
+ */
+ foldingRange?: FoldingRangeClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/selectionRange` request.
+ *
+ * @since 3.15.0
+ */
+ selectionRange?: SelectionRangeClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/publishDiagnostics` notification.
+ */
+ publishDiagnostics?: PublishDiagnosticsClientCapabilities;
+ /**
+ * Capabilities specific to the various call hierarchy requests.
+ *
+ * @since 3.16.0
+ */
+ callHierarchy?: CallHierarchyClientCapabilities;
+ /**
+ * Capabilities specific to the various semantic token request.
+ *
+ * @since 3.16.0
+ */
+ semanticTokens?: SemanticTokensClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/linkedEditingRange` request.
+ *
+ * @since 3.16.0
+ */
+ linkedEditingRange?: LinkedEditingRangeClientCapabilities;
+ /**
+ * Client capabilities specific to the `textDocument/moniker` request.
+ *
+ * @since 3.16.0
+ */
+ moniker?: MonikerClientCapabilities;
+ /**
+ * Capabilities specific to the various type hierarchy requests.
+ *
+ * @since 3.17.0
+ */
+ typeHierarchy?: TypeHierarchyClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/inlineValue` request.
+ *
+ * @since 3.17.0
+ */
+ inlineValue?: InlineValueClientCapabilities;
+ /**
+ * Capabilities specific to the `textDocument/inlayHint` request.
+ *
+ * @since 3.17.0
+ */
+ inlayHint?: InlayHintClientCapabilities;
+ /**
+ * Capabilities specific to the diagnostic pull model.
+ *
+ * @since 3.17.0
+ */
+ diagnostic?: DiagnosticClientCapabilities;
+ /**
+ * Client capabilities specific to inline completions.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+ inlineCompletion?: InlineCompletionClientCapabilities;
+}
+
+/**
+ * Capabilities specific to the notebook document support.
+ *
+ * @since 3.17.0
+ */
+export interface NotebookDocumentClientCapabilities {
+ /**
+ * Capabilities specific to notebook document synchronization
+ *
+ * @since 3.17.0
+ */
+ synchronization: NotebookDocumentSyncClientCapabilities;
+}
+
+export interface WindowClientCapabilities {
+ /**
+ * It indicates whether the client supports server initiated
+ * progress using the `window/workDoneProgress/create` request.
+ *
+ * The capability also controls Whether client supports handling
+ * of progress notifications. If set servers are allowed to report a
+ * `workDoneProgress` property in the request specific server
+ * capabilities.
+ *
+ * @since 3.15.0
+ */
+ workDoneProgress?: boolean;
+ /**
+ * Capabilities specific to the showMessage request.
+ *
+ * @since 3.16.0
+ */
+ showMessage?: ShowMessageRequestClientCapabilities;
+ /**
+ * Capabilities specific to the showDocument request.
+ *
+ * @since 3.16.0
+ */
+ showDocument?: ShowDocumentClientCapabilities;
+}
+
+/**
+ * General client capabilities.
+ *
+ * @since 3.16.0
+ */
+export interface GeneralClientCapabilities {
+ /**
+ * Client capability that signals how the client
+ * handles stale requests (e.g. a request
+ * for which the client will not process the response
+ * anymore since the information is outdated).
+ *
+ * @since 3.17.0
+ */
+ staleRequestSupport?: {
+ cancel: boolean;
+ retryOnContentModified: (string)[]
+ };
+ /**
+ * Client capabilities specific to regular expressions.
+ *
+ * @since 3.16.0
+ */
+ regularExpressions?: RegularExpressionsClientCapabilities;
+ /**
+ * Client capabilities specific to the client's markdown parser.
+ *
+ * @since 3.16.0
+ */
+ markdown?: MarkdownClientCapabilities;
+ /**
+ * The position encodings supported by the client. Client and server
+ * have to agree on the same position encoding to ensure that offsets
+ * (e.g. character position in a line) are interpreted the same on both
+ * sides.
+ *
+ * To keep the protocol backwards compatible the following applies: if
+ * the value 'utf-16' is missing from the array of position encodings
+ * servers can assume that the client supports UTF-16. UTF-16 is
+ * therefore a mandatory encoding.
+ *
+ * If omitted it defaults to ['utf-16'].
+ *
+ * Implementation considerations: since the conversion from one encoding
+ * into another requires the content of the file / line the conversion
+ * is best done where the file is read which is usually on the server
+ * side.
+ *
+ * @since 3.17.0
+ */
+ positionEncodings?: (PositionEncodingKind)[];
+}
+
+/**
+ * A relative pattern is a helper to construct glob patterns that are matched
+ * relatively to a base URI. The common value for a `baseUri` is a workspace
+ * folder root, but it can be another absolute URI as well.
+ *
+ * @since 3.17.0
+ */
+export interface RelativePattern {
+ /**
+ * A workspace folder or a base URI to which this pattern will be matched
+ * against relatively.
+ */
+ baseUri: WorkspaceFolder | string;
+ /**
+ * The actual glob pattern;
+ */
+ pattern: Pattern;
+}
+
+export interface WorkspaceEditClientCapabilities {
+ /**
+ * The client supports versioned document changes in `WorkspaceEdit`s
+ */
+ documentChanges?: boolean;
+ /**
+ * The resource operations the client supports. Clients should at least
+ * support 'create', 'rename' and 'delete' files and folders.
+ *
+ * @since 3.13.0
+ */
+ resourceOperations?: (ResourceOperationKind)[];
+ /**
+ * The failure handling strategy of a client if applying the workspace edit
+ * fails.
+ *
+ * @since 3.13.0
+ */
+ failureHandling?: FailureHandlingKind;
+ /**
+ * Whether the client normalizes line endings to the client specific
+ * setting.
+ * If set to `true` the client will normalize line ending characters
+ * in a workspace edit to the client-specified new line
+ * character.
+ *
+ * @since 3.16.0
+ */
+ normalizesLineEndings?: boolean;
+ /**
+ * Whether the client in general supports change annotations on text edits,
+ * create file, rename file and delete file changes.
+ *
+ * @since 3.16.0
+ */
+ changeAnnotationSupport?: {
+ groupsOnLabel?: boolean
+ };
+}
+
+export interface DidChangeConfigurationClientCapabilities {
+ /**
+ * Did change configuration notification supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+}
+
+export interface DidChangeWatchedFilesClientCapabilities {
+ /**
+ * Did change watched files notification supports dynamic registration. Please note
+ * that the current protocol doesn't support static configuration for file changes
+ * from the server side.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * Whether the client has support for {@link RelativePattern relative pattern}
+ * or not.
+ *
+ * @since 3.17.0
+ */
+ relativePatternSupport?: boolean;
+}
+
+/**
+ * Client capabilities for a {@link WorkspaceSymbolRequest}.
+ */
+export interface WorkspaceSymbolClientCapabilities {
+ /**
+ * Symbol request supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * Specific capabilities for the `SymbolKind` in the `workspace/symbol` request.
+ */
+ symbolKind?: {
+ valueSet?: (SymbolKind)[]
+ };
+ /**
+ * The client supports tags on `SymbolInformation`.
+ * Clients supporting tags have to handle unknown tags gracefully.
+ *
+ * @since 3.16.0
+ */
+ tagSupport?: {
+ valueSet: (SymbolTag)[]
+ };
+ /**
+ * The client support partial workspace symbols. The client will send the
+ * request `workspaceSymbol/resolve` to the server to resolve additional
+ * properties.
+ *
+ * @since 3.17.0
+ */
+ resolveSupport?: {
+ properties: (string)[]
+ };
+}
+
+/**
+ * The client capabilities of a {@link ExecuteCommandRequest}.
+ */
+export interface ExecuteCommandClientCapabilities {
+ /**
+ * Execute command supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensWorkspaceClientCapabilities {
+ /**
+ * Whether the client implementation supports a refresh request sent from
+ * the server to the client.
+ *
+ * Note that this event is global and will force the client to refresh all
+ * semantic tokens currently shown. It should be used with absolute care
+ * and is useful for situation where a server for example detects a project
+ * wide change that requires such a calculation.
+ */
+ refreshSupport?: boolean;
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface CodeLensWorkspaceClientCapabilities {
+ /**
+ * Whether the client implementation supports a refresh request sent from the
+ * server to the client.
+ *
+ * Note that this event is global and will force the client to refresh all
+ * code lenses currently shown. It should be used with absolute care and is
+ * useful for situation where a server for example detect a project wide
+ * change that requires such a calculation.
+ */
+ refreshSupport?: boolean;
+}
+
+/**
+ * Capabilities relating to events from file operations by the user in the client.
+ *
+ * These events do not come from the file system, they come from user operations
+ * like renaming a file in the UI.
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationClientCapabilities {
+ /**
+ * Whether the client supports dynamic registration for file requests/notifications.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * The client has support for sending didCreateFiles notifications.
+ */
+ didCreate?: boolean;
+ /**
+ * The client has support for sending willCreateFiles requests.
+ */
+ willCreate?: boolean;
+ /**
+ * The client has support for sending didRenameFiles notifications.
+ */
+ didRename?: boolean;
+ /**
+ * The client has support for sending willRenameFiles requests.
+ */
+ willRename?: boolean;
+ /**
+ * The client has support for sending didDeleteFiles notifications.
+ */
+ didDelete?: boolean;
+ /**
+ * The client has support for sending willDeleteFiles requests.
+ */
+ willDelete?: boolean;
+}
+
+/**
+ * Client workspace capabilities specific to inline values.
+ *
+ * @since 3.17.0
+ */
+export interface InlineValueWorkspaceClientCapabilities {
+ /**
+ * Whether the client implementation supports a refresh request sent from the
+ * server to the client.
+ *
+ * Note that this event is global and will force the client to refresh all
+ * inline values currently shown. It should be used with absolute care and is
+ * useful for situation where a server for example detects a project wide
+ * change that requires such a calculation.
+ */
+ refreshSupport?: boolean;
+}
+
+/**
+ * Client workspace capabilities specific to inlay hints.
+ *
+ * @since 3.17.0
+ */
+export interface InlayHintWorkspaceClientCapabilities {
+ /**
+ * Whether the client implementation supports a refresh request sent from
+ * the server to the client.
+ *
+ * Note that this event is global and will force the client to refresh all
+ * inlay hints currently shown. It should be used with absolute care and
+ * is useful for situation where a server for example detects a project wide
+ * change that requires such a calculation.
+ */
+ refreshSupport?: boolean;
+}
+
+/**
+ * Workspace client capabilities specific to diagnostic pull requests.
+ *
+ * @since 3.17.0
+ */
+export interface DiagnosticWorkspaceClientCapabilities {
+ /**
+ * Whether the client implementation supports a refresh request sent from
+ * the server to the client.
+ *
+ * Note that this event is global and will force the client to refresh all
+ * pulled diagnostics currently shown. It should be used with absolute care and
+ * is useful for situation where a server for example detects a project wide
+ * change that requires such a calculation.
+ */
+ refreshSupport?: boolean;
+}
+
+/**
+ * Client workspace capabilities specific to folding ranges
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export interface FoldingRangeWorkspaceClientCapabilities {
+ /**
+ * Whether the client implementation supports a refresh request sent from the
+ * server to the client.
+ *
+ * Note that this event is global and will force the client to refresh all
+ * folding ranges currently shown. It should be used with absolute care and is
+ * useful for situation where a server for example detects a project wide
+ * change that requires such a calculation.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+ refreshSupport?: boolean;
+}
+
+export interface TextDocumentSyncClientCapabilities {
+ /**
+ * Whether text document synchronization supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * The client supports sending will save notifications.
+ */
+ willSave?: boolean;
+ /**
+ * The client supports sending a will save request and
+ * waits for a response providing text edits which will
+ * be applied to the document before it is saved.
+ */
+ willSaveWaitUntil?: boolean;
+ /**
+ * The client supports did save notifications.
+ */
+ didSave?: boolean;
+}
+
+/**
+ * Completion client capabilities
+ */
+export interface CompletionClientCapabilities {
+ /**
+ * Whether completion supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * The client supports the following `CompletionItem` specific
+ * capabilities.
+ */
+ completionItem?: {
+ snippetSupport?: boolean;
+ commitCharactersSupport?: boolean;
+ documentationFormat?: (MarkupKind)[];
+ deprecatedSupport?: boolean;
+ preselectSupport?: boolean;
+ tagSupport?: {
+ valueSet: (CompletionItemTag)[]
+ };
+ insertReplaceSupport?: boolean;
+ resolveSupport?: {
+ properties: (string)[]
+ };
+ insertTextModeSupport?: {
+ valueSet: (InsertTextMode)[]
+ };
+ labelDetailsSupport?: boolean
+ };
+ completionItemKind?: {
+ valueSet?: (CompletionItemKind)[]
+ };
+ /**
+ * Defines how the client handles whitespace and indentation
+ * when accepting a completion item that uses multi line
+ * text in either `insertText` or `textEdit`.
+ *
+ * @since 3.17.0
+ */
+ insertTextMode?: InsertTextMode;
+ /**
+ * The client supports to send additional context information for a
+ * `textDocument/completion` request.
+ */
+ contextSupport?: boolean;
+ /**
+ * The client supports the following `CompletionList` specific
+ * capabilities.
+ *
+ * @since 3.17.0
+ */
+ completionList?: {
+ itemDefaults?: (string)[]
+ };
+}
+
+export interface HoverClientCapabilities {
+ /**
+ * Whether hover supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * Client supports the following content formats for the content
+ * property. The order describes the preferred format of the client.
+ */
+ contentFormat?: (MarkupKind)[];
+}
+
+/**
+ * Client Capabilities for a {@link SignatureHelpRequest}.
+ */
+export interface SignatureHelpClientCapabilities {
+ /**
+ * Whether signature help supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * The client supports the following `SignatureInformation`
+ * specific properties.
+ */
+ signatureInformation?: {
+ documentationFormat?: (MarkupKind)[];
+ parameterInformation?: {
+ labelOffsetSupport?: boolean
+ };
+ activeParameterSupport?: boolean
+ };
+ /**
+ * The client supports to send additional context information for a
+ * `textDocument/signatureHelp` request. A client that opts into
+ * contextSupport will also support the `retriggerCharacters` on
+ * `SignatureHelpOptions`.
+ *
+ * @since 3.15.0
+ */
+ contextSupport?: boolean;
+}
+
+/**
+ * @since 3.14.0
+ */
+export interface DeclarationClientCapabilities {
+ /**
+ * Whether declaration supports dynamic registration. If this is set to `true`
+ * the client supports the new `DeclarationRegistrationOptions` return value
+ * for the corresponding server capability as well.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * The client supports additional metadata in the form of declaration links.
+ */
+ linkSupport?: boolean;
+}
+
+/**
+ * Client Capabilities for a {@link DefinitionRequest}.
+ */
+export interface DefinitionClientCapabilities {
+ /**
+ * Whether definition supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * The client supports additional metadata in the form of definition links.
+ *
+ * @since 3.14.0
+ */
+ linkSupport?: boolean;
+}
+
+/**
+ * Since 3.6.0
+ */
+export interface TypeDefinitionClientCapabilities {
+ /**
+ * Whether implementation supports dynamic registration. If this is set to `true`
+ * the client supports the new `TypeDefinitionRegistrationOptions` return value
+ * for the corresponding server capability as well.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * The client supports additional metadata in the form of definition links.
+ *
+ * Since 3.14.0
+ */
+ linkSupport?: boolean;
+}
+
+/**
+ * @since 3.6.0
+ */
+export interface ImplementationClientCapabilities {
+ /**
+ * Whether implementation supports dynamic registration. If this is set to `true`
+ * the client supports the new `ImplementationRegistrationOptions` return value
+ * for the corresponding server capability as well.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * The client supports additional metadata in the form of definition links.
+ *
+ * @since 3.14.0
+ */
+ linkSupport?: boolean;
+}
+
+/**
+ * Client Capabilities for a {@link ReferencesRequest}.
+ */
+export interface ReferenceClientCapabilities {
+ /**
+ * Whether references supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+}
+
+/**
+ * Client Capabilities for a {@link DocumentHighlightRequest}.
+ */
+export interface DocumentHighlightClientCapabilities {
+ /**
+ * Whether document highlight supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+}
+
+/**
+ * Client Capabilities for a {@link DocumentSymbolRequest}.
+ */
+export interface DocumentSymbolClientCapabilities {
+ /**
+ * Whether document symbol supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * Specific capabilities for the `SymbolKind` in the
+ * `textDocument/documentSymbol` request.
+ */
+ symbolKind?: {
+ valueSet?: (SymbolKind)[]
+ };
+ /**
+ * The client supports hierarchical document symbols.
+ */
+ hierarchicalDocumentSymbolSupport?: boolean;
+ /**
+ * The client supports tags on `SymbolInformation`. Tags are supported on
+ * `DocumentSymbol` if `hierarchicalDocumentSymbolSupport` is set to true.
+ * Clients supporting tags have to handle unknown tags gracefully.
+ *
+ * @since 3.16.0
+ */
+ tagSupport?: {
+ valueSet: (SymbolTag)[]
+ };
+ /**
+ * The client supports an additional label presented in the UI when
+ * registering a document symbol provider.
+ *
+ * @since 3.16.0
+ */
+ labelSupport?: boolean;
+}
+
+/**
+ * The Client Capabilities of a {@link CodeActionRequest}.
+ */
+export interface CodeActionClientCapabilities {
+ /**
+ * Whether code action supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * The client support code action literals of type `CodeAction` as a valid
+ * response of the `textDocument/codeAction` request. If the property is not
+ * set the request can only return `Command` literals.
+ *
+ * @since 3.8.0
+ */
+ codeActionLiteralSupport?: {
+ codeActionKind: {
+ valueSet: (CodeActionKind)[]
+ }
+ };
+ /**
+ * Whether code action supports the `isPreferred` property.
+ *
+ * @since 3.15.0
+ */
+ isPreferredSupport?: boolean;
+ /**
+ * Whether code action supports the `disabled` property.
+ *
+ * @since 3.16.0
+ */
+ disabledSupport?: boolean;
+ /**
+ * Whether code action supports the `data` property which is
+ * preserved between a `textDocument/codeAction` and a
+ * `codeAction/resolve` request.
+ *
+ * @since 3.16.0
+ */
+ dataSupport?: boolean;
+ /**
+ * Whether the client supports resolving additional code action
+ * properties via a separate `codeAction/resolve` request.
+ *
+ * @since 3.16.0
+ */
+ resolveSupport?: {
+ properties: (string)[]
+ };
+ /**
+ * Whether the client honors the change annotations in
+ * text edits and resource operations returned via the
+ * `CodeAction#edit` property by for example presenting
+ * the workspace edit in the user interface and asking
+ * for confirmation.
+ *
+ * @since 3.16.0
+ */
+ honorsChangeAnnotations?: boolean;
+}
+
+/**
+ * The client capabilities of a {@link CodeLensRequest}.
+ */
+export interface CodeLensClientCapabilities {
+ /**
+ * Whether code lens supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+}
+
+/**
+ * The client capabilities of a {@link DocumentLinkRequest}.
+ */
+export interface DocumentLinkClientCapabilities {
+ /**
+ * Whether document link supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * Whether the client supports the `tooltip` property on `DocumentLink`.
+ *
+ * @since 3.15.0
+ */
+ tooltipSupport?: boolean;
+}
+
+export interface DocumentColorClientCapabilities {
+ /**
+ * Whether implementation supports dynamic registration. If this is set to `true`
+ * the client supports the new `DocumentColorRegistrationOptions` return value
+ * for the corresponding server capability as well.
+ */
+ dynamicRegistration?: boolean;
+}
+
+/**
+ * Client capabilities of a {@link DocumentFormattingRequest}.
+ */
+export interface DocumentFormattingClientCapabilities {
+ /**
+ * Whether formatting supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+}
+
+/**
+ * Client capabilities of a {@link DocumentRangeFormattingRequest}.
+ */
+export interface DocumentRangeFormattingClientCapabilities {
+ /**
+ * Whether range formatting supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * Whether the client supports formatting multiple ranges at once.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+ rangesSupport?: boolean;
+}
+
+/**
+ * Client capabilities of a {@link DocumentOnTypeFormattingRequest}.
+ */
+export interface DocumentOnTypeFormattingClientCapabilities {
+ /**
+ * Whether on type formatting supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+}
+
+export interface RenameClientCapabilities {
+ /**
+ * Whether rename supports dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * Client supports testing for validity of rename operations
+ * before execution.
+ *
+ * @since 3.12.0
+ */
+ prepareSupport?: boolean;
+ /**
+ * Client supports the default behavior result.
+ *
+ * The value indicates the default behavior used by the
+ * client.
+ *
+ * @since 3.16.0
+ */
+ prepareSupportDefaultBehavior?: PrepareSupportDefaultBehavior;
+ /**
+ * Whether the client honors the change annotations in
+ * text edits and resource operations returned via the
+ * rename request's workspace edit by for example presenting
+ * the workspace edit in the user interface and asking
+ * for confirmation.
+ *
+ * @since 3.16.0
+ */
+ honorsChangeAnnotations?: boolean;
+}
+
+export interface FoldingRangeClientCapabilities {
+ /**
+ * Whether implementation supports dynamic registration for folding range
+ * providers. If this is set to `true` the client supports the new
+ * `FoldingRangeRegistrationOptions` return value for the corresponding
+ * server capability as well.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * The maximum number of folding ranges that the client prefers to receive
+ * per document. The value serves as a hint, servers are free to follow the
+ * limit.
+ */
+ rangeLimit?: number;
+ /**
+ * If set, the client signals that it only supports folding complete lines.
+ * If set, client will ignore specified `startCharacter` and `endCharacter`
+ * properties in a FoldingRange.
+ */
+ lineFoldingOnly?: boolean;
+ /**
+ * Specific options for the folding range kind.
+ *
+ * @since 3.17.0
+ */
+ foldingRangeKind?: {
+ valueSet?: (FoldingRangeKind)[]
+ };
+ /**
+ * Specific options for the folding range.
+ *
+ * @since 3.17.0
+ */
+ foldingRange?: {
+ collapsedText?: boolean
+ };
+}
+
+export interface SelectionRangeClientCapabilities {
+ /**
+ * Whether implementation supports dynamic registration for selection range providers. If this is set to `true`
+ * the client supports the new `SelectionRangeRegistrationOptions` return value for the corresponding server
+ * capability as well.
+ */
+ dynamicRegistration?: boolean;
+}
+
+/**
+ * The publish diagnostic client capabilities.
+ */
+export interface PublishDiagnosticsClientCapabilities {
+ /**
+ * Whether the clients accepts diagnostics with related information.
+ */
+ relatedInformation?: boolean;
+ /**
+ * Client supports the tag property to provide meta data about a diagnostic.
+ * Clients supporting tags have to handle unknown tags gracefully.
+ *
+ * @since 3.15.0
+ */
+ tagSupport?: {
+ valueSet: (DiagnosticTag)[]
+ };
+ /**
+ * Whether the client interprets the version property of the
+ * `textDocument/publishDiagnostics` notification's parameter.
+ *
+ * @since 3.15.0
+ */
+ versionSupport?: boolean;
+ /**
+ * Client supports a codeDescription property
+ *
+ * @since 3.16.0
+ */
+ codeDescriptionSupport?: boolean;
+ /**
+ * Whether code action supports the `data` property which is
+ * preserved between a `textDocument/publishDiagnostics` and
+ * `textDocument/codeAction` request.
+ *
+ * @since 3.16.0
+ */
+ dataSupport?: boolean;
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface CallHierarchyClientCapabilities {
+ /**
+ * Whether implementation supports dynamic registration. If this is set to `true`
+ * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+ * return value for the corresponding server capability as well.
+ */
+ dynamicRegistration?: boolean;
+}
+
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensClientCapabilities {
+ /**
+ * Whether implementation supports dynamic registration. If this is set to `true`
+ * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+ * return value for the corresponding server capability as well.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * Which requests the client supports and might send to the server
+ * depending on the server's capability. Please note that clients might not
+ * show semantic tokens or degrade some of the user experience if a range
+ * or full request is advertised by the client but not provided by the
+ * server. If for example the client capability `requests.full` and
+ * `request.range` are both set to true but the server only provides a
+ * range provider the client might not render a minimap correctly or might
+ * even decide to not show any semantic tokens at all.
+ */
+ requests: {
+ range?: boolean | {
+
+ };
+ full?: boolean | {
+ delta?: boolean
+ }
+ };
+ /**
+ * The token types that the client supports.
+ */
+ tokenTypes: (string)[];
+ /**
+ * The token modifiers that the client supports.
+ */
+ tokenModifiers: (string)[];
+ /**
+ * The token formats the clients supports.
+ */
+ formats: (TokenFormat)[];
+ /**
+ * Whether the client supports tokens that can overlap each other.
+ */
+ overlappingTokenSupport?: boolean;
+ /**
+ * Whether the client supports tokens that can span multiple lines.
+ */
+ multilineTokenSupport?: boolean;
+ /**
+ * Whether the client allows the server to actively cancel a
+ * semantic token request, e.g. supports returning
+ * LSPErrorCodes.ServerCancelled. If a server does the client
+ * needs to retrigger the request.
+ *
+ * @since 3.17.0
+ */
+ serverCancelSupport?: boolean;
+ /**
+ * Whether the client uses semantic tokens to augment existing
+ * syntax tokens. If set to `true` client side created syntax
+ * tokens and semantic tokens are both used for colorization. If
+ * set to `false` the client only uses the returned semantic tokens
+ * for colorization.
+ *
+ * If the value is `undefined` then the client behavior is not
+ * specified.
+ *
+ * @since 3.17.0
+ */
+ augmentsSyntaxTokens?: boolean;
+}
+
+/**
+ * Client capabilities for the linked editing range request.
+ *
+ * @since 3.16.0
+ */
+export interface LinkedEditingRangeClientCapabilities {
+ /**
+ * Whether implementation supports dynamic registration. If this is set to `true`
+ * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+ * return value for the corresponding server capability as well.
+ */
+ dynamicRegistration?: boolean;
+}
+
+/**
+ * Client capabilities specific to the moniker request.
+ *
+ * @since 3.16.0
+ */
+export interface MonikerClientCapabilities {
+ /**
+ * Whether moniker supports dynamic registration. If this is set to `true`
+ * the client supports the new `MonikerRegistrationOptions` return value
+ * for the corresponding server capability as well.
+ */
+ dynamicRegistration?: boolean;
+}
+
+/**
+ * @since 3.17.0
+ */
+export interface TypeHierarchyClientCapabilities {
+ /**
+ * Whether implementation supports dynamic registration. If this is set to `true`
+ * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+ * return value for the corresponding server capability as well.
+ */
+ dynamicRegistration?: boolean;
+}
+
+/**
+ * Client capabilities specific to inline values.
+ *
+ * @since 3.17.0
+ */
+export interface InlineValueClientCapabilities {
+ /**
+ * Whether implementation supports dynamic registration for inline value providers.
+ */
+ dynamicRegistration?: boolean;
+}
+
+/**
+ * Inlay hint client capabilities.
+ *
+ * @since 3.17.0
+ */
+export interface InlayHintClientCapabilities {
+ /**
+ * Whether inlay hints support dynamic registration.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * Indicates which properties a client can resolve lazily on an inlay
+ * hint.
+ */
+ resolveSupport?: {
+ properties: (string)[]
+ };
+}
+
+/**
+ * Client capabilities specific to diagnostic pull requests.
+ *
+ * @since 3.17.0
+ */
+export interface DiagnosticClientCapabilities {
+ /**
+ * Whether implementation supports dynamic registration. If this is set to `true`
+ * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+ * return value for the corresponding server capability as well.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * Whether the clients supports related documents for document diagnostic pulls.
+ */
+ relatedDocumentSupport?: boolean;
+}
+
+/**
+ * Client capabilities specific to inline completions.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export interface InlineCompletionClientCapabilities {
+ /**
+ * Whether implementation supports dynamic registration for inline completion providers.
+ */
+ dynamicRegistration?: boolean;
+}
+
+/**
+ * Notebook specific client capabilities.
+ *
+ * @since 3.17.0
+ */
+export interface NotebookDocumentSyncClientCapabilities {
+ /**
+ * Whether implementation supports dynamic registration. If this is
+ * set to `true` the client supports the new
+ * `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+ * return value for the corresponding server capability as well.
+ */
+ dynamicRegistration?: boolean;
+ /**
+ * The client supports sending execution summary data per cell.
+ */
+ executionSummarySupport?: boolean;
+}
+
+/**
+ * Show message request client capabilities
+ */
+export interface ShowMessageRequestClientCapabilities {
+ /**
+ * Capabilities specific to the `MessageActionItem` type.
+ */
+ messageActionItem?: {
+ additionalPropertiesSupport?: boolean
+ };
+}
+
+/**
+ * Client capabilities for the showDocument request.
+ *
+ * @since 3.16.0
+ */
+export interface ShowDocumentClientCapabilities {
+ /**
+ * The client has support for the showDocument
+ * request.
+ */
+ support: boolean;
+}
+
+/**
+ * Client capabilities specific to regular expressions.
+ *
+ * @since 3.16.0
+ */
+export interface RegularExpressionsClientCapabilities {
+ /**
+ * The engine's name.
+ */
+ engine: string;
+ /**
+ * The engine's version.
+ */
+ version?: string;
+}
+
+/**
+ * Client capabilities specific to the used markdown parser.
+ *
+ * @since 3.16.0
+ */
+export interface MarkdownClientCapabilities {
+ /**
+ * The name of the parser.
+ */
+ parser: string;
+ /**
+ * The version of the parser.
+ */
+ version?: string;
+ /**
+ * A list of HTML tags that the client allows / supports in
+ * Markdown.
+ *
+ * @since 3.17.0
+ */
+ allowedTags?: (string)[];
+}
+
+/**
+ * Represents a capability with its associated method and registration options type
+ */
+export class Capability {
+ constructor(public readonly method: string) { }
+}
+
+/**
+ * Map of all LSP capabilities with their registration options
+ */
+export 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'),
+};
+
+/**
+ * LSP API Contract
+ */
+export const api = contract({
+ name: "LSP",
+ server: {
+ /**
+ * A request to resolve the implementation locations of a symbol at a given text
+ * document position. The request's parameter is of type {@link TextDocumentPositionParams}
+ * the response is of type {@link Definition} or a Thenable that resolves to such.
+ */
+ textDocumentImplementation: unverifiedRequest({ method: "textDocument/implementation" }),
+ /**
+ * A request to resolve the type definition locations of a symbol at a given text
+ * document position. The request's parameter is of type {@link TextDocumentPositionParams}
+ * the response is of type {@link Definition} or a Thenable that resolves to such.
+ */
+ textDocumentTypeDefinition: unverifiedRequest({ method: "textDocument/typeDefinition" }),
+ /**
+ * A request to list all color symbols found in a given text document. The request's
+ * parameter is of type {@link DocumentColorParams} the
+ * response is of type {@link ColorInformation ColorInformation[]} or a Thenable
+ * that resolves to such.
+ */
+ textDocumentDocumentColor: unverifiedRequest({ method: "textDocument/documentColor" }),
+ /**
+ * A request to list all presentation for a color. The request's
+ * parameter is of type {@link ColorPresentationParams} the
+ * response is of type {@link ColorInformation ColorInformation[]} or a Thenable
+ * that resolves to such.
+ */
+ textDocumentColorPresentation: unverifiedRequest({ method: "textDocument/colorPresentation" }),
+ /**
+ * A request to provide folding ranges in a document. The request's
+ * parameter is of type {@link FoldingRangeParams}, the
+ * response is of type {@link FoldingRangeList} or a Thenable
+ * that resolves to such.
+ */
+ textDocumentFoldingRange: unverifiedRequest({ method: "textDocument/foldingRange" }),
+ /**
+ * A request to resolve the type definition locations of a symbol at a given text
+ * document position. The request's parameter is of type {@link TextDocumentPositionParams}
+ * the response is of type {@link Declaration} or a typed array of {@link DeclarationLink}
+ * or a Thenable that resolves to such.
+ */
+ textDocumentDeclaration: unverifiedRequest({ method: "textDocument/declaration" }),
+ /**
+ * A request to provide selection ranges in a document. The request's
+ * parameter is of type {@link SelectionRangeParams}, the
+ * response is of type {@link SelectionRange SelectionRange[]} or a Thenable
+ * that resolves to such.
+ */
+ textDocumentSelectionRange: unverifiedRequest({ method: "textDocument/selectionRange" }),
+ /**
+ * A request to result a `CallHierarchyItem` in a document at a given position.
+ * Can be used as an input to an incoming or outgoing call hierarchy.
+ *
+ * @since 3.16.0
+ */
+ textDocumentPrepareCallHierarchy: unverifiedRequest({ method: "textDocument/prepareCallHierarchy" }),
+ /**
+ * A request to resolve the incoming calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0
+ */
+ callHierarchyIncomingCalls: unverifiedRequest({ method: "callHierarchy/incomingCalls" }),
+ /**
+ * A request to resolve the outgoing calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0
+ */
+ callHierarchyOutgoingCalls: unverifiedRequest({ method: "callHierarchy/outgoingCalls" }),
+ /**
+ * @since 3.16.0
+ */
+ textDocumentSemanticTokensFull: unverifiedRequest({ method: "textDocument/semanticTokens/full" }),
+ /**
+ * @since 3.16.0
+ */
+ textDocumentSemanticTokensFullDelta: unverifiedRequest({ method: "textDocument/semanticTokens/full/delta" }),
+ /**
+ * @since 3.16.0
+ */
+ textDocumentSemanticTokensRange: unverifiedRequest({ method: "textDocument/semanticTokens/range" }),
+ /**
+ * A request to provide ranges that can be edited together.
+ *
+ * @since 3.16.0
+ */
+ textDocumentLinkedEditingRange: unverifiedRequest({ method: "textDocument/linkedEditingRange" }),
+ /**
+ * The will create files request is sent from the client to the server before files are actually
+ * created as long as the creation is triggered from within the client.
+ *
+ * The request can return a `WorkspaceEdit` which will be applied to workspace before the
+ * files are created. Hence the `WorkspaceEdit` can not manipulate the content of the file
+ * to be created.
+ *
+ * @since 3.16.0
+ */
+ workspaceWillCreateFiles: unverifiedRequest({ method: "workspace/willCreateFiles" }),
+ /**
+ * The will rename files request is sent from the client to the server before files are actually
+ * renamed as long as the rename is triggered from within the client.
+ *
+ * @since 3.16.0
+ */
+ workspaceWillRenameFiles: unverifiedRequest({ method: "workspace/willRenameFiles" }),
+ /**
+ * The did delete files notification is sent from the client to the server when
+ * files were deleted from within the client.
+ *
+ * @since 3.16.0
+ */
+ workspaceWillDeleteFiles: unverifiedRequest({ method: "workspace/willDeleteFiles" }),
+ /**
+ * A request to get the moniker of a symbol at a given text document position.
+ * The request parameter is of type {@link TextDocumentPositionParams}.
+ * The response is of type {@link Moniker Moniker[]} or `null`.
+ */
+ textDocumentMoniker: unverifiedRequest({ method: "textDocument/moniker" }),
+ /**
+ * A request to result a `TypeHierarchyItem` in a document at a given position.
+ * Can be used as an input to a subtypes or supertypes type hierarchy.
+ *
+ * @since 3.17.0
+ */
+ textDocumentPrepareTypeHierarchy: unverifiedRequest({ method: "textDocument/prepareTypeHierarchy" }),
+ /**
+ * A request to resolve the supertypes for a given `TypeHierarchyItem`.
+ *
+ * @since 3.17.0
+ */
+ typeHierarchySupertypes: unverifiedRequest({ method: "typeHierarchy/supertypes" }),
+ /**
+ * A request to resolve the subtypes for a given `TypeHierarchyItem`.
+ *
+ * @since 3.17.0
+ */
+ typeHierarchySubtypes: unverifiedRequest({ method: "typeHierarchy/subtypes" }),
+ /**
+ * A request to provide inline values in a document. The request's parameter is of
+ * type {@link InlineValueParams}, the response is of type
+ * {@link InlineValue InlineValue[]} or a Thenable that resolves to such.
+ *
+ * @since 3.17.0
+ */
+ textDocumentInlineValue: unverifiedRequest({ method: "textDocument/inlineValue" }),
+ /**
+ * A request to provide inlay hints in a document. The request's parameter is of
+ * type {@link InlayHintsParams}, the response is of type
+ * {@link InlayHint InlayHint[]} or a Thenable that resolves to such.
+ *
+ * @since 3.17.0
+ */
+ textDocumentInlayHint: unverifiedRequest({ method: "textDocument/inlayHint" }),
+ /**
+ * A request to resolve additional properties for an inlay hint.
+ * The request's parameter is of type {@link InlayHint}, the response is
+ * of type {@link InlayHint} or a Thenable that resolves to such.
+ *
+ * @since 3.17.0
+ */
+ inlayHintResolve: unverifiedRequest({ method: "inlayHint/resolve" }),
+ /**
+ * The document diagnostic request definition.
+ *
+ * @since 3.17.0
+ */
+ textDocumentDiagnostic: unverifiedRequest({ method: "textDocument/diagnostic" }),
+ /**
+ * The workspace diagnostic request definition.
+ *
+ * @since 3.17.0
+ */
+ workspaceDiagnostic: unverifiedRequest({ method: "workspace/diagnostic" }),
+ /**
+ * A request to provide inline completions in a document. The request's parameter is of
+ * type {@link InlineCompletionParams}, the response is of type
+ * {@link InlineCompletion InlineCompletion[]} or a Thenable that resolves to such.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+ textDocumentInlineCompletion: unverifiedRequest({ method: "textDocument/inlineCompletion" }),
+ /**
+ * The initialize request is sent from the client to the server.
+ * It is sent once as the request after starting up the server.
+ * The requests parameter is of type {@link InitializeParams}
+ * the response if of type {@link InitializeResult} of a Thenable that
+ * resolves to such.
+ */
+ initialize: unverifiedRequest({ method: "initialize" }),
+ /**
+ * A shutdown request is sent from the client to the server.
+ * It is sent once when the client decides to shutdown the
+ * server. The only notification that is sent after a shutdown request
+ * is the exit event.
+ */
+ shutdown: unverifiedRequest({ method: "shutdown" }),
+ /**
+ * A document will save request is sent from the client to the server before
+ * the document is actually saved. The request can return an array of TextEdits
+ * which will be applied to the text document before it is saved. Please note that
+ * clients might drop results if computing the text edits took too long or if a
+ * server constantly fails on this request. This is done to keep the save fast and
+ * reliable.
+ */
+ textDocumentWillSaveWaitUntil: unverifiedRequest({ method: "textDocument/willSaveWaitUntil" }),
+ /**
+ * Request to request completion at a given text document position. The request's
+ * parameter is of type {@link TextDocumentPosition} the response
+ * is of type {@link CompletionItem CompletionItem[]} or {@link CompletionList}
+ * or a Thenable that resolves to such.
+ *
+ * The request can delay the computation of the {@link CompletionItem.detail `detail`}
+ * and {@link CompletionItem.documentation `documentation`} properties to the `completionItem/resolve`
+ * request. However, properties that are needed for the initial sorting and filtering, like `sortText`,
+ * `filterText`, `insertText`, and `textEdit`, must not be changed during resolve.
+ */
+ textDocumentCompletion: unverifiedRequest({ method: "textDocument/completion" }),
+ /**
+ * Request to resolve additional information for a given completion item.The request's
+ * parameter is of type {@link CompletionItem} the response
+ * is of type {@link CompletionItem} or a Thenable that resolves to such.
+ */
+ completionItemResolve: unverifiedRequest({ method: "completionItem/resolve" }),
+ /**
+ * Request to request hover information at a given text document position. The request's
+ * parameter is of type {@link TextDocumentPosition} the response is of
+ * type {@link Hover} or a Thenable that resolves to such.
+ */
+ textDocumentHover: unverifiedRequest({ method: "textDocument/hover" }),
+ textDocumentSignatureHelp: unverifiedRequest({ method: "textDocument/signatureHelp" }),
+ /**
+ * A request to resolve the definition location of a symbol at a given text
+ * document position. The request's parameter is of type {@link TextDocumentPosition}
+ * the response is of either type {@link Definition} or a typed array of
+ * {@link DefinitionLink} or a Thenable that resolves to such.
+ */
+ textDocumentDefinition: unverifiedRequest({ method: "textDocument/definition" }),
+ /**
+ * A request to resolve project-wide references for the symbol denoted
+ * by the given text document position. The request's parameter is of
+ * type {@link ReferenceParams} the response is of type
+ * {@link Location Location[]} or a Thenable that resolves to such.
+ */
+ textDocumentReferences: unverifiedRequest({ method: "textDocument/references" }),
+ /**
+ * Request to resolve a {@link DocumentHighlight} for a given
+ * text document position. The request's parameter is of type {@link TextDocumentPosition}
+ * the request response is an array of type {@link DocumentHighlight}
+ * or a Thenable that resolves to such.
+ */
+ textDocumentDocumentHighlight: unverifiedRequest({ method: "textDocument/documentHighlight" }),
+ /**
+ * A request to list all symbols found in a given text document. The request's
+ * parameter is of type {@link TextDocumentIdentifier} the
+ * response is of type {@link SymbolInformation SymbolInformation[]} or a Thenable
+ * that resolves to such.
+ */
+ textDocumentDocumentSymbol: unverifiedRequest({ method: "textDocument/documentSymbol" }),
+ /**
+ * A request to provide commands for the given text document and range.
+ */
+ textDocumentCodeAction: unverifiedRequest({ method: "textDocument/codeAction" }),
+ /**
+ * Request to resolve additional information for a given code action.The request's
+ * parameter is of type {@link CodeAction} the response
+ * is of type {@link CodeAction} or a Thenable that resolves to such.
+ */
+ codeActionResolve: unverifiedRequest({ method: "codeAction/resolve" }),
+ /**
+ * A request to list project-wide symbols matching the query string given
+ * by the {@link WorkspaceSymbolParams}. The response is
+ * of type {@link SymbolInformation SymbolInformation[]} or a Thenable that
+ * resolves to such.
+ *
+ * @since 3.17.0 - support for WorkspaceSymbol in the returned data. Clients
+ * need to advertise support for WorkspaceSymbols via the client capability
+ * `workspace.symbol.resolveSupport`.
+ *
+ */
+ workspaceSymbol: unverifiedRequest({ method: "workspace/symbol" }),
+ /**
+ * A request to resolve the range inside the workspace
+ * symbol's location.
+ *
+ * @since 3.17.0
+ */
+ workspaceSymbolResolve: unverifiedRequest({ method: "workspaceSymbol/resolve" }),
+ /**
+ * A request to provide code lens for the given text document.
+ */
+ textDocumentCodeLens: unverifiedRequest({ method: "textDocument/codeLens" }),
+ /**
+ * A request to resolve a command for a given code lens.
+ */
+ codeLensResolve: unverifiedRequest({ method: "codeLens/resolve" }),
+ /**
+ * A request to provide document links
+ */
+ textDocumentDocumentLink: unverifiedRequest({ method: "textDocument/documentLink" }),
+ /**
+ * Request to resolve additional information for a given document link. The request's
+ * parameter is of type {@link DocumentLink} the response
+ * is of type {@link DocumentLink} or a Thenable that resolves to such.
+ */
+ documentLinkResolve: unverifiedRequest({ method: "documentLink/resolve" }),
+ /**
+ * A request to format a whole document.
+ */
+ textDocumentFormatting: unverifiedRequest({ method: "textDocument/formatting" }),
+ /**
+ * A request to format a range in a document.
+ */
+ textDocumentRangeFormatting: unverifiedRequest({ method: "textDocument/rangeFormatting" }),
+ /**
+ * A request to format ranges in a document.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+ textDocumentRangesFormatting: unverifiedRequest({ method: "textDocument/rangesFormatting" }),
+ /**
+ * A request to format a document on type.
+ */
+ textDocumentOnTypeFormatting: unverifiedRequest({ method: "textDocument/onTypeFormatting" }),
+ /**
+ * A request to rename a symbol.
+ */
+ textDocumentRename: unverifiedRequest({ method: "textDocument/rename" }),
+ /**
+ * A request to test and perform the setup necessary for a rename.
+ *
+ * @since 3.16 - support for default behavior
+ */
+ textDocumentPrepareRename: unverifiedRequest({ method: "textDocument/prepareRename" }),
+ /**
+ * A request send from the client to the server to execute a command. The request might return
+ * a workspace edit which the client will apply to the workspace.
+ */
+ workspaceExecuteCommand: unverifiedRequest({ method: "workspace/executeCommand" }),
+ /**
+ * The `workspace/didChangeWorkspaceFolders` notification is sent from the client to the server when the workspace
+ * folder configuration changes.
+ */
+ workspaceDidChangeWorkspaceFolders: unverifiedNotification({ method: "workspace/didChangeWorkspaceFolders" }),
+ /**
+ * The `window/workDoneProgress/cancel` notification is sent from the client to the server to cancel a progress
+ * initiated on the server side.
+ */
+ windowWorkDoneProgressCancel: unverifiedNotification({ method: "window/workDoneProgress/cancel" }),
+ /**
+ * The did create files notification is sent from the client to the server when
+ * files were created from within the client.
+ *
+ * @since 3.16.0
+ */
+ workspaceDidCreateFiles: unverifiedNotification({ method: "workspace/didCreateFiles" }),
+ /**
+ * The did rename files notification is sent from the client to the server when
+ * files were renamed from within the client.
+ *
+ * @since 3.16.0
+ */
+ workspaceDidRenameFiles: unverifiedNotification({ method: "workspace/didRenameFiles" }),
+ /**
+ * The will delete files request is sent from the client to the server before files are actually
+ * deleted as long as the deletion is triggered from within the client.
+ *
+ * @since 3.16.0
+ */
+ workspaceDidDeleteFiles: unverifiedNotification({ method: "workspace/didDeleteFiles" }),
+ /**
+ * A notification sent when a notebook opens.
+ *
+ * @since 3.17.0
+ */
+ notebookDocumentDidOpen: unverifiedNotification({ method: "notebookDocument/didOpen" }),
+ notebookDocumentDidChange: unverifiedNotification({ method: "notebookDocument/didChange" }),
+ /**
+ * A notification sent when a notebook document is saved.
+ *
+ * @since 3.17.0
+ */
+ notebookDocumentDidSave: unverifiedNotification({ method: "notebookDocument/didSave" }),
+ /**
+ * A notification sent when a notebook closes.
+ *
+ * @since 3.17.0
+ */
+ notebookDocumentDidClose: unverifiedNotification({ method: "notebookDocument/didClose" }),
+ /**
+ * The initialized notification is sent from the client to the
+ * server after the client is fully initialized and the server
+ * is allowed to send requests from the server to the client.
+ */
+ initialized: unverifiedNotification({ method: "initialized" }),
+ /**
+ * The exit event is sent from the client to the server to
+ * ask the server to exit its process.
+ */
+ exit: unverifiedNotification({ method: "exit" }),
+ /**
+ * The configuration change notification is sent from the client to the server
+ * when the client's configuration has changed. The notification contains
+ * the changed configuration as defined by the language client.
+ */
+ workspaceDidChangeConfiguration: unverifiedNotification({ method: "workspace/didChangeConfiguration" }),
+ /**
+ * The document open notification is sent from the client to the server to signal
+ * newly opened text documents. The document's truth is now managed by the client
+ * and the server must not try to read the document's truth using the document's
+ * uri. Open in this sense means it is managed by the client. It doesn't necessarily
+ * mean that its content is presented in an editor. An open notification must not
+ * be sent more than once without a corresponding close notification send before.
+ * This means open and close notification must be balanced and the max open count
+ * is one.
+ */
+ textDocumentDidOpen: unverifiedNotification({ method: "textDocument/didOpen" }),
+ /**
+ * The document change notification is sent from the client to the server to signal
+ * changes to a text document.
+ */
+ textDocumentDidChange: unverifiedNotification({ method: "textDocument/didChange" }),
+ /**
+ * The document close notification is sent from the client to the server when
+ * the document got closed in the client. The document's truth now exists where
+ * the document's uri points to (e.g. if the document's uri is a file uri the
+ * truth now exists on disk). As with the open notification the close notification
+ * is about managing the document's content. Receiving a close notification
+ * doesn't mean that the document was open in an editor before. A close
+ * notification requires a previous open notification to be sent.
+ */
+ textDocumentDidClose: unverifiedNotification({ method: "textDocument/didClose" }),
+ /**
+ * The document save notification is sent from the client to the server when
+ * the document got saved in the client.
+ */
+ textDocumentDidSave: unverifiedNotification({ method: "textDocument/didSave" }),
+ /**
+ * A document will save notification is sent from the client to the server before
+ * the document is actually saved.
+ */
+ textDocumentWillSave: unverifiedNotification({ method: "textDocument/willSave" }),
+ /**
+ * The watched files notification is sent from the client to the server when
+ * the client detects changes to file watched by the language client.
+ */
+ workspaceDidChangeWatchedFiles: unverifiedNotification({ method: "workspace/didChangeWatchedFiles" }),
+ setTrace: unverifiedNotification({ method: "$/setTrace" }),
+ cancelRequest: unverifiedNotification({ method: "$/cancelRequest" }),
+ progress: unverifiedNotification({ method: "$/progress" }),
+ },
+ client: {
+ /**
+ * The `workspace/workspaceFolders` is sent from the server to the client to fetch the open workspace folders.
+ */
+ workspaceWorkspaceFolders: unverifiedRequest({ method: "workspace/workspaceFolders" }).optional(),
+ /**
+ * The 'workspace/configuration' request is sent from the server to the client to fetch a certain
+ * configuration setting.
+ *
+ * This pull model replaces the old push model where the client signaled configuration change via an
+ * event. If the server still needs to react to configuration changes (since the server caches the
+ * result of `workspace/configuration` requests) the server should register for an empty configuration
+ * change event and empty the cache if such an event is received.
+ */
+ workspaceConfiguration: unverifiedRequest({ method: "workspace/configuration" }).optional(),
+ /**
+ * @since 3.18.0
+ * @proposed
+ */
+ workspaceFoldingRangeRefresh: unverifiedRequest({ method: "workspace/foldingRange/refresh" }).optional(),
+ /**
+ * The `window/workDoneProgress/create` request is sent from the server to the client to initiate progress
+ * reporting from the server.
+ */
+ windowWorkDoneProgressCreate: unverifiedRequest({ method: "window/workDoneProgress/create" }).optional(),
+ /**
+ * @since 3.16.0
+ */
+ workspaceSemanticTokensRefresh: unverifiedRequest({ method: "workspace/semanticTokens/refresh" }).optional(),
+ /**
+ * A request to show a document. This request might open an
+ * external program depending on the value of the URI to open.
+ * For example a request to open `https://code.visualstudio.com/`
+ * will very likely open the URI in a WEB browser.
+ *
+ * @since 3.16.0
+ */
+ windowShowDocument: unverifiedRequest({ method: "window/showDocument" }).optional(),
+ /**
+ * @since 3.17.0
+ */
+ workspaceInlineValueRefresh: unverifiedRequest({ method: "workspace/inlineValue/refresh" }).optional(),
+ /**
+ * @since 3.17.0
+ */
+ workspaceInlayHintRefresh: unverifiedRequest({ method: "workspace/inlayHint/refresh" }).optional(),
+ /**
+ * The diagnostic refresh request definition.
+ *
+ * @since 3.17.0
+ */
+ workspaceDiagnosticRefresh: unverifiedRequest({ method: "workspace/diagnostic/refresh" }).optional(),
+ /**
+ * The `client/registerCapability` request is sent from the server to the client to register a new capability
+ * handler on the client side.
+ */
+ clientRegisterCapability: unverifiedRequest({ method: "client/registerCapability" }).optional(),
+ /**
+ * The `client/unregisterCapability` request is sent from the server to the client to unregister a previously registered capability
+ * handler on the client side.
+ */
+ clientUnregisterCapability: unverifiedRequest({ method: "client/unregisterCapability" }).optional(),
+ /**
+ * The show message request is sent from the server to the client to show a message
+ * and a set of options actions to the user.
+ */
+ windowShowMessageRequest: unverifiedRequest({ method: "window/showMessageRequest" }).optional(),
+ /**
+ * A request to refresh all code actions
+ *
+ * @since 3.16.0
+ */
+ workspaceCodeLensRefresh: unverifiedRequest({ method: "workspace/codeLens/refresh" }).optional(),
+ /**
+ * A request sent from the server to the client to modified certain resources.
+ */
+ workspaceApplyEdit: unverifiedRequest({ method: "workspace/applyEdit" }).optional(),
+ /**
+ * The show message notification is sent from a server to a client to ask
+ * the client to display a particular message in the user interface.
+ */
+ windowShowMessage: unverifiedNotification({ method: "window/showMessage" }),
+ /**
+ * The log message notification is sent from the server to the client to ask
+ * the client to log a particular message.
+ */
+ windowLogMessage: unverifiedNotification({ method: "window/logMessage" }),
+ /**
+ * The telemetry event notification is sent from the server to the client to ask
+ * the client to log telemetry data.
+ */
+ telemetryEvent: unverifiedNotification({ method: "telemetry/event" }),
+ /**
+ * Diagnostics notification are sent from the server to the client to signal
+ * results of validation runs.
+ */
+ textDocumentPublishDiagnostics: unverifiedNotification({ method: "textDocument/publishDiagnostics" }),
+ logTrace: unverifiedNotification({ method: "$/logTrace" }),
+ cancelRequest: unverifiedNotification({ method: "$/cancelRequest" }),
+ progress: unverifiedNotification({ method: "$/progress" }),
+ }
+});
diff --git a/monaco-lsp-client/src/utils.ts b/monaco-lsp-client/src/utils.ts
new file mode 100644
index 00000000..00905499
--- /dev/null
+++ b/monaco-lsp-client/src/utils.ts
@@ -0,0 +1,75 @@
+export interface IDisposable {
+ dispose(): void;
+}
+
+export class Disposable implements IDisposable {
+ static None = Object.freeze({ dispose() { } });
+
+ private _store = new DisposableStore();
+
+ constructor() { }
+
+ public dispose(): void {
+ this._store.dispose();
+ }
+
+ protected _register(t: T): T {
+ if ((t as any) === this) {
+ throw new Error('Cannot register a disposable on itself!');
+ }
+ return this._store.add(t);
+ }
+}
+
+export class DisposableStore implements IDisposable {
+ static DISABLE_DISPOSED_WARNING = false;
+
+ private _toDispose = new Set();
+ private _isDisposed = false;
+
+ public dispose(): void {
+ if (this._isDisposed) {
+ return;
+ }
+
+ this._isDisposed = true;
+ this.clear();
+ }
+
+ public clear(): void {
+ if (this._toDispose.size === 0) {
+ return;
+ }
+
+ try {
+ for (const item of this._toDispose) {
+ item.dispose();
+ }
+ } finally {
+ this._toDispose.clear();
+ }
+ }
+
+ public add(t: T): T {
+ if (!t) {
+ return t;
+ }
+ if ((t as any) === this) {
+ throw new Error('Cannot register a disposable on itself!');
+ }
+
+ if (this._isDisposed) {
+ if (!DisposableStore.DISABLE_DISPOSED_WARNING) {
+ console.warn(
+ new Error(
+ 'Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!'
+ ).stack
+ );
+ }
+ } else {
+ this._toDispose.add(t);
+ }
+
+ return t;
+ }
+}
diff --git a/monaco.d.ts b/monaco.d.ts
deleted file mode 100644
index ade5dcfa..00000000
--- a/monaco.d.ts
+++ /dev/null
@@ -1,5252 +0,0 @@
-/*!-----------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Type definitions for monaco-editor v0.10.0
- * Released under the MIT license
-*-----------------------------------------------------------*/
-/*---------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-declare module monaco {
-
- interface Thenable {
- /**
- * Attaches callbacks for the resolution and/or rejection of the Promise.
- * @param onfulfilled The callback to execute when the Promise is resolved.
- * @param onrejected The callback to execute when the Promise is rejected.
- * @returns A Promise for the completion of which ever callback is executed.
- */
- then(onfulfilled?: (value: T) => TResult | Thenable, onrejected?: (reason: any) => TResult | Thenable): Thenable;
- then(onfulfilled?: (value: T) => TResult | Thenable, onrejected?: (reason: any) => void): Thenable;
- }
-
- export interface IDisposable {
- dispose(): void;
- }
-
- export interface IEvent {
- (listener: (e: T) => any, thisArg?: any): IDisposable;
- }
-
- /**
- * A helper that allows to emit and listen to typed events
- */
- export class Emitter {
- constructor();
- readonly event: IEvent