@codingame/monaco-editor-wrapper 2.1.1 → 2.2.1

package/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 - CodinGame
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -56,10 +56,10 @@ Instead of using `monaco.editor.create`, you should use the `createEditor` expos
 By default, monaco-editor contains worker to achieve IntelliSense in CSS, SCSS, JavaScript, TypeScript, JSON and HTML.
 
 To enable them, import the following files:
-- JSON: `import '@codingame/monaco-editor-wrapper/dist/jsonContribution'`
-- JavaScript/TypeScript: `import '@codingame/monaco-editor-wrapper/dist/typescriptContribution'`
-- CSS/SCSS: `import '@codingame/monaco-editor-wrapper/dist/cssContribution'`
-- HTML: `import '@codingame/monaco-editor-wrapper/dist/htmlContribution'`
+- JSON: `import '@codingame/monaco-editor-wrapper/features/jsonContribution'`
+- JavaScript/TypeScript: `import '@codingame/monaco-editor-wrapper/features/typescriptContribution'`
+- CSS/SCSS: `import '@codingame/monaco-editor-wrapper/features/cssContribution'`
+- HTML: `import '@codingame/monaco-editor-wrapper/features/htmlContribution'`
 
 #### Additional apis
 
@@ -79,4 +79,5 @@ This library exposed some functions to manage the user global configuration:
 - `updateUserConfiguration` Update the user configuration, overrides the default configuration, uses the same syntax as VS Code configuration
 - `getConfiguration` allows to get a given configuration key in a given language
 - `onConfigurationChanged` listen to configuration change
-- `updateEditorKeybindings` allows to update the editor keybindings with the same syntax as in VS Code, or enabled Emacs/Vim keybindings
+- `updateKeybindings` allows to update the editor keybindings with the same syntax as in VS Code
+- `updateEditorKeybindingsMode` switch between `vim`, `emacs` or `classic` keybindings

package/dist/configuration/files.d.ts

@@ -0,0 +1,6 @@
+/**
+ * comes from https://github.com/microsoft/vscode/blob/16d0a319b28caa4b6cf4e6801fd508282b7533e0/src/vs/workbench/contrib/files/browser/files.contribution.ts#L132
+ * files.exclude and files.associations are required by the Lua language server
+ */
+export declare const FILES_EXCLUDE_CONFIG = "files.exclude";
+export declare const FILES_ASSOCIATIONS_CONFIG = "files.associations";

package/dist/configuration/index.d.ts

@@ -1,6 +1,10 @@
 import * as monaco from 'monaco-editor';
-export declare const onConfigurationChanged: monaco.IEvent<monaco.extra.IConfigurationChangeEvent>;
+import { IConfigurationChangeEvent } from 'vscode/services';
+import * as vscode from 'vscode';
+import { updateUserConfiguration } from 'vscode/service-override/configuration';
+import './files';
+export declare function onConfigurationChanged(listener: (e: IConfigurationChangeEvent) => void): vscode.Disposable;
 export declare function getConfiguration<C = Partial<monaco.editor.IEditorOptions>>(language?: string, section?: string): C | undefined;
-export declare function updateUserConfiguration(configurationJson: string): void;
+export { updateUserConfiguration };
 export declare function registerConfigurations(configurations: monaco.extra.IConfigurationNode[], validate?: boolean): void;
 export declare function registerDefaultConfigurations(defaultConfigurations: monaco.extra.IStringDictionary<unknown>[]): void;

package/dist/features/extensionConfigurations.d.ts

@@ -1,7 +1 @@
 export declare function loadConfigurationForExtension(extensionId: string): Promise<void>;
-/**
- * comes from https://github.com/microsoft/vscode/blob/16d0a319b28caa4b6cf4e6801fd508282b7533e0/src/vs/workbench/contrib/files/browser/files.contribution.ts#L132
- * Required by the Lua language server
- */
-export declare const FILES_EXCLUDE_CONFIG = "files.exclude";
-export declare const FILES_ASSOCIATIONS_CONFIG = "files.associations";

