lean4monaco 1.0.45 → 1.0.46

package/dist/vscode-lean4/vscode-lean4/node_modules/vscode-languageserver-protocol/package.json

@@ -1,45 +0,0 @@
-{
-	"name": "vscode-languageserver-protocol",
-	"description": "VSCode Language Server Protocol implementation",
-	"version": "3.17.3",
-	"author": "Microsoft Corporation",
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/Microsoft/vscode-languageserver-node.git",
-		"directory": "protocol"
-	},
-	"bugs": {
-		"url": "https://github.com/Microsoft/vscode-languageserver-node/issues"
-	},
-	"main": "./lib/node/main.js",
-	"browser": {
-		"./lib/node/main.js": "./lib/browser/main.js"
-	},
-	"typings": "./lib/common/api.d.ts",
-	"dependencies": {
-		"vscode-jsonrpc": "8.1.0",
-		"vscode-languageserver-types": "3.17.3"
-	},
-	"scripts": {
-		"prepublishOnly": "echo \"⛔ Can only publish from a secure pipeline ⛔\" && node ../build/npm/fail",
-		"prepack": "npm run all:publish",
-		"postpublish": "node ../build/npm/post-publish.js",
-		"preversion": "npm test",
-		"compile": "node ../build/bin/tsc -b ./tsconfig.json",
-		"watch": "node ../build/bin/tsc -b ./tsconfig.watch.json -w",
-		"clean": "node ../node_modules/rimraf/bin.js lib && node ../node_modules/rimraf/bin.js dist",
-		"lint": "node ../node_modules/eslint/bin/eslint.js --ext ts src",
-		"test": "npm run test:node && npm run test:browser",
-		"test:node": "node ../node_modules/mocha/bin/_mocha",
-		"test:browser": "npm run webpack:test:silent && node ../build/bin/runBrowserTests.js  http://127.0.0.1:8080/protocol/src/browser/test/",
-		"webpack:test": "cd ../types && npm run compile:esm && cd ../protocol && node ../build/bin/webpack --mode none --config ./src/browser/test/webpack.config.js",
-		"webpack:test:silent": "cd ../types && npm run compile:esm && cd ../protocol && node ../build/bin/webpack --no-stats --mode none --config ./src/browser/test/webpack.config.js",
-		"compile:metaModelTool": "cd ../tools && npm run compile && cd ../protocol",
-		"generate:metaModel": "node ../tools/lib/generator-main.js -p ./src/common/tsconfig.json > ./metaModel.json",
-		"generate:metaModelSchema": "ts-json-schema-generator --path ../tools/src/metaModel.ts > ./metaModel.schema.json",
-		"all": "npm run clean && npm run compile && npm run lint && npm run test && npm run compile:metaModelTool && npm run generate:metaModel && npm run generate:metaModelSchema",
-		"compile:publish": "node ../build/bin/tsc -b ./tsconfig.publish.json",
-		"all:publish": "git clean -xfd . && npm install && npm run compile:publish && npm run lint && npm run test && npm run compile:metaModelTool && npm run generate:metaModel && npm run generate:metaModelSchema"
-	}
-}

package/dist/vscode-lean4/vscode-lean4/node_modules/vscode-languageserver-types/package.json

@@ -1,32 +0,0 @@
-{
-	"name": "vscode-languageserver-types",
-	"description": "Types used by the Language server for node",
-	"version": "3.17.3",
-	"author": "Microsoft Corporation",
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/Microsoft/vscode-languageserver-node.git",
-		"directory": "types"
-	},
-	"bugs": {
-		"url": "https://github.com/Microsoft/vscode-languageserver-node/issues"
-	},
-	"main": "./lib/umd/main.js",
-	"typings": "./lib/umd/main",
-	"module": "./lib/esm/main.js",
-	"scripts": {
-		"prepublishOnly": "echo \"⛔ Can only publish from a secure pipeline ⛔\" && node ../build/npm/fail",
-		"prepack": "npm run all:publish",
-		"compile": "node ../build/bin/tsc -b ./tsconfig.json",
-		"clean": "node ../node_modules/rimraf/bin.js lib",
-		"watch": "node ../build/bin/tsc -b ./tsconfig.watch.json -w",
-		"lint": "node ../node_modules/eslint/bin/eslint.js --ext ts src",
-		"test": "node ../node_modules/mocha/bin/_mocha",
-		"all": "npm run clean && npm run compile && npm run lint && npm run test",
-		"compile:esm": "node ../build/bin/tsc -b ./tsconfig.esm.publish.json",
-		"compile:umd": "node ../build/bin/tsc -b ./tsconfig.umd.publish.json",
-		"all:publish": "git clean -xfd . && npm install && npm run compile:esm && npm run compile:umd && npm run lint && npm run test",
-		"preversion": "npm test"
-	}
-}

