lean4monaco 1.0.45 → 1.1.0

package/dist/monaco-lean4/vscode-lean4/src/utils/leanInstaller.js

@@ -0,0 +1,210 @@
+import { EventEmitter, window } from 'vscode';
+import { getPowerShellPath, isRunningTest } from '../config';
+import { ExecutionExitCode, batchExecute, displayResultError } from './batch';
+import { elanSelfUpdate } from './elan';
+import { logger } from './logger';
+import { displayError, displayErrorWithOptionalInput, displayNotificationWithInput, } from './notifs';
+export class LeanVersion {
+    version;
+    error;
+}
+export class LeanInstaller {
+    leanInstallerLinux = 'https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh';
+    leanInstallerWindows = 'https://raw.githubusercontent.com/leanprover/elan/master/elan-init.ps1';
+    outputChannel;
+    prompting = false;
+    installing = false;
+    freshInstallDefaultToolchain;
+    elanDefaultToolchain = ''; // the default toolchain according to elan (toolchain marked with '(default)')
+    workspaceSuffix = '(workspace override)';
+    defaultSuffix = '(default)';
+    promptUser = true;
+    // This event is raised whenever a version change happens.
+    // The event provides the workspace Uri where the change happened.
+    installChangedEmitter = new EventEmitter();
+    installChanged = this.installChangedEmitter.event;
+    constructor(outputChannel, freshInstallDefaultToolchain) {
+        this.outputChannel = outputChannel;
+        this.freshInstallDefaultToolchain = freshInstallDefaultToolchain;
+        if (isRunningTest()) {
+            this.promptUser = false;
+            if (process.env.LEAN4_PROMPT_USER === 'true') {
+                this.promptUser = true;
+            }
+        }
+    }
+    getPromptUser() {
+        return this.promptUser;
+    }
+    getOutputChannel() {
+        return this.outputChannel;
+    }
+    handleVersionChanged(packageUri) {
+        void this.showRestartPromptAndRestart('Lean version changed', packageUri);
+    }
+    isPromptVisible() {
+        return this.prompting;
+    }
+    async showRestartPromptAndRestart(message, packageUri) {
+        if (!this.promptUser) {
+            this.installChangedEmitter.fire(packageUri);
+            return;
+        }
+        if (this.prompting) {
+            return;
+        }
+        this.prompting = true;
+        const finalizer = () => {
+            this.prompting = false;
+        };
+        displayErrorWithOptionalInput(message, 'Restart Lean', () => this.installChangedEmitter.fire(packageUri), finalizer);
+    }
+    handleLakeFileChanged(packageUri) {
+        void this.showRestartPromptAndRestart('Lake file configuration changed', packageUri);
+    }
+    removeSuffix(version) {
+        let s = version;
+        const suffixes = [this.defaultSuffix, this.workspaceSuffix];
+        suffixes.forEach(suffix => {
+            if (s.endsWith(suffix)) {
+                s = s.substr(0, s.length - suffix.length);
+            }
+        });
+        return s.trim();
+    }
+    async getElanDefaultToolchain(packageUri) {
+        if (this.elanDefaultToolchain) {
+            return this.elanDefaultToolchain;
+        }
+        const toolChains = await this.elanListToolChains(packageUri);
+        let result = '';
+        toolChains.forEach(s => {
+            if (s.endsWith(this.defaultSuffix)) {
+                result = this.removeSuffix(s);
+            }
+        });
+        this.elanDefaultToolchain = result;
+        return result;
+    }
+    async elanListToolChains(packageUri) {
+        try {
+            const cmd = 'elan';
+            const options = ['toolchain', 'list'];
+            const cwd = packageUri.scheme === 'file' ? packageUri.fsPath : undefined;
+            const stdout = (await batchExecute(cmd, options, cwd)).stdout;
+            if (!stdout) {
+                throw new Error('elan toolchain list returned no output.');
+            }
+            const result = [];
+            stdout.split(/\r?\n/).forEach(s => {
+                s = s.trim();
+                if (s !== '') {
+                    result.push(s);
+                }
+            });
+            return result;
+        }
+        catch (err) {
+            return [`${err}`];
+        }
+    }
+    async hasElan() {
+        try {
+            const options = ['--version'];
+            const result = await batchExecute('elan', options);
+            const filterVersion = /elan (\d+)\.\d+\..+/;
+            const match = filterVersion.exec(result.stdout);
+            return match !== null;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async displayInstallElanPrompt(severity, reason) {
+        if (!this.getPromptUser()) {
+            // Used in tests
+            await this.autoInstall();
+            return true;
+        }
+        const reasonPrefix = reason ? reason + ' ' : '';
+        const installElanItem = 'Install Elan and Lean 4';
+        const installElanChoice = await displayNotificationWithInput(severity, reasonPrefix + "Do you want to install Lean's version manager Elan and a recent stable version of Lean 4?", installElanItem);
+        if (installElanChoice === undefined) {
+            return false;
+        }
+        await this.installElan();
+        return true;
+    }
+    async displayUpdateElanPrompt(severity, currentVersion, recommendedVersion) {
+        const updateElanItem = 'Update Elan';
+        const updateElanChoice = await displayNotificationWithInput(severity, `Lean's version manager Elan is outdated: the installed version is ${currentVersion.toString()}, but a version of ${recommendedVersion.toString()} is recommended. Do you want to update Elan?`, updateElanItem);
+        if (updateElanChoice === undefined) {
+            return false;
+        }
+        if (currentVersion.compare('3.1.0') === 0) {
+            // `elan self update` was broken in elan 3.1.0, so we need to take a different approach to updating elan here.
+            const installElanResult = await this.installElan();
+            return installElanResult === 'Success';
+        }
+        const elanSelfUpdateResult = await elanSelfUpdate(this.outputChannel);
+        if (elanSelfUpdateResult.exitCode !== ExecutionExitCode.Success) {
+            displayResultError(elanSelfUpdateResult, "Cannot update Elan. If you suspect that this is due to the way that you have set up Elan (e.g. from a package repository that ships an outdated version of Elan), you can disable these warnings using the 'Lean4: Show Setup Warnings' setting under 'File' > 'Preferences' > 'Settings'.");
+            return false;
+        }
+        return true;
+    }
+    async autoInstall() {
+        logger.log('[LeanInstaller] Installing Elan ...');
+        await this.installElan();
+        logger.log('[LeanInstaller] Elan installed');
+    }
+    async installElan() {
+        if (this.installing) {
+            displayError('Elan is already being installed. Please wait until the installation has finished.');
+            return 'PendingInstallation';
+        }
+        this.installing = true;
+        const terminalName = 'Lean installation via elan';
+        let terminalOptions = { name: terminalName };
+        if (process.platform === 'win32') {
+            terminalOptions = { name: terminalName, shellPath: getPowerShellPath() };
+        }
+        const terminal = window.createTerminal(terminalOptions);
+        terminal.show();
+        // We register a listener, to restart the Lean extension once elan has finished.
+        const resultPromise = new Promise(function (resolve, reject) {
+            window.onDidCloseTerminal(async (t) => {
+                if (t === terminal) {
+                    resolve(true);
+                }
+                else {
+                    logger.log('[LeanInstaller] ignoring terminal closed: ' + t.name + ', waiting for: ' + terminalName);
+                }
+            });
+        });
+        if (process.platform === 'win32') {
+            terminal.sendText(`Start-BitsTransfer -Source "${this.leanInstallerWindows}" -Destination "elan-init.ps1"\r\n` +
+                'Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope Process\r\n' +
+                `$rc = .\\elan-init.ps1 -NoPrompt 1 -DefaultToolchain ${this.freshInstallDefaultToolchain}\r\n` +
+                'Write-Host "elan-init returned [$rc]"\r\n' +
+                'del .\\elan-init.ps1\r\n' +
+                'if ($rc -ne 0) {\r\n' +
+                '    Read-Host -Prompt "Press ENTER to continue"\r\n' +
+                '}\r\n' +
+                'exit\r\n');
+        }
+        else {
+            const elanArgs = `-y --default-toolchain ${this.freshInstallDefaultToolchain}`;
+            const prompt = '(echo && read -n 1 -s -r -p "Install failed, press ENTER to continue...")';
+            terminal.sendText(`bash -c 'curl ${this.leanInstallerLinux} -sSf | sh -s -- ${elanArgs} || ${prompt}' && exit `);
+        }
+        const result = await resultPromise;
+        this.elanDefaultToolchain = this.freshInstallDefaultToolchain;
+        this.installing = false;
+        if (!result) {
+            displayError('Elan installation failed. Check the terminal output for details.');
+            return 'InstallationFailed';
+        }
+        return 'Success';
+    }
+}

package/dist/monaco-lean4/vscode-lean4/src/utils/logger.d.ts

@@ -0,0 +1,7 @@
+declare class Logger {
+    private static now;
+    log(msg: string): void;
+    error(msg: string): void;
+}
+declare const logger: Logger;
+export { logger };

package/dist/monaco-lean4/vscode-lean4/src/utils/logger.js

@@ -0,0 +1,20 @@
+class Logger {
+    static now() {
+        const now = new Date();
+        return (String(now.getUTCHours()).padStart(2, '0') +
+            ':' +
+            String(now.getMinutes()).padStart(2, '0') +
+            ':' +
+            String(now.getUTCSeconds()).padStart(2, '0') +
+            '.' +
+            String(now.getMilliseconds()).padStart(3, '0'));
+    }
+    log(msg) {
+        console.log(Logger.now(), '-', msg);
+    }
+    error(msg) {
+        console.error(Logger.now(), '-', msg);
+    }
+}
+const logger = new Logger();
+export { logger };

package/dist/monaco-lean4/vscode-lean4/src/utils/notifs.d.ts

@@ -0,0 +1,24 @@
+export type NotificationSeverity = 'Information' | 'Warning' | 'Error';
+export declare function displayNotification(severity: NotificationSeverity, message: string, finalizer?: (() => void) | undefined): void;
+export declare function displayNotificationWithInput<T extends string>(severity: NotificationSeverity, message: string, ...items: T[]): Promise<T | undefined>;
+export declare function displayNotificationWithOptionalInput<T extends string>(severity: NotificationSeverity, message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): void;
+export declare function displayNotificationWithOutput(severity: NotificationSeverity, message: string, finalizer?: (() => void) | undefined): void;
+export declare function displayNotificationWithSetupGuide(severity: NotificationSeverity, message: string, finalizer?: (() => void) | undefined): void;
+export declare function displayError(message: string, finalizer?: (() => void) | undefined): void;
+export declare function displayErrorWithInput<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
+export declare function displayErrorWithOptionalInput<T extends string>(message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): void;
+export declare function displayErrorWithOutput(message: string, finalizer?: (() => void) | undefined): void;
+export declare function displayErrorWithSetupGuide(message: string, finalizer?: (() => void) | undefined): void;
+export declare function displayWarning(message: string, finalizer?: (() => void) | undefined): void;
+export declare function displayModalWarning(message: string): Promise<'Proceed' | 'Abort'>;
+export declare function displayWarningWithInput<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
+export declare function displayWarningWithOptionalInput<T extends string>(message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): void;
+export declare function displayWarningWithOutput(message: string, finalizer?: (() => void) | undefined): void;
+export declare function displayModalWarningWithOutput(message: string): Promise<'Proceed' | 'Abort'>;
+export declare function displayWarningWithSetupGuide(message: string, finalizer?: (() => void) | undefined): void;
+export declare function displayModalWarningWithSetupGuide(message: string): Promise<'Proceed' | 'Abort'>;
+export declare function displayInformation(message: string, finalizer?: (() => void) | undefined): void;
+export declare function displayInformationWithInput<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
+export declare function displayInformationWithOptionalInput<T extends string>(message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): void;
+export declare function displayInformationWithOutput(message: string, finalizer?: (() => void) | undefined): void;
+export declare function displayInformationWithSetupGuide(message: string, finalizer?: (() => void) | undefined): void;

package/dist/monaco-lean4/vscode-lean4/src/utils/notifs.js

@@ -0,0 +1,110 @@
+import { commands, window } from 'vscode';
+function toNotif(severity) {
+    switch (severity) {
+        case 'Information':
+            return window.showInformationMessage;
+        case 'Warning':
+            return window.showWarningMessage;
+        case 'Error':
+            return window.showErrorMessage;
+    }
+}
+export function displayNotification(severity, message, finalizer) {
+    void (async () => {
+        await toNotif(severity)(message, {});
+        if (finalizer) {
+            finalizer();
+        }
+    })();
+}
+export async function displayNotificationWithInput(severity, message, ...items) {
+    return await toNotif(severity)(message, { modal: true }, ...items);
+}
+export function displayNotificationWithOptionalInput(severity, message, input, action, finalizer) {
+    void (async () => {
+        const choice = await toNotif(severity)(message, {}, input);
+        if (choice === input) {
+            action();
+        }
+        if (finalizer) {
+            finalizer();
+        }
+    })();
+}
+export function displayNotificationWithOutput(severity, message, finalizer) {
+    displayNotificationWithOptionalInput(severity, message, 'Show Output', () => commands.executeCommand('lean4.troubleshooting.showOutput'), finalizer);
+}
+export function displayNotificationWithSetupGuide(severity, message, finalizer) {
+    displayNotificationWithOptionalInput(severity, message, 'Open Setup Guide', () => commands.executeCommand('lean4.docs.showSetupGuide'), finalizer);
+}
+export function displayError(message, finalizer) {
+    displayNotification('Error', message, finalizer);
+}
+export async function displayErrorWithInput(message, ...items) {
+    return await displayNotificationWithInput('Error', message, ...items);
+}
+export function displayErrorWithOptionalInput(message, input, action, finalizer) {
+    displayNotificationWithOptionalInput('Error', message, input, action, finalizer);
+}
+export function displayErrorWithOutput(message, finalizer) {
+    displayNotificationWithOutput('Error', message, finalizer);
+}
+export function displayErrorWithSetupGuide(message, finalizer) {
+    displayNotificationWithSetupGuide('Error', message, finalizer);
+}
+export function displayWarning(message, finalizer) {
+    displayNotification('Warning', message, finalizer);
+}
+export async function displayModalWarning(message) {
+    const choice = await window.showWarningMessage(message, { modal: true }, 'Proceed Regardless');
+    return choice === 'Proceed Regardless' ? 'Proceed' : 'Abort';
+}
+export async function displayWarningWithInput(message, ...items) {
+    return await displayNotificationWithInput('Warning', message, ...items);
+}
+export function displayWarningWithOptionalInput(message, input, action, finalizer) {
+    displayNotificationWithOptionalInput('Warning', message, input, action, finalizer);
+}
+export function displayWarningWithOutput(message, finalizer) {
+    displayNotificationWithOutput('Warning', message, finalizer);
+}
+export async function displayModalWarningWithOutput(message) {
+    const choice = await window.showWarningMessage(message, 'Show Output', 'Proceed Regardless');
+    if (choice === undefined) {
+        return 'Abort';
+    }
+    if (choice === 'Proceed Regardless') {
+        return 'Proceed';
+    }
+    await commands.executeCommand('lean4.troubleshooting.showOutput');
+    return 'Abort';
+}
+export function displayWarningWithSetupGuide(message, finalizer) {
+    displayNotificationWithSetupGuide('Warning', message, finalizer);
+}
+export async function displayModalWarningWithSetupGuide(message) {
+    const choice = await window.showWarningMessage(message, 'Open Setup Guide', 'Proceed Regardless');
+    if (choice === undefined) {
+        return 'Abort';
+    }
+    if (choice === 'Proceed Regardless') {
+        return 'Proceed';
+    }
+    await commands.executeCommand('lean4.docs.showSetupGuide');
+    return 'Abort';
+}
+export function displayInformation(message, finalizer) {
+    displayNotification('Information', message, finalizer);
+}
+export async function displayInformationWithInput(message, ...items) {
+    return await displayNotificationWithInput('Information', message, ...items);
+}
+export function displayInformationWithOptionalInput(message, input, action, finalizer) {
+    displayNotificationWithOptionalInput('Information', message, input, action, finalizer);
+}
+export function displayInformationWithOutput(message, finalizer) {
+    displayNotificationWithOutput('Information', message, finalizer);
+}
+export function displayInformationWithSetupGuide(message, finalizer) {
+    displayNotificationWithSetupGuide('Information', message, finalizer);
+}

package/dist/monaco-lean4/vscode-lean4/src/utils/projectInfo.d.ts

@@ -0,0 +1,9 @@
+import { ExtUri, FileUri } from './exturi';
+export declare function isCoreLean4Directory(path: FileUri): Promise<boolean>;
+export declare function findLeanProjectRootInfo(uri: FileUri): Promise<[FileUri, FileUri | undefined]>;
+export declare function findLeanProjectRoot(uri: FileUri): Promise<FileUri>;
+export declare function findLeanProjectInfo(uri: FileUri): Promise<[FileUri, string | undefined]>;
+export declare function readLeanToolchain(projectUri: FileUri): Promise<string | undefined>;
+export declare function isValidLeanProject(projectFolder: FileUri): Promise<boolean>;
+export declare function checkParentFoldersForLeanProject(folder: FileUri): Promise<FileUri | undefined>;
+export declare function willUseLakeServer(folder: ExtUri): Promise<boolean>;

package/dist/monaco-lean4/vscode-lean4/src/utils/projectInfo.js

@@ -0,0 +1,125 @@
+import * as fs from 'fs';
+import { FileUri, getWorkspaceFolderUri } from './exturi';
+import { dirExists, fileExists } from './fsHelper';
+import path from 'path';
+// Detect lean4 root directory (works for both lean4 repo and nightly distribution)
+export async function isCoreLean4Directory(path) {
+    const licensePath = path.join('LICENSE').fsPath;
+    const licensesPath = path.join('LICENSES').fsPath;
+    const srcPath = path.join('src').fsPath;
+    const isCoreLean4RootDirectory = (await fileExists(licensePath)) && (await fileExists(licensesPath)) && (await dirExists(srcPath));
+    if (isCoreLean4RootDirectory) {
+        return true;
+    }
+    const initPath = path.join('Init.lean').fsPath;
+    const leanPath = path.join('Lean.lean').fsPath;
+    const kernelPath = path.join('kernel').fsPath;
+    const runtimePath = path.join('runtime').fsPath;
+    const isCoreLean4SrcDirectory = (await fileExists(initPath)) &&
+        (await fileExists(leanPath)) &&
+        (await dirExists(kernelPath)) &&
+        (await dirExists(runtimePath));
+    return isCoreLean4SrcDirectory;
+}
+// Find the root of a Lean project and the Uri for the 'lean-toolchain' file found there.
+export async function findLeanProjectRootInfo(uri) {
+    const toolchainFileName = 'lean-toolchain';
+    let path = uri;
+    const containingWsFolderUri = getWorkspaceFolderUri(uri);
+    // then start searching from the directory containing this document.
+    // The given uri may already be a folder Uri in some cases.
+    if (fs.lstatSync(path.fsPath).isFile()) {
+        path = uri.join('..');
+    }
+    let bestFolder = path;
+    let bestLeanToolchain;
+    while (true) {
+        const leanToolchain = path.join(toolchainFileName);
+        if (await fileExists(leanToolchain.fsPath)) {
+            bestFolder = path;
+            bestLeanToolchain = leanToolchain;
+        }
+        else if (await isCoreLean4Directory(path)) {
+            bestFolder = path;
+            bestLeanToolchain = undefined;
+            // Stop searching in case users accidentally created a lean-toolchain file above the core directory
+            break;
+        }
+        if (containingWsFolderUri !== undefined && path.equals(containingWsFolderUri)) {
+            if (bestLeanToolchain === undefined) {
+                // If we haven't found a toolchain yet, prefer the workspace folder as the project scope for the file,
+                // but keep looking in case there is a lean-toolchain above the workspace folder
+                // (New users sometimes accidentally open sub-folders of projects)
+                bestFolder = path;
+            }
+            else {
+                // Stop looking above the barrier if we have a toolchain. This is necessary for the nested lean-toolchain setup of core.
+                break;
+            }
+        }
+        const parent = path.join('..');
+        if (parent.equals(path)) {
+            // no project file found.
+            break;
+        }
+        path = parent;
+    }
+    return [bestFolder, bestLeanToolchain];
+}
+export async function findLeanProjectRoot(uri) {
+    const [projectRootUri, _] = await findLeanProjectRootInfo(uri);
+    return projectRootUri;
+}
+export async function findLeanProjectInfo(uri) {
+    const [projectUri, toolchainUri] = await findLeanProjectRootInfo(uri);
+    if (!toolchainUri) {
+        return [projectUri, undefined];
+    }
+    return [projectUri, await readLeanToolchainFile(toolchainUri)];
+}
+export async function readLeanToolchain(projectUri) {
+    const toolchainFileName = 'lean-toolchain';
+    const leanToolchain = projectUri.join(toolchainFileName);
+    if (!fs.existsSync(leanToolchain.fsPath)) {
+        return undefined;
+    }
+    return await readLeanToolchainFile(leanToolchain);
+}
+async function readLeanToolchainFile(toolchainFileUri) {
+    try {
+        return (await fs.promises.readFile(toolchainFileUri.fsPath, { encoding: 'utf-8' })).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function isValidLeanProject(projectFolder) {
+    try {
+        const leanToolchainPath = projectFolder.join('lean-toolchain').fsPath;
+        const isLeanProject = await fileExists(leanToolchainPath);
+        const isLeanItself = await isCoreLean4Directory(projectFolder);
+        return isLeanProject || isLeanItself;
+    }
+    catch {
+        return false;
+    }
+}
+export async function checkParentFoldersForLeanProject(folder) {
+    let childFolder;
+    do {
+        childFolder = folder;
+        folder = new FileUri(path.dirname(folder.fsPath));
+        if (await isValidLeanProject(folder)) {
+            return folder;
+        }
+    } while (!childFolder.equals(folder));
+    return undefined;
+}
+export async function willUseLakeServer(folder) {
+    if (folder.scheme !== 'file') {
+        return false;
+    }
+    const lakefileLean = folder.join('lakefile.lean');
+    const lakefileToml = folder.join('lakefile.toml');
+    return (await fileExists(lakefileLean.fsPath)) || (await fileExists(lakefileToml.fsPath));
+}

package/dist/monacoleanclient.d.ts

@@ -1,4 +1,3 @@
 import { WorkerConfigDirect, WebSocketConfigOptions, WebSocketConfigOptionsUrl, WorkerConfigOptions } from 'monaco-editor-wrapper';
-import { ExtUri } from 'lean4/src/utils/exturi';
 import { LanguageClientOptions } from 'vscode-languageclient/node';
-export declare const setupMonacoClient: (options: WebSocketConfigOptions | WebSocketConfigOptionsUrl | WorkerConfigOptions | WorkerConfigDirect) => (clientOptions: LanguageClientOptions, folderUri: ExtUri, elanDefaultToolchain: string) => Promise<import("monaco-languageclient").MonacoLanguageClient>;
+export declare const setupMonacoClient: (options: WebSocketConfigOptions | WebSocketConfigOptionsUrl | WorkerConfigOptions | WorkerConfigDirect) => (clientOptions: LanguageClientOptions) => Promise<import("monaco-languageclient").MonacoLanguageClient>;

package/dist/monacoleanclient.js

@@ -1,7 +1,7 @@
 import { LanguageClientWrapper } from 'monaco-editor-wrapper';
-import { displayError } from 'lean4/src/utils/notifs';
+import { displayNotification } from './vscode-lean4/vscode-lean4/src/utils/notifs';
 export const setupMonacoClient = (options) => {
-    return async (clientOptions, folderUri, elanDefaultToolchain) => {
+    return async (clientOptions) => {
         const languageClientWrapper = new LanguageClientWrapper();
         await languageClientWrapper.init({
             languageClientConfig: {
@@ -15,7 +15,7 @@ export const setupMonacoClient = (options) => {
                             handleMessage: (message, next) => {
                                 if (message.error) {
                                     // TODO: Handle Lean errors correctly
-                                    displayError(message.error.message);
+                                    displayNotification("Error", message.error.message);
                                     next(message); // remove this to prevent propagating the message
                                 }
                                 else {

package/dist/preconditions.d.ts

@@ -1,4 +1,4 @@
 import { OutputChannel } from "vscode";
-import { ExtUri } from "lean4/src/utils/exturi";
-import { PreconditionCheckResult } from "lean4/src/diagnostics/setupNotifs";
+import { ExtUri } from "./vscode-lean4/vscode-lean4/src/utils/exturi";
+import { PreconditionCheckResult } from "./vscode-lean4/vscode-lean4/src/diagnostics/setupNotifs";
 export declare function checkLean4ProjectPreconditions(channel: OutputChannel, folderUri: ExtUri): Promise<PreconditionCheckResult>;

package/dist/vscode-lean4/lean4-infoview/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@leanprover/infoview",
-    "version": "0.7.3",
+    "version": "0.8.5",
     "description": "An interactive display for the Lean 4 theorem prover.",
     "scripts": {
         "watch": "rollup --config --environment NODE_ENV:development --watch",
@@ -9,49 +9,51 @@
         "test": "tsc -p test/tsconfig.json"
     },
     "exports": {
-        ".": "./dist/index.development.js",
-        "./loader": "./dist/loader.production.min.js",
+        ".": {
+            "default": "./dist/index.production.min.js",
+            "types": "./dist/index.d.ts"
+        },
+        "./loader": {
+            "default": "./dist/loader.production.min.js",
+            "types": "./dist/loader.d.ts"
+        },
         "./package.json": "./package.json"
     },
-    "typesVersions": {
-        "*": {
-            "*": [
-                "dist/index.d.ts"
-            ],
-            "loader": [
-                "dist/loader.d.ts"
-            ]
-        }
-    },
     "files": [
         "dist/*"
     ],
     "type": "module",
     "license": "Apache-2.0",
     "devDependencies": {
-        "@floating-ui/react": "^0.24.7",
-        "@rollup/plugin-commonjs": "^23.0.7",
+        "@floating-ui/react": "^0.26.25",
+        "@rollup/plugin-commonjs": "^28.0.0",
+        "@rollup/plugin-json": "^6.1.0",
         "@rollup/plugin-node-resolve": "^15.1.0",
-        "@rollup/plugin-replace": "^5.0.2",
-        "@rollup/plugin-terser": "^0.1.0",
-        "@rollup/plugin-typescript": "^9.0.2",
+        "@rollup/plugin-replace": "^6.0.1",
+        "@rollup/plugin-terser": "^0.4.4",
+        "@rollup/plugin-typescript": "^12.1.0",
         "@rollup/plugin-url": "^8.0.1",
-        "@types/marked": "^4.3.1",
         "@types/react": "^18.2.15",
         "@types/react-dom": "^18.2.7",
+        "@types/react-syntax-highlighter": "^15.5.13",
         "current-release": "npm:@leanprover/infoview@latest",
+        "highlightjs-lean": "^1.2.0",
         "react": "^18.2.0",
         "react-dom": "^18.2.0",
-        "rollup": "^3.26.2",
+        "react-markdown": "^9.0.1",
+        "react-syntax-highlighter": "^15.5.0",
+        "remark-math": "^6.0.0",
+        "rehype-mathjax": "^6.0.0",
+        "rollup": "^4.24.0",
         "rollup-plugin-css-only": "^4.3.0",
         "typescript": "^5.4.5"
     },
     "dependencies": {
-        "@leanprover/infoview-api": "~0.4.0",
+        "@leanprover/infoview-api": "~0.7.0",
         "@vscode/codicons": "^0.0.32",
-        "@vscode/webview-ui-toolkit": "^1.4.0",
+        "@vscode-elements/react-elements": "^0.5.0",
+        "es-module-lexer": "^1.5.4",
         "es-module-shims": "^1.7.3",
-        "marked": "^4.3.0",
         "react-fast-compare": "^3.2.2",
         "tachyons": "^4.12.0",
         "vscode-languageserver-protocol": "^3.17.3"

package/dist/vscode-lean4/lean4-infoview/tsconfig.json

@@ -10,13 +10,17 @@
 
         /* Modules */
         "module": "esnext",
-        "moduleResolution": "node",
+        "moduleResolution": "bundler",
 
-        /* Emit */
+        /* Emit code */
         "sourceMap": true,
         "rootDir": "src",
         "outDir": "dist",
 
+        /* Emit declarations */
+        "declaration": true,
+        "declarationDir": "dist",
+
         /* Interop Constraints */
         "esModuleInterop": true,
         "forceConsistentCasingInFileNames": true,

package/dist/vscode-lean4/lean4-infoview-api/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@leanprover/infoview-api",
-    "version": "0.4.0",
+    "version": "0.7.0",
     "description": "Types and API for @leanprover/infoview.",
     "scripts": {
         "watch": "tsc --watch",