package/dist/features/extensionConfigurations.js

@@ -1,4 +1,3 @@
-import { _ as _objectSpread2 } from '../_rollupPluginBabelHelpers.js';
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 
 // Generated file, do not modify
@@ -138,65 +137,5 @@ async function loadConfigurationForExtension(extensionId) {
   const configuration = await loader$1();
   configurationRegistry.registerConfigurations(configuration);
 }
-/**
- * comes from https://github.com/microsoft/vscode/blob/16d0a319b28caa4b6cf4e6801fd508282b7533e0/src/vs/workbench/contrib/files/browser/files.contribution.ts#L132
- * Required by the Lua language server
- */
-
-const FILES_EXCLUDE_CONFIG = 'files.exclude';
-const FILES_ASSOCIATIONS_CONFIG = 'files.associations';
-const ConfigurationScope = monaco.extra.ConfigurationScope;
-const nls = {
-  localize: (key, defaultValue) => defaultValue
-};
-configurationRegistry.registerConfiguration({
-  id: 'files',
-  order: 9,
-  title: 'Files',
-  type: 'object',
-  properties: {
-    [FILES_EXCLUDE_CONFIG]: {
-      type: 'object',
-      markdownDescription: nls.localize('exclude', 'Configure glob patterns for excluding files and folders. For example, the file Explorer decides which files and folders to show or hide based on this setting. Refer to the `#search.exclude#` setting to define search specific excludes. Read more about glob patterns [here](https://code.visualstudio.com/docs/editor/codebasics#_advanced-search-options).'),
-      default: _objectSpread2(_objectSpread2({}, {
-        '**/.git': true,
-        '**/.svn': true,
-        '**/.hg': true,
-        '**/CVS': true,
-        '**/.DS_Store': true,
-        '**/Thumbs.db': true
-      }), {
-        '**/*.crswap': true
-        /* filter out swap files used for local file access */
-
-      } ),
-      scope: ConfigurationScope.RESOURCE,
-      additionalProperties: {
-        anyOf: [{
-          type: 'boolean',
-          description: nls.localize('files.exclude.boolean', 'The glob pattern to match file paths against. Set to true or false to enable or disable the pattern.')
-        }, {
-          type: 'object',
-          properties: {
-            when: {
-              type: 'string',
-              // expression ({ "**/*.js": { "when": "$(basename).js" } })
-              pattern: '\\w*\\$\\(basename\\)\\w*',
-              default: '$(basename).ext',
-              description: nls.localize('files.exclude.when', 'Additional check on the siblings of a matching file. Use $(basename) as variable for the matching file name.')
-            }
-          }
-        }]
-      }
-    },
-    [FILES_ASSOCIATIONS_CONFIG]: {
-      type: 'object',
-      markdownDescription: nls.localize('associations', 'Configure file associations to languages (e.g. `"*.extension": "html"`). These have precedence over the default associations of the languages installed.'),
-      additionalProperties: {
-        type: 'string'
-      }
-    }
-  }
-});
 
-export { FILES_ASSOCIATIONS_CONFIG, FILES_EXCLUDE_CONFIG, loadConfigurationForExtension };
+export { loadConfigurationForExtension };

package/dist/features/htmlContribution.js

@@ -2,6 +2,9 @@ import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import 'monaco-editor/esm/vs/language/html/monaco.contribution';
 import { r as registerConfigurations, g as getConfiguration, o as onConfigurationChanged } from '../index.js';
 import { r as registerWorkerLoader } from '../worker.js';
+import 'vscode/services';
+import 'vscode/service-override/configuration';
+import '../_rollupPluginBabelHelpers.js';
 
 const workerLoader = async () => (await import(
 /* webpackChunkName: "MonacoHtmlWorker" */
@@ -30,11 +33,15 @@ registerConfigurations([{
     }
   }
 }]);