package/dist/vscode-lean4/vscode-lean4/src/leanclientsetup.d.ts

@@ -1,3 +0,0 @@
-import { LanguageClient, LanguageClientOptions } from 'vscode-languageclient/node';
-import { ExtUri } from './utils/exturi';
-export declare function setupClient(toolchainOverride: string | undefined, folderUri: ExtUri, clientOptions: LanguageClientOptions): Promise<LanguageClient>;

package/dist/vscode-lean4/vscode-lean4/src/leanclientsetup.js

@@ -1,58 +0,0 @@
-import { LanguageClient, } from 'vscode-languageclient/node';
-import { serverArgs, serverLoggingEnabled, serverLoggingPath } from './config';
-import { patchConverters } from './utils/converters';
-import { willUseLakeServer } from './utils/projectInfo';
-const leanClientCapabilities = {
-    silentDiagnosticSupport: true,
-};
-async function determineExecutable(folderUri) {
-    if (await willUseLakeServer(folderUri)) {
-        return ['lake', ['serve', '--']];
-    }
-    else {
-        return ['lean', ['--server']];
-    }
-}
-async function determineServerOptions(toolchainOverride, folderUri) {
-    const env = Object.assign({}, process.env);
-    if (serverLoggingEnabled()) {
-        env.LEAN_SERVER_LOG_DIR = serverLoggingPath();
-    }
-    const [serverExecutable, options] = await determineExecutable(folderUri);
-    if (toolchainOverride) {
-        options.unshift('+' + toolchainOverride);
-    }
-    const cwd = folderUri.scheme === 'file' ? folderUri.fsPath : undefined;
-    if (cwd) {
-        // Add folder name to command-line so that it shows up in `ps aux`.
-        options.push(cwd);
-    }
-    else {
-        options.push('untitled');
-    }
-    return {
-        command: serverExecutable,
-        args: options.concat(serverArgs()),
-        options: {
-            cwd,
-            env,
-        },
-    };
-}
-export async function setupClient(toolchainOverride, folderUri, clientOptions) {
-    const serverOptions = await determineServerOptions(toolchainOverride, folderUri);
-    const client = new LanguageClient('lean4', 'Lean 4', serverOptions, clientOptions);
-    const leanCapabilityFeature = {
-        initialize(_1, _2) { },
-        getState() {
-            return { kind: 'static' };
-        },
-        fillClientCapabilities(capabilities) {
-            capabilities.lean = leanClientCapabilities;
-        },
-        dispose() { },
-    };
-    client.registerFeature(leanCapabilityFeature);
-    patchConverters(client.protocol2CodeConverter, client.code2ProtocolConverter);
-    return client;
-}

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

@@ -1,40 +0,0 @@
-import { OutputChannel } from 'vscode';
-export interface ExecutionChannel {
-    combined?: OutputChannel | undefined;
-    stdout?: OutputChannel | undefined;
-    stderr?: OutputChannel | undefined;
-}
-export declare enum ExecutionExitCode {
-    Success = 0,
-    CannotLaunch = 1,
-    ExecutionError = 2,
-    Cancelled = 3
-}
-export interface ExecutionResult {
-    exitCode: ExecutionExitCode;
-    stdout: string;
-    stderr: string;
-    combined: string;
-}
-export declare function createCannotLaunchExecutionResult(message: string): ExecutionResult;
-export interface ProgressExecutionOptions {
-    cwd?: string | undefined;
-    channel?: OutputChannel | undefined;
-    translator?: ((line: string) => string | undefined) | undefined;
-    envExtensions?: {
-        [key: string]: string;
-    } | undefined;
-    allowCancellation?: boolean;
-}
-export type ExecutionHandler = () => Promise<ExecutionResult>;
-export interface BatchExecution {
-    execute: ExecutionHandler;
-    optional?: boolean | undefined;
-}
-export declare function executeAll(executions: BatchExecution[]): Promise<ExecutionResult[]>;
-export declare function displayResultError(result: ExecutionResult, message: string): void;
-export declare function formatErrorMessage(error: ExecutionResult, message: string): string;
-export declare function batchExecuteDummy(executablePath: string, args: string[], workingDirectory?: string | undefined, channel?: ExecutionChannel | undefined, envExtensions?: {
-    [key: string]: string;
-} | undefined): Promise<ExecutionResult>;
-export declare function batchExecuteWithProgressDummy(executablePath: string, args: string[], context: string | undefined, title: string, options?: ProgressExecutionOptions): Promise<ExecutionResult>;

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

