@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/terminalContrib/quickFix/browser/terminalQuickFixBuiltinActions.js

@@ -0,0 +1,323 @@
+import { URI } from '../../../../../base/common/uri.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { TerminalQuickFixType } from './quickFix.js';
+const GitCommandLineRegex = /git/;
+const GitPullOutputRegex = /and can be fast-forwarded/;
+const GitPushCommandLineRegex = /git\s+push/;
+const GitTwoDashesRegex = /error: did you mean `--(.+)` \(with two dashes\)\?/;
+const GitSimilarOutputRegex = /(?:(most similar commands? (is|are)))/;
+const FreePortOutputRegex = /(?:address already in use (?:0\.0\.0\.0|127\.0\.0\.1|localhost|::):|Unable to bind [^ ]*:|can't listen on port |listen EADDRINUSE [^ ]*:)(?<portNumber>\d{4,5})/;
+const GitPushOutputRegex = /git push --set-upstream origin (?<branchName>[^\s]+)/;
+const GitCreatePrOutputRegex = /remote:\s*(?<link>https:\/\/github\.com\/.+\/.+\/pull\/new\/.+)/;
+const PwshGeneralErrorOutputRegex = /Suggestion \[General\]:/;
+const PwshUnixCommandNotFoundErrorOutputRegex = /Suggestion \[cmd-not-found\]:/;
+function gitSimilar() {
+    return {
+        id: 'Git Similar',
+        type: 'internal',
+        commandLineMatcher: GitCommandLineRegex,
+        outputMatcher: {
+            lineMatcher: GitSimilarOutputRegex,
+            anchor: 'bottom',
+            offset: 0,
+            length: 10
+        },
+        commandExitResult: 'error',
+        getQuickFixes: (matchResult) => {
+            const regexMatch = matchResult.outputMatch?.regexMatch[0];
+            if (!regexMatch || !matchResult.outputMatch) {
+                return;
+            }
+            const actions = [];
+            const startIndex = matchResult.outputMatch.outputLines.findIndex(l => l.includes(regexMatch)) + 1;
+            const results = ( matchResult.outputMatch.outputLines.map(r => r.trim()));
+            for (let i = startIndex; i < results.length; i++) {
+                const fixedCommand = results[i];
+                if (fixedCommand) {
+                    actions.push({
+                        id: 'Git Similar',
+                        type: TerminalQuickFixType.TerminalCommand,
+                        terminalCommand: matchResult.commandLine.replace(/git\s+[^\s]+/, () => `git ${fixedCommand}`),
+                        shouldExecute: true,
+                        source: "builtin"
+                    });
+                }
+            }
+            return actions;
+        }
+    };
+}
+function gitPull() {
+    return {
+        id: 'Git Pull',
+        type: 'internal',
+        commandLineMatcher: GitCommandLineRegex,
+        outputMatcher: {
+            lineMatcher: GitPullOutputRegex,
+            anchor: 'bottom',
+            offset: 0,
+            length: 8
+        },
+        commandExitResult: 'success',
+        getQuickFixes: (matchResult) => {
+            return {
+                type: TerminalQuickFixType.TerminalCommand,
+                id: 'Git Pull',
+                terminalCommand: `git pull`,
+                shouldExecute: true,
+                source: "builtin"
+            };
+        }
+    };
+}
+function gitTwoDashes() {
+    return {
+        id: 'Git Two Dashes',
+        type: 'internal',
+        commandLineMatcher: GitCommandLineRegex,
+        outputMatcher: {
+            lineMatcher: GitTwoDashesRegex,
+            anchor: 'bottom',
+            offset: 0,
+            length: 2
+        },
+        commandExitResult: 'error',
+        getQuickFixes: (matchResult) => {
+            const problemArg = matchResult?.outputMatch?.regexMatch?.[1];
+            if (!problemArg) {
+                return;
+            }
+            return {
+                type: TerminalQuickFixType.TerminalCommand,
+                id: 'Git Two Dashes',
+                terminalCommand: matchResult.commandLine.replace(` -${problemArg}`, () => ` --${problemArg}`),
+                shouldExecute: true,
+                source: "builtin"
+            };
+        }
+    };
+}
+function freePort(runCallback) {
+    return {
+        id: 'Free Port',
+        type: 'internal',
+        commandLineMatcher: /.+/,
+        outputMatcher: {
+            lineMatcher: FreePortOutputRegex,
+            anchor: 'bottom',
+            offset: 0,
+            length: 30
+        },
+        commandExitResult: 'error',
+        getQuickFixes: (matchResult) => {
+            const port = matchResult?.outputMatch?.regexMatch?.groups?.portNumber;
+            if (!port) {
+                return;
+            }
+            const label = ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/quickFix/browser/terminalQuickFixBuiltinActions',
+                "terminal.freePort",
+                "Free port {0}",
+                port
+            ));
+            return {
+                type: TerminalQuickFixType.Port,
+                class: undefined,
+                tooltip: label,
+                id: 'Free Port',
+                label,
+                enabled: true,
+                source: "builtin" ,
+                run: () => runCallback(port, matchResult.commandLine)
+            };
+        }
+    };
+}
+function gitPushSetUpstream() {
+    return {
+        id: 'Git Push Set Upstream',
+        type: 'internal',
+        commandLineMatcher: GitPushCommandLineRegex,
+        outputMatcher: {
+            lineMatcher: GitPushOutputRegex,
+            anchor: 'bottom',
+            offset: 0,
+            length: 8
+        },
+        commandExitResult: 'error',
+        getQuickFixes: (matchResult) => {
+            const matches = matchResult.outputMatch;
+            const commandToRun = 'git push --set-upstream origin ${group:branchName}';
+            if (!matches) {
+                return;
+            }
+            const groups = matches.regexMatch.groups;
+            if (!groups) {
+                return;
+            }
+            const actions = [];
+            let fixedCommand = commandToRun;
+            for (const [key, value] of Object.entries(groups)) {
+                const varToResolve = '${group:' + `${key}` + '}';
+                if (!commandToRun.includes(varToResolve)) {
+                    return [];
+                }
+                fixedCommand = fixedCommand.replaceAll(varToResolve, () => value);
+            }
+            if (fixedCommand) {
+                actions.push({
+                    type: TerminalQuickFixType.TerminalCommand,
+                    id: 'Git Push Set Upstream',
+                    terminalCommand: fixedCommand,
+                    shouldExecute: true,
+                    source: "builtin"
+                });
+                return actions;
+            }
+            return;
+        }
+    };
+}
+function gitCreatePr() {
+    return {
+        id: 'Git Create Pr',
+        type: 'internal',
+        commandLineMatcher: GitPushCommandLineRegex,
+        outputMatcher: {
+            lineMatcher: GitCreatePrOutputRegex,
+            anchor: 'bottom',
+            offset: 4,
+            length: 12
+        },
+        commandExitResult: 'success',
+        getQuickFixes: (matchResult) => {
+            const link = matchResult?.outputMatch?.regexMatch?.groups?.link;
+            if (!link) {
+                return;
+            }
+            const label = ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/quickFix/browser/terminalQuickFixBuiltinActions',
+                "terminal.createPR",
+                "Create PR {0}",
+                link
+            ));
+            return {
+                id: 'Git Create Pr',
+                label,
+                enabled: true,
+                type: TerminalQuickFixType.Opener,
+                uri: ( URI.parse(link)),
+                source: "builtin"
+            };
+        }
+    };
+}
+function pwshGeneralError() {
+    return {
+        id: 'Pwsh General Error',
+        type: 'internal',
+        commandLineMatcher: /.+/,
+        outputMatcher: {
+            lineMatcher: PwshGeneralErrorOutputRegex,
+            anchor: 'bottom',
+            offset: 0,
+            length: 10
+        },
+        commandExitResult: 'error',
+        getQuickFixes: (matchResult) => {
+            const lines = matchResult.outputMatch?.regexMatch.input?.split('\n');
+            if (!lines) {
+                return;
+            }
+            let i = 0;
+            let inFeedbackProvider = false;
+            for (; i < lines.length; i++) {
+                if (lines[i].match(PwshGeneralErrorOutputRegex)) {
+                    inFeedbackProvider = true;
+                    break;
+                }
+            }
+            if (!inFeedbackProvider) {
+                return;
+            }
+            const suggestions = lines[i + 1].match(/The most similar commands are: (?<values>.+)./)?.groups?.values?.split(', ');
+            if (!suggestions) {
+                return;
+            }
+            const result = [];
+            for (const suggestion of suggestions) {
+                result.push({
+                    id: 'Pwsh General Error',
+                    type: TerminalQuickFixType.TerminalCommand,
+                    terminalCommand: suggestion,
+                    source: "builtin"
+                });
+            }
+            return result;
+        }
+    };
+}
+function pwshUnixCommandNotFoundError() {
+    return {
+        id: 'Unix Command Not Found',
+        type: 'internal',
+        commandLineMatcher: /.+/,
+        outputMatcher: {
+            lineMatcher: PwshUnixCommandNotFoundErrorOutputRegex,
+            anchor: 'bottom',
+            offset: 0,
+            length: 10
+        },
+        commandExitResult: 'error',
+        getQuickFixes: (matchResult) => {
+            const lines = matchResult.outputMatch?.regexMatch.input?.split('\n');
+            if (!lines) {
+                return;
+            }
+            let i = 0;
+            let inFeedbackProvider = false;
+            for (; i < lines.length; i++) {
+                if (lines[i].match(PwshUnixCommandNotFoundErrorOutputRegex)) {
+                    inFeedbackProvider = true;
+                    break;
+                }
+            }
+            if (!inFeedbackProvider) {
+                return;
+            }
+            const result = [];
+            let inSuggestions = false;
+            for (; i < lines.length; i++) {
+                const line = lines[i].trim();
+                if (line.length === 0) {
+                    break;
+                }
+                const installCommand = line.match(/You also have .+ installed, you can run '(?<command>.+)' instead./)?.groups?.command;
+                if (installCommand) {
+                    result.push({
+                        id: 'Pwsh Unix Command Not Found Error',
+                        type: TerminalQuickFixType.TerminalCommand,
+                        terminalCommand: installCommand,
+                        source: "builtin"
+                    });
+                    inSuggestions = false;
+                    continue;
+                }
+                if (line.match(/Command '.+' not found, but can be installed with:/)) {
+                    inSuggestions = true;
+                    continue;
+                }
+                if (inSuggestions) {
+                    result.push({
+                        id: 'Pwsh Unix Command Not Found Error',
+                        type: TerminalQuickFixType.TerminalCommand,
+                        terminalCommand: line.trim(),
+                        source: "builtin"
+                    });
+                }
+            }
+            return result;
+        }
+    };
+}
+export { FreePortOutputRegex, GitCommandLineRegex, GitCreatePrOutputRegex, GitPullOutputRegex, GitPushCommandLineRegex, GitPushOutputRegex, GitSimilarOutputRegex, GitTwoDashesRegex, PwshGeneralErrorOutputRegex, PwshUnixCommandNotFoundErrorOutputRegex, freePort, gitCreatePr, gitPull, gitPushSetUpstream, gitSimilar, gitTwoDashes, pwshGeneralError, pwshUnixCommandNotFoundError };

