lean4monaco 1.0.6 → 1.0.8

package/README.md

@@ -23,7 +23,7 @@ useEffect(() => {
     const leanMonacoEditor = new LeanMonacoEditor()
 
     ;(async () => {
-        await leanMonaco.start('ws://localhost:8080/')
+        await leanMonaco.start({websocket: {url: 'ws://localhost:8080/'}})
         leanMonaco.setInfoviewElement(infoviewRef.current)
         await leanMonacoEditor.start(codeviewRef.current!, '/project/test.lean', '#check Nat')
     })()
@@ -76,4 +76,33 @@ export default {
   },
   [...]
 }
+```
+
+Moreover, the infoview javascript files need to be served:
+```ts
+// vite.config.ts
+import { viteStaticCopy } from 'vite-plugin-static-copy'
+import { normalizePath } from 'vite'
+import path from 'node:path'
+
+export default {
+  plugins: [
+    viteStaticCopy({
+      targets: [
+        {
+          src: normalizePath(path.resolve(__dirname, './node_modules/@leanprover/infoview/dist/*.production.min.js')),
+          dest: 'infoview'
+        }
+      ]
+    })
+  ]
+}
+```
+
+## Troubleshooting
+
+* Make sure that only one version of the npm package `monaco-vscode-api` is installed.
+The error I typically got is:
+```
+this._configurationService.onDidChangeConfiguration is not a function
 ```

package/dist/editor.js

@@ -14,9 +14,8 @@ export class LeanMonacoEditor {
         fs.mkdirSync(path.dirname(fileName), { recursive: true });
         fs.writeFileSync(fileName, '');
         // Create editor and model
-        const theme = "Visual Studio Light"; //"Visual Studio Dark" //"Default Light Modern" //"Default Light+" //"Default Dark+" //"Default High Contrast"
-        this.editor = monaco.editor.create(editorEl, { automaticLayout: true, theme });
         this.modelRef = await createModelReference(Uri.parse(fileName), code);
+        this.editor = monaco.editor.create(editorEl, { automaticLayout: true });
         this.editor.setModel(this.modelRef.object.textEditorModel);
         // Set focus on editor to trigger infoview to open
         this.editor.focus();

package/dist/leanmonaco.d.ts

@@ -1,17 +1,24 @@
 import 'vscode/localExtensionHost';
-import { RegisterExtensionResult } from 'monaco-editor-wrapper';
+import { RegisterExtensionResult, WebSocketConfigOptionsUrl } from 'monaco-editor-wrapper';
 import { LeanClientProvider } from './monaco-lean4/vscode-lean4/src/utils/clientProvider';
 import { InfoProvider } from './monaco-lean4/vscode-lean4/src/infoview';
 import { AbbreviationFeature } from './monaco-lean4/vscode-lean4/src/abbreviation/AbbreviationFeature';
 import { LeanTaskGutter } from './monaco-lean4/vscode-lean4/src/taskgutter';
 import { IFrameInfoWebviewFactory } from './infowebview';
-import { Logger } from 'monaco-languageclient/tools';
+import { IExtensionManifest } from 'vscode/extensions';
 import { DisposableStore } from 'vscode/monaco';
+export type LeanMonacoOptions = {
+    websocket: {
+        url: string;
+    };
+    vscode?: {
+        [id: string]: any;
+    };
+};
 export declare class LeanMonaco {
     ready: (value: void | PromiseLike<void>) => void;
     whenReady: Promise<void>;
     static activeInstance: LeanMonaco | null;
-    logger: Logger;
     registerFileUrlResults: DisposableStore;
     extensionRegisterResult: RegisterExtensionResult | undefined;
     clientProvider: LeanClientProvider | undefined;
@@ -20,7 +27,10 @@ export declare class LeanMonaco {
     abbreviationFeature: AbbreviationFeature | undefined;
     taskGutter: LeanTaskGutter | undefined;
     disposed: boolean;
-    start(websocketUrl: string): Promise<void>;
+    start(options: LeanMonacoOptions): Promise<void>;
     setInfoviewElement(infoviewEl: HTMLElement): void;
+    protected getExtensionFiles(): Map<string, URL>;
+    protected getExtensionManifest(options: LeanMonacoOptions): IExtensionManifest;
+    protected getWebSocketOptions(options: LeanMonacoOptions): WebSocketConfigOptionsUrl;
     dispose(): void;
 }

package/dist/leanmonaco.js

@@ -7,110 +7,21 @@ import { LeanTaskGutter } from './monaco-lean4/vscode-lean4/src/taskgutter';
 import { IFrameInfoWebviewFactory } from './infowebview';
 import { setupMonacoClient } from './monacoleanclient';
 import { checkLean4ProjectPreconditions } from './preconditions';
-import { checkServiceConsistency } from 'monaco-editor-wrapper/vscode/services';
-import { Logger } from 'monaco-languageclient/tools';
+import { initialize } from 'vscode/services';
 import getConfigurationServiceOverride from '@codingame/monaco-vscode-configuration-service-override';
 import getTextmateServiceOverride from '@codingame/monaco-vscode-textmate-service-override';
 import getThemeServiceOverride from '@codingame/monaco-vscode-theme-service-override';
-import { initServices } from 'monaco-languageclient/vscode/services';
+import getLanguagesServiceOverride from '@codingame/monaco-vscode-languages-service-override';
+import getModelServiceOverride from '@codingame/monaco-vscode-model-service-override';
 import { registerExtension } from 'vscode/extensions';
 import { DisposableStore } from 'vscode/monaco';
-const extensionFilesOrContents = new Map();
-extensionFilesOrContents.set('/language-configuration.json', new URL('./monaco-lean4/vscode-lean4/language-configuration.json', import.meta.url));
-extensionFilesOrContents.set('/syntaxes/lean4.json', new URL('./monaco-lean4/vscode-lean4/syntaxes/lean4.json', import.meta.url));
-extensionFilesOrContents.set('/syntaxes/lean4-markdown.json', new URL('./monaco-lean4/vscode-lean4/syntaxes/lean4-markdown.json', import.meta.url));
-extensionFilesOrContents.set('/syntaxes/codeblock.json', new URL('./monaco-lean4/vscode-lean4/syntaxes/codeblock.json', import.meta.url));
-const extensionConfig = {
-    name: 'lean4web',
-    publisher: 'leanprover-community',
-    version: '1.0.0',
-    engines: {
-        vscode: '*'
-    },
-    "contributes": {
-        "languages": [
-            {
-                "id": "lean4",
-                "configuration": "./language-configuration.json",
-                "extensions": [
-                    ".lean"
-                ],
-            },
-            {
-                "id": "lean4markdown",
-                "aliases": [],
-                "extensions": [
-                    ".lean4markdown"
-                ],
-                "configuration": "./language-configuration.json"
-            }
-        ],
-        "grammars": [
-            {
-                "language": "lean4",
-                "scopeName": "source.lean4",
-                "path": "./syntaxes/lean4.json"
-            },
-            {
-                "language": "lean4markdown",
-                "scopeName": "source.lean4.markdown",
-                "path": "./syntaxes/lean4-markdown.json"
-            },
-            {
-                "language": "lean4",
-                "scopeName": "markdown.lean4.codeblock",
-                "path": "./syntaxes/codeblock.json",
-                "injectTo": [
-                    "text.html.markdown"
-                ],
-                "embeddedLanguages": {
-                    "meta.embedded.block.lean4": "lean4"
-                }
-            }
-        ],
-    }
-};
-const serviceConfig = {
-    userServices: {
-        ...getTextmateServiceOverride(),
-        ...getThemeServiceOverride(),
-        ...getConfigurationServiceOverride()
-    },
-    workspaceConfig: {
-        workspaceProvider: {
-            trusted: true,
-            workspace: {
-                workspaceUri: Uri.file('/workspace')
-            },
-            async open() {
-                return false;
-            }
-        }
-    }
-};
-const websocketOptions = {
-    $type: 'WebSocketUrl',
-    url: '',
-    startOptions: {
-        onCall: () => {
-            console.log('Connected to socket.');
-        },
-        reportStatus: true
-    },
-    stopOptions: {
-        onCall: () => {
-            console.log('Disconnected from socket.');
-        },
-        reportStatus: true
-    }
-};
+import packageJson from './monaco-lean4/vscode-lean4/package.json';
 export class LeanMonaco {
     ready;
     whenReady = new Promise((resolve) => {
         this.ready = resolve;
     });
     static activeInstance = null;
-    logger = new Logger();
     registerFileUrlResults = new DisposableStore();
     extensionRegisterResult;
     clientProvider;
@@ -119,7 +30,7 @@ export class LeanMonaco {
     abbreviationFeature;
     taskGutter;
     disposed = false;
-    async start(websocketUrl) {
+    async start(options) {
         if (LeanMonaco.activeInstance == this) {
             console.warn('A LeanMonaco instance cannot be started twice.');
             return;
@@ -129,7 +40,7 @@ export class LeanMonaco {
             LeanMonaco.activeInstance?.dispose();
         }
         LeanMonaco.activeInstance = this;
-        if (!window.MonacoEnvironment?.getWorker) {
+        if (!window.MonacoEnvironment) {
             const workerLoaders = {
                 editorWorkerService: () => new Worker(new URL('monaco-editor/esm/vs/editor/editor.worker.js', import.meta.url), { type: 'module' }),
                 textMateWorker: () => new Worker(new URL('@codingame/monaco-vscode-textmate-service-override/worker', import.meta.url), { type: 'module' }),
@@ -143,40 +54,51 @@ export class LeanMonaco {
                     throw new Error(`Unimplemented worker ${label} (${moduleId})`);
                 }
             };
+            await initialize({
+                ...getTextmateServiceOverride(),
+                ...getThemeServiceOverride(),
+                ...getConfigurationServiceOverride(),
+                ...getLanguagesServiceOverride(),
+                ...getModelServiceOverride()
+            }, undefined, {
+                workspaceProvider: {
+                    trusted: true,
+                    workspace: {
+                        workspaceUri: Uri.file('/workspace.code-workspace')
+                    },
+                    async open() {
+                        return false;
+                    }
+                }
+            });
         }
-        await initServices({
-            serviceConfig,
-            caller: `Lean monaco-editor`,
-            performChecks: checkServiceConsistency,
-            logger: this.logger
-        });
         await (await import('@codingame/monaco-vscode-theme-defaults-default-extension')).whenReady;
         if (this.disposed)
             return;
-        this.extensionRegisterResult = registerExtension(extensionConfig, 1 /* ExtensionHostKind.LocalProcess */);
-        if (extensionFilesOrContents) {
-            for (const entry of extensionFilesOrContents) {
-                const registerFileUrlResult = this.extensionRegisterResult.registerFileUrl(entry[0], entry[1].href);
-                this.registerFileUrlResults.add(registerFileUrlResult);
-            }
+        this.extensionRegisterResult = registerExtension(this.getExtensionManifest(options), 1 /* ExtensionHostKind.LocalProcess */);
+        for (const entry of this.getExtensionFiles()) {
+            const registerFileUrlResult = this.extensionRegisterResult.registerFileUrl(entry[0], entry[1].href);
+            this.registerFileUrlResults.add(registerFileUrlResult);
         }
         await this.extensionRegisterResult.whenReady();
         if (this.disposed)
             return;
-        this.abbreviationFeature = new AbbreviationFeature({});
+        this.abbreviationFeature = new AbbreviationFeature({}, { kind: 'MoveAllSelections' });
         this.clientProvider = new LeanClientProvider({
             installChanged: () => { return { dispose: () => { } }; },
             testLeanVersion: () => { return "lean4/stable"; },
             getElanDefaultToolchain: () => { return "lean4/stable"; }
         }, { appendLine: () => { }
-        }, setupMonacoClient({
-            ...websocketOptions,
-            url: websocketUrl,
-        }), checkLean4ProjectPreconditions, (docUri) => { return true; });
+        }, setupMonacoClient(this.getWebSocketOptions(options)), checkLean4ProjectPreconditions, (docUri) => { return true; });
         this.taskGutter = new LeanTaskGutter(this.clientProvider, { asAbsolutePath: (path) => Uri.parse(`${new URL('monaco-lean4/vscode-lean4/' + path, import.meta.url)}`), });
         if (!this.iframeWebviewFactory)
             this.iframeWebviewFactory = new IFrameInfoWebviewFactory();
         this.infoProvider = new InfoProvider(this.clientProvider, { language: 'lean4' }, {}, this.iframeWebviewFactory);
+        const fontFile = new FontFace("JuliaMono", `url(${new URL("./JuliaMono-Regular.ttf", import.meta.url)})`);
+        document.fonts.add(fontFile);
+        await fontFile.load();
+        if (this.disposed)
+            return;
         this.ready();
     }
     setInfoviewElement(infoviewEl) {
@@ -184,6 +106,121 @@ export class LeanMonaco {
             this.iframeWebviewFactory = new IFrameInfoWebviewFactory();
         this.iframeWebviewFactory.setInfoviewElement(infoviewEl);
     }
+    getExtensionFiles() {
+        const extensionFiles = new Map();
+        extensionFiles.set('/language-configuration.json', new URL('./monaco-lean4/vscode-lean4/language-configuration.json', import.meta.url));
+        extensionFiles.set('/syntaxes/lean4.json', new URL('./monaco-lean4/vscode-lean4/syntaxes/lean4.json', import.meta.url));
+        extensionFiles.set('/syntaxes/lean4-markdown.json', new URL('./monaco-lean4/vscode-lean4/syntaxes/lean4-markdown.json', import.meta.url));
+        extensionFiles.set('/syntaxes/codeblock.json', new URL('./monaco-lean4/vscode-lean4/syntaxes/codeblock.json', import.meta.url));
+        extensionFiles.set('/themes/cobalt2.json', new URL('./themes/cobalt2.json', import.meta.url));
+        return extensionFiles;
+    }
+    getExtensionManifest(options) {
+        for (let o in options.vscode) {
+            if (packageJson.contributes.configuration.properties[o]) {
+                packageJson.contributes.configuration.properties[o].default = options.vscode[o];
+            }
+        }
+        return {
+            name: 'lean4web',
+            publisher: 'leanprover-community',
+            version: '1.0.0',
+            engines: {
+                vscode: '*'
+            },
+            "contributes": {
+                "configuration": packageJson.contributes.configuration,
+                "languages": [
+                    {
+                        "id": "lean4",
+                        "configuration": "./language-configuration.json",
+                        "extensions": [
+                            ".lean"
+                        ],
+                    },
+                    {
+                        "id": "lean4markdown",
+                        "aliases": [],
+                        "extensions": [
+                            ".lean4markdown"
+                        ],
+                        "configuration": "./language-configuration.json"
+                    }
+                ],
+                "grammars": [
+                    {
+                        "language": "lean4",
+                        "scopeName": "source.lean4",
+                        "path": "./syntaxes/lean4.json"
+                    },
+                    {
+                        "language": "lean4markdown",
+                        "scopeName": "source.lean4.markdown",
+                        "path": "./syntaxes/lean4-markdown.json"
+                    },
+                    {
+                        "language": "lean4",
+                        "scopeName": "markdown.lean4.codeblock",
+                        "path": "./syntaxes/codeblock.json",
+                        "injectTo": [
+                            "text.html.markdown"
+                        ],
+                        "embeddedLanguages": {
+                            "meta.embedded.block.lean4": "lean4"
+                        }
+                    }
+                ],
+                "configurationDefaults": {
+                    "[lean4]": {
+                        "editor.folding": false,
+                        "editor.wordSeparators": "`~@$%^&*()-=+[{]}⟨⟩⦃⦄⟦⟧⟮⟯‹›\\|;:\",.<>/",
+                        "editor.lineNumbers": 'on',
+                        "editor.lineNumbersMinChars": 1,
+                        "editor.glyphMargin": true,
+                        "editor.lineDecorationsWidth": 5,
+                        "editor.tabSize": 2,
+                        "editor.detectIndentation": false,
+                        "editor.lightbulb.enabled": "on",
+                        "editor.unicodeHighlight.ambiguousCharacters": false,
+                        "editor.minimap.enabled": false,
+                        "editor.semanticHighlighting.enabled": true,
+                        "editor.wordWrap": "off",
+                        "editor.acceptSuggestionOnEnter": "off",
+                        "editor.fontFamily": "JuliaMono",
+                        "editor.wrappingStrategy": "advanced",
+                        "editor.theme": "Visual Studio Light", //"Cobalt" // "Visual Studio Light" //"Visual Studio Dark" //"Default Light Modern" //"Default Light+" //"Default Dark+" //"Default High Contrast"
+                        ...options.vscode
+                    }
+                },
+                "themes": [
+                    {
+                        "id": "Cobalt",
+                        "label": "Cobalt",
+                        "uiTheme": "vs",
+                        "path": "./themes/cobalt2.json"
+                    }
+                ],
+            },
+        };
+    }
+    getWebSocketOptions(options) {
+        return {
+            $type: 'WebSocketUrl',
+            startOptions: {
+                onCall: () => {
+                    console.log('Connected to socket.');
+                },
+                reportStatus: true
+            },
+            stopOptions: {
+                onCall: () => {
+                    console.log('Disconnected from socket.');
+                },
+                reportStatus: true
+            },
+            ...options.websocket
+        };
+    }
     dispose() {
         if (LeanMonaco.activeInstance == this) {
             LeanMonaco.activeInstance = null;

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/AbbreviationFeature.d.ts

@@ -1,8 +1,9 @@
 import { AbbreviationProvider } from '@leanprover/unicode-input';
 import { OutputChannel } from 'vscode';
+import { SelectionMoveMode } from '@leanprover/unicode-input';
 export declare class AbbreviationFeature {
     private readonly disposables;
     readonly abbreviations: AbbreviationProvider;
-    constructor(outputChannel: OutputChannel);
+    constructor(outputChannel: OutputChannel, selectionMoveMove?: SelectionMoveMode);
     dispose(): void;
 }

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/AbbreviationFeature.js

@@ -6,11 +6,11 @@ import { VSCodeAbbreviationConfig } from './VSCodeAbbreviationConfig';
 export class AbbreviationFeature {
     disposables = new Array();
     abbreviations;
-    constructor(outputChannel) {
+    constructor(outputChannel, selectionMoveMove) {
         const config = new VSCodeAbbreviationConfig();
         this.disposables.push(config);
         this.abbreviations = new AbbreviationProvider(config);
-        this.disposables.push(languages.registerHoverProvider(config.languages, new AbbreviationHoverProvider(config, this.abbreviations)), new AbbreviationRewriterFeature(config, this.abbreviations, outputChannel));
+        this.disposables.push(languages.registerHoverProvider(config.languages, new AbbreviationHoverProvider(config, this.abbreviations)), new AbbreviationRewriterFeature(config, this.abbreviations, outputChannel, selectionMoveMove));
     }
     dispose() {
         for (const d of this.disposables) {

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/AbbreviationRewriterFeature.d.ts

@@ -1,4 +1,4 @@
-import { AbbreviationProvider } from '@leanprover/unicode-input';
+import { AbbreviationProvider, SelectionMoveMode } from '@leanprover/unicode-input';
 import { OutputChannel } from 'vscode';
 import { VSCodeAbbreviationConfig } from './VSCodeAbbreviationConfig';
 /**
@@ -9,9 +9,10 @@ export declare class AbbreviationRewriterFeature {
     private readonly config;
     private readonly abbreviationProvider;
     private readonly outputChannel;
+    private readonly selectionMoveMove?;
     private readonly disposables;
     private activeAbbreviationRewriter;
-    constructor(config: VSCodeAbbreviationConfig, abbreviationProvider: AbbreviationProvider, outputChannel: OutputChannel);
+    constructor(config: VSCodeAbbreviationConfig, abbreviationProvider: AbbreviationProvider, outputChannel: OutputChannel, selectionMoveMove?: SelectionMoveMode | undefined);
     private disposeActiveAbbreviationRewriter;
     private changedActiveTextEditor;
     private shouldEnableRewriterForEditor;

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/AbbreviationRewriterFeature.js

@@ -9,12 +9,14 @@ export class AbbreviationRewriterFeature {
     config;
     abbreviationProvider;
     outputChannel;
+    selectionMoveMove;
     disposables = new Array();
     activeAbbreviationRewriter;
-    constructor(config, abbreviationProvider, outputChannel) {
+    constructor(config, abbreviationProvider, outputChannel, selectionMoveMove) {
         this.config = config;
         this.abbreviationProvider = abbreviationProvider;
         this.outputChannel = outputChannel;
+        this.selectionMoveMove = selectionMoveMove;
         void this.changedActiveTextEditor(window.activeTextEditor);
         this.disposables.push(commands.registerTextEditorCommand('lean4.input.convert', async () => {
             if (this.activeAbbreviationRewriter === undefined) {
@@ -33,7 +35,7 @@ export class AbbreviationRewriterFeature {
             }
             if (this.activeAbbreviationRewriter === undefined &&
                 this.shouldEnableRewriterForEditor(window.activeTextEditor)) {
-                this.activeAbbreviationRewriter = new VSCodeAbbreviationRewriter(config, abbreviationProvider, outputChannel, window.activeTextEditor);
+                this.activeAbbreviationRewriter = new VSCodeAbbreviationRewriter(config, abbreviationProvider, outputChannel, window.activeTextEditor, this.selectionMoveMove);
             }
             else if (this.activeAbbreviationRewriter !== undefined &&
                 !this.shouldEnableRewriterForEditor(window.activeTextEditor)) {
@@ -57,7 +59,7 @@ export class AbbreviationRewriterFeature {
         if (!this.shouldEnableRewriterForEditor(activeTextEditor)) {
             return;
         }
-        this.activeAbbreviationRewriter = new VSCodeAbbreviationRewriter(this.config, this.abbreviationProvider, this.outputChannel, activeTextEditor);
+        this.activeAbbreviationRewriter = new VSCodeAbbreviationRewriter(this.config, this.abbreviationProvider, this.outputChannel, activeTextEditor, this.selectionMoveMove);
     }
     shouldEnableRewriterForEditor(editor) {
         if (!this.config.inputModeEnabled) {

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/VSCodeAbbreviationRewriter.d.ts

@@ -8,13 +8,14 @@ export declare class VSCodeAbbreviationRewriter implements AbbreviationTextSourc
     readonly abbreviationProvider: AbbreviationProvider;
     private readonly outputChannel;
     private readonly textEditor;
+    private selectionMoveMoveOverride?;
     private readonly disposables;
     private readonly rewriter;
     private readonly decorationType;
     private firstOutput;
     private isVimExtensionInstalled;
     private checkIsVimExtensionInstalled;
-    constructor(config: AbbreviationConfig, abbreviationProvider: AbbreviationProvider, outputChannel: OutputChannel, textEditor: TextEditor);
+    constructor(config: AbbreviationConfig, abbreviationProvider: AbbreviationProvider, outputChannel: OutputChannel, textEditor: TextEditor, selectionMoveMoveOverride?: SelectionMoveMode | undefined);
     private writeError;
     selectionMoveMode(): SelectionMoveMode;
     collectSelections(): Range[];

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/VSCodeAbbreviationRewriter.js

@@ -8,6 +8,7 @@ export class VSCodeAbbreviationRewriter {
     abbreviationProvider;
     outputChannel;
     textEditor;
+    selectionMoveMoveOverride;
     disposables = new Array();
     rewriter;
     decorationType = window.createTextEditorDecorationType({
@@ -18,11 +19,12 @@ export class VSCodeAbbreviationRewriter {
     checkIsVimExtensionInstalled() {
         this.isVimExtensionInstalled = extensions.getExtension('vscodevim.vim') !== undefined;
     }
-    constructor(config, abbreviationProvider, outputChannel, textEditor) {
+    constructor(config, abbreviationProvider, outputChannel, textEditor, selectionMoveMoveOverride) {
         this.config = config;
         this.abbreviationProvider = abbreviationProvider;
         this.outputChannel = outputChannel;
         this.textEditor = textEditor;
+        this.selectionMoveMoveOverride = selectionMoveMoveOverride;
         this.rewriter = new AbbreviationRewriter(config, abbreviationProvider, this);
         this.disposables.push(this.decorationType);
         this.disposables.push(workspace.onDidChangeTextDocument(async (e) => {
@@ -56,7 +58,7 @@ export class VSCodeAbbreviationRewriter {
         }
     }
     selectionMoveMode() {
-        return { kind: 'OnlyMoveCursorSelections', updateUnchangedSelections: this.isVimExtensionInstalled };
+        return this.selectionMoveMoveOverride ?? { kind: 'OnlyMoveCursorSelections', updateUnchangedSelections: this.isVimExtensionInstalled };
     }
     collectSelections() {
         return this.textEditor.selections.map(s => fromVsCodeRange(s, this.textEditor.document));