@@ -1,48 +0,0 @@
-import { displayNotificationWithOutput } from './notifs';
-export var ExecutionExitCode;
-(function (ExecutionExitCode) {
-    ExecutionExitCode[ExecutionExitCode["Success"] = 0] = "Success";
-    ExecutionExitCode[ExecutionExitCode["CannotLaunch"] = 1] = "CannotLaunch";
-    ExecutionExitCode[ExecutionExitCode["ExecutionError"] = 2] = "ExecutionError";
-    ExecutionExitCode[ExecutionExitCode["Cancelled"] = 3] = "Cancelled";
-})(ExecutionExitCode || (ExecutionExitCode = {}));
-export function createCannotLaunchExecutionResult(message) {
-    return {
-        exitCode: ExecutionExitCode.CannotLaunch,
-        stdout: message,
-        stderr: '',
-        combined: message,
-    };
-}
-export async function executeAll(executions) {
-    const results = [];
-    for (const execution of executions) {
-        const result = await execution.execute();
-        results.push(result);
-        if (execution.optional !== true && result.exitCode !== ExecutionExitCode.Success) {
-            break;
-        }
-    }
-    return results;
-}
-export function displayResultError(result, message) {
-    if (result.exitCode === ExecutionExitCode.Success) {
-        throw Error();
-    }
-    const errorMessage = formatErrorMessage(result, message);
-    displayNotificationWithOutput('Error', errorMessage);
-}
-export function formatErrorMessage(error, message) {
-    if (error.combined === '') {
-        return `${message}`;
-    }
-    return `${message} Command output: ${error.combined}`;
-}
-export async function batchExecuteDummy(executablePath, args, workingDirectory, channel, envExtensions) {
-    return { exitCode: ExecutionExitCode.Success, stdout: "sample stdout", stderr: "sample stderr", combined: "sample stdout and stderr" };
-    // const [_, execPromise] = batchExecuteWithProc(executablePath, args, workingDirectory, channel, envExtensions)
-    // return execPromise
-}
-export async function batchExecuteWithProgressDummy(executablePath, args, context, title, options = {}) {
-    return { exitCode: ExecutionExitCode.Success, stdout: "sample stdout", stderr: "sample stderr", combined: "sample stdout and stderr" };
-}

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

@@ -1,14 +0,0 @@
-export declare enum ExecutionExitCode {
-    Success = 0,
-    CannotLaunch = 1,
-    ExecutionError = 2,
-    Cancelled = 3
-}
-export interface ExecutionResult {
-    exitCode: ExecutionExitCode;
-    stdout: string;
-    stderr: string;
-    combined: string;
-}
-export declare function displayResultError(result: ExecutionResult, message: string): void;
-export declare const dummyExecutionResult: ExecutionResult;

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

@@ -1,22 +0,0 @@
-import { displayNotificationWithOutput } from './notifs';
-export var ExecutionExitCode;
-(function (ExecutionExitCode) {
-    ExecutionExitCode[ExecutionExitCode["Success"] = 0] = "Success";
-    ExecutionExitCode[ExecutionExitCode["CannotLaunch"] = 1] = "CannotLaunch";
-    ExecutionExitCode[ExecutionExitCode["ExecutionError"] = 2] = "ExecutionError";
-    ExecutionExitCode[ExecutionExitCode["Cancelled"] = 3] = "Cancelled";
-})(ExecutionExitCode || (ExecutionExitCode = {}));
-export function displayResultError(result, message) {
-    if (result.exitCode === ExecutionExitCode.Success) {
-        throw Error();
-    }
-    const errorMessage = formatErrorMessage(result, message);
-    displayNotificationWithOutput('Error', errorMessage);
-}
-function formatErrorMessage(error, message) {
-    if (error.combined === '') {
-        return `${message}`;
-    }
-    return `${message} Command output: ${error.combined}`;
-}
-export const dummyExecutionResult = { exitCode: ExecutionExitCode.ExecutionError, stdout: "", stderr: "", combined: "" };

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