-let autoClosingTags = getConfiguration(undefined, 'html.autoClosingTags');
-onConfigurationChanged(e => {
-  if (e.affectsConfiguration('html.autoClosingTags')) {
-    autoClosingTags = getConfiguration(undefined, 'html.autoClosingTags');
-  }
+let autoClosingTags = false;
+setTimeout(() => {
+  // In a timeout so the service can be overriden
+  autoClosingTags = getConfiguration(undefined, 'html.autoClosingTags');
+  onConfigurationChanged(e => {
+    if (e.affectsConfiguration('html.autoClosingTags')) {
+      autoClosingTags = getConfiguration(undefined, 'html.autoClosingTags');
+    }
+  });
 });
 
 function autoCloseHtmlTags(editor) {
@@ -101,14 +108,17 @@ function autoCloseHtmlTags(editor) {
   return disposableStore;
 }
 
-const codeEditors = monaco.extra.StandaloneServices.get(monaco.extra.ICodeEditorService).listCodeEditors();
+setTimeout(() => {
+  // In a timeout so the service can be overriden
+  const codeEditors = monaco.extra.StandaloneServices.get(monaco.extra.ICodeEditorService).listCodeEditors();
 
-for (const editor of codeEditors) {
-  autoCloseHtmlTags(editor);
-}
+  for (const editor of codeEditors) {
+    autoCloseHtmlTags(editor);
+  }
 
-monaco.editor.onDidCreateEditor(editor => {
-  autoCloseHtmlTags(editor);
+  monaco.editor.onDidCreateEditor(editor => {
+    autoCloseHtmlTags(editor);
+  });
 });
 /**
  * End autoclosing html tags

package/dist/index.js

@@ -1,4 +1,7 @@
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import { IConfigurationService } from 'vscode/services';
+import 'vscode/service-override/configuration';
+import { _ as _objectSpread2 } from './_rollupPluginBabelHelpers.js';
 
 var configurationDefaults = {
 	"[go]": {
@@ -1216,29 +1219,100 @@ var extensions = {
 	semanticTokenModifiers: semanticTokenModifiers
 };
 
+const configurationRegistry$1 = monaco.extra.Registry.as(monaco.extra.ConfigurationExtensions.Configuration);
+/**
+ * comes from https://github.com/microsoft/vscode/blob/16d0a319b28caa4b6cf4e6801fd508282b7533e0/src/vs/workbench/contrib/files/browser/files.contribution.ts#L132
+ * files.exclude and files.associations are required by the Lua language server
+ */
+
+const FILES_EXCLUDE_CONFIG = 'files.exclude';
+const FILES_ASSOCIATIONS_CONFIG = 'files.associations';
+const ConfigurationScope = monaco.extra.ConfigurationScope;
+const nls = {
+  localize: (key, defaultValue) => defaultValue
+};
+configurationRegistry$1.registerConfiguration({
+  id: 'files',
+  order: 9,
+  title: 'Files',
+  type: 'object',
+  properties: {
+    'files.eol': {
+      type: 'string',
+      enum: ['\n', '\r\n', 'auto'],
+      enumDescriptions: [nls.localize('eol.LF', 'LF'), nls.localize('eol.CRLF', 'CRLF'), nls.localize('eol.auto', 'Uses operating system specific end of line character.')],
+      default: 'auto',
+      description: nls.localize('eol', 'The default end of line character.'),
+      scope: ConfigurationScope.LANGUAGE_OVERRIDABLE
+    },
+    [FILES_EXCLUDE_CONFIG]: {
+      type: 'object',
+      markdownDescription: nls.localize('exclude', 'Configure glob patterns for excluding files and folders. For example, the file Explorer decides which files and folders to show or hide based on this setting. Refer to the `#search.exclude#` setting to define search specific excludes. Read more about glob patterns [here](https://code.visualstudio.com/docs/editor/codebasics#_advanced-search-options).'),
+      default: _objectSpread2(_objectSpread2({}, {
+        '**/.git': true,
+        '**/.svn': true,
+        '**/.hg': true,
+        '**/CVS': true,
+        '**/.DS_Store': true,
+        '**/Thumbs.db': true
+      }), {
+        '**/*.crswap': true
+        /* filter out swap files used for local file access */
+
+      } ),
+      scope: ConfigurationScope.RESOURCE,
+      additionalProperties: {
+        anyOf: [{
+          type: 'boolean',
+          description: nls.localize('files.exclude.boolean', 'The glob pattern to match file paths against. Set to true or false to enable or disable the pattern.')
+        }, {
+          type: 'object',
+          properties: {
+            when: {
+              type: 'string',
+              // expression ({ "**/*.js": { "when": "$(basename).js" } })
+              pattern: '\\w*\\$\\(basename\\)\\w*',
+              default: '$(basename).ext',
+              description: nls.localize('files.exclude.when', 'Additional check on the siblings of a matching file. Use $(basename) as variable for the matching file name.')
+            }
+          }
+        }]
+      }
+    },
+    [FILES_ASSOCIATIONS_CONFIG]: {
+      type: 'object',
+      markdownDescription: nls.localize('associations', 'Configure file associations to languages (e.g. `"*.extension": "html"`). These have precedence over the default associations of the languages installed.'),
+      additionalProperties: {
+        type: 'string'
+      }
+    }
+  }
+});
+
 const configurationRegistry = monaco.extra.Registry.as(monaco.extra.ConfigurationExtensions.Configuration);
 configurationRegistry.registerDefaultConfigurations([{
   overrides: {
     'editor.codeLens': false,
     'editor.fontSize': 12,
     'editor.maxTokenizationLineLength': 1000,
-    'editor.quickSuggestions': false
+    'editor.quickSuggestions': false,
+    'files.eol': '\n'
   }
 }]);
 configurationRegistry.registerDefaultConfigurations([{
   overrides: extensions.configurationDefaults
 }]);
-const simpleConfigurationService = monaco.extra.StandaloneServices.get(monaco.extra.IConfigurationService);
-const onConfigurationChanged = simpleConfigurationService.onDidChangeConfiguration;
+function onConfigurationChanged(listener) {
+  const configurationService = monaco.extra.StandaloneServices.get(IConfigurationService);
+  return configurationService.onDidChangeConfiguration(listener);
+}
 function getConfiguration(language) {
   let section = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'editor';
-  return simpleConfigurationService.getValue(section, {
+  const configurationService = monaco.extra.StandaloneServices.get(IConfigurationService);
+  return configurationService.getValue(section, {
     overrideIdentifier: language
   });
 }
-function updateUserConfiguration(configurationJson) {
-  simpleConfigurationService.updateUserConfiguration(configurationJson);
-}
 function registerConfigurations(configurations, validate) {
   configurationRegistry.registerConfigurations(configurations, validate);
 }
@@ -1248,4 +1322,4 @@ function registerDefaultConfigurations(defaultConfigurations) {
   })));
 }
 
-export { registerDefaultConfigurations as a, extensions as e, getConfiguration as g, onConfigurationChanged as o, registerConfigurations as r, updateUserConfiguration as u };
+export { registerDefaultConfigurations as a, extensions as e, getConfiguration as g, onConfigurationChanged as o, registerConfigurations as r };

package/dist/main.js

@@ -4,10 +4,13 @@ import { _ as _objectSpread2, a as _defineProperty } from './_rollupPluginBabelH
 import onigFile from 'vscode-oniguruma/release/onig.wasm';
 import { loadWASM, createOnigScanner, createOnigString } from 'vscode-oniguruma';
 import { e as extensions, g as getConfiguration$1, o as onConfigurationChanged } from './index.js';
-export { g as getConfiguration, o as onConfigurationChanged, r as registerConfigurations, a as registerDefaultConfigurations, u as updateUserConfiguration } from './index.js';
+export { g as getConfiguration, o as onConfigurationChanged, r as registerConfigurations, a as registerDefaultConfigurations } from './index.js';
 import getModelEditorServiceOverride from 'vscode/service-override/modelEditor';
 import getMessageServiceOverride from 'vscode/service-override/messages';
+import getConfigurationServiceOverride from 'vscode/service-override/configuration';
+export { updateUserConfiguration } from 'vscode/service-override/configuration';
 import './worker.js';
+import { createConfiguredEditor } from 'vscode/monaco';
 import 'monaco-editor/esm/vs/editor/editor.all';
 import 'monaco-editor/esm/vs/editor/standalone/browser/accessibilityHelp/accessibilityHelp';
 import 'monaco-editor/esm/vs/editor/standalone/browser/iPadShowKeyboard/iPadShowKeyboard';
@@ -18,6 +21,7 @@ import 'monaco-editor/esm/vs/editor/standalone/browser/quickAccess/standaloneGot
 import 'monaco-editor/esm/vs/editor/standalone/browser/quickAccess/standaloneCommandsQuickAccess';
 import 'monaco-editor/esm/vs/editor/standalone/browser/referenceSearch/standaloneReferenceSearch';
 import * as shiftCommand from 'monaco-editor/esm/vs/editor/common/commands/shiftCommand';
+import 'vscode/services';
 
 function _mergeNamespaces(n, m) {
 	m.forEach(function (e) {
@@ -1852,11 +1856,10 @@ function getOrCreateGrammarFactory() {
   return textMateGrammarFactory;
 }
 
-const languageService$2 = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
-
 async function createTextMateTokensProvider(languageId) {
+  const languageService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
   const grammarFactory = getOrCreateGrammarFactory();
-  const encodedLanguageId = languageService$2.languageIdCodec.encodeLanguageId(languageId);
+  const encodedLanguageId = languageService.languageIdCodec.encodeLanguageId(languageId);
 
   if (!grammarFactory.has(languageId)) {
     return null;
@@ -1875,7 +1878,7 @@ async function createTextMateTokensProvider(languageId) {
   const tokenization = new monaco$2.extra.TMTokenization(grammar, initialState, containsEmbeddedLanguages);
   tokenization.onDidEncounterLanguage(encodedLanguageId => {
     // Force monaco to load this language and trigger the global `onDidEncounterLanguage`
-    languageService$2.createById(languageService$2.languageIdCodec.decodeLanguageId(encodedLanguageId));
+    languageService.createById(languageService.languageIdCodec.decodeLanguageId(encodedLanguageId));
   });
   return new CGTMTokenizationSupport(languageId, encodedLanguageId, tokenization, grammar);
 }
@@ -4108,9 +4111,12 @@ class SimpleSnippetService {
 
 }
 
-const languageService$1 = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
-const languageConfigurationService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageConfigurationService);
-monaco$2.extra.setSnippetSuggestSupport(new monaco$2.extra.SnippetCompletionProvider(languageService$1, new SimpleSnippetService(), languageConfigurationService));
+setTimeout(() => {
+  // In a timeout so the service can be overriden
+  const languageService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
+  const languageConfigurationService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageConfigurationService);
+  monaco$2.extra.setSnippetSuggestSupport(new monaco$2.extra.SnippetCompletionProvider(languageService, new SimpleSnippetService(), languageConfigurationService));
+});
 
 /* Add custom blocks parsing (for tech.io):
 // { [autofold]
@@ -4153,7 +4159,6 @@ for (const [languageId, aliases] of Object.entries(customAliases)) {
   });
 }
 
-const languageService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
 const languagesIds = Array.from(new Set([...Object.keys(languageLoader), ...textMateLanguages.map(rawLanguage => rawLanguage.id)]));
 
 for (const textMateLanguage of textMateLanguages) {
@@ -4218,19 +4223,24 @@ async function loadLanguageConfiguration(languageId) {
   }
 }
 
-languageService.onDidEncounterLanguage(async languageId => {
-  if (languageId === 'plaintext') {
-    return;
-  }
+setTimeout(() => {
+  // In a timeout so the service can be overriden
+  const languageService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
+  languageService.onDidEncounterLanguage(async languageId => {
+    if (languageId === 'plaintext') {
+      return;
+    }
 
-  loadLanguageConfiguration(languageId).catch(error => {
-    monaco$2.errorHandler.onUnexpectedError(new Error("Unable to load language configuration for language ".concat(languageId), {
-      cause: error
-    }));
+    loadLanguageConfiguration(languageId).catch(error => {
+      monaco$2.errorHandler.onUnexpectedError(new Error("Unable to load language configuration for language ".concat(languageId), {
+        cause: error
+      }));
+    });
   });
 });
 
 function getMonacoLanguage(languageOrModeId) {
+  const languageService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
   const modeId = languageService.getLanguageIdByLanguageName(languageOrModeId.toLowerCase());
 
   if (modeId != null) {
@@ -4626,24 +4636,20 @@ class EditorOpenHandlerRegistry {
 }
 
 const editorOpenHandlerRegistry = new EditorOpenHandlerRegistry();
-monaco$2.extra.StandaloneServices.initialize(_objectSpread2(_objectSpread2({}, getModelEditorServiceOverride((model, input, sideBySide) => {
+monaco$2.extra.StandaloneServices.initialize(_objectSpread2(_objectSpread2(_objectSpread2({}, getModelEditorServiceOverride((model, input, sideBySide) => {
   return editorOpenHandlerRegistry.openCodeEditor(model, input, sideBySide);
-})), getMessageServiceOverride(document.body))); // Disable high contrast autodetection because it fallbacks on the hc-black no matter what
-
-monaco$2.extra.StandaloneServices.get(monaco$2.editor.IStandaloneThemeService).setAutoDetectHighContrast(false); // Force EOL to be '\n' even on Windows
+})), getMessageServiceOverride(document.body)), getConfigurationServiceOverride())); // Disable high contrast autodetection because it fallbacks on the hc-black no matter what
 
-const configurationService = monaco$2.extra.StandaloneServices.get(monaco$2.extra.IConfigurationService);
-configurationService.updateValue('files.eol', '\n').catch(error => {
-  monaco$2.errorHandler.onUnexpectedError(new Error('Unable to set file eol', {
-    cause: error
-  }));
+setTimeout(() => {
+  // In a timeout so the service can be overriden
+  monaco$2.extra.StandaloneServices.get(monaco$2.editor.IStandaloneThemeService).setAutoDetectHighContrast(false);
 });
 monaco$2.errorHandler.setUnexpectedErrorHandler(error => {
   console.warn('Unexpected error', error);
 });
 
 function createEditor(domElement, options) {
-  const editor = monaco$2.editor.create(domElement, options);
+  const editor = createConfiguredEditor(domElement, options);
   setup(editor);
   return editor;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-editor-wrapper",
-  "version": "2.1.1",
+  "version": "2.2.1",
   "private": false,
   "description": "Enhanced Monaco editor with TextMate grammars and more",
   "scripts": {
@@ -66,7 +66,7 @@
   ],
   "dependencies": {
     "monaco-editor": "npm:@codingame/monaco-editor@^0.33.6",
-    "vscode": "npm:@codingame/monaco-vscode-api@~1.67.9",
+    "vscode": "npm:@codingame/monaco-vscode-api@~1.67.19",
     "vscode-oniguruma": "^1.6.2"
   },
   "devDependencies": {
@@ -88,6 +88,7 @@
     "@types/js-yaml": "^4.0.5",
     "@types/node": "16.11.7",
     "@types/rollup-plugin-node-builtins": "^2.1.2",
+    "@types/vscode": "~1.67.0",
     "@typescript-eslint/eslint-plugin": "5.27.1",
     "@typescript-eslint/parser": "5.27.1",
     "conventional-changelog-conventionalcommits": "^4.6.3",