package/vscode/src/vs/workbench/contrib/terminalContrib/quickFix/browser/terminalQuickFixService.js

@@ -0,0 +1,168 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../../base/common/event.js';
+import { toDisposable } from '../../../../../base/common/lifecycle.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { ILogService } from '../../../../../platform/log/common/log.js';
+import { isProposedApiEnabled } from '../../../../services/extensions/common/extensions.js';
+import { ExtensionsRegistry } from '../../../../services/extensions/common/extensionsRegistry.js';
+let TerminalQuickFixService = class TerminalQuickFixService {
+    get providers() { return this._providers; }
+    constructor(_logService) {
+        this._logService = _logService;
+        this._selectors = ( new Map());
+        this._providers = ( new Map());
+        this._onDidRegisterProvider = ( new Emitter());
+        this.onDidRegisterProvider = this._onDidRegisterProvider.event;
+        this._onDidRegisterCommandSelector = ( new Emitter());
+        this.onDidRegisterCommandSelector = this._onDidRegisterCommandSelector.event;
+        this._onDidUnregisterProvider = ( new Emitter());
+        this.onDidUnregisterProvider = this._onDidUnregisterProvider.event;
+        this.extensionQuickFixes = ( new Promise((r) => quickFixExtensionPoint.setHandler(fixes => {
+            r(( fixes.filter(c => isProposedApiEnabled(c.description, 'terminalQuickFixProvider')).map(c => {
+                if (!c.value) {
+                    return [];
+                }
+                return ( c.value.map(
+                    fix => { return { ...fix, extensionIdentifier: c.description.identifier.value }; }
+                ));
+            })).flat());
+        })));
+        this.extensionQuickFixes.then(selectors => {
+            for (const selector of selectors) {
+                this.registerCommandSelector(selector);
+            }
+        });
+    }
+    registerCommandSelector(selector) {
+        this._selectors.set(selector.id, selector);
+        this._onDidRegisterCommandSelector.fire(selector);
+    }
+    registerQuickFixProvider(id, provider) {
+        let disposed = false;
+        this.extensionQuickFixes.then(() => {
+            if (disposed) {
+                return;
+            }
+            this._providers.set(id, provider);
+            const selector = this._selectors.get(id);
+            if (!selector) {
+                this._logService.error(`No registered selector for ID: ${id}`);
+                return;
+            }
+            this._onDidRegisterProvider.fire({ selector, provider });
+        });
+        return toDisposable(() => {
+            disposed = true;
+            this._providers.delete(id);
+            const selector = this._selectors.get(id);
+            if (selector) {
+                this._selectors.delete(id);
+                this._onDidUnregisterProvider.fire(selector.id);
+            }
+        });
+    }
+};
+TerminalQuickFixService = ( __decorate([
+    ( __param(0, ILogService))
+], TerminalQuickFixService));
+const quickFixExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'terminalQuickFixes',
+    defaultExtensionKind: ['workspace'],
+    activationEventsGenerator: (terminalQuickFixes, result) => {
+        for (const quickFixContrib of terminalQuickFixes ?? []) {
+            result.push(`onTerminalQuickFixRequest:${quickFixContrib.id}`);
+        }
+    },
+    jsonSchema: {
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/terminalContrib/quickFix/browser/terminalQuickFixService',
+            'vscode.extension.contributes.terminalQuickFixes',
+            'Contributes terminal quick fixes.'
+        )),
+        type: 'array',
+        items: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['id', 'commandLineMatcher', 'outputMatcher', 'commandExitResult'],
+            defaultSnippets: [{
+                    body: {
+                        id: '$1',
+                        commandLineMatcher: '$2',
+                        outputMatcher: '$3',
+                        exitStatus: '$4'
+                    }
+                }],
+            properties: {
+                id: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/contrib/terminalContrib/quickFix/browser/terminalQuickFixService',
+                        'vscode.extension.contributes.terminalQuickFixes.id',
+                        "The ID of the quick fix provider"
+                    )),
+                    type: 'string',
+                },
+                commandLineMatcher: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/contrib/terminalContrib/quickFix/browser/terminalQuickFixService',
+                        'vscode.extension.contributes.terminalQuickFixes.commandLineMatcher',
+                        "A regular expression or string to test the command line against"
+                    )),
+                    type: 'string',
+                },
+                outputMatcher: {
+                    markdownDescription: ( localizeWithPath(
+                        'vs/workbench/contrib/terminalContrib/quickFix/browser/terminalQuickFixService',
+                        'vscode.extension.contributes.terminalQuickFixes.outputMatcher',
+                        "A regular expression or string to match a single line of the output against, which provides groups to be referenced in terminalCommand and uri.\n\nFor example:\n\n `lineMatcher: /git push --set-upstream origin (?<branchName>[^\s]+)/;`\n\n`terminalCommand: 'git push --set-upstream origin ${group:branchName}';`\n"
+                    )),
+                    type: 'object',
+                    required: ['lineMatcher', 'anchor', 'offset', 'length'],
+                    properties: {
+                        lineMatcher: {
+                            description: 'A regular expression or string to test the command line against',
+                            type: 'string'
+                        },
+                        anchor: {
+                            description: 'Where the search should begin in the buffer',
+                            enum: ['top', 'bottom']
+                        },
+                        offset: {
+                            description: 'The number of lines vertically from the anchor in the buffer to start matching against',
+                            type: 'number'
+                        },
+                        length: {
+                            description: 'The number of rows to match against, this should be as small as possible for performance reasons',
+                            type: 'number'
+                        }
+                    }
+                },
+                commandExitResult: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/contrib/terminalContrib/quickFix/browser/terminalQuickFixService',
+                        'vscode.extension.contributes.terminalQuickFixes.commandExitResult',
+                        "The command exit result to match on"
+                    )),
+                    enum: ['success', 'error'],
+                    enumDescriptions: [
+                        'The command exited with an exit code of zero.',
+                        'The command exited with a non-zero exit code.'
+                    ]
+                },
+                kind: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/contrib/terminalContrib/quickFix/browser/terminalQuickFixService',
+                        'vscode.extension.contributes.terminalQuickFixes.kind',
+                        "The kind of the resulting quick fix. This changes how the quick fix is presented. Defaults to {0}.",
+                        '`"fix"`'
+                    )),
+                    enum: ['default', 'explain'],
+                    enumDescriptions: [
+                        'A high confidence quick fix.',
+                        'An explanation of the problem.'
+                    ]
+                }
+            },
+        }
+    },
+});
+export { TerminalQuickFixService };

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/media/stickyScroll.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".terminal-sticky-scroll{background:var(--vscode-terminalStickyScroll-background,var(--vscode-terminal-background,var(--vscode-panel-background)));box-shadow:var(--vscode-scrollbar-shadow) 0 3px 2px -2px;display:none;left:0;position:absolute;right:0;z-index:32}.part.auxiliarybar .terminal-sticky-scroll,.part.sidebar .terminal-sticky-scroll{background:var(--vscode-terminalStickyScroll-background,var(--vscode-terminal-background,var(--vscode-sideBar-background)))}.editor-instance .terminal-sticky-scroll{background:var(--vscode-terminalStickyScroll-background,var(--vscode-terminal-background,var(--vscode-editor-background)))}.terminal-sticky-scroll.visible{display:block}.terminal-sticky-scroll:hover{cursor:pointer!important}.terminal-sticky-scroll .xterm{padding-bottom:0!important;pointer-events:none;position:relative!important}.terminal-sticky-scroll .hover-overlay{bottom:0;cursor:pointer!important;left:0;position:absolute;right:0;top:0}.terminal-sticky-scroll .hover-overlay:hover{background-color:var(--vscode-terminalStickyScrollHover-background,transparent)}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminal.stickyScroll.contribution.js