@@ -1,2 +0,0 @@
-export declare function groupByKey<K, V>(values: V[], key: (value: V) => K): Map<K, V[]>;
-export declare function groupByUniqueKey<K, V>(values: V[], key: (value: V) => K): Map<K, V>;

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

@@ -1,17 +0,0 @@
-export function groupByKey(values, key) {
-    const r = new Map();
-    for (const v of values) {
-        const k = key(v);
-        const group = r.get(k) ?? [];
-        group.push(v);
-        r.set(k, group);
-    }
-    return r;
-}
-export function groupByUniqueKey(values, key) {
-    const r = new Map();
-    for (const v of values) {
-        r.set(key(v), v);
-    }
-    return r;
-}

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

@@ -1,34 +0,0 @@
-import { ExtensionContext, OutputChannel } from 'vscode';
-import { ExecutionResult } from './batch';
-import { FileUri } from './exturi';
-export type ToolchainUpdateMode = 'UpdateAutomatically' | 'PromptAboutUpdate' | 'DoNotUpdate';
-export type ToolchainDecisionOptions = {
-    channel: OutputChannel | undefined;
-    cwdUri: FileUri | undefined;
-    context: string | undefined;
-    toolchainUpdateMode: ToolchainUpdateMode;
-    toolchain?: string | undefined;
-};
-export type LeanCommandOptions = ToolchainDecisionOptions & {
-    waitingPrompt: string;
-    translator?: ((line: string) => string | undefined) | undefined;
-};
-export declare class LeanCommandRunner {
-    private stickyUpdateDecisions;
-    private runCmd;
-    private analyzeElanStateDumpWithoutNetResult;
-    private analyzeElanDumpStateWithNetResult;
-    decideToolchain(options: ToolchainDecisionOptions): Promise<{
-        kind: 'RunWithActiveToolchain';
-    } | {
-        kind: 'RunWithSpecificToolchain';
-        toolchain: string;
-    } | {
-        kind: 'Error';
-        message: string;
-    }>;
-    runLeanCommand(executablePath: string, args: string[], options: LeanCommandOptions): Promise<ExecutionResult>;
-}
-export declare let leanRunner: LeanCommandRunner;
-/** Must be called at the very start when the extension is activated so that `leanRunner` is defined. */
-export declare function registerLeanCommandRunner(context: ExtensionContext): void;

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

