lean4monaco 1.1.2 → 1.1.4

package/README.md

@@ -109,7 +109,7 @@ export default {
 For Vite dev mode to work properly, the following plugin is necessary:
 
 ```
-npm install -D 'https://gitpkg.vercel.app/hhu-adam/lean4monaco/esbuild-import-meta-url-plugin?main'
+npm install --save-dev '@codingame/esbuild-import-meta-url-plugin'
 ```
 
 ```ts
@@ -126,8 +126,6 @@ export default {
 }
 ```
 
-This could be replaced by `npm install --save-dev @codingame/esbuild-import-meta-url-plugin` when this PR is accepted: https://github.com/CodinGame/esbuild-import-meta-url-plugin/pull/5
-
 #### infoview
 
 Moreover, the infoview javascript files need to be served:

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

@@ -313,7 +313,9 @@ export class LeanClient {
             return true;
         }
         if (this.folderUri.scheme === 'file' && uri.scheme === 'file') {
-            return uri.isInFolder(this.folderUri);
+            // lean4monaco: To avoid file system issues, we let any client manage any file:
+            return true;
+            // return uri.isInFolder(this.folderUri)
         }
         return false;
     }

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

@@ -168,8 +168,6 @@ export class LeanClientProvider {
                 bestCandidate = candidate;
             }
         }
