lean4monaco 1.1.3 → 1.1.5

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

@@ -1,130 +0,0 @@
-import { LeanFileProgressKind } from '@leanprover/infoview-api';
-import { OverviewRulerLane, Range, window } from 'vscode';
-class LeanFileTaskGutter {
-    uri;
-    decorations;
-    processed;
-    timeout;
-    constructor(uri, decorations, processed) {
-        this.uri = uri;
-        this.decorations = decorations;
-        this.processed = processed;
-        this.schedule(100);
-    }
-    setProcessed(processed) {
-        if (processed === this.processed)
-            return;
-        const oldProcessed = this.processed;
-        this.processed = processed;
-        if (processed === undefined) {
-            this.processed = [];
-            this.clearTimeout();
-            this.updateDecos();
-        }
-        else if (this.timeout === undefined) {
-            this.schedule(oldProcessed === undefined ? 500 : 20);
-        }
-    }
-    schedule(ms) {
-        this.timeout = setTimeout(() => {
-            this.timeout = undefined;
-            this.updateDecos();
-        }, ms);
-    }
-    clearTimeout() {
-        if (this.timeout !== undefined) {
-            clearTimeout(this.timeout);
-            this.timeout = undefined;
-        }
-    }
-    updateDecos() {
-        for (const editor of window.visibleTextEditors) {
-            if (editor.document.uri.toString() === this.uri) {
-                for (const [kind, [decoration, message]] of this.decorations) {
-                    editor.setDecorations(decoration, this.processed
-                        .filter(info => (info.kind === undefined ? LeanFileProgressKind.Processing : info.kind) === kind)
-                        .map(info => ({
-                        range: new Range(info.range.start.line, 0, info.range.end.line, 0),
-                        hoverMessage: message,
-                    })));
-                }
-            }
-        }
-    }
-    dispose() {
-        this.clearTimeout();
-    }
-}
-export class LeanTaskGutter {
-    decorations = new Map();
-    status = {};
-    gutters = {};
-    subscriptions = [];
-    constructor(client, context) {
-        this.decorations.set(LeanFileProgressKind.Processing, [
-            window.createTextEditorDecorationType({
-                overviewRulerLane: OverviewRulerLane.Left,
-                overviewRulerColor: 'rgba(255, 165, 0, 0.5)',
-                dark: {
-                    gutterIconPath: context.asAbsolutePath('media/progress-dark.svg'),
-                },
-                light: {
-                    gutterIconPath: context.asAbsolutePath('media/progress-light.svg'),
-                },
-                gutterIconSize: 'contain',
-            }),
-            'busily processing...',
-        ]);
-        this.decorations.set(LeanFileProgressKind.FatalError, [
-            window.createTextEditorDecorationType({
-                overviewRulerLane: OverviewRulerLane.Left,
-                overviewRulerColor: 'rgba(255, 0, 0, 0.5)',
-                dark: {
-                    gutterIconPath: context.asAbsolutePath('media/progress-error-dark.svg'),
-                },
-                light: {
-                    gutterIconPath: context.asAbsolutePath('media/progress-error-light.svg'),
-                },
-                gutterIconSize: 'contain',
-            }),
-            'processing stopped',
-        ]);
-        this.subscriptions.push(window.onDidChangeVisibleTextEditors(() => this.updateDecos()), client.progressChanged(([uri, processing]) => {
-            this.status[uri] = processing;
-            this.updateDecos();
-        }));
-    }
-    updateDecos() {
-        const uris = {};
-        for (const editor of window.visibleTextEditors) {
-            if (editor.document.languageId !== 'lean4')
-                continue;
-            const uri = editor.document.uri.toString();
-            uris[uri] = true;
-            const processed = uri in this.status ? this.status[uri] : [];
-            if (this.gutters[uri]) {
-                const gutter = this.gutters[uri];
-                if (gutter)
-                    gutter.setProcessed(processed);
-            }
-            else {
-                this.gutters[uri] = new LeanFileTaskGutter(uri, this.decorations, processed);
-            }
-        }
-        for (const uri of Object.getOwnPropertyNames(this.gutters)) {
-            if (!uris[uri]) {
-                this.gutters[uri]?.dispose();
-                this.gutters[uri] = undefined;
-                // TODO: also clear this.status for this uri ?
-            }
-        }
-    }
-    dispose() {
-        for (const [decoration, _message] of this.decorations.values()) {
-            decoration.dispose();
-        }
-        for (const s of this.subscriptions) {
-            s.dispose();
-        }
-    }
-}

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