@@ -1,249 +0,0 @@
-import path from 'path';
-import { alwaysAskBeforeInstallingLeanVersions } from '../config';
-import { batchExecuteWithProgress, ExecutionExitCode } from './batch';
-import { elanDumpStateWithNet, elanDumpStateWithoutNet, elanInstallToolchain, ElanToolchains, ElanUnresolvedToolchain, } from './elan';
-import { displayNotification, displayNotificationWithInput } from './notifs';
-function shouldUpdateToolchainAutomatically(mode) {
-    return !alwaysAskBeforeInstallingLeanVersions() && mode === 'UpdateAutomatically';
-}
-function overrideReason(activeOverride) {
-    switch (activeOverride?.kind) {
-        case undefined:
-            return undefined;
-        case 'Environment':
-            return undefined;
-        case 'Manual':
-            return `set by \`elan override\` in folder '${path.basename(activeOverride.directoryPath.fsPath)}'`;
-        case 'ToolchainFile':
-            return `of Lean project '${path.dirname(activeOverride.toolchainPath.fsPath)}'`;
-        case 'LeanpkgFile':
-            return `of Lean project '${path.dirname(activeOverride.leanpkgPath.fsPath)}'`;
-        case 'ToolchainDirectory':
-            return `of Lean project '${activeOverride.directoryPath.fsPath}'`;
-    }
-}
-function leanNotInstalledError(activeOverride, unresolvedActiveToolchain) {
-    const or = overrideReason(activeOverride);
-    const formattedOverride = or !== undefined ? ' ' + or : '';
-    if (unresolvedActiveToolchain.fromChannel !== undefined) {
-        const prefix = activeOverride === undefined ? 'default ' : '';
-        return `No Lean version for ${prefix}release channel '${ElanUnresolvedToolchain.toolchainName(unresolvedActiveToolchain)}'${formattedOverride} is installed.`;
-    }
-    else {
-        const prefix = activeOverride === undefined ? 'Default ' : '';
-        return `${prefix}Lean version '${ElanUnresolvedToolchain.toolchainName(unresolvedActiveToolchain)}'${formattedOverride} is not installed.`;
-    }
-}
-function installationPrompt(activeOverride, unresolvedActiveToolchain) {
-    const error = leanNotInstalledError(activeOverride, unresolvedActiveToolchain);
-    if (unresolvedActiveToolchain.fromChannel !== undefined) {
-        return `${error}\n\n` + 'Do you wish to install one?';
-    }
-    else {
-        return `${error}\n\n` + 'Do you wish to install it?';
-    }
-}
-function updatePrompt(activeOverride, releaseChannel, cachedActiveToolchain, resolvedActiveToolchain) {
-    const prefix = activeOverride === undefined ? 'default ' : '';
-    const reason = overrideReason(activeOverride);
-    return (`Installed Lean version '${cachedActiveToolchain}' for ${prefix}release channel '${releaseChannel}'${reason !== undefined ? ' ' + reason : ''} is outdated.\n\n` +
-        `Do you wish to install the new Lean version '${resolvedActiveToolchain}' or continue using the outdated Lean version?`);
-}
-function updateDecisionKey(cwdUri, cachedToolchain) {
-    return JSON.stringify({
-        cwdUri,
-        cachedToolchain,
-    });
-}
-export class LeanCommandRunner {
-    stickyUpdateDecisions = new Map();
-    async runCmd(executablePath, args, options, toolchain) {
-        const toolchainOverride = toolchain ?? options.toolchain;
-        if (toolchainOverride !== undefined) {
-            args = [`+${toolchainOverride}`, ...args];
-        }
-        return await batchExecuteWithProgress(executablePath, args, options.context, options.waitingPrompt, {
-            cwd: options.cwdUri?.fsPath,
-            channel: options.channel,
-            translator: options.translator,
-            allowCancellation: true,
-        });
-    }
-    async analyzeElanStateDumpWithoutNetResult(channel, context, r) {
-        const runWithActiveToolchain = { kind: 'RunWithActiveToolchain' };
-        let elanState;
-        switch (r.kind) {
-            case 'Success':
-                elanState = r.state;
-                break;
-            case 'ElanNotFound':
-                return runWithActiveToolchain;
-            case 'ExecutionError':
-                return runWithActiveToolchain;
-        }
-        const unresolvedToolchain = ElanToolchains.unresolvedToolchain(elanState.toolchains);
-        const toolchainResolutionResult = elanState.toolchains.resolvedActive;
-        if (unresolvedToolchain === undefined || toolchainResolutionResult === undefined) {
-            return runWithActiveToolchain;
-        }
-        if (unresolvedToolchain.kind === 'Local') {
-            return runWithActiveToolchain;
-        }
-        const cachedToolchain = toolchainResolutionResult.cachedToolchain;
-        if (cachedToolchain === undefined) {
-            const installNewToolchain = async () => {
-                const elanInstallToolchainResult = await elanInstallToolchain(channel, context, ElanUnresolvedToolchain.toolchainName(unresolvedToolchain));
-                switch (elanInstallToolchainResult.kind) {
-                    case 'Success':
-                    case 'ElanNotFound':
-                    case 'ToolchainAlreadyInstalled':
-                        return runWithActiveToolchain;
-                    case 'Error':
-                        return {
-                            kind: 'Error',
-                            message: leanNotInstalledError(elanState.toolchains.activeOverride?.reason, unresolvedToolchain) + ` Reason: Installation failed. Error: ${elanInstallToolchainResult.message}`,
-                        };
-                    case 'Cancelled':
-                        return {
-                            kind: 'Error',
-                            message: leanNotInstalledError(elanState.toolchains.activeOverride?.reason, unresolvedToolchain) + ' Reason: Installation was cancelled.',
-                        };
-                }
-            };
-            if (!alwaysAskBeforeInstallingLeanVersions()) {
-                return await installNewToolchain();
-            }
-            const choice = await displayNotificationWithInput('Information', installationPrompt(elanState.toolchains.activeOverride?.reason, unresolvedToolchain), ['Install Version']);
-            if (choice === undefined) {
-                return {
-                    kind: 'Error',
-                    message: leanNotInstalledError(elanState.toolchains.activeOverride?.reason, unresolvedToolchain),
-                };
-            }
-            choice;
-            return await installNewToolchain();
-        }
-        if (unresolvedToolchain.fromChannel === undefined) {
-            return runWithActiveToolchain;
-        }
-        return { kind: 'CheckForToolchainUpdate', cachedToolchain };
-    }
-    async analyzeElanDumpStateWithNetResult(channel, context, toolchainUpdateMode, cachedToolchain, r) {
-        const runWithActiveToolchain = { kind: 'RunWithActiveToolchain' };
-        const runWithCachedToolchain = warning => ({
-            kind: 'RunWithCachedToolchain',
-            warning,
-        });
-        let elanState;
-        switch (r.kind) {
-            case 'Success':
-                elanState = r.state;
-                break;
-            case 'ElanNotFound':
-                return runWithActiveToolchain;
-            case 'ExecutionError':
-                return runWithActiveToolchain;
-            case 'Cancelled':
-                return runWithCachedToolchain(`Lean version information query was cancelled, falling back to installed Lean version '${cachedToolchain}'.`);
-        }
-        const unresolvedToolchain = ElanToolchains.unresolvedToolchain(elanState.toolchains);
-        const toolchainResolutionResult = elanState.toolchains.resolvedActive;
-        if (unresolvedToolchain === undefined || toolchainResolutionResult === undefined) {
-            return runWithActiveToolchain;
-        }
-        if (unresolvedToolchain.kind === 'Local' || unresolvedToolchain.fromChannel === undefined) {
-            return runWithActiveToolchain;
-        }
-        const resolvedToolchainResult = toolchainResolutionResult.resolvedToolchain;
-        let resolvedToolchain;
-        switch (resolvedToolchainResult.kind) {
-            case 'Error':
-                return runWithCachedToolchain(`Could not fetch Lean version information, falling back to installed Lean version '${cachedToolchain}'. Error: ${resolvedToolchainResult.message}`);
-            case 'Ok':
-                resolvedToolchain = resolvedToolchainResult.value;
-                break;
-        }
-        const willActiveToolchainBeUpdated = cachedToolchain !== resolvedToolchain;
-        if (!willActiveToolchainBeUpdated) {
-            return runWithActiveToolchain;
-        }
-        const isResolvedToolchainAlreadyInstalled = elanState.toolchains.installed.has(resolvedToolchain);
-        if (isResolvedToolchainAlreadyInstalled) {
-            return runWithActiveToolchain;
-        }
-        const updateToolchain = async () => {
-            const elanInstallToolchainResult = await elanInstallToolchain(channel, context, ElanUnresolvedToolchain.toolchainName(unresolvedToolchain));
-            switch (elanInstallToolchainResult.kind) {
-                case 'Success':
-                case 'ElanNotFound':
-                case 'ToolchainAlreadyInstalled':
-                    return runWithActiveToolchain;
-                case 'Error':
-                    return runWithCachedToolchain(`Could not update Lean version, falling back to installed Lean version '${cachedToolchain}'. Error: ${elanInstallToolchainResult.message}`);
-                case 'Cancelled':
-                    return runWithCachedToolchain(`Lean version update was cancelled, falling back to installed Lean version '${cachedToolchain}'.`);
-            }
-        };
-        if (shouldUpdateToolchainAutomatically(toolchainUpdateMode)) {
-            return await updateToolchain();
-        }
-        const choice = await displayNotificationWithInput('Information', updatePrompt(elanState.toolchains.activeOverride?.reason, ElanUnresolvedToolchain.toolchainName(unresolvedToolchain), cachedToolchain, resolvedToolchain), ['Update Lean Version'], 'Use Old Version');
-        if (choice === undefined || choice === 'Use Old Version') {
-            return runWithCachedToolchain(undefined);
-        }
-        choice;
-        return await updateToolchain();
-    }
-    async decideToolchain(options) {
-        const elanStateDumpWithoutNetResult = await elanDumpStateWithoutNet(options.cwdUri, options.toolchain);
-        const withoutNetAnalysisResult = await this.analyzeElanStateDumpWithoutNetResult(options.channel, options.context, elanStateDumpWithoutNetResult);
-        if (withoutNetAnalysisResult.kind !== 'CheckForToolchainUpdate') {
-            return withoutNetAnalysisResult;
-        }
-        const cachedToolchain = withoutNetAnalysisResult.cachedToolchain;
-        const key = updateDecisionKey(options.cwdUri, cachedToolchain);
-        if (options.toolchainUpdateMode === 'DoNotUpdate' ||
-            (!shouldUpdateToolchainAutomatically(options.toolchainUpdateMode) &&
-                this.stickyUpdateDecisions.get(key) === 'DoNotUpdate')) {
-            return { kind: 'RunWithSpecificToolchain', toolchain: cachedToolchain };
-        }
-        const elanStateDumpWithNetResult = await elanDumpStateWithNet(options.cwdUri, options.context, options.toolchain);
-        const withNetAnalysisResult = await this.analyzeElanDumpStateWithNetResult(options.channel, options.context, options.toolchainUpdateMode, cachedToolchain, elanStateDumpWithNetResult);
-        if (withNetAnalysisResult.kind === 'RunWithCachedToolchain') {
-            this.stickyUpdateDecisions.set(key, 'DoNotUpdate');
-            if (withNetAnalysisResult.warning !== undefined) {
-                displayNotification('Warning', withNetAnalysisResult.warning);
-            }
-            return { kind: 'RunWithSpecificToolchain', toolchain: cachedToolchain };
-        }
-        return withNetAnalysisResult;
-    }
-    async runLeanCommand(executablePath, args, options) {
-        const toolchainDecision = await this.decideToolchain(options);
-        if (toolchainDecision.kind === 'Error') {
-            return {
-                exitCode: ExecutionExitCode.ExecutionError,
-                stdout: toolchainDecision.message,
-                stderr: '',
-                combined: toolchainDecision.message,
-            };
-        }
-        if (toolchainDecision.kind === 'RunWithActiveToolchain') {
-            return await this.runCmd(executablePath, args, options, undefined);
-        }
-        toolchainDecision.kind;
-        return await this.runCmd(executablePath, args, options, toolchainDecision.toolchain);
-    }
-}
-export let leanRunner;
-/** Must be called at the very start when the extension is activated so that `leanRunner` is defined. */
-export function registerLeanCommandRunner(context) {
-    leanRunner = new LeanCommandRunner();
-    context.subscriptions.push({
-        dispose: () => {
-            const u = undefined;
-            // Implicit invariant: When the extension deactivates, `leanRunner` is not called after this assignment.
-            leanRunner = u;
-        },
-    });
-}

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