@@ -0,0 +1,5 @@
+import { registerTerminalContribution } from '../../../terminal/browser/terminalExtensions.js';
+import { TerminalStickyScrollContribution } from './terminalStickyScrollContribution.js';
+import './media/stickyScroll.css.js';
+import './terminalStickyScrollColorRegistry.js';
+registerTerminalContribution(TerminalStickyScrollContribution.ID, TerminalStickyScrollContribution, true);

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollColorRegistry.js

@@ -0,0 +1,35 @@
+import { Color } from '../../../../../base/common/color.js';
+import './media/stickyScroll.css.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { registerColor } from '../../../../../platform/theme/common/colorUtils.js';
+import '../../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../../platform/theme/common/colors/listColors.js';
+import '../../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../../platform/theme/common/colors/searchColors.js';
+const terminalStickyScrollBackground = registerColor('terminalStickyScroll.background', {
+    light: null,
+    dark: null,
+    hcDark: null,
+    hcLight: null
+}, ( localizeWithPath(
+    'vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollColorRegistry',
+    'terminalStickyScroll.background',
+    'The background color of the sticky scroll overlay in the terminal.'
+)));
+const terminalStickyScrollHoverBackground = registerColor('terminalStickyScrollHover.background', {
+    dark: '#2A2D2E',
+    light: '#F0F0F0',
+    hcDark: null,
+    hcLight: ( ( Color.fromHex('#0F4A85')).transparent(0.1))
+}, ( localizeWithPath(
+    'vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollColorRegistry',
+    'terminalStickyScrollHover.background',
+    'The background color of the sticky scroll overlay in the terminal when hovered.'
+)));
+export { terminalStickyScrollBackground, terminalStickyScrollHoverBackground };

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollContribution.js

