lean4monaco 1.0.35 → 1.0.37

package/dist/monaco-lean4/vscode-lean4/src/leanclient.d.ts

@@ -1,67 +0,0 @@
-import { DiagnosticCollection, Disposable, OutputChannel, TextDocument } from 'vscode';
-import { BaseLanguageClient, DidChangeTextDocumentParams, DidCloseTextDocumentParams, InitializeResult, LanguageClientOptions, PublishDiagnosticsParams } from 'vscode-languageclient/node';
-import { LeanFileProgressProcessingInfo, ServerStoppedReason } from '@leanprover/infoview-api';
-import { ExtUri } from './utils/exturi';
-export type ServerProgress = Map<ExtUri, LeanFileProgressProcessingInfo[]>;
-export declare class LeanClient implements Disposable {
-    private setupClient;
-    private isOpenLeanDocument;
-    running: boolean;
-    private client;
-    private outputChannel;
-    folderUri: ExtUri;
-    private subscriptions;
-    private noPrompt;
-    private showingRestartMessage;
-    private elanDefaultToolchain;
-    private isRestarting;
-    private staleDepNotifier;
-    private openServerDocuments;
-    private didChangeEmitter;
-    didChange: import("vscode").Event<DidChangeTextDocumentParams>;
-    private diagnosticsEmitter;
-    diagnostics: import("vscode").Event<PublishDiagnosticsParams>;
-    private didSetLanguageEmitter;
-    didSetLanguage: import("vscode").Event<string>;
-    private didCloseEmitter;
-    didClose: import("vscode").Event<DidCloseTextDocumentParams>;
-    private customNotificationEmitter;
-    /** Fires whenever a custom notification (i.e. one not defined in LSP) is received. */
-    customNotification: import("vscode").Event<{
-        method: string;
-        params: any;
-    }>;
-    /** saved progress info in case infoview is opened, it needs to get all of it. */
-    progress: ServerProgress;
-    private progressChangedEmitter;
-    progressChanged: import("vscode").Event<[string, LeanFileProgressProcessingInfo[]]>;
-    private stoppedEmitter;
-    stopped: import("vscode").Event<ServerStoppedReason>;
-    private restartedEmitter;
-    restarted: import("vscode").Event<unknown>;
-    private restartingEmitter;
-    restarting: import("vscode").Event<unknown>;
-    private restartedWorkerEmitter;
-    restartedWorker: import("vscode").Event<string>;
-    private serverFailedEmitter;
-    serverFailed: import("vscode").Event<string>;
-    constructor(folderUri: ExtUri, outputChannel: OutputChannel, elanDefaultToolchain: string, setupClient: (clientOptions: LanguageClientOptions, folderUri: ExtUri, elanDefaultToolchain: string) => Promise<BaseLanguageClient>, isOpenLeanDocument: (docUri: ExtUri) => boolean);
-    dispose(): void;
-    showRestartMessage(restartFile?: boolean, uri?: ExtUri | undefined): void;
-    restart(): Promise<void>;
-    private startClient;
-    private checkForImportsOutdatedError;
-    withStoppedClient(action: () => Promise<void>): Promise<'Success' | 'IsRestarting'>;
-    isInFolderManagedByThisClient(uri: ExtUri): boolean;
-    getClientFolder(): ExtUri;
-    start(): Promise<void>;
-    isStarted(): boolean;
-    isRunning(): boolean;
-    stop(): Promise<void>;
-    restartFile(doc: TextDocument): Promise<void>;
-    sendRequest(method: string, params: any): Promise<any>;
-    sendNotification(method: string, params: any): Promise<void> | undefined;
-    getDiagnostics(): DiagnosticCollection | undefined;
-    get initializeResult(): InitializeResult | undefined;
-    private obtainClientOptions;
-}

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