@@ -1,83 +0,0 @@
-import { Disposable, ExtensionContext, TextDocument, TextEditor, TextEditorEdit, TextEditorSelectionChangeEvent } from 'vscode';
-import { ExtUri } from './exturi';
-export declare class LeanDocument {
-    readonly doc: TextDocument;
-    readonly extUri: ExtUri;
-    constructor(doc: TextDocument, extUri: ExtUri);
-    equals(other: LeanDocument): boolean;
-    equalsTextDocument(other: TextDocument): boolean;
-    static equalsWithUndefined(a: LeanDocument | undefined, b: LeanDocument | undefined): boolean;
-}
-export declare class LeanEditor {
-    readonly editor: TextEditor;
-    readonly documentExtUri: ExtUri;
-    constructor(editor: TextEditor, documentExtUri: ExtUri);
-    equals(other: LeanEditor): boolean;
-    equalsTextEditor(other: TextEditor): boolean;
-    static equalsWithUndefined(a: LeanEditor | undefined, b: LeanEditor | undefined): boolean;
-}
-export declare function isLeanDocument(doc: TextDocument): boolean;
-export declare function asLeanDocument(doc: TextDocument): LeanDocument | undefined;
-export declare function filterLeanDocuments(docs: readonly TextDocument[]): LeanDocument[];
-export declare function filterLeanDocument(doc: TextDocument | undefined): LeanDocument | undefined;
-export declare function isLeanEditor(editor: TextEditor): boolean;
-export declare function asLeanEditor(editor: TextEditor): LeanEditor | undefined;
-export declare function filterLeanEditors(editors: readonly TextEditor[]): LeanEditor[];
-export declare function filterLeanEditor(editor: TextEditor | undefined): LeanEditor | undefined;
-export declare class LeanEditorProvider implements Disposable {
-    private subscriptions;
-    private _visibleLeanEditors;
-    private visibleLeanEditorsByUri;
-    private readonly onDidChangeVisibleLeanEditorsEmitter;
-    readonly onDidChangeVisibleLeanEditors: import("vscode").Event<readonly LeanEditor[]>;
-    private _activeLeanEditor;
-    private readonly onDidChangeActiveLeanEditorEmitter;
-    readonly onDidChangeActiveLeanEditor: import("vscode").Event<LeanEditor | undefined>;
-    private _lastActiveLeanEditor;
-    private readonly onDidChangeLastActiveLeanEditorEmitter;
-    readonly onDidChangeLastActiveLeanEditor: import("vscode").Event<LeanEditor | undefined>;
-    private _leanDocuments;
-    private leanDocumentsByUri;
-    private readonly onDidChangeLeanDocumentsEmitter;
-    readonly onDidChangeLeanDocuments: import("vscode").Event<readonly LeanDocument[]>;
-    private readonly onDidOpenLeanDocumentEmitter;
-    readonly onDidOpenLeanDocument: import("vscode").Event<LeanDocument>;
-    private readonly onDidCloseLeanDocumentEmitter;
-    readonly onDidCloseLeanDocument: import("vscode").Event<LeanDocument>;
-    private _lastActiveLeanDocument;
-    private readonly onDidChangeLastActiveLeanDocumentEmitter;
-    readonly onDidChangeLastActiveLeanDocument: import("vscode").Event<LeanDocument | undefined>;
-    private readonly onDidRevealLeanEditorEmitter;
-    readonly onDidRevealLeanEditor: import("vscode").Event<LeanEditor>;
-    private readonly onDidConcealLeanEditorEmitter;
-    readonly onDidConcealLeanEditor: import("vscode").Event<LeanEditor>;
-    private readonly onDidChangeLeanEditorSelectionEmitter;
-    readonly onDidChangeLeanEditorSelection: import("vscode").Event<TextEditorSelectionChangeEvent>;
-    constructor();
-    private updateVisibleTextEditors;
-    private updateActiveTextEditor;
-    private updateVisibleLeanEditors;
-    private revealLeanEditors;
-    private concealLeanEditors;
-    private updateActiveLeanEditor;
-    private invalidateInvisibleLastActiveLeanEditor;
-    private updateLastActiveLeanEditor;
-    private updateLeanDocuments;
-    private openLeanDocument;
-    private closeLeanDocument;
-    private invalidateClosedLastActiveLeanDocument;
-    private updateLastActiveLeanDocument;
-    private updateTextEditorSelection;
-    get visibleLeanEditors(): readonly LeanEditor[];
-    get activeLeanEditor(): LeanEditor | undefined;
-    get lastActiveLeanEditor(): LeanEditor | undefined;
-    get leanDocuments(): readonly LeanDocument[];
-    get lastActiveLeanDocument(): LeanDocument | undefined;
-    getVisibleLeanEditorsByUri(uri: ExtUri): readonly LeanEditor[];
-    getLeanDocumentByUri(uri: ExtUri): LeanDocument | undefined;
-    registerLeanEditorCommand(command: string, callback: (leanEditor: LeanEditor, edit: TextEditorEdit, ...args: any[]) => void, thisArg?: any): Disposable;
-    dispose(): void;
-}
-export declare let lean: LeanEditorProvider;
-/** Must be called at the very start when the extension is activated so that `lean` is defined. */
-export declare function registerLeanEditorProvider(context: ExtensionContext): void;