lean4monaco 1.0.45 → 1.1.0

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/AbbreviationFeature.d.ts

@@ -0,0 +1,9 @@
+import { AbbreviationProvider } from '@leanprover/unicode-input';
+import { OutputChannel } from 'vscode';
+import { SelectionMoveMode } from '@leanprover/unicode-input';
+export declare class AbbreviationFeature {
+    private readonly disposables;
+    readonly abbreviations: AbbreviationProvider;
+    constructor(outputChannel: OutputChannel, selectionMoveMove?: SelectionMoveMode);
+    dispose(): void;
+}

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/AbbreviationFeature.js

@@ -0,0 +1,20 @@
+import { AbbreviationProvider } from '@leanprover/unicode-input';
+import { languages } from 'vscode';
+import { AbbreviationHoverProvider } from './AbbreviationHoverProvider';
+import { AbbreviationRewriterFeature } from './AbbreviationRewriterFeature';
+import { VSCodeAbbreviationConfig } from './VSCodeAbbreviationConfig';
+export class AbbreviationFeature {
+    disposables = new Array();
+    abbreviations;
+    constructor(outputChannel, selectionMoveMove) {
+        const config = new VSCodeAbbreviationConfig();
+        this.disposables.push(config);
+        this.abbreviations = new AbbreviationProvider(config);
+        this.disposables.push(languages.registerHoverProvider(config.languages, new AbbreviationHoverProvider(config, this.abbreviations)), new AbbreviationRewriterFeature(config, this.abbreviations, outputChannel, selectionMoveMove));
+    }
+    dispose() {
+        for (const d of this.disposables) {
+            d.dispose();
+        }
+    }
+}

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/AbbreviationHoverProvider.d.ts

@@ -0,0 +1,12 @@
+import { AbbreviationConfig, AbbreviationProvider } from '@leanprover/unicode-input';
+import { Hover, HoverProvider, Position, TextDocument } from 'vscode';
+/**
+ * Adds hover behaviour for getting translations of unicode characters.
+ * Eg: "Type ⊓ using \glb or \sqcap"
+ */
+export declare class AbbreviationHoverProvider implements HoverProvider {
+    private readonly config;
+    private readonly abbreviations;
+    constructor(config: AbbreviationConfig, abbreviations: AbbreviationProvider);
+    provideHover(document: TextDocument, pos: Position): Hover | undefined;
+}

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/AbbreviationHoverProvider.js