@@ -0,0 +1,91 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from '../../../../../base/common/event.js';
+import { Disposable, MutableDisposable } from '../../../../../base/common/lifecycle.js';
+import './media/stickyScroll.css.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.js';
+import { TerminalInstance, TerminalInstanceColorProvider } from '../../../terminal/browser/terminalInstance.js';
+import { TerminalStickyScrollOverlay } from './terminalStickyScrollOverlay.js';
+var TerminalStickyScrollContribution_1;
+let TerminalStickyScrollContribution = class TerminalStickyScrollContribution extends Disposable {
+    static { TerminalStickyScrollContribution_1 = this; }
+    static { this.ID = 'terminal.stickyScroll'; }
+    static get(instance) {
+        return instance.getContribution(TerminalStickyScrollContribution_1.ID);
+    }
+    constructor(_instance, processManager, widgetManager, _configurationService, _contextKeyService, _instantiationService, _keybindingService) {
+        super();
+        this._instance = _instance;
+        this._configurationService = _configurationService;
+        this._contextKeyService = _contextKeyService;
+        this._instantiationService = _instantiationService;
+        this._keybindingService = _keybindingService;
+        this._overlay = this._register(( new MutableDisposable()));
+        this._enableListeners = this._register(( new MutableDisposable()));
+        this._disableListeners = this._register(( new MutableDisposable()));
+        this._register(Event.runAndSubscribe(this._configurationService.onDidChangeConfiguration, e => {
+            if (!e || e.affectsConfiguration("terminal.integrated.stickyScroll.enabled" )) {
+                this._refreshState();
+            }
+        }));
+    }
+    xtermReady(xterm) {
+        this._xterm = xterm;
+        this._refreshState();
+    }
+    xtermOpen(xterm) {
+        this._refreshState();
+    }
+    _refreshState() {
+        if (this._overlay.value) {
+            this._tryDisable();
+        }
+        else {
+            this._tryEnable();
+        }
+        if (this._overlay.value) {
+            this._enableListeners.clear();
+            if (!this._disableListeners.value) {
+                this._disableListeners.value = this._instance.capabilities.onDidRemoveCapability(e => {
+                    if (e.id === 2 ) {
+                        this._refreshState();
+                    }
+                });
+            }
+        }
+        else {
+            this._disableListeners.clear();
+            if (!this._enableListeners.value) {
+                this._enableListeners.value = this._instance.capabilities.onDidAddCapability(e => {
+                    if (e.id === 2 ) {
+                        this._refreshState();
+                    }
+                });
+            }
+        }
+    }
+    _tryEnable() {
+        if (this._shouldBeEnabled()) {
+            const xtermCtorEventually = TerminalInstance.getXtermConstructor(this._keybindingService, this._contextKeyService);
+            this._overlay.value = this._instantiationService.createInstance(TerminalStickyScrollOverlay, this._instance, this._xterm, this._instantiationService.createInstance(TerminalInstanceColorProvider, this._instance), this._instance.capabilities.get(2 ), xtermCtorEventually);
+        }
+    }
+    _tryDisable() {
+        if (!this._shouldBeEnabled()) {
+            this._overlay.clear();
+        }
+    }
+    _shouldBeEnabled() {
+        const capability = this._instance.capabilities.get(2 );
+        return !!(this._configurationService.getValue("terminal.integrated.stickyScroll.enabled" ) && capability && this._xterm?.raw?.element);
+    }
+};
+TerminalStickyScrollContribution = TerminalStickyScrollContribution_1 = ( __decorate([
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IKeybindingService))
+], TerminalStickyScrollContribution));
+export { TerminalStickyScrollContribution };