@@ -1,443 +0,0 @@
-import { Disposable, DocumentHighlightKind, EventEmitter, ProgressLocation, Range, window, workspace, } from 'vscode';
-import { DiagnosticSeverity, RevealOutputChannelOn, State, } from 'vscode-languageclient/node';
-import { getElaborationDelay, getFallBackToStringOccurrenceHighlighting, shouldAutofocusOutput, } from './config';
-import { logger } from './utils/logger';
-// @ts-ignore
-import { SemVer } from 'semver';
-import { c2pConverter, p2cConverter, patchConverters, setDependencyBuildMode } from './utils/converters';
-import { parseExtUri, toExtUri } from './utils/exturi';
-import { displayError, displayErrorWithOptionalInput, displayErrorWithOutput, displayInformationWithOptionalInput, } from './utils/notifs';
-import path from 'path';
-const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-export class LeanClient {
-    setupClient;
-    isOpenLeanDocument;
-    running;
-    client;
-    outputChannel;
-    folderUri;
-    subscriptions = [];
-    noPrompt = false;
-    showingRestartMessage = false;
-    elanDefaultToolchain;
-    isRestarting = false;
-    staleDepNotifier;
-    openServerDocuments = new Set();
-    didChangeEmitter = new EventEmitter();
-    didChange = this.didChangeEmitter.event;
-    diagnosticsEmitter = new EventEmitter();
-    diagnostics = this.diagnosticsEmitter.event;
-    didSetLanguageEmitter = new EventEmitter();
-    didSetLanguage = this.didSetLanguageEmitter.event;
-    didCloseEmitter = new EventEmitter();
-    didClose = this.didCloseEmitter.event;
-    customNotificationEmitter = new EventEmitter();
-    /** Fires whenever a custom notification (i.e. one not defined in LSP) is received. */
-    customNotification = this.customNotificationEmitter.event;
-    /** saved progress info in case infoview is opened, it needs to get all of it. */
-    progress = new Map();
-    progressChangedEmitter = new EventEmitter();
-    progressChanged = this.progressChangedEmitter.event;
-    stoppedEmitter = new EventEmitter();
-    stopped = this.stoppedEmitter.event;
-    restartedEmitter = new EventEmitter();
-    restarted = this.restartedEmitter.event;
-    restartingEmitter = new EventEmitter();
-    restarting = this.restartingEmitter.event;
-    restartedWorkerEmitter = new EventEmitter();
-    restartedWorker = this.restartedWorkerEmitter.event;
-    serverFailedEmitter = new EventEmitter();
-    serverFailed = this.serverFailedEmitter.event;
-    constructor(folderUri, outputChannel, elanDefaultToolchain, setupClient, isOpenLeanDocument) {
-        this.setupClient = setupClient;
-        this.isOpenLeanDocument = isOpenLeanDocument;
-        this.outputChannel = outputChannel; // can be null when opening adhoc files.
-        this.folderUri = folderUri;
-        this.elanDefaultToolchain = elanDefaultToolchain;
-        this.subscriptions.push(new Disposable(() => {
-            if (this.staleDepNotifier) {
-                this.staleDepNotifier.dispose();
-            }
-        }));
-    }
-    dispose() {
-        this.subscriptions.forEach(s => s.dispose());
-        if (this.isStarted())
-            void this.stop();
-    }
-    showRestartMessage(restartFile = false, uri) {
-        if (this.showingRestartMessage) {
-            return;
-        }
-        this.showingRestartMessage = true;
-        const finalizer = () => {
-            this.showingRestartMessage = false;
-        };
-        let restartItem;
-        let messageTitle;
-        if (!restartFile) {
-            restartItem = 'Restart Lean Server';
-            messageTitle = 'Lean Server has stopped unexpectedly.';
-        }
-        else {
-            restartItem = 'Restart Lean Server on this file';
-            messageTitle = 'The Lean Server has stopped processing this file.';
-        }
-        displayErrorWithOptionalInput(messageTitle, restartItem, () => {
-            if (restartFile && uri !== undefined) {
-                const document = workspace.textDocuments.find(doc => uri.equalsUri(doc.uri));
-                if (document) {
-                    void this.restartFile(document);
-                }
-            }
-            else {
-                void this.start();
-            }
-        }, finalizer);
-    }
-    async restart() {
-        if (this.isRestarting) {
-            displayError('Client is already being started.');
-            return;
-        }
-        this.isRestarting = true;
-        try {
-            logger.log('[LeanClient] Restarting Lean Server');
-            if (this.isStarted()) {
-                await this.stop();
-            }
-            this.restartingEmitter.fire(undefined);
-            const progressOptions = {
-                location: ProgressLocation.Notification,
-                title: 'Starting Lean language client',
-                cancellable: false,
-            };
-            await window.withProgress(progressOptions, async (progress) => await this.startClient(progress));
-        }
-        finally {
-            this.isRestarting = false;
-        }
-    }
-    async startClient(progress) {
-        // Should only be called from `restart`
-        const startTime = Date.now();
-        progress.report({ increment: 0 });
-        this.client = await this.setupClient(this.obtainClientOptions(), this.folderUri, this.elanDefaultToolchain);
-        patchConverters(this.client.protocol2CodeConverter, this.client.code2ProtocolConverter);
-        let insideRestart = true;
-        try {
-            this.client.onDidChangeState(async (s) => {
-                // see https://github.com/microsoft/vscode-languageserver-node/issues/825
-                if (s.newState === State.Starting) {
-                    logger.log('[LeanClient] starting');
-                }
-                else if (s.newState === State.Running) {
-                    const end = Date.now();
-                    logger.log(`[LeanClient] running, started in ${end - startTime} ms`);
-                    this.running = true; // may have been auto restarted after it failed.
-                    if (!insideRestart) {
-                        this.restartedEmitter.fire(undefined);
-                    }
-                }
-                else if (s.newState === State.Stopped) {
-                    this.running = false;
-                    logger.log('[LeanClient] has stopped or it failed to start');
-                    if (!this.noPrompt) {
-                        // only raise this event and show the message if we are not the ones
-                        // who called the stop() method.
-                        this.stoppedEmitter.fire({ message: 'Lean server has stopped.', reason: '' });
-                        this.showRestartMessage();
-                    }
-                }
-            });
-            progress.report({ increment: 80 });
-            await this.client.start();
-            const version = this.client.initializeResult?.serverInfo?.version;
-            if (version && new SemVer(version).compare('0.2.0') < 0) {
-                if (this.staleDepNotifier) {
-                    this.staleDepNotifier.dispose();
-                }
-                this.staleDepNotifier = this.diagnostics(params => this.checkForImportsOutdatedError(params));
-            }
-            // if we got this far then the client is happy so we are running!
-            this.running = true;
-        }
-        catch (error) {
-            const msg = '' + error;
-            logger.log(`[LeanClient] restart error ${msg}`);
-            this.outputChannel.appendLine(msg);
-            this.serverFailedEmitter.fire(msg);
-            insideRestart = false;
-            return;
-        }
-        // HACK(WN): Register a default notification handler to fire on custom notifications.
-        // A mechanism to do this is provided in vscode-jsonrpc. One can register a `StarNotificationHandler`
-        // here: https://github.com/microsoft/vscode-languageserver-node/blob/b2fc85d28a1a44c22896559ee5f4d3ba37a02ef5/jsonrpc/src/common/connection.ts#L497
-        // which fires on any LSP notifications not in the standard, for example the `$/lean/..` ones.
-        // However this mechanism is not exposed in vscode-languageclient, so we hack around its implementation.
-        const starHandler = (method, params_) => {
-            if (method === '$/lean/fileProgress' && this.client) {
-                const params = params_;
-                const uri = toExtUri(p2cConverter.asUri(params.textDocument.uri));
-                if (uri !== undefined) {
-                    this.progressChangedEmitter.fire([uri.toString(), params.processing]);
-                    // save the latest progress on this Uri in case infoview needs it later.
-                    this.progress.set(uri, params.processing);
-                }
-            }
-            this.customNotificationEmitter.fire({ method, params: params_ });
-        };
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        this.client.onNotification(starHandler, () => { });
-        // Reveal the standard error output channel when the server prints something to stderr.
-        // The vscode-languageclient library already takes care of writing it to the output channel.
-        let stderrMsgBoxVisible = false;
-        this.client._serverProcess.stderr.on('data', async (chunk) => {
-            if (shouldAutofocusOutput()) {
-                this.client?.outputChannel.show(true);
-            }
-            else if (!stderrMsgBoxVisible) {
-                stderrMsgBoxVisible = true;
-                const finalizer = () => {
-                    stderrMsgBoxVisible = false;
-                };
-                displayErrorWithOutput(`Lean server printed an error:\n${chunk.toString()}`, finalizer);
-            }
-        });
-        this.restartedEmitter.fire(undefined);
-        insideRestart = false;
-    }
-    checkForImportsOutdatedError(params) {
-        const fileUri = parseExtUri(params.uri);
-        if (fileUri === undefined) {
-            return;
-        }
-        const fileName = fileUri.scheme === 'file' ? path.basename(fileUri.fsPath) : 'untitled';
-        const isImportsOutdatedError = params.diagnostics.some(d => d.severity === DiagnosticSeverity.Error &&
-            d.message.includes('Imports are out of date and must be rebuilt') &&
-            d.range.start.line === 0 &&
-            d.range.start.character === 0 &&
-            d.range.end.line === 0 &&
-            d.range.end.character === 0);
-        if (!isImportsOutdatedError) {
-            return;
-        }
-        const message = `Imports of '${fileName}' are out of date and must be rebuilt. Restarting the file will rebuild them.`;
-        const input = 'Restart File';
-        displayInformationWithOptionalInput(message, input, () => {
-            const document = workspace.textDocuments.find(doc => fileUri.equalsUri(doc.uri));
-            if (!document || document.isClosed) {
-                displayError(`'${fileName}' was closed in the meantime. Imports will not be rebuilt.`);
-                return;
-            }
-            void this.restartFile(document);
-        });
-    }
-    async withStoppedClient(action) {
-        if (this.isRestarting) {
-            return 'IsRestarting';
-        }
-        this.isRestarting = true; // Ensure that client cannot be restarted in the mean-time
-        if (this.isStarted()) {
-            await this.stop();
-        }
-        await action();
-        this.isRestarting = false;
-        await this.restart();
-        return 'Success';
-    }
-    isInFolderManagedByThisClient(uri) {
-        if (this.folderUri.scheme === 'untitled' && uri.scheme === 'untitled') {
-            return true;
-        }
-        if (this.folderUri.scheme === 'file' && uri.scheme === 'file') {
-            return uri.isInFolder(this.folderUri);
-        }
-        return false;
-    }
-    getClientFolder() {
-        return this.folderUri;
-    }
-    start() {
-        return this.restart();
-    }
-    isStarted() {
-        return this.client !== undefined;
-    }
-    isRunning() {
-        if (this.client) {
-            return this.running;
-        }
-        return false;
-    }
-    async stop() {
-        if (this.client && this.running) {
-            this.noPrompt = true;
-            try {
-                // some timing conditions can happen while running unit tests that cause
-                // this to throw an exception which then causes those tests to fail.
-                await this.client.stop();
-            }
-            catch (e) {
-                logger.log(`[LeanClient] Error stopping language client: ${e}`);
-            }
-        }
-        this.noPrompt = false;
-        this.progress = new Map();
-        this.client = undefined;
-        this.openServerDocuments = new Set();
-        this.running = false;
-    }
-    async restartFile(doc) {
-        if (this.client === undefined || !this.running)
-            return; // there was a problem starting lean server.
-        const docUri = toExtUri(doc.uri);
-        if (docUri === undefined) {
-            return;
-        }
-        if (!this.isInFolderManagedByThisClient(docUri)) {
-            return;
-        }
-        const uri = docUri.toString();
-        if (!this.openServerDocuments.delete(uri)) {
-            return;
-        }
-        logger.log(`[LeanClient] Restarting File: ${uri}`);
-        await this.client.sendNotification('textDocument/didClose', this.client.code2ProtocolConverter.asCloseTextDocumentParams(doc));
-        if (this.openServerDocuments.has(uri)) {
-            return;
-        }
-        this.openServerDocuments.add(uri);
-        await this.client.sendNotification('textDocument/didOpen', setDependencyBuildMode(this.client.code2ProtocolConverter.asOpenTextDocumentParams(doc), 'once'));
-        this.restartedWorkerEmitter.fire(uri);
-    }
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-    sendRequest(method, params) {
-        return this.running && this.client
-            ? this.client.sendRequest(method, params)
-            : new Promise((_, reject) => {
-                reject('Client is not running');
-            });
-    }
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-    sendNotification(method, params) {
-        return this.running && this.client ? this.client.sendNotification(method, params) : undefined;
-    }
-    getDiagnostics() {
-        return this.running ? this.client?.diagnostics : undefined;
-    }
-    get initializeResult() {
-        return this.running ? this.client?.initializeResult : undefined;
-    }
-    obtainClientOptions() {
-        const documentSelector = {
-            language: 'lean4',
-        };
-        let workspaceFolder;
-        documentSelector.scheme = this.folderUri.scheme;
-        if (this.folderUri.scheme === 'file') {
-            documentSelector.pattern = `${this.folderUri.fsPath}/**/*`;
-            workspaceFolder = {
-                uri: this.folderUri.asUri(),
-                name: path.basename(this.folderUri.fsPath),
-                index: 0, // the language client library does not actually need this index
-            };
-        }
-        return {
-            outputChannel: this.outputChannel,
-            revealOutputChannelOn: RevealOutputChannelOn.Never, // contrary to the name, this disables the message boxes
-            documentSelector: [documentSelector],
-            workspaceFolder,
-            initializationOptions: {
-                editDelay: getElaborationDelay(),
-                hasWidgets: true,
-            },
-            connectionOptions: {
-                maxRestartCount: 0,
-                cancellationStrategy: undefined,
-            },
-            middleware: {
-                handleDiagnostics: (uri, diagnostics, next) => {
-                    next(uri, diagnostics);
-                    const uri_ = c2pConverter.asUri(uri);
-                    const diagnostics_ = [];
-                    for (const d of diagnostics) {
-                        const d_ = {
-                            ...c2pConverter.asDiagnostic(d),
-                        };
-                        diagnostics_.push(d_);
-                    }
-                    this.diagnosticsEmitter.fire({ uri: uri_, diagnostics: diagnostics_ });
-                },
-                didOpen: async (doc, next) => {
-                    const docUri = toExtUri(doc.uri);
-                    if (!docUri) {
-                        return; // This should never happen since the glob we launch the client for ensures that all uris are ext uris
-                    }
-                    const docIsOpen = this.isOpenLeanDocument(docUri);
-                    if (!docIsOpen) {
-                        // The language client library emits a `didOpen` notification when hovering over an identifier while holding `Ctrl` in order to provide a preview for the line that the definition is on.
-                        // In Lean, this is very expensive and hence does not make much sense, so we filter these notification here.
-                        // Should VS Code decide to send requests to a file that was filtered here, the language server will respond with an error, which VS Code will silently discard and interpret as having received an empty response.
-                        // See https://github.com/microsoft/vscode/issues/78453 (the solution suggested in the thread is wrong, but `collectAllOpenLeanDocumentUris` works).
-                    }
-                    if (this.openServerDocuments.has(docUri.toString())) {
-                        return;
-                    }
-                    this.openServerDocuments.add(docUri.toString());
-                    await next(doc);
-                    // Opening the document may have set the language ID.
-                    this.didSetLanguageEmitter.fire(doc.languageId);
-                },
-                didChange: async (data, next) => {
-                    await next(data);
-                    const params = c2pConverter.asChangeTextDocumentParams(data, data.document.uri, data.document.version);
-                    this.didChangeEmitter.fire(params);
-                },
-                didClose: async (doc, next) => {
-                    const docUri = toExtUri(doc.uri);
-                    if (!docUri) {
-                        return; // This should never happen since the glob we launch the client for ensures that all uris are ext uris
-                    }
-                    if (!this.openServerDocuments.delete(docUri.toString())) {
-                        // Do not send `didClose` if we filtered the corresponding `didOpen` (see comment in the `didOpen` middleware).
-                        // The language server is only resilient against requests for closed files, not the `didClose` notification itself.
-                        return;
-                    }
-                    await next(doc);
-                    const params = c2pConverter.asCloseTextDocumentParams(doc);
-                    this.didCloseEmitter.fire(params);
-                },
-                provideDocumentHighlights: async (doc, pos, ctok, next) => {
-                    const leanHighlights = await next(doc, pos, ctok);
-                    if (leanHighlights?.length)
-                        return leanHighlights;
-                    // vscode doesn't fall back to textual highlights, so we
-                    // need to do that manually if the user asked for it
-                    if (!getFallBackToStringOccurrenceHighlighting()) {
-                        return [];
-                    }
-                    await new Promise(res => setTimeout(res, 250));
-                    if (ctok.isCancellationRequested)
-                        return;
-                    const wordRange = doc.getWordRangeAtPosition(pos);
-                    if (!wordRange)
-                        return;
-                    const word = doc.getText(wordRange);
-                    const highlights = [];
-                    const text = doc.getText();
-                    const nonWordPattern = '[`~@$%^&*()-=+\\[{\\]}⟨⟩⦃⦄⟦⟧⟮⟯‹›\\\\|;:",./\\s]|^|$';
-                    const regexp = new RegExp(`(?<=${nonWordPattern})${escapeRegExp(word)}(?=${nonWordPattern})`, 'g');
-                    for (const match of text.matchAll(regexp)) {
-                        const start = doc.positionAt(match.index ?? 0);
-                        highlights.push({
-                            range: new Range(start, start.translate(0, match[0].length)),
-                            kind: DocumentHighlightKind.Text,
-                        });
-                    }
-                    return highlights;
-                },
-            },
-        };
-    }
-}