@@ -1,37 +0,0 @@
-/// <reference types="node" />
-import { ChildProcessWithoutNullStreams } from 'child_process';
-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 batchExecuteWithProc(executablePath: string, args: string[], workingDirectory?: string | undefined, channel?: ExecutionChannel | undefined): [ChildProcessWithoutNullStreams | 'CannotLaunch', Promise<ExecutionResult>];
-export declare function batchExecute(executablePath: string, args: string[], workingDirectory?: string | undefined, channel?: ExecutionChannel | undefined): Promise<ExecutionResult>;
-interface ProgressExecutionOptions {
-    cwd?: string | undefined;
-    channel?: OutputChannel | undefined;
-    translator?: ((line: string) => string | undefined) | undefined;
-    allowCancellation?: boolean;
-}
-export declare function batchExecuteWithProgress(executablePath: string, args: string[], title: string, options?: ProgressExecutionOptions): Promise<ExecutionResult>;
-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 {};

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

@@ -1,203 +0,0 @@
-import { spawn } from 'child_process';
-import { ProgressLocation, window } from 'vscode';
-import { logger } from './logger';
-import { displayErrorWithOutput } 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 = {}));
-function createCannotLaunchExecutionResult(message) {
-    return {
-        exitCode: ExecutionExitCode.CannotLaunch,
-        stdout: message,
-        stderr: '',
-        combined: message,
-    };
-}
-export function batchExecuteWithProc(executablePath, args, workingDirectory, channel) {
-    let stdout = '';
-    let stderr = '';
-    let combined = '';
-    let options = {};
-    if (workingDirectory !== undefined) {
-        options = { cwd: workingDirectory };
-    }
-    if (channel?.combined) {
-        const formattedCwd = workingDirectory ? `${workingDirectory}` : '';
-        const formattedArgs = args.map(arg => (arg.includes(' ') ? `"${arg}"` : arg)).join(' ');
-        channel.combined.appendLine(`${formattedCwd}> ${executablePath} ${formattedArgs}`);
-    }
-    let proc;
-    try {
-        proc = spawn(executablePath, args, options);
-    }
-    catch (e) {
-        return ['CannotLaunch', new Promise(resolve => resolve(createCannotLaunchExecutionResult('')))];
-    }
-    const execPromise = new Promise(resolve => {
-        const conclude = (r) => resolve({
-            exitCode: r.exitCode,
-            stdout: r.stdout.trim(),
-            stderr: r.stderr.trim(),
-            combined: r.combined.trim(),
-        });
-        proc.on('error', err => {
-            conclude(createCannotLaunchExecutionResult(err.message));
-        });
-        proc.stdout.on('data', line => {
-            const s = line.toString();
-            if (channel?.combined)
-                channel.combined.appendLine(s);
-            if (channel?.stdout)
-                channel.stdout.appendLine(s);
-            stdout += s + '\n';
-            combined += s + '\n';
-        });
-        proc.stderr.on('data', line => {
-            const s = line.toString();
-            if (channel?.combined)
-                channel.combined.appendLine(s);
-            if (channel?.stderr)
-                channel.stderr.appendLine(s);
-            stderr += s + '\n';
-            combined += s + '\n';
-        });
-        proc.on('close', (code, signal) => {
-            logger.log(`child process exited with code ${code}`);
-            if (signal === 'SIGTERM') {
-                if (channel?.combined) {
-                    channel.combined.appendLine('=> Operation cancelled by user.');
-                }
-                conclude({
-                    exitCode: ExecutionExitCode.Cancelled,
-                    stdout,
-                    stderr,
-                    combined,
-                });
-                return;
-            }
-            if (code !== 0) {
-                if (channel?.combined) {
-                    const formattedCode = code ? `Exit code: ${code}.` : '';
-                    const formattedSignal = signal ? `Signal: ${signal}.` : '';
-                    channel.combined.appendLine(`=> Operation failed. ${formattedCode} ${formattedSignal}`.trim());
-                }
-                conclude({
-                    exitCode: ExecutionExitCode.ExecutionError,
-                    stdout,
-                    stderr,
-                    combined,
-                });
-                return;
-            }
-            conclude({
-                exitCode: ExecutionExitCode.Success,
-                stdout,
-                stderr,
-                combined,
-            });
-        });
-    });
-    return [proc, execPromise];
-}
-export async function batchExecute(executablePath, args, workingDirectory, channel) {
-    const [_, execPromise] = batchExecuteWithProc(executablePath, args, workingDirectory, channel);
-    return execPromise;
-}
-export async function batchExecuteWithProgress(executablePath, args, title, options = {}) {
-    const titleSuffix = options.channel ? ' [(Details)](command:lean4.troubleshooting.showOutput)' : '';
-    const progressOptions = {
-        location: ProgressLocation.Notification,
-        title: title + titleSuffix,
-        cancellable: options.allowCancellation === true,
-    };
-    let inc = 0;
-    let lastReportedMessage;
-    let progress;
-    const progressChannel = {
-        name: 'ProgressChannel',
-        append(value) {
-            if (options.translator) {
-                const translatedValue = options.translator(value);
-                if (translatedValue === undefined) {
-                    return;
-                }
-                value = translatedValue;
-            }
-            if (options.channel) {
-                options.channel.appendLine(value.trimEnd());
-            }
-            if (inc < 90) {
-                inc += 2;
-            }
-            if (progress !== undefined) {
-                progress.report({ increment: inc, message: value });
-            }
-            lastReportedMessage = value;
-        },
-        appendLine(value) {
-            this.append(value + '\n');
-        },
-        replace(_) {
-            /* empty */
-        },
-        clear() {
-            /* empty */
-        },
-        show() {
-            /* empty */
-        },
-        hide() {
-            /* empty */
-        },
-        dispose() {
-            /* empty */
-        },
-    };
-    const expensiveExecutionTimeoutPromise = new Promise((resolve, _) => setTimeout(() => resolve(undefined), 250));
-    const [proc, executionPromise] = batchExecuteWithProc(executablePath, args, options.cwd, {
-        combined: progressChannel,
-    });
-    if (proc === 'CannotLaunch') {
-        return executionPromise; // resolves to a 'CannotLaunch' ExecutionResult
-    }
-    const preliminaryResult = await Promise.race([expensiveExecutionTimeoutPromise, executionPromise]);
-    if (preliminaryResult !== undefined) {
-        return preliminaryResult;
-    }
-    // Execution already took longer than 250ms, let's start displaying a progress bar now
-    const result = await window.withProgress(progressOptions, (p, token) => {
-        progress = p;
-        token.onCancellationRequested(() => proc.kill());
-        progress.report({ message: lastReportedMessage, increment: inc });
-        return executionPromise;
-    });
-    return result;
-}
-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);
-    displayErrorWithOutput(errorMessage);
-}
-function formatErrorMessage(error, message) {
-    if (error.combined === '') {
-        return `${message}`;
-    }
-    return `${message} Command output: ${error.combined}`;
-}

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