-        // lean4monaco: Due to issues with Windows file paths, we assume for now that there is only one client.
-        return this.getClients()[0];
         return bestCandidate;
     }
     getClients() {

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

@@ -0,0 +1,81 @@
+import { Disposable, OutputChannel } from 'vscode';
+import { ExecutionResult } from './batch';
+import { NotificationSeverity, StickyInput, StickyNotificationOptions } from './notifs';
+export type LinuxPackageManager = {
+    kind: 'Apt';
+    isPkExecAvailable: boolean;
+} | {
+    kind: 'Dnf';
+    isPkExecAvailable: boolean;
+} | {
+    kind: 'Other';
+};
+export type DependencyInstallationMethod = {
+    kind: 'Automatic';
+    shell: 'Windows' | 'Unix';
+    script: string;
+    manualBackupScript: string | undefined;
+    pathExtensions: string[];
+} | {
+    kind: 'Manual';
+    script: string | undefined;
+};
+export type MissingDependencyInstallationProcedure = {
+    kind: 'Linux';
+    isGitAvailable: boolean;
+    isCurlAvailable: boolean;
+    packageManager: LinuxPackageManager;
+} | {
+    kind: 'MacOS';
+    isGitAvailable: boolean;
+    isCurlAvailable: true;
+} | {
+    kind: 'Windows';
+    isGitAvailable: boolean;
+    isCurlAvailable: true;
+    isWinGetAvailable: boolean;
+} | {
+    kind: 'Other';
+    isGitAvailable: boolean;
+    isCurlAvailable: boolean;
+};
+export type DependencyInstallationProcedure = {
+    kind: 'AllDepsInstalled';
+} | (MissingDependencyInstallationProcedure & {
+    method: DependencyInstallationMethod;
+});
+export type DependencyInstallationResult = {
+    kind: 'Success';
+} | {
+    kind: 'Error';
+    result: ExecutionResult;
+} | {
+    kind: 'Cancelled';
+} | {
+    kind: 'PendingInstall';
+};
+export declare function depInstallationLocations(): string[];
+export declare class DepInstaller implements Disposable {
+    readonly outputChannel: OutputChannel;
+    private pendingInstall;
+    private diagnoser;
+    private subscriptions;
+    constructor(outputChannel: OutputChannel);
+    displayInstallDependenciesPrompt(severity: NotificationSeverity, reason: string | undefined): Promise<'Success' | 'PendingInstall' | 'Failure'>;
+    displayStickyInstallDependenciesPrompt(severity: NotificationSeverity, reason: string | undefined, options: StickyNotificationOptions<string>, otherItems?: StickyInput<string>[]): Promise<Disposable>;
+    private installMissingDepsAndDisplayNotification;
+    installMissingDeps(p: MissingDependencyInstallationProcedure & {
+        method: DependencyInstallationMethod;
+    }): Promise<DependencyInstallationResult>;
+    private addDepsToProcessEnv;
+    determineDependencyInstallationProcedure(): Promise<DependencyInstallationProcedure>;
+    private determineMissingDependencyInstallationProcedure;
+    private runCommand;
+    dispose(): void;
+}
+export declare function missingDepsSentence(p: MissingDependencyInstallationProcedure): string;
+export declare function sentenceJoin(entries: string[]): string;
+export declare function missingDeps(p: MissingDependencyInstallationProcedure): string[];
+export declare function unsuccessfulDependencyInstallationPrompt(p: MissingDependencyInstallationProcedure & {
+    method: DependencyInstallationMethod;
+}): string;

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

@@ -0,0 +1,372 @@
+import * as os from 'os';
+import path from 'path';
+import { commands, Disposable, env } from 'vscode';
+import { SetupDiagnoser } from '../diagnostics/setupDiagnoser';
+import { batchExecuteWithProgress, displayModalResultError, ExecutionExitCode, } from './batch';
+import { addToProcessEnvPATH } from './envPath';
+import { displayModalNotification, displayNotification, displayNotificationWithInput, displayStickyNotificationWithOptionalInput, } from './notifs';
+const gitInstallDir = path.join('c:', 'Program Files', 'Git', 'cmd');
+export function depInstallationLocations() {
+    switch (os.type()) {
+        case 'Linux':
+            // Installation locations of Git and curl should already be in PATH on most Linux systems
+            return [];
+        case 'Darwin':
+            // MacOS ships with a dummy executable for Git that is already in the PATH, which is replaced
+            // with the real executable when Apple Command Line Tools is installed.
+            return [];
+        case 'Windows_NT':
+            return [gitInstallDir];
+    }
+    return [];
+}
+const windowsRawGitInstallScript = `$gitInstallerUrl = "https://github.com/git-for-windows/git/releases/download/v2.50.1.windows.1/Git-2.50.1-64-bit.exe"
+$installDir = "%TEMP%\\lean4-vscode-extension"
+$gitInstallerLoc = "$installDir\\GitInstaller.exe"
+New-Item -ItemType Directory -Path $installDir -Force
+Invoke-WebRequest -Uri $gitInstallerUrl -OutFile $gitInstallerLoc
+& $gitInstallerLoc /VERYSILENT /NORESTART /SP-
+exit $LASTEXITCODE`;
+const macOsInstallScript = `set -e
+touch "/tmp/.com.apple.dt.CommandLineTools.installondemand.in-progress"
+aclt_label="$(/usr/sbin/softwareupdate -l |
+              grep -B 1 -E 'Command Line Tools' |
+              awk -F'*' '/^ *\\*/ {print $2}' |
+              sed -e 's/^ *Label: //' -e 's/^ *//' |
+              sort -V |
+              tail -n1 |
+              tr -d '\n')"
+/usr/sbin/softwareupdate -i "$aclt_label"`;
+export class DepInstaller {
+    outputChannel;
+    pendingInstall = false;
+    diagnoser;
+    subscriptions = [];
+    constructor(outputChannel) {
+        this.outputChannel = outputChannel;
+        this.diagnoser = new SetupDiagnoser({
+            channel: outputChannel,
+            cwdUri: undefined,
+            context: 'Dependency Installation',
+        });
+        this.subscriptions.push(commands.registerCommand('lean4.setup.installDeps', () => this.displayInstallDependenciesPrompt('Information', undefined)));
+    }
+    async displayInstallDependenciesPrompt(severity, reason) {
+        const p = await this.determineDependencyInstallationProcedure();
+        if (p.kind === 'AllDepsInstalled') {
+            displayNotification('Information', 'All dependencies of Lean (Git and curl) are already installed.');
+            return 'Success';
+        }
+        if (p.method.kind === 'Manual') {
+            await displayManualInstallationPrompt(severity, reason, p);
+            return 'Failure';
+        }
+        const choice = await displayNotificationWithInput(severity, installDependenciesPrompt(reason, p), ['Proceed']);
+        if (choice !== 'Proceed') {
+            return 'Failure';
+        }
+        return await this.installMissingDepsAndDisplayNotification(p);
+    }
+    async displayStickyInstallDependenciesPrompt(severity, reason, options, otherItems = []) {
+        const p = await this.determineDependencyInstallationProcedure();
+        if (p.kind === 'AllDepsInstalled') {
+            displayNotification('Information', 'All dependencies of Lean (Git and curl) are already installed.');
+            return Disposable.from();
+        }
+        if (p.method.kind === 'Manual') {
+            return await displayStickyManualInstallationPrompt(severity, reason, p, options, otherItems);
+        }
+        const installDepsItem = {
+            input: 'Install Dependencies',
+            continueDisplaying: false,
+            action: async () => {
+                await this.installMissingDepsAndDisplayNotification(p);
+            },
+        };
+        return displayStickyNotificationWithOptionalInput(severity, installDependenciesPrompt(reason, p), options, [
+            installDepsItem,
+            ...otherItems,
+        ]);
+    }
+    async installMissingDepsAndDisplayNotification(p) {
+        const r = await this.installMissingDeps(p);
+        switch (r.kind) {
+            case 'Success':
+                displayNotification('Information', 'Dependency installation successful!');
+                return 'Success';
+            case 'Error':
+                await displayModalResultError(r.result, unsuccessfulDependencyInstallationPrompt(p));
+                return 'Failure';
+            case 'Cancelled':
+                return 'Failure';
+            case 'PendingInstall':
+                return 'PendingInstall';
+        }
+    }
+    async installMissingDeps(p) {
+        if (p.method.kind === 'Manual') {
+            throw new Error('got manual installation method in `installMissingDeps`');
+        }
+        if (this.pendingInstall) {
+            displayNotification('Error', 'Dependencies are already being installed.');
+            return { kind: 'PendingInstall' };
+        }
+        this.pendingInstall = true;
+        try {
+            const installationResult = await this.runCommand(p.method.script, [], 'Installing missing dependencies', p.method.shell);
+            switch (installationResult.exitCode) {
+                case ExecutionExitCode.Success:
+                    this.addDepsToProcessEnv(p.method);
+                    return { kind: 'Success' };
+                case ExecutionExitCode.CannotLaunch:
+                case ExecutionExitCode.ExecutionError:
+                    return { kind: 'Error', result: installationResult };
+                case ExecutionExitCode.Cancelled:
+                    return { kind: 'Cancelled' };
+            }
+        }
+        finally {
+            this.pendingInstall = false;
+        }
+    }
+    addDepsToProcessEnv(method) {
+        if (method.kind !== 'Automatic') {
+            return;
+        }
+        for (const pathExt of method.pathExtensions) {
+            addToProcessEnvPATH(pathExt);
+        }
+    }
+    async determineDependencyInstallationProcedure() {
+        const p = await this.determineMissingDependencyInstallationProcedure();
+        if (p === undefined) {
+            return { kind: 'AllDepsInstalled' };
+        }
+        return { ...p, method: dependencyInstallationMethod(p) };
+    }
+    async determineMissingDependencyInstallationProcedure() {
+        const isCurlAvailable = await this.diagnoser.checkCurlAvailable();
+        const isGitAvailable = await this.diagnoser.checkGitAvailable();
+        if (isCurlAvailable && isGitAvailable) {
+            return undefined;
+        }
+        switch (os.type()) {
+            case 'Linux':
+                const isAptAvailable = await this.diagnoser.checkAptGetAvailable();
+                if (isAptAvailable) {
+                    const isPkExecAvailable = await this.diagnoser.checkPkExecAvailable();
+                    return {
+                        kind: 'Linux',
+                        isCurlAvailable,
+                        isGitAvailable,
+                        packageManager: { kind: 'Apt', isPkExecAvailable },
+                    };
+                }
+                const isDnfAvailable = await this.diagnoser.checkDnfAvailable();
+                if (isDnfAvailable) {
+                    const isPkExecAvailable = await this.diagnoser.checkPkExecAvailable();
+                    return {
+                        kind: 'Linux',
+                        isCurlAvailable,
+                        isGitAvailable,
+                        packageManager: { kind: 'Dnf', isPkExecAvailable },
+                    };
+                }
+                return {
+                    kind: 'Linux',
+                    isCurlAvailable,
+                    isGitAvailable,
+                    packageManager: { kind: 'Other' },
+                };
+            case 'Darwin':
+                return {
+                    kind: 'MacOS',
+                    isCurlAvailable: true,
+                    isGitAvailable,
+                };
+            case 'Windows_NT':
+                const isWinGetAvailable = await this.diagnoser.checkWinGetAvailable();
+                return {
+                    kind: 'Windows',
+                    isCurlAvailable: true,
+                    isGitAvailable,
+                    isWinGetAvailable,
+                };
+        }
+        return {
+            kind: 'Other',
+            isCurlAvailable,
+            isGitAvailable,
+        };
+    }
+    async runCommand(executablePath, args, title, shell) {
+        const options = {
+            allowCancellation: true,
+            channel: this.outputChannel,
+            shell,
+        };
+        return batchExecuteWithProgress(executablePath, args, 'Dependency Installation', title, options);
+    }
+    dispose() {
+        for (const s of this.subscriptions) {
+            s.dispose();
+        }
+    }
+}
+function dependencyInstallationMethod(p) {
+    switch (p.kind) {
+        case 'Linux':
+            switch (p.packageManager.kind) {
+                case 'Apt':
+                    const manualAptScript = `sudo apt update && sudo apt install ${missingDeps(p).join(' ')}`;
+                    if (!p.packageManager.isPkExecAvailable) {
+                        return {
+                            kind: 'Manual',
+                            script: manualAptScript,
+                        };
+                    }
+                    return {
+                        kind: 'Automatic',
+                        shell: 'Unix',
+                        // `ulimit -Sn 1024`: https://github.com/microsoft/vscode/issues/237427
+                        script: `ulimit -Sn 1024; pkexec bash -c 'export DEBIAN_FRONTEND=noninteractive; apt-get update -y && apt-get install -y ${missingDeps(p).join(' ')}'`,
+                        manualBackupScript: manualAptScript,
+                        pathExtensions: [],
+                    };
+                case 'Dnf':
+                    const manualDnfScript = `sudo dnf install ${missingDeps(p).join(' ')}`;
+                    if (!p.packageManager.isPkExecAvailable) {
+                        return {
+                            kind: 'Manual',
+                            script: manualDnfScript,
+                        };
+                    }
+                    return {
+                        kind: 'Automatic',
+                        shell: 'Unix',
+                        script: `pkexec dnf install -y ${missingDeps(p).join(' ')}`,
+                        manualBackupScript: manualDnfScript,
+                        pathExtensions: [],
+                    };
+                case 'Other':
+                    return {
+                        kind: 'Manual',
+                        script: undefined,
+                    };
+            }
+        case 'MacOS':
+            return {
+                kind: 'Automatic',
+                shell: 'Unix',
+                script: macOsInstallScript,
+                manualBackupScript: macOsInstallScript,
+                pathExtensions: [],
+            };
+        case 'Windows':
+            if (!p.isWinGetAvailable) {
+                return {
+                    kind: 'Automatic',
+                    shell: 'Windows',
+                    script: windowsRawGitInstallScript,
+                    manualBackupScript: undefined,
+                    pathExtensions: [gitInstallDir],
+                };
+            }
+            const windowsWingetGitInstallScript = 'winget install -e --id Git.Git --silent --accept-package-agreements --accept-source-agreements --disable-interactivity';
+            return {
+                kind: 'Automatic',
+                shell: 'Windows',
+                script: windowsWingetGitInstallScript,
+                manualBackupScript: windowsWingetGitInstallScript,
+                pathExtensions: [gitInstallDir],
+            };
+        case 'Other':
+            return {
+                kind: 'Manual',
+                script: undefined,
+            };
+    }
+}
+async function displayManualInstallationPrompt(severity, reason, p) {
+    let reasonPrefix = '';
+    if (reason !== undefined) {
+        reasonPrefix = `${reason} `;
+    }
+    if (p.method.script === undefined) {
+        await displayModalNotification(severity, `${reasonPrefix}Please install ${missingDepsSentence(p)} and restart VS Code.`);
+        return;
+    }
+    const prompt = `${reasonPrefix}Please install ${missingDepsSentence(p)} from a terminal using the script below and restart VS Code.\n\n${p.method.script}`;
+    const copyToClipboardInput = 'Copy Script to Clipboard';
+    const choice = await displayNotificationWithInput('Information', prompt, [copyToClipboardInput], 'Close');
+    if (choice === copyToClipboardInput) {
+        await env.clipboard.writeText(p.method.script);
+    }
+}
+async function displayStickyManualInstallationPrompt(severity, reason, p, options, otherItems = []) {
+    let reasonPrefix = '';
+    if (reason !== undefined) {
+        reasonPrefix = `${reason} `;
+    }
+    const script = p.method.script;
+    if (script === undefined) {
+        await displayModalNotification(severity, `${reasonPrefix}Please install ${missingDepsSentence(p)} and restart VS Code.`);
+        return Disposable.from();
+    }
+    const prompt = `${reasonPrefix}Please install ${missingDepsSentence(p)} from a [terminal](command:workbench.action.terminal.new) using the script below and restart VS Code.\n\n${script}`;
+    const copyToClipboardItem = {
+        input: 'Copy Script to Clipboard',
+        continueDisplaying: true,
+        action: async () => {
+            await env.clipboard.writeText(script);
+        },
+    };
+    return displayStickyNotificationWithOptionalInput(severity, prompt, options, [copyToClipboardItem, ...otherItems]);
+}
+export function missingDepsSentence(p) {
+    return sentenceJoin(missingDeps(p).map(d => '`' + d + '`'));
+}
+export function sentenceJoin(entries) {
+    if (entries.length === 0) {
+        throw new Error('Cannot join empty array.');
+    }
+    if (entries.length === 1) {
+        return entries[0];
+    }
+    if (entries.length === 2) {
+        return `${entries[0]} and ${entries[1]}`;
+    }
+    return `${entries.slice(0, entries.length - 1).join(', ')} and ${entries[entries.length - 1]}`;
+}
+export function missingDeps(p) {
+    const missingDeps = [];
+    if (!p.isGitAvailable) {
+        missingDeps.push('git');
+    }
+    if (!p.isCurlAvailable) {
+        missingDeps.push('curl');
+    }
+    return missingDeps;
+}
+function installDependenciesPrompt(reason, p) {
+    if (p.method.kind === 'Manual') {
+        throw new Error('cannot display installDependenciesPrompt for manual installation');
+    }
+    let reasonPrefix = '';
+    if (reason !== undefined) {
+        reasonPrefix = `${reason} `;
+    }
+    return `${reasonPrefix}Do you wish to install ${missingDepsSentence(p)}?`;
+}
+export function unsuccessfulDependencyInstallationPrompt(p) {
+    if (p.method.kind === 'Manual') {
+        throw new Error('cannot display unsuccessfulDependencyInstallationPrompt for manual installation');
+    }
+    if (p.method.manualBackupScript === undefined) {
+        return `Installation of ${missingDepsSentence(p)} unsuccessful.`;
+    }
+    return `Installation of ${missingDepsSentence(p)} unsuccessful.
+If you are unable to figure out the issue from the command output below, you can also try running the following manual installation script from a terminal:
+
+${p.method.manualBackupScript}`;
+}

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

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import path from 'path';
-import { FileUri, isWorkspaceFolder, UntitledUri } from './exturi';
+import { FileUri, UntitledUri } from './exturi';
 import { dirExists, fileExists } from './fsHelper';
 // Detect lean4 root directory (works for both lean4 repo and nightly distribution)
 export async function isCoreLean4Directory(path) {
@@ -26,57 +26,58 @@ export async function findLeanProjectRootInfo(uri) {
     if (uri.scheme === 'untitled') {
         return { kind: 'Success', projectRootUri: new UntitledUri(), toolchainUri: undefined };
     }
-    let path = uri;
+    // lean4monaco: Prevent filesystem access:
+    return { kind: 'Success', projectRootUri: uri.join('..'), toolchainUri: undefined };
+    /*
+    let path = uri
     try {
         if ((await fs.promises.stat(path.fsPath)).isFile()) {
-            path = uri.join('..');
+            path = uri.join('..')
         }
+    } catch (e) {
+        return { kind: 'FileNotFound' }
     }
-    catch (e) {
-        return { kind: 'FileNotFound' };
-    }
-    let bestFolder = path;
-    let bestLeanToolchain;
+
+    let bestFolder = path
+    let bestLeanToolchain: FileUri | undefined
     while (true) {
-        const leanToolchain = path.join('lean-toolchain');
-        const lakefileLean = path.join('lakefile.lean');
-        const lakefileToml = path.join('lakefile.toml');
+        const leanToolchain = path.join('lean-toolchain')
+        const lakefileLean = path.join('lakefile.lean')
+        const lakefileToml = path.join('lakefile.toml')
         if (await fileExists(leanToolchain.fsPath)) {
-            bestFolder = path;
-            bestLeanToolchain = leanToolchain;
-        }
-        else if (await isCoreLean4Directory(path)) {
-            bestFolder = path;
-            bestLeanToolchain = undefined;
+            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;
-        }
-        else if (await fileExists(lakefileLean.fsPath)) {
-            return { kind: 'LakefileWithoutToolchain', projectRootUri: path, lakefileUri: lakefileLean };
-        }
-        else if (await fileExists(lakefileToml.fsPath)) {
-            return { kind: 'LakefileWithoutToolchain', projectRootUri: path, lakefileUri: lakefileToml };
+            break
+        } else if (await fileExists(lakefileLean.fsPath)) {
+            return { kind: 'LakefileWithoutToolchain', projectRootUri: path, lakefileUri: lakefileLean }
+        } else if (await fileExists(lakefileToml.fsPath)) {
+            return { kind: 'LakefileWithoutToolchain', projectRootUri: path, lakefileUri: lakefileToml }
         }
         if (isWorkspaceFolder(path)) {
             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 {
+                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;
+                break
             }
         }
-        const parent = path.join('..');
+        const parent = path.join('..')
         if (parent.equals(path)) {
             // no project file found.
-            break;
+            break
         }
-        path = parent;
+        path = parent
     }
-    return { kind: 'Success', projectRootUri: bestFolder, toolchainUri: bestLeanToolchain };
+
+    return { kind: 'Success', projectRootUri: bestFolder, toolchainUri: bestLeanToolchain }
+    */
 }
 export async function findLeanProjectInfo(uri) {
     const info = await findLeanProjectRootInfo(uri);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lean4monaco",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Monaco Editor support for the Lean 4 theorem prover.",
   "keywords": [
     "lean",
@@ -39,7 +39,10 @@
     "watch:copyfiles": "nodemon --watch ./src --exec \"npm run build:copyfiles\"",
     "build:copyfiles": "cd src && copyfiles \"**/*.json\" \"**/*.css\" \"**/*.ttf\" \"**/*.otf\" \"**/*.svg\" ../dist/",
     "build": "tsc && webpack && npm run build:copyfiles",
-    "test": "npm run demo:setup && concurrently --hide 0 --kill-others \"npm start\" \"wait-on http://localhost:5173 && cypress run\" -n server,cypress -s command-cypress"
+    "test:bare": "wait-on http://localhost:5173 && cypress run",
+    "test": "npm run demo:setup && concurrently --hide 0 --kill-others \"npm start\" \"npm run test:bare\" -n server,cypress -s command-cypress",
+    "test:windows:bare": "wait-on http://localhost:5173 && CYPRESS_USER_AGENT_OS=\"Windows NT 10.0; Win64; x64\" cypress run --browser chromium",
+    "test:windows": "npm run demo:setup && concurrently --hide 0 --kill-others \"npm start\" \"npm run test:windows:bare\" -n server,cypress -s command-cypress"
   },
   "dependencies": {
     "@leanprover/infoview": "~0.8.5",

package/dist/lean4-infoview/esm-shims/react-dom.d.ts

@@ -1,5 +0,0 @@
-/** @module See `rollup.config.js` for what this file does. */
-import * as ReactDOM from 'react-dom';
-import { createPortal, createRoot, findDOMNode, flushSync, hydrate, hydrateRoot, render, unmountComponentAtNode, unstable_batchedUpdates, unstable_renderSubtreeIntoContainer, version, __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED } from 'react-dom';
-export default ReactDOM;
-export { __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, createPortal, createRoot, findDOMNode, flushSync, hydrate, hydrateRoot, render, unmountComponentAtNode, unstable_batchedUpdates, unstable_renderSubtreeIntoContainer, version, };

package/dist/lean4-infoview/esm-shims/react-jsx-runtime.d.ts

@@ -1,5 +0,0 @@
-/** @module See `rollup.config.js` for what this file does. */
-import * as Jsx from 'react/jsx-runtime';
-import { Fragment, jsx, jsxs } from 'react/jsx-runtime';
-export default Jsx;
-export { Fragment, jsx, jsxs };

package/dist/lean4-infoview/esm-shims/react.d.ts

@@ -1,5 +0,0 @@
-/** @module See `rollup.config.js` for what this file does. */
-import * as React from 'react';
-export default React;
-import { Children, cloneElement, Component, createContext, createElement, createFactory, createRef, forwardRef, Fragment, isValidElement, lazy, memo, Profiler, PureComponent, startTransition, StrictMode, Suspense, unstable_act, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, useTransition, version, __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED } from 'react';
-export { Children, Component, Fragment, Profiler, PureComponent, StrictMode, Suspense, __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, cloneElement, createContext, createElement, createFactory, createRef, forwardRef, isValidElement, lazy, memo, startTransition, unstable_act, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, useTransition, version, };