package/dist/monaco-lean4/vscode-lean4/src/rpc.d.ts

@@ -1,16 +0,0 @@
-export declare class Rpc {
-    readonly sendMessage: (msg: any) => void;
-    private seqNum;
-    private methods;
-    private pending;
-    /** Resolves when both sides of the channel are ready to receive procedure calls. */
-    private initPromise;
-    private resolveInit;
-    private initialized;
-    constructor(sendMessage: (msg: any) => void);
-    /** Register procedures that the other side of the channel can invoke. Must be called exactly once. */
-    register<T>(methods: T): void;
-    messageReceived(msg: any): void;
-    invoke(name: string, args: any[]): Promise<any>;
-    getApi<T>(): T;
-}

package/dist/monaco-lean4/vscode-lean4/src/rpc.js

@@ -1,102 +0,0 @@
-export class Rpc {
-    sendMessage;
-    seqNum = 0;
-    methods = {};
-    pending = {};
-    /** Resolves when both sides of the channel are ready to receive procedure calls. */
-    initPromise;
-    resolveInit;
-    initialized = false;
-    constructor(sendMessage) {
-        this.sendMessage = sendMessage;
-        this.resolveInit = () => { }; // pacify the typechecker; the real initializer is below
-        this.initPromise = new Promise(resolve => {
-            this.resolveInit = resolve;
-        });
-    }
-    /** Register procedures that the other side of the channel can invoke. Must be called exactly once. */
-    register(methods) {
-        if (this.initialized)
-            throw new Error('RPC methods already registered');
-        this.methods = { ...methods };
-        const interval = setInterval(() => {
-            this.sendMessage({ kind: 'initialize' });
-        }, 50);
-        const prevResolveInit = this.resolveInit;
-        this.resolveInit = () => {
-            clearInterval(interval);
-            prevResolveInit();
-        };
-        this.initialized = true;
-    }
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-    messageReceived(msg) {
-        if (msg.kind) {
-            if (msg.kind === 'initialize') {
-                this.sendMessage({ kind: 'initialized' });
-            }
-            else if (msg.kind === 'initialized' && this.initialized) {
-                this.resolveInit();
-            }
-            return;
-        }
-        const { seqNum, name, args, result, exception } = msg;
-        if (seqNum === undefined)
-            return;
-        if (name !== undefined) {
-            // It's important that we wait on `initPromise` here. Otherwise we may try to invoke
-            // a method before `register` is called.
-            return void this.initPromise.then(async () => {
-                try {
-                    const fn = this.methods[name];
-                    if (fn === undefined)
-                        throw new Error(`unknown RPC method ${name}`);
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                    this.sendMessage({ seqNum, result: await fn(...args) });
-                }
-                catch (ex) {
-                    this.sendMessage({ seqNum, exception: prepareExceptionForSerialization(ex) });
-                }
-            });
-        }
-        if (exception !== undefined) {
-            this.pending[seqNum].reject(exception);
-        }
-        else {
-            this.pending[seqNum].resolve(result);
-        }
-        delete this.pending[seqNum];
-    }
-    async invoke(name, args) {
-        await this.initPromise;
-        this.seqNum += 1;
-        const seqNum = this.seqNum;
-        return new Promise((resolve, reject) => {
-            this.pending[seqNum] = { resolve, reject };
-            this.sendMessage({ seqNum, name, args });
-        });
-    }
-    getApi() {
-        return new Proxy({}, {
-            get: (_, prop) => (...args) => this.invoke(prop, args),
-        });
-    }
-}
-function prepareExceptionForSerialization(ex) {
-    if (ex === undefined) {
-        return 'error';
-    }
-    else if (typeof ex === 'object' && !(ex instanceof Array)) {
-        /* Certain properties (such as `ex.message`) are not /enumerable/ per ECMAScript
-         * and disappear along the way through `Webview.postMessage`; we create a new object
-         * so that they make it through. */
-        const exOut = {};
-        for (const p of Object.getOwnPropertyNames(ex)) {
-            exOut[p] = ex[p];
-        }
-        return exOut;
-    }
-    else {
-        return ex;
-    }
-}

package/dist/monaco-lean4/vscode-lean4/src/taskgutter.d.ts

@@ -1,11 +0,0 @@
-import { Disposable, ExtensionContext } from 'vscode';
-import { LeanClientProvider } from './utils/clientProvider';
-export declare class LeanTaskGutter implements Disposable {
-    private decorations;
-    private status;
-    private gutters;
-    private subscriptions;
-    constructor(client: LeanClientProvider, context: ExtensionContext);
-    private updateDecos;
-    dispose(): void;
-}