@@ -1,41 +0,0 @@
-import { LeanFileProgressProcessingInfo, ServerStoppedReason } from '@leanprover/infoview-api';
-import { Disposable, OutputChannel, TextDocument } from 'vscode';
-import { PreconditionCheckResult } from '../diagnostics/setupNotifs';
-import { LeanClient } from '../leanclient';
-import { ExtUri } from './exturi';
-import { LeanInstaller } from './leanInstaller';
-import { BaseLanguageClient, LanguageClientOptions } from 'vscode-languageclient/node';
-export declare class LeanClientProvider implements Disposable {
-    private setupClient;
-    private checkLean4ProjectPreconditions;
-    private isOpenLeanDocument;
-    private subscriptions;
-    private outputChannel;
-    private installer;
-    private clients;
-    private pending;
-    private pendingInstallChanged;
-    private processingInstallChanged;
-    private activeClient;
-    private progressChangedEmitter;
-    progressChanged: import("vscode").Event<[string, LeanFileProgressProcessingInfo[]]>;
-    private clientAddedEmitter;
-    clientAdded: import("vscode").Event<LeanClient>;
-    private clientRemovedEmitter;
-    clientRemoved: import("vscode").Event<LeanClient>;
-    private clientStoppedEmitter;
-    clientStopped: import("vscode").Event<[LeanClient, boolean, ServerStoppedReason]>;
-    constructor(installer: LeanInstaller, outputChannel: OutputChannel, setupClient: (clientOptions: LanguageClientOptions, folderUri: ExtUri, elanDefaultToolchain: string) => Promise<BaseLanguageClient>, checkLean4ProjectPreconditions: (channel: OutputChannel, folderUri: ExtUri) => Promise<PreconditionCheckResult>, isOpenLeanDocument: (docUri: ExtUri) => boolean);
-    getActiveClient(): LeanClient | undefined;
-    private onInstallChanged;
-    private restartFile;
-    private stopActiveClient;
-    private restartActiveClient;
-    clientIsStarted(): void;
-    didOpenEditor(document: TextDocument): Promise<void>;
-    findClient(path: ExtUri): LeanClient | undefined;
-    getClients(): LeanClient[];
-    getClientForFolder(folder: ExtUri): LeanClient | undefined;
-    ensureClient(uri: ExtUri): Promise<[boolean, LeanClient | undefined]>;
-    dispose(): void;
-}

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