@@ -0,0 +1,40 @@
+import { Hover, Range } from 'vscode';
+/**
+ * Adds hover behaviour for getting translations of unicode characters.
+ * Eg: "Type ⊓ using \glb or \sqcap"
+ */
+export class AbbreviationHoverProvider {
+    config;
+    abbreviations;
+    constructor(config, abbreviations) {
+        this.config = config;
+        this.abbreviations = abbreviations;
+    }
+    provideHover(document, pos) {
+        const context = document.lineAt(pos.line).text.substr(pos.character);
+        const symbolsAtCursor = this.abbreviations.findSymbolsIn(context);
+        const allAbbrevs = symbolsAtCursor.map(symbol => ({
+            symbol,
+            abbrevs: this.abbreviations.collectAllAbbreviations(symbol),
+        }));
+        if (allAbbrevs.length === 0 || allAbbrevs.every(a => a.abbrevs.length === 0)) {
+            return undefined;
+        }
+        const leader = this.config.abbreviationCharacter;
+        const hoverMarkdown = allAbbrevs
+            .map(({ symbol, abbrevs }) => {
+            const abbrevInfo = `Type ${symbol} using ${abbrevs.map(a => '`' + leader + a + '`').join(' or ')}`;
+            const autoClosingAbbrevs = this.abbreviations.findAutoClosingAbbreviations(symbol);
+            const autoClosingInfo = autoClosingAbbrevs.length === 0
+                ? ''
+                : `. ${symbol} can be auto-closed with ${autoClosingAbbrevs
+                    .map(([a, closingSym]) => `${closingSym} using \`${leader}${a}\``)
+                    .join(' or ')}.`;
+            return abbrevInfo + autoClosingInfo;
+        })
+            .join('\n\n');
+        const maxSymbolLength = Math.max(...allAbbrevs.map(a => a.symbol.length));
+        const hoverRange = new Range(pos, pos.translate(0, maxSymbolLength));
+        return new Hover(hoverMarkdown, hoverRange);
+    }
+}

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/AbbreviationRewriterFeature.d.ts

@@ -0,0 +1,20 @@
+import { AbbreviationProvider, SelectionMoveMode } from '@leanprover/unicode-input';
+import { OutputChannel } from 'vscode';
+import { VSCodeAbbreviationConfig } from './VSCodeAbbreviationConfig';
+/**
+ * Sets up everything required for the abbreviation rewriter feature.
+ * Creates an `AbbreviationRewriter` for the active editor.
+ */
+export declare class AbbreviationRewriterFeature {
+    private readonly config;
+    private readonly abbreviationProvider;
+    private readonly outputChannel;
+    private readonly selectionMoveMove?;
+    private readonly disposables;
+    private activeAbbreviationRewriter;
+    constructor(config: VSCodeAbbreviationConfig, abbreviationProvider: AbbreviationProvider, outputChannel: OutputChannel, selectionMoveMove?: SelectionMoveMode | undefined);
+    private disposeActiveAbbreviationRewriter;
+    private changedActiveTextEditor;
+    private shouldEnableRewriterForEditor;
+    dispose(): void;
+}

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/AbbreviationRewriterFeature.js

@@ -0,0 +1,79 @@
+import { commands, languages, window, workspace } from 'vscode';
+import { extUriEquals, toExtUri } from '../utils/exturi';
+import { VSCodeAbbreviationRewriter } from './VSCodeAbbreviationRewriter';
+/**
+ * Sets up everything required for the abbreviation rewriter feature.
+ * Creates an `AbbreviationRewriter` for the active editor.
+ */
+export class AbbreviationRewriterFeature {
+    config;
+    abbreviationProvider;
+    outputChannel;
+    selectionMoveMove;
+    disposables = new Array();
+    activeAbbreviationRewriter;
+    constructor(config, abbreviationProvider, outputChannel, selectionMoveMove) {
+        this.config = config;
+        this.abbreviationProvider = abbreviationProvider;
+        this.outputChannel = outputChannel;
+        this.selectionMoveMove = selectionMoveMove;
+        void this.changedActiveTextEditor(window.activeTextEditor);
+        this.disposables.push(commands.registerTextEditorCommand('lean4.input.convert', async () => {
+            if (this.activeAbbreviationRewriter === undefined) {
+                return;
+            }
+            await this.activeAbbreviationRewriter.replaceAllTrackedAbbreviations();
+        }), window.onDidChangeActiveTextEditor(editor => this.changedActiveTextEditor(editor)), workspace.onDidOpenTextDocument(async (doc) => {
+            // Ensure that we create/remove abbreviation rewriters when the language ID changes
+            if (window.activeTextEditor === undefined) {
+                return;
+            }
+            const editorUri = toExtUri(window.activeTextEditor.document.uri);
+            const docUri = toExtUri(doc.uri);
+            if (editorUri === undefined || docUri === undefined || !extUriEquals(editorUri, docUri)) {
+                return;
+            }
+            if (this.activeAbbreviationRewriter === undefined &&
+                this.shouldEnableRewriterForEditor(window.activeTextEditor)) {
+                this.activeAbbreviationRewriter = new VSCodeAbbreviationRewriter(config, abbreviationProvider, outputChannel, window.activeTextEditor, this.selectionMoveMove);
+            }
+            else if (this.activeAbbreviationRewriter !== undefined &&
+                !this.shouldEnableRewriterForEditor(window.activeTextEditor)) {
+                await this.disposeActiveAbbreviationRewriter();
+            }
+        }));
+    }
+    async disposeActiveAbbreviationRewriter() {
+        if (this.activeAbbreviationRewriter === undefined) {
+            return;
+        }
+        await this.activeAbbreviationRewriter.replaceAllTrackedAbbreviations();
+        this.activeAbbreviationRewriter.dispose();
+        this.activeAbbreviationRewriter = undefined;
+    }
+    async changedActiveTextEditor(activeTextEditor) {
+        await this.disposeActiveAbbreviationRewriter();
+        if (activeTextEditor === undefined) {
+            return;
+        }
+        if (!this.shouldEnableRewriterForEditor(activeTextEditor)) {
+            return;
+        }
+        this.activeAbbreviationRewriter = new VSCodeAbbreviationRewriter(this.config, this.abbreviationProvider, this.outputChannel, activeTextEditor, this.selectionMoveMove);
+    }
+    shouldEnableRewriterForEditor(editor) {
+        if (!this.config.inputModeEnabled) {
+            return false;
+        }
+        if (!languages.match(this.config.languages, editor.document)) {
+            return false;
+        }
+        return true;
+    }
+    dispose() {
+        for (const d of this.disposables) {
+            d.dispose();
+        }
+        this.activeAbbreviationRewriter?.dispose();
+    }
+}

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/VSCodeAbbreviationConfig.d.ts

@@ -0,0 +1,13 @@
+import { AbbreviationConfig, SymbolsByAbbreviation } from '@leanprover/unicode-input';
+import { Disposable } from 'vscode';
+export declare class VSCodeAbbreviationConfig implements AbbreviationConfig, Disposable {
+    abbreviationCharacter: string;
+    customTranslations: SymbolsByAbbreviation;
+    eagerReplacementEnabled: boolean;
+    inputModeEnabled: boolean;
+    languages: string[];
+    private subscriptions;
+    constructor();
+    private reloadConfig;
+    dispose(): void;
+}

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/VSCodeAbbreviationConfig.js

@@ -0,0 +1,29 @@
+import { workspace } from 'vscode';
+export class VSCodeAbbreviationConfig {
+    abbreviationCharacter;
+    customTranslations;
+    eagerReplacementEnabled;
+    inputModeEnabled;
+    languages;
+    subscriptions = [];
+    constructor() {
+        this.reloadConfig();
+        this.subscriptions.push(workspace.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('lean4.input')) {
+                this.reloadConfig();
+            }
+        }));
+    }
+    reloadConfig() {
+        this.inputModeEnabled = workspace.getConfiguration('lean4.input').get('enabled', true);
+        this.abbreviationCharacter = workspace.getConfiguration('lean4.input').get('leader', '\\');
+        this.languages = workspace.getConfiguration('lean4.input').get('languages', ['lean4']);
+        this.customTranslations = workspace.getConfiguration('lean4.input').get('customTranslations', {});
+        this.eagerReplacementEnabled = workspace.getConfiguration('lean4.input').get('eagerReplacementEnabled', true);
+    }
+    dispose() {
+        for (const s of this.subscriptions) {
+            s.dispose();
+        }
+    }
+}

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/VSCodeAbbreviationRewriter.d.ts

@@ -0,0 +1,28 @@
+import { AbbreviationConfig, AbbreviationProvider, AbbreviationTextSource, Change, Range, SelectionMoveMode } from '@leanprover/unicode-input';
+import { OutputChannel, TextEditor } from 'vscode';
+/**
+ * Tracks abbreviations in a given text editor and replaces them when dynamically.
+ */
+export declare class VSCodeAbbreviationRewriter implements AbbreviationTextSource {
+    readonly config: AbbreviationConfig;
+    readonly abbreviationProvider: AbbreviationProvider;
+    private readonly outputChannel;
+    private readonly textEditor;
+    private selectionMoveMoveOverride?;
+    private readonly disposables;
+    private readonly rewriter;
+    private readonly decorationType;
+    private firstOutput;
+    private isVimExtensionInstalled;
+    private checkIsVimExtensionInstalled;
+    constructor(config: AbbreviationConfig, abbreviationProvider: AbbreviationProvider, outputChannel: OutputChannel, textEditor: TextEditor, selectionMoveMoveOverride?: SelectionMoveMode | undefined);
+    private writeError;
+    selectionMoveMode(): SelectionMoveMode;
+    collectSelections(): Range[];
+    setSelections(selections: Range[]): void;
+    replaceAbbreviations(changes: Change[]): Promise<boolean>;
+    replaceAllTrackedAbbreviations(): Promise<void>;
+    private updateState;
+    private setInputActive;
+    dispose(): void;
+}

package/dist/monaco-lean4/vscode-lean4/src/abbreviation/VSCodeAbbreviationRewriter.js

@@ -0,0 +1,124 @@
+import { AbbreviationRewriter, Range, } from '@leanprover/unicode-input';
+import { Range as LineColRange, Selection, commands, extensions, window, workspace, } from 'vscode';
+/**
+ * Tracks abbreviations in a given text editor and replaces them when dynamically.
+ */
+export class VSCodeAbbreviationRewriter {
+    config;
+    abbreviationProvider;
+    outputChannel;
+    textEditor;
+    selectionMoveMoveOverride;
+    disposables = new Array();
+    rewriter;
+    decorationType = window.createTextEditorDecorationType({
+        textDecoration: 'underline',
+    });
+    firstOutput = true;
+    isVimExtensionInstalled = false;
+    checkIsVimExtensionInstalled() {
+        this.isVimExtensionInstalled = extensions.getExtension('vscodevim.vim') !== undefined;
+    }
+    constructor(config, abbreviationProvider, outputChannel, textEditor, selectionMoveMoveOverride) {
+        this.config = config;
+        this.abbreviationProvider = abbreviationProvider;
+        this.outputChannel = outputChannel;
+        this.textEditor = textEditor;
+        this.selectionMoveMoveOverride = selectionMoveMoveOverride;
+        this.rewriter = new AbbreviationRewriter(config, abbreviationProvider, this);
+        this.disposables.push(this.decorationType);
+        this.disposables.push(workspace.onDidChangeTextDocument(async (e) => {
+            if (e.document !== this.textEditor.document) {
+                return;
+            }
+            const changes = e.contentChanges.map(changeEvent => ({
+                range: new Range(changeEvent.rangeOffset, changeEvent.rangeLength),
+                newText: changeEvent.text,
+            }));
+            this.rewriter.changeInput(changes);
+            await this.rewriter.triggerAbbreviationReplacement();
+            this.updateState();
+        }));
+        this.disposables.push(window.onDidChangeTextEditorSelection(async (e) => {
+            if (e.textEditor.document !== this.textEditor.document) {
+                return;
+            }
+            const selections = e.selections.map(s => fromVsCodeRange(s, e.textEditor.document));
+            await this.rewriter.changeSelections(selections);
+            this.updateState();
+        }));
+        this.checkIsVimExtensionInstalled();
+        this.disposables.push(extensions.onDidChange(_ => this.checkIsVimExtensionInstalled()));
+    }
+    writeError(e) {
+        this.outputChannel.appendLine(e);
+        if (this.firstOutput) {
+            this.outputChannel.show(true);
+            this.firstOutput = false;
+        }
+    }
+    selectionMoveMode() {
+        return this.selectionMoveMoveOverride ?? { kind: 'OnlyMoveCursorSelections', updateUnchangedSelections: this.isVimExtensionInstalled };
+    }
+    collectSelections() {
+        return this.textEditor.selections.map(s => fromVsCodeRange(s, this.textEditor.document));
+    }
+    setSelections(selections) {
+        this.textEditor.selections = selections.map(s => {
+            const vr = toVsCodeRange(s, this.textEditor.document);
+            return new Selection(vr.start, vr.end);
+        });
+    }
+    async replaceAbbreviations(changes) {
+        let ok = false;
+        let retries = 0;
+        try {
+            // The user may have changed the text document in-between `this.textEditor` being updated
+            // (when the call to the extension was started) and `this.textEditor.edit()` being executed.
+            // In this case, since the state of the editor that the extension sees and the state that
+            // the user sees are different, VS Code will reject the edit.
+            // This occurs especially often in setups with increased latency until the extension is triggered,
+            // e.g. an SSH setup. Since VS Code does not appear to support an atomic read -> write operation,
+            // unfortunately the only thing we can do here is to retry.
+            while (!ok && retries < 10) {
+                ok = await this.textEditor.edit(builder => {
+                    for (const c of changes) {
+                        builder.replace(toVsCodeRange(c.range, this.textEditor.document), c.newText);
+                    }
+                });
+                retries++;
+            }
+        }
+        catch (e) {
+            this.writeError('Error while replacing abbreviation: ' + e);
+        }
+        return ok;
+    }
+    async replaceAllTrackedAbbreviations() {
+        await this.rewriter.replaceAllTrackedAbbreviations();
+        this.updateState();
+    }
+    updateState() {
+        const trackedAbbreviations = this.rewriter.getTrackedAbbreviations();
+        this.textEditor.setDecorations(this.decorationType, [...trackedAbbreviations].map(a => toVsCodeRange(a.range, this.textEditor.document)));
+        void this.setInputActive(trackedAbbreviations.size > 0);
+    }
+    async setInputActive(isActive) {
+        await commands.executeCommand('setContext', 'lean4.input.isActive', isActive);
+    }
+    dispose() {
+        for (const d of this.disposables) {
+            d.dispose();
+        }
+    }
+}
+function fromVsCodeRange(range, doc) {
+    const start = doc.offsetAt(range.start);
+    const end = doc.offsetAt(range.end);
+    return new Range(start, end - start);
+}
+function toVsCodeRange(range, doc) {
+    const start = doc.positionAt(range.offset);
+    const end = doc.positionAt(range.offsetEnd + 1);
+    return new LineColRange(start, end);
+}

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

@@ -0,0 +1,33 @@
+import { PATH } from './utils/envPath';
+export declare function getPowerShellPath(): string;
+export declare function automaticallyBuildDependencies(): boolean;
+export declare function envPathExtensions(): PATH;
+export declare function serverArgs(): string[];
+export declare function serverLoggingEnabled(): boolean;
+export declare function serverLoggingPath(): string;
+export declare function shouldAutofocusOutput(): boolean;
+export declare function getInfoViewStyle(): string;
+export declare function getInfoViewAutoOpen(): boolean;
+export declare function getInfoViewAutoOpenShowsGoal(): boolean;
+export declare function getInfoViewAllErrorsOnLine(): boolean;
+export declare function getInfoViewDebounceTime(): number;
+export declare function getInfoViewShowExpectedType(): boolean;
+export declare function getInfoViewShowGoalNames(): boolean;
+export declare function getInfoViewEmphasizeFirstGoal(): boolean;
+export declare function getInfoViewReverseTacticState(): boolean;
+export declare function getInfoViewShowTooltipOnHover(): boolean;
+export declare function getElaborationDelay(): number;
+export declare function shouldShowSetupWarnings(): boolean;
+export declare function getFallBackToStringOccurrenceHighlighting(): boolean;
+export declare function isRunningTest(): boolean;
+export declare function getTestFolder(): string;
+export declare function getDefaultLeanVersion(): string;
+/** The editor line height, in pixels. */
+export declare function getEditorLineHeight(): number;
+/**
+ * The literal 'production' or 'development', depending on the build.
+ * Should be turned into a string literal by build tools.
+ */
+export declare const prodOrDev: string;
+/** The literal '.min' or empty, depending on the build. See {@link prodOrDev}. */
+export declare const minIfProd: string;

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

@@ -0,0 +1,119 @@
+import { workspace } from 'vscode';
+import { PATH } from './utils/envPath';
+// TODO: does currently not contain config options for `./abbreviation`
+// so that it is easy to keep it in sync with vscode-lean.
+export function getPowerShellPath() {
+    const windir = process.env.windir;
+    return `${windir}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+}
+export function automaticallyBuildDependencies() {
+    return workspace.getConfiguration('lean4').get('automaticallyBuildDependencies', false);
+}
+export function envPathExtensions() {
+    return new PATH(workspace.getConfiguration('lean4').get('envPathExtensions', []));
+}
+export function serverArgs() {
+    return workspace.getConfiguration('lean4').get('serverArgs', []);
+}
+export function serverLoggingEnabled() {
+    return workspace.getConfiguration('lean4.serverLogging').get('enabled', false);
+}
+export function serverLoggingPath() {
+    return workspace.getConfiguration('lean4.serverLogging').get('path', '.');
+}
+export function shouldAutofocusOutput() {
+    return workspace.getConfiguration('lean4').get('autofocusOutput', false);
+}
+export function getInfoViewStyle() {
+    const val = workspace.getConfiguration('lean4.infoview').get('style');
+    if (val !== undefined)
+        return val;
+    // Try deprecated name of the same setting if not found
+    return workspace.getConfiguration('lean4').get('infoViewStyle', '');
+}
+export function getInfoViewAutoOpen() {
+    const val = workspace.getConfiguration('lean4.infoview').get('autoOpen');
+    if (val !== undefined)
+        return val;
+    return workspace.getConfiguration('lean4').get('infoViewAutoOpen', true);
+}
+export function getInfoViewAutoOpenShowsGoal() {
+    const val = workspace.getConfiguration('lean4.infoview').get('autoOpenShowsGoal');
+    if (val !== undefined)
+        return val;
+    return workspace.getConfiguration('lean4').get('infoViewAutoOpenShowGoal', true);
+}
+export function getInfoViewAllErrorsOnLine() {
+    const val = workspace.getConfiguration('lean4.infoview').get('allErrorsOnLine');
+    if (val !== undefined)
+        return val;
+    return workspace.getConfiguration('lean4').get('infoViewAllErrorsOnLine', true);
+}
+export function getInfoViewDebounceTime() {
+    return workspace.getConfiguration('lean4.infoview').get('debounceTime', 50);
+}
+export function getInfoViewShowExpectedType() {
+    return workspace.getConfiguration('lean4.infoview').get('showExpectedType', true);
+}
+export function getInfoViewShowGoalNames() {
+    return workspace.getConfiguration('lean4.infoview').get('showGoalNames', true);
+}
+export function getInfoViewEmphasizeFirstGoal() {
+    return workspace.getConfiguration('lean4.infoview').get('emphasizeFirstGoal', false);
+}
+export function getInfoViewReverseTacticState() {
+    return workspace.getConfiguration('lean4.infoview').get('reverseTacticState', false);
+}
+export function getInfoViewShowTooltipOnHover() {
+    return workspace.getConfiguration('lean4.infoview').get('showTooltipOnHover', true);
+}
+export function getElaborationDelay() {
+    return workspace.getConfiguration('lean4').get('elaborationDelay', 200);
+}
+export function shouldShowSetupWarnings() {
+    return workspace.getConfiguration('lean4').get('showSetupWarnings', true);
+}
+export function getFallBackToStringOccurrenceHighlighting() {
+    return workspace.getConfiguration('lean4').get('fallBackToStringOccurrenceHighlighting', false);
+}
+export function isRunningTest() {
+    return typeof process.env.LEAN4_TEST_FOLDER === 'string';
+}
+export function getTestFolder() {
+    return typeof process.env.LEAN4_TEST_FOLDER === 'string' ? process.env.LEAN4_TEST_FOLDER : '';
+}
+export function getDefaultLeanVersion() {
+    return typeof process.env.DEFAULT_LEAN_TOOLCHAIN === 'string'
+        ? process.env.DEFAULT_LEAN_TOOLCHAIN
+        : 'leanprover/lean4:stable';
+}
+/** The editor line height, in pixels. */
+export function getEditorLineHeight() {
+    // The implementation
+    // (recommended by Microsoft: https://github.com/microsoft/vscode/issues/125341#issuecomment-854812591)
+    // is absolutely cursed. It's just to copy whatever VSCode does internally.
+    const fontSize = workspace.getConfiguration('editor').get('fontSize') ?? 0;
+    let lineHeight = workspace.getConfiguration('editor').get('lineHeight') ?? 0;
+    const GOLDEN_LINE_HEIGHT_RATIO = process.platform === 'darwin' ? 1.5 : 1.35;
+    const MINIMUM_LINE_HEIGHT = 8;
+    if (lineHeight === 0) {
+        lineHeight = GOLDEN_LINE_HEIGHT_RATIO * fontSize;
+    }
+    else if (lineHeight < MINIMUM_LINE_HEIGHT) {
+        // Values too small to be line heights in pixels are in ems.
+        lineHeight = lineHeight * fontSize;
+    }
+    // Enforce integer, minimum constraints
+    lineHeight = Math.round(lineHeight);
+    if (lineHeight < MINIMUM_LINE_HEIGHT) {
+        lineHeight = MINIMUM_LINE_HEIGHT;
+    }
+    return lineHeight;
+}
+/**
+ * The literal 'production' or 'development', depending on the build.
+ * Should be turned into a string literal by build tools.
+ */
+export const prodOrDev = process.env.NODE_ENV && process.env.NODE_ENV === 'production' ? 'production' : 'development';
+/** The literal '.min' or empty, depending on the build. See {@link prodOrDev}. */
+export const minIfProd = process.env.NODE_ENV && process.env.NODE_ENV === 'production' ? '.min' : '';

package/dist/monaco-lean4/vscode-lean4/src/diagnostics/setupNotifs.d.ts

@@ -0,0 +1,27 @@
+import { SemVer } from 'semver';
+import { LeanInstaller } from '../utils/leanInstaller';
+export type PreconditionCheckResult = 'Fulfilled' | 'Warning' | 'Fatal';
+export declare function preconditionCheckResultToSeverity(result: PreconditionCheckResult): 0 | 1 | 2;
+export declare function severityToPreconditionCheckResult(severity: 0 | 1 | 2): PreconditionCheckResult;
+export declare function worstPreconditionViolation(...results: PreconditionCheckResult[]): PreconditionCheckResult;
+export type SetupWarningOptions = {
+    modal: true;
+} | {
+    modal: false;
+    finalizer?: (() => void) | undefined;
+};
+export declare function displaySetupError(message: string, finalizer?: (() => void) | undefined): PreconditionCheckResult;
+export declare function displaySetupErrorWithInput<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
+export declare function displaySetupErrorWithOptionalInput<T extends string>(message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): PreconditionCheckResult;
+export declare function displaySetupErrorWithOutput(message: string, finalizer?: (() => void) | undefined): PreconditionCheckResult;
+export declare function displaySetupErrorWithSetupGuide(message: string, finalizer?: (() => void) | undefined): PreconditionCheckResult;
+export declare function displayDependencySetupError(missingDeps: string[]): PreconditionCheckResult;
+export declare function displayElanSetupError(installer: LeanInstaller, reason: string): Promise<PreconditionCheckResult>;
+export declare function displayElanOutdatedSetupError(installer: LeanInstaller, currentVersion: SemVer, recommendedVersion: SemVer): Promise<PreconditionCheckResult>;
+export declare function displaySetupWarning(message: string, options?: SetupWarningOptions): Promise<PreconditionCheckResult>;
+export declare function displaySetupWarningWithInput<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
+export declare function displaySetupWarningWithOptionalInput<T extends string>(message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): PreconditionCheckResult;
+export declare function displaySetupWarningWithOutput(message: string, options?: SetupWarningOptions): Promise<PreconditionCheckResult>;
+export declare function displaySetupWarningWithSetupGuide(message: string, options?: SetupWarningOptions): Promise<PreconditionCheckResult>;
+export declare function displayElanSetupWarning(installer: LeanInstaller, reason: string): Promise<PreconditionCheckResult>;
+export declare function displayElanOutdatedSetupWarning(installer: LeanInstaller, currentVersion: SemVer, recommendedVersion: SemVer): Promise<PreconditionCheckResult>;