lean4monaco 1.0.27 → 1.0.28

package/dist/editor.js

@@ -20,7 +20,7 @@ export class LeanMonacoEditor {
             // Note: looks like setting options here prevents them from being overwritten later.
             // TODO: Looks like these options cannot be set in `updateVSCodeOptions` in `leanmonaco.ts`
             // so we set them here
-            contextmenu: false, // the context menu breaks mobile support.
+            contextmenu: true, // the context menu breaks mobile support.
             lineNumbersMinChars: 1, // minimal no. of characters for line numbers
             lineDecorationsWidth: 5, // distance (px) between line number and code.
         });

package/dist/leanmonaco.js

@@ -102,7 +102,7 @@ export class LeanMonaco {
             testLeanVersion: () => { return "lean4/stable"; },
             getElanDefaultToolchain: () => { return "lean4/stable"; }
         }, { appendLine: () => { }
-        }, setupMonacoClient(this.getWebSocketOptions(options)), checkLean4ProjectPreconditions);
+        }, checkLean4ProjectPreconditions, setupMonacoClient(this.getWebSocketOptions(options)));
         const asAbsolutePath = (path) => {
             switch (path) {
                 // url.pathToFileURL

package/dist/vscode-lean4/vscode-lean4/src/diagnostics/setupDiagnoser.d.ts

@@ -0,0 +1,94 @@
+import { SemVer } from 'semver';
+import { OutputChannel } from 'vscode';
+import { ExecutionResult } from '../utils/batch';
+import { FileUri } from '../utils/exturi';
+export type SystemQueryResult = {
+    operatingSystem: string;
+    cpuArchitecture: string;
+    cpuModels: string;
+    totalMemory: string;
+};
+export type VersionQueryResult = {
+    kind: 'Success';
+    version: SemVer;
+} | {
+    kind: 'CommandNotFound';
+} | {
+    kind: 'CommandError';
+    message: string;
+} | {
+    kind: 'InvalidVersion';
+    versionResult: string;
+};
+export type ElanVersionDiagnosis = {
+    kind: 'UpToDate';
+    version: SemVer;
+} | {
+    kind: 'Outdated';
+    currentVersion: SemVer;
+    recommendedVersion: SemVer;
+} | {
+    kind: 'NotInstalled';
+} | {
+    kind: 'ExecutionError';
+    message: string;
+};
+export type ProjectSetupDiagnosis = {
+    kind: 'SingleFile';
+} | {
+    kind: 'MissingLeanToolchain';
+    folder: FileUri;
+    parentProjectFolder: FileUri | undefined;
+} | {
+    kind: 'ValidProjectSetup';
+    projectFolder: FileUri;
+};
+export type LeanVersionDiagnosis = {
+    kind: 'UpToDate';
+    version: SemVer;
+} | {
+    kind: 'IsLean3Version';
+    version: SemVer;
+} | {
+    kind: 'IsAncientLean4Version';
+    version: SemVer;
+} | {
+    kind: 'NotInstalled';
+} | {
+    kind: 'ExecutionError';
+    message: string;
+};
+export type VSCodeVersionDiagnosis = {
+    kind: 'UpToDate';
+    version: SemVer;
+} | {
+    kind: 'Outdated';
+    currentVersion: SemVer;
+    recommendedVersion: SemVer;
+};
+export declare function versionQueryResult(executionResult: ExecutionResult, versionRegex: RegExp): VersionQueryResult;
+export declare function checkElanVersion(elanVersionResult: VersionQueryResult): ElanVersionDiagnosis;
+export declare function checkLeanVersion(leanVersionResult: VersionQueryResult): LeanVersionDiagnosis;
+export declare class SetupDiagnoser {
+    readonly channel: OutputChannel | undefined;
+    readonly cwdUri: FileUri | undefined;
+    readonly toolchain: string | undefined;
+    constructor(channel: OutputChannel | undefined, cwdUri: FileUri | undefined, toolchain?: string | undefined);
+    checkCurlAvailable(): Promise<boolean>;
+    checkGitAvailable(): Promise<boolean>;
+    queryLakeVersion(): Promise<VersionQueryResult>;
+    checkLakeAvailable(): Promise<boolean>;
+    querySystemInformation(): SystemQueryResult;
+    queryExtensionVersion(): SemVer;
+    queryVSCodeVersion(): VSCodeVersionDiagnosis;
+    queryLeanVersion(): Promise<VersionQueryResult>;
+    queryElanVersion(): Promise<VersionQueryResult>;
+    queryElanShow(): Promise<ExecutionResult>;
+    elanVersion(): Promise<ElanVersionDiagnosis>;
+    projectSetup(): Promise<ProjectSetupDiagnosis>;
+    leanVersion(): Promise<LeanVersionDiagnosis>;
+    private runSilently;
+    private runWithProgress;
+    private runLeanCommand;
+}
+export declare function diagnose(channel: OutputChannel | undefined, cwdUri: FileUri | undefined, toolchain?: string | undefined): SetupDiagnoser;

package/dist/vscode-lean4/vscode-lean4/src/diagnostics/setupDiagnoser.js

@@ -0,0 +1,180 @@
+import * as os from 'os';
+import { SemVer } from 'semver';
+import { extensions, version } from 'vscode';
+import { ExecutionExitCode, batchExecute, batchExecuteWithProgress } from '../utils/batch';
+import { checkParentFoldersForLeanProject, isValidLeanProject } from '../utils/projectInfo';
+const recommendedElanVersion = new SemVer('3.1.1');
+// Should be bumped in a release *before* we bump the version requirement of the VS Code extension so that
+// users know that they need to update and do not get stuck on an old VS Code version.
+const recommendedVSCodeVersion = new SemVer('1.75.0');
+export function versionQueryResult(executionResult, versionRegex) {
+    if (executionResult.exitCode === ExecutionExitCode.CannotLaunch) {
+        return { kind: 'CommandNotFound' };
+    }
+    if (executionResult.exitCode === ExecutionExitCode.ExecutionError) {
+        return { kind: 'CommandError', message: executionResult.combined };
+    }
+    const match = versionRegex.exec(executionResult.stdout);
+    if (!match) {
+        return { kind: 'InvalidVersion', versionResult: executionResult.stdout };
+    }
+    return { kind: 'Success', version: new SemVer(match[1]) };
+}
+export function checkElanVersion(elanVersionResult) {
+    switch (elanVersionResult.kind) {
+        case 'CommandNotFound':
+            return { kind: 'NotInstalled' };
+        case 'CommandError':
+            return { kind: 'ExecutionError', message: elanVersionResult.message };
+        case 'InvalidVersion':
+            return {
+                kind: 'ExecutionError',
+                message: `Invalid Elan version format: '${elanVersionResult.versionResult}'`,
+            };
+        case 'Success':
+            if (elanVersionResult.version.compare(recommendedElanVersion) < 0) {
+                return {
+                    kind: 'Outdated',
+                    currentVersion: elanVersionResult.version,
+                    recommendedVersion: recommendedElanVersion,
+                };
+            }
+            return { kind: 'UpToDate', version: elanVersionResult.version };
+    }
+}
+export function checkLeanVersion(leanVersionResult) {
+    if (leanVersionResult.kind === 'CommandNotFound') {
+        return { kind: 'NotInstalled' };
+    }
+    if (leanVersionResult.kind === 'CommandError') {
+        return {
+            kind: 'ExecutionError',
+            message: leanVersionResult.message,
+        };
+    }
+    if (leanVersionResult.kind === 'InvalidVersion') {
+        return {
+            kind: 'ExecutionError',
+            message: `Invalid Lean version format: '${leanVersionResult.versionResult}'`,
+        };
+    }
+    const leanVersion = leanVersionResult.version;
+    if (leanVersion.major === 3) {
+        return { kind: 'IsLean3Version', version: leanVersion };
+    }
+    if (leanVersion.major === 4 && leanVersion.minor === 0 && leanVersion.prerelease.length > 0) {
+        return { kind: 'IsAncientLean4Version', version: leanVersion };
+    }
+    return { kind: 'UpToDate', version: leanVersion };
+}
+export class SetupDiagnoser {
+    channel;
+    cwdUri;
+    toolchain;
+    constructor(channel, cwdUri, toolchain) {
+        this.channel = channel;
+        this.cwdUri = cwdUri;
+        this.toolchain = toolchain;
+    }
+    async checkCurlAvailable() {
+        const curlVersionResult = await this.runSilently('curl', ['--version']);
+        return curlVersionResult.exitCode === ExecutionExitCode.Success;
+    }
+    async checkGitAvailable() {
+        const gitVersionResult = await this.runSilently('git', ['--version']);
+        return gitVersionResult.exitCode === ExecutionExitCode.Success;
+    }
+    async queryLakeVersion() {
+        const lakeVersionResult = await this.runLeanCommand('lake', ['--version'], 'Checking Lake version');
+        return versionQueryResult(lakeVersionResult, /version (\d+\.\d+\.\d+(\w|-)*)/);
+    }
+    async checkLakeAvailable() {
+        const lakeVersionResult = await this.queryLakeVersion();
+        return lakeVersionResult.kind === 'Success';
+    }
+    querySystemInformation() {
+        const cpuModels = os.cpus().map(cpu => cpu.model);
+        const groupedCpuModels = new Map();
+        for (const cpuModel of cpuModels) {
+            const counter = groupedCpuModels.get(cpuModel);
+            if (counter === undefined) {
+                groupedCpuModels.set(cpuModel, 1);
+            }
+            else {
+                groupedCpuModels.set(cpuModel, counter + 1);
+            }
+        }
+        const formattedCpuModels = Array.from(groupedCpuModels.entries())
+            .map(([cpuModel, amount]) => `${amount} x ${cpuModel}`)
+            .join(', ');
+        const totalMemory = (os.totalmem() / 1_000_000_000).toFixed(2);
+        return {
+            operatingSystem: `${os.type()} (release: ${os.release()})`,
+            cpuArchitecture: os.arch(),
+            cpuModels: formattedCpuModels,
+            totalMemory: `${totalMemory} GB`,
+        };
+    }
+    queryExtensionVersion() {
+        return new SemVer(extensions.getExtension('leanprover.lean4').packageJSON.version);
+    }
+    queryVSCodeVersion() {
+        const currentVSCodeVersion = new SemVer(version);
+        if (currentVSCodeVersion.compare(recommendedVSCodeVersion) < 0) {
+            return {
+                kind: 'Outdated',
+                currentVersion: currentVSCodeVersion,
+                recommendedVersion: recommendedVSCodeVersion,
+            };
+        }
+        return { kind: 'UpToDate', version: currentVSCodeVersion };
+    }
+    async queryLeanVersion() {
+        const leanVersionResult = await this.runLeanCommand('lean', ['--version'], 'Checking Lean version');
+        return versionQueryResult(leanVersionResult, /version (\d+\.\d+\.\d+(\w|-)*)/);
+    }
+    async queryElanVersion() {
+        const elanVersionResult = await this.runSilently('elan', ['--version']);
+        return versionQueryResult(elanVersionResult, /elan (\d+\.\d+\.\d+)/);
+    }
+    async queryElanShow() {
+        return await this.runSilently('elan', ['show']);
+    }
+    async elanVersion() {
+        const elanVersionResult = await this.queryElanVersion();
+        return checkElanVersion(elanVersionResult);
+    }
+    async projectSetup() {
+        if (this.cwdUri === undefined) {
+            return { kind: 'SingleFile' };
+        }
+        if (!(await isValidLeanProject(this.cwdUri))) {
+            const parentProjectFolder = await checkParentFoldersForLeanProject(this.cwdUri);
+            return { kind: 'MissingLeanToolchain', folder: this.cwdUri, parentProjectFolder };
+        }
+        return { kind: 'ValidProjectSetup', projectFolder: this.cwdUri };
+    }
+    async leanVersion() {
+        const leanVersionResult = await this.queryLeanVersion();
+        return checkLeanVersion(leanVersionResult);
+    }
+    async runSilently(executablePath, args) {
+        return batchExecute(executablePath, args, this.cwdUri?.fsPath, { combined: this.channel });
+    }
+    async runWithProgress(executablePath, args, title) {
+        return batchExecuteWithProgress(executablePath, args, title, {
+            cwd: this.cwdUri?.fsPath,
+            channel: this.channel,
+        });
+    }
+    async runLeanCommand(executablePath, args, title) {
+        const leanArgs = [...args];
+        if (this.toolchain !== undefined) {
+            leanArgs.unshift(`+${this.toolchain}`);
+        }
+        return await this.runWithProgress(executablePath, leanArgs, title);
+    }
+}
+export function diagnose(channel, cwdUri, toolchain) {
+    return new SetupDiagnoser(channel, cwdUri, toolchain);
+}

package/dist/vscode-lean4/vscode-lean4/src/diagnostics/setupDiagnostics.d.ts

@@ -0,0 +1,21 @@
+import { OutputChannel } from 'vscode';
+import { ExtUri, FileUri } from '../utils/exturi';
+import { LeanInstaller } from '../utils/leanInstaller';
+import { PreconditionCheckResult } from './setupNotifs';
+export declare function checkAll(...checks: (() => Promise<PreconditionCheckResult>)[]): Promise<PreconditionCheckResult>;
+export declare function checkAreDependenciesInstalled(channel: OutputChannel, cwdUri: FileUri | undefined): Promise<PreconditionCheckResult>;
+export declare function checkIsLean4Installed(installer: LeanInstaller, cwdUri: FileUri | undefined): Promise<PreconditionCheckResult>;
+export declare function checkIsElanUpToDate(installer: LeanInstaller, cwdUri: FileUri | undefined, options: {
+    elanMustBeInstalled: boolean;
+    modal: boolean;
+}): Promise<PreconditionCheckResult>;
+export declare function checkIsValidProjectFolder(channel: OutputChannel, folderUri: ExtUri): Promise<PreconditionCheckResult>;
+export declare function checkIsLeanVersionUpToDate(channel: OutputChannel, folderUri: ExtUri, options: {
+    toolchainOverride?: string | undefined;
+    modal: boolean;
+}): Promise<PreconditionCheckResult>;
+export declare function checkIsLakeInstalledCorrectly(channel: OutputChannel, folderUri: ExtUri, options: {
+    toolchainOverride?: string | undefined;
+}): Promise<PreconditionCheckResult>;
+export declare function checkIsVSCodeUpToDate(): Promise<PreconditionCheckResult>;
+export declare function checkLean4ProjectPreconditions(channel: OutputChannel, folderUri: ExtUri): Promise<PreconditionCheckResult>;

package/dist/vscode-lean4/vscode-lean4/src/diagnostics/setupDiagnostics.js

@@ -0,0 +1,150 @@
+import { commands } from 'vscode';
+import { extUriToCwdUri } from '../utils/exturi';
+import { willUseLakeServer } from '../utils/projectInfo';
+import { diagnose } from './setupDiagnoser';
+import { displayDependencySetupError, displayElanOutdatedSetupWarning, displayElanSetupError, displayElanSetupWarning, displaySetupError, displaySetupErrorWithOutput, displaySetupWarning, displaySetupWarningWithOptionalInput, displaySetupWarningWithOutput, worstPreconditionViolation, } from './setupNotifs';
+export async function checkAll(...checks) {
+    let worstViolation = 'Fulfilled';
+    for (const check of checks) {
+        const result = await check();
+        worstViolation = worstPreconditionViolation(worstViolation, result);
+        if (worstViolation === 'Fatal') {
+            return 'Fatal';
+        }
+    }
+    return worstViolation;
+}
+const singleFileWarningMessage = `Lean 4 server is operating in restricted single file mode.
+Please open a valid Lean 4 project containing a \'lean-toolchain\' file for full functionality.
+Click the following link to learn how to set up or open Lean projects: [(Show Setup Guide)](command:lean4.docs.showSetupGuide)`;
+const missingLeanToolchainWarningMessage = `Opened folder does not contain a valid Lean 4 project.
+Please open a valid Lean 4 project containing a \'lean-toolchain\' file for full functionality.
+Click the following link to learn how to set up or open Lean projects: [(Show Setup Guide)](command:lean4.docs.showSetupGuide)`;
+const missingLeanToolchainWithParentProjectWarningMessage = (parentProjectFolder) => `Opened folder does not contain a valid Lean 4 project folder because it does not contain a 'lean-toolchain' file.
+However, a valid Lean 4 project folder was found in one of the parent directories at '${parentProjectFolder.fsPath}'.
+Open this project instead?`;
+const lean3ProjectErrorMessage = (origin, projectVersion) => `${origin} is using Lean 3 (version: ${projectVersion.toString()}).
+If you want to use Lean 3, disable this extension ('Extensions' in the left sidebar > Cog icon on 'lean4' > 'Disable') and install the 'lean' extension for Lean 3 support.`;
+const ancientLean4ProjectWarningMessage = (origin, projectVersion) => `${origin} is using a Lean 4 version (${projectVersion.toString()}) from before the first Lean 4 stable release (4.0.0).
+Pre-stable Lean 4 versions are increasingly less supported, so please consider updating to a newer Lean 4 version.`;
+export async function checkAreDependenciesInstalled(channel, cwdUri) {
+    const missingDeps = [];
+    if (!(await diagnose(channel, cwdUri).checkCurlAvailable())) {
+        missingDeps.push('curl');
+    }
+    if (!(await diagnose(channel, cwdUri).checkGitAvailable())) {
+        missingDeps.push('git');
+    }
+    if (missingDeps.length === 0) {
+        return 'Fulfilled';
+    }
+    displayDependencySetupError(missingDeps);
+    return 'Fatal';
+}
+export async function checkIsLean4Installed(installer, cwdUri) {
+    const leanVersionResult = await diagnose(installer.getOutputChannel(), cwdUri).queryLeanVersion();
+    switch (leanVersionResult.kind) {
+        case 'Success':
+            return 'Fulfilled';
+        case 'CommandError':
+            return displaySetupErrorWithOutput(`Error while checking Lean version: ${leanVersionResult.message}`);
+        case 'InvalidVersion':
+            return displaySetupErrorWithOutput(`Error while checking Lean version: 'lean --version' returned a version that could not be parsed: '${leanVersionResult.versionResult}'`);
+        case 'CommandNotFound':
+            return await displayElanSetupError(installer, 'Lean is not installed.');
+    }
+}
+export async function checkIsElanUpToDate(installer, cwdUri, options) {
+    const elanDiagnosis = await diagnose(installer.getOutputChannel(), cwdUri).elanVersion();
+    switch (elanDiagnosis.kind) {
+        case 'NotInstalled':
+            if (options.elanMustBeInstalled) {
+                return await displayElanSetupError(installer, "Lean's version manager Elan is not installed.");
+            }
+            return await displayElanSetupWarning(installer, "Lean's version manager Elan is not installed. This means that the correct Lean 4 toolchain version of Lean 4 projects will not be selected or installed automatically.");
+        case 'ExecutionError':
+            return await displaySetupWarningWithOutput('Cannot determine Elan version: ' + elanDiagnosis.message, {
+                modal: options.modal,
+            });
+        case 'Outdated':
+            return await displayElanOutdatedSetupWarning(installer, elanDiagnosis.currentVersion, elanDiagnosis.recommendedVersion);
+        case 'UpToDate':
+            return 'Fulfilled';
+    }
+}
+export async function checkIsValidProjectFolder(channel, folderUri) {
+    const projectSetupDiagnosis = await diagnose(channel, extUriToCwdUri(folderUri)).projectSetup();
+    switch (projectSetupDiagnosis.kind) {
+        case 'SingleFile':
+            return await displaySetupWarning(singleFileWarningMessage);
+        case 'MissingLeanToolchain':
+            const parentProjectFolder = projectSetupDiagnosis.parentProjectFolder;
+            if (parentProjectFolder === undefined) {
+                return await displaySetupWarning(missingLeanToolchainWarningMessage);
+            }
+            else {
+                return displaySetupWarningWithOptionalInput(missingLeanToolchainWithParentProjectWarningMessage(parentProjectFolder), 'Open Parent Directory Project', 
+                // this kills the extension host
+                () => commands.executeCommand('vscode.openFolder', parentProjectFolder));
+            }
+        case 'ValidProjectSetup':
+            return 'Fulfilled';
+    }
+}
+export async function checkIsLeanVersionUpToDate(channel, folderUri, options) {
+    let origin;
+    if (options.toolchainOverride !== undefined) {
+        origin = `Project toolchain '${options.toolchainOverride}'`;
+    }
+    else if (folderUri.scheme === 'untitled') {
+        origin = 'Opened file';
+    }
+    else {
+        origin = 'Opened project';
+    }
+    const projectLeanVersionDiagnosis = await diagnose(channel, extUriToCwdUri(folderUri), options.toolchainOverride).leanVersion();
+    switch (projectLeanVersionDiagnosis.kind) {
+        case 'NotInstalled':
+            return displaySetupErrorWithOutput("Error while checking Lean version: 'lean' command was not found.");
+        case 'ExecutionError':
+            return displaySetupErrorWithOutput(`Error while checking Lean version: ${projectLeanVersionDiagnosis.message}`);
+        case 'IsLean3Version':
+            return displaySetupError(lean3ProjectErrorMessage(origin, projectLeanVersionDiagnosis.version));
+        case 'IsAncientLean4Version':
+            return await displaySetupWarning(ancientLean4ProjectWarningMessage(origin, projectLeanVersionDiagnosis.version), {
+                modal: options.modal,
+            });
+        case 'UpToDate':
+            return 'Fulfilled';
+    }
+}
+export async function checkIsLakeInstalledCorrectly(channel, folderUri, options) {
+    const lakeVersionResult = await diagnose(channel, extUriToCwdUri(folderUri), options.toolchainOverride).queryLakeVersion();
+    switch (lakeVersionResult.kind) {
+        case 'CommandNotFound':
+            return displaySetupErrorWithOutput("Error while checking Lake version: 'lake' command was not found.");
+        case 'CommandError':
+            return displaySetupErrorWithOutput(`Error while checking Lake version: ${lakeVersionResult.message}`);
+        case 'InvalidVersion':
+            return displaySetupErrorWithOutput(`Error while checking Lake version: Invalid Lake version format: '${lakeVersionResult.versionResult}'`);
+        case 'Success':
+            return 'Fulfilled';
+    }
+}
+export async function checkIsVSCodeUpToDate() {
+    const vscodeVersionResult = diagnose(undefined, undefined).queryVSCodeVersion();
+    switch (vscodeVersionResult.kind) {
+        case 'Outdated':
+            return displaySetupWarning(`VS Code version is too out-of-date for new versions of the Lean 4 VS Code extension. The current VS Code version is ${vscodeVersionResult.currentVersion}, but at least a version of ${vscodeVersionResult.recommendedVersion} is recommended so that new versions of the Lean 4 VS Code extension can be installed.`);
+        case 'UpToDate':
+            return 'Fulfilled';
+    }
+}
+export async function checkLean4ProjectPreconditions(channel, folderUri) {
+    return await checkAll(() => checkIsValidProjectFolder(channel, folderUri), () => checkIsLeanVersionUpToDate(channel, folderUri, { modal: false }), async () => {
+        if (!(await willUseLakeServer(folderUri))) {
+            return 'Fulfilled';
+        }
+        return await checkIsLakeInstalledCorrectly(channel, folderUri, {});
+    });
+}

package/dist/vscode-lean4/vscode-lean4/src/utils/clientProvider.d.ts

@@ -6,8 +6,8 @@ import { LeanClient } from '../leanclient';
 import { ExtUri } from './exturi';
 import { LeanInstaller } from './leanInstaller';
 export declare class LeanClientProvider implements Disposable {
-    private setupClient;
     private checkLean4ProjectPreconditions;
+    private setupClient;
     private subscriptions;
     private outputChannel;
     private installer;
@@ -24,7 +24,7 @@ export declare class LeanClientProvider implements Disposable {
     clientRemoved: import("vscode").Event<LeanClient>;
     private clientStoppedEmitter;
     clientStopped: import("vscode").Event<[LeanClient, boolean, ServerStoppedReason]>;
-    constructor(installer: LeanInstaller, outputChannel: OutputChannel, setupClient: (clientOptions: LanguageClientOptions, folderUri: ExtUri, elanDefaultToolchain: string) => Promise<BaseLanguageClient>, checkLean4ProjectPreconditions: (channel: OutputChannel, folderUri: ExtUri) => Promise<PreconditionCheckResult>);
+    constructor(installer: LeanInstaller, outputChannel: OutputChannel, checkLean4ProjectPreconditions: (channel: OutputChannel, folderUri: ExtUri) => Promise<PreconditionCheckResult>, setupClient: (clientOptions: LanguageClientOptions, folderUri: ExtUri, elanDefaultToolchain: string) => Promise<BaseLanguageClient>);
     getActiveClient(): LeanClient | undefined;
     private onInstallChanged;
     private restartFile;

package/dist/vscode-lean4/vscode-lean4/src/utils/clientProvider.js

@@ -6,8 +6,8 @@ import { displayError } from './notifs';
 import { findLeanProjectRoot } from './projectInfo';
 // This class ensures we have one LeanClient per folder.
 export class LeanClientProvider {
-    setupClient;
     checkLean4ProjectPreconditions;
+    setupClient;
     subscriptions = [];
     outputChannel;
     installer;
@@ -24,9 +24,9 @@ export class LeanClientProvider {
     clientRemoved = this.clientRemovedEmitter.event;
     clientStoppedEmitter = new EventEmitter();
     clientStopped = this.clientStoppedEmitter.event;
-    constructor(installer, outputChannel, setupClient, checkLean4ProjectPreconditions) {
-        this.setupClient = setupClient;
+    constructor(installer, outputChannel, checkLean4ProjectPreconditions, setupClient) {
         this.checkLean4ProjectPreconditions = checkLean4ProjectPreconditions;
+        this.setupClient = setupClient;
         this.outputChannel = outputChannel;
         this.installer = installer;
         // we must setup the installChanged event handler first before any didOpenEditor calls.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lean4monaco",
-  "version": "1.0.27",
+  "version": "1.0.28",
   "description": "Monaco Editor support for the Lean 4 theorem prover.",
   "keywords": [
     "lean",
@@ -40,7 +40,7 @@
     "test": "(cd demo && npm install && npm run build_server) && concurrently --kill-others \"npm start 1> /dev/null\" \"wait-on http://localhost:5173 && cypress run\" -n server,cypress -s command-cypress"
   },
   "dependencies": {
-    "@leanprover/infoview": "^0.7.0",
+    "@leanprover/infoview": "^0.7.3",
     "@leanprover/infoview-api": "^0.4.0",
     "@leanprover/unicode-input": "^0.1.0",
     "concurrently": "^8.2.2",