@@ -1,205 +0,0 @@
-import { EventEmitter, commands, window, workspace } from 'vscode';
-import { LeanClient } from '../leanclient';
-import { UntitledUri, getWorkspaceFolderUri, toExtUri } from './exturi';
-import { logger } from './logger';
-import { displayError } from './notifs';
-import { findLeanProjectRoot } from './projectInfo';
-// This class ensures we have one LeanClient per folder.
-export class LeanClientProvider {
-    setupClient;
-    checkLean4ProjectPreconditions;
-    isOpenLeanDocument;
-    subscriptions = [];
-    outputChannel;
-    installer;
-    clients = new Map();
-    pending = new Map();
-    pendingInstallChanged = [];
-    processingInstallChanged = false;
-    activeClient = undefined;
-    progressChangedEmitter = new EventEmitter();
-    progressChanged = this.progressChangedEmitter.event;
-    clientAddedEmitter = new EventEmitter();
-    clientAdded = this.clientAddedEmitter.event;
-    clientRemovedEmitter = new EventEmitter();
-    clientRemoved = this.clientRemovedEmitter.event;
-    clientStoppedEmitter = new EventEmitter();
-    clientStopped = this.clientStoppedEmitter.event;
-    constructor(installer, outputChannel, setupClient, checkLean4ProjectPreconditions, isOpenLeanDocument) {
-        this.setupClient = setupClient;
-        this.checkLean4ProjectPreconditions = checkLean4ProjectPreconditions;
-        this.isOpenLeanDocument = isOpenLeanDocument;
-        this.outputChannel = outputChannel;
-        this.installer = installer;
-        // we must setup the installChanged event handler first before any didOpenEditor calls.
-        this.subscriptions.push(installer.installChanged(async (uri) => await this.onInstallChanged(uri)));
-        window.visibleTextEditors.forEach(e => this.didOpenEditor(e.document));
-        this.subscriptions.push(window.onDidChangeActiveTextEditor(async (e) => {
-            if (!e) {
-                return;
-            }
-            await this.didOpenEditor(e.document);
-        }));
-        this.subscriptions.push(commands.registerCommand('lean4.restartFile', () => this.restartFile()), commands.registerCommand('lean4.refreshFileDependencies', () => this.restartFile()), commands.registerCommand('lean4.restartServer', () => this.restartActiveClient()), commands.registerCommand('lean4.stopServer', () => this.stopActiveClient()));
-        this.subscriptions.push(workspace.onDidOpenTextDocument(document => this.didOpenEditor(document)));
-        this.subscriptions.push(workspace.onDidChangeWorkspaceFolders(event => {
-            // Remove all clients that are not referenced by any folder anymore
-            if (event.removed.length === 0) {
-                return;
-            }
-            this.clients.forEach((client, key) => {
-                if (client.folderUri.scheme === 'untitled' || getWorkspaceFolderUri(client.folderUri)) {
-                    return;
-                }
-                logger.log(`[ClientProvider] onDidChangeWorkspaceFolders removing client for ${key}`);
-                this.clients.delete(key);
-                client.dispose();
-                this.clientRemovedEmitter.fire(client);
-            });
-        }));
-    }
-    getActiveClient() {
-        return this.activeClient;
-    }
-    async onInstallChanged(uri) {
-        // Uri is a package Uri in the case a lean package file was changed.
-        logger.log(`[ClientProvider] installChanged for ${uri}`);
-        this.pendingInstallChanged.push(uri);
-        if (this.processingInstallChanged) {
-            // avoid re-entrancy.
-            return;
-        }
-        this.processingInstallChanged = true;
-        while (true) {
-            const uri = this.pendingInstallChanged.pop();
-            if (!uri) {
-                break;
-            }
-            try {
-                const projectUri = await findLeanProjectRoot(uri);
-                const preconditionCheckResult = await this.checkLean4ProjectPreconditions(this.outputChannel, projectUri);
-                if (preconditionCheckResult !== 'Fatal') {
-                    logger.log('[ClientProvider] got lean version 4');
-                    const [cached, client] = await this.ensureClient(uri);
-                    if (cached && client) {
-                        await client.restart();
-                        logger.log('[ClientProvider] restart complete');
-                    }
-                }
-            }
-            catch (e) {
-                logger.log(`[ClientProvider] Exception checking lean version: ${e}`);
-            }
-        }
-        this.processingInstallChanged = false;
-    }
-    restartFile() {
-        if (!this.activeClient || !this.activeClient.isRunning()) {
-            displayError('No active client.');
-            return;
-        }
-        if (!window.activeTextEditor || window.activeTextEditor.document.languageId !== 'lean4') {
-            displayError('No active Lean editor tab. Make sure to focus the Lean editor tab for which you want to issue a restart.');
-            return;
-        }
-        void this.activeClient.restartFile(window.activeTextEditor.document);
-    }
-    stopActiveClient() {
-        if (this.activeClient && this.activeClient.isStarted()) {
-            void this.activeClient?.stop();
-        }
-    }
-    async restartActiveClient() {
-        void this.activeClient?.restart();
-    }
-    clientIsStarted() {
-        void this.activeClient?.isStarted();
-    }
-    async didOpenEditor(document) {
-        // bail as quickly as possible on non-lean files.
-        if (document.languageId !== 'lean4') {
-            return;
-        }
-        const uri = toExtUri(document.uri);
-        if (uri === undefined) {
-            return;
-        }
-        await this.ensureClient(uri);
-    }
-    // Find the client for a given document.
-    findClient(path) {
-        const candidates = this.getClients().filter(client => client.isInFolderManagedByThisClient(path));
-        // All candidate folders are a prefix of `path`, so they must necessarily be prefixes of one another
-        // => the best candidate (the most top-level client folder) is just the one with the shortest path
-        let bestCandidate;
-        for (const candidate of candidates) {
-            if (!bestCandidate) {
-                bestCandidate = candidate;
-                continue;
-            }
-            const folder = candidate.getClientFolder();
-            const bestFolder = bestCandidate.getClientFolder();
-            if (folder.scheme === 'file' &&
-                bestFolder.scheme === 'file' &&
-                folder.fsPath.length < bestFolder.fsPath.length) {
-                bestCandidate = candidate;
-            }
-        }
-        return bestCandidate;
-    }
-    getClients() {
-        return Array.from(this.clients.values());
-    }
-    getClientForFolder(folder) {
-        return this.clients.get(folder.toString());
-    }
-    // Starts a LeanClient if the given file is in a new workspace we haven't seen before.
-    // Returns a boolean "true" if the LeanClient was already created.
-    // Returns a null client if it turns out the new workspace is a lean3 workspace.
-    async ensureClient(uri) {
-        const folderUri = uri.scheme === 'file' ? await findLeanProjectRoot(uri) : new UntitledUri();
-        let client = this.getClientForFolder(folderUri);
-        if (client) {
-            this.activeClient = client;
-            return [true, client];
-        }
-        const key = folderUri.toString();
-        if (this.pending.has(key)) {
-            return [false, undefined];
-        }
-        this.pending.set(key, true);
-        const preconditionCheckResult = await this.checkLean4ProjectPreconditions(this.outputChannel, folderUri);
-        if (preconditionCheckResult === 'Fatal') {
-            this.pending.delete(key);
-            return [false, undefined];
-        }
-        logger.log('[ClientProvider] Creating LeanClient for ' + folderUri.toString());
-        const elanDefaultToolchain = await this.installer.getElanDefaultToolchain(folderUri);
-        client = new LeanClient(folderUri, this.outputChannel, elanDefaultToolchain, this.setupClient, this.isOpenLeanDocument);
-        this.subscriptions.push(client);
-        this.clients.set(key, client);
-        client.serverFailed(err => {
-            this.clients.delete(key);
-            client.dispose();
-            displayError(err);
-        });
-        client.stopped(reason => {
-            this.clientStoppedEmitter.fire([client, client === this.activeClient, reason]);
-        });
-        // aggregate progress changed events.
-        client.progressChanged(arg => {
-            this.progressChangedEmitter.fire(arg);
-        });
-        this.pending.delete(key);
-        this.clientAddedEmitter.fire(client);
-        await client.start();
-        // tell the InfoView about this activated client.
-        this.activeClient = client;
-        return [false, client];
-    }
-    dispose() {
-        for (const s of this.subscriptions) {
-            s.dispose();
-        }
-    }
-}

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

@@ -1,16 +0,0 @@
-/**
- * For LSP communication, we need a way to translate between LSP types and corresponding VSCode types.
- * By default this translation is provided as a bunch of methods on a `LanguageClient`, but this is
- * awkward to use in multi-client workspaces wherein we need to look up specific clients. In fact the
- * conversions are *not* stateful, so having them depend on the client is unnecessary. Instead, we
- * provide global converters here.
- *
- * Some of the conversions are patched to support extended Lean-specific structures.
- *
- * @module
- */
-import { Code2ProtocolConverter, DidOpenTextDocumentParams, Protocol2CodeConverter } from 'vscode-languageclient';
-export declare function setDependencyBuildMode(params: DidOpenTextDocumentParams, dependencyBuildMode: 'once' | 'never'): DidOpenTextDocumentParams;
-export declare const p2cConverter: Protocol2CodeConverter;
-export declare const c2pConverter: Code2ProtocolConverter;
-export declare function patchConverters(p2cConverter: Protocol2CodeConverter, c2pConverter: Code2ProtocolConverter): void;