@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/terminal/common/terminalContextKey.js

@@ -0,0 +1,157 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+var TerminalContextKeys;
+( (function(TerminalContextKeys) {
+    TerminalContextKeys.isOpen = ( new RawContextKey("terminalIsOpen" , false, true));
+    TerminalContextKeys.focus = ( new RawContextKey(
+        "terminalFocus" ,
+        false,
+        ( localize('terminalFocusContextKey', "Whether the terminal is focused."))
+    ));
+    TerminalContextKeys.accessibleBufferFocus = ( new RawContextKey(
+        "terminalAccessibleBufferFocus" ,
+        false,
+        ( localize(
+            'terminalAccessibleBufferFocusContextKey',
+            "Whether the terminal accessible buffer is focused."
+        ))
+    ));
+    TerminalContextKeys.editorFocus = ( new RawContextKey(
+        "terminalEditorFocus" ,
+        false,
+        ( localize(
+            'terminalEditorFocusContextKey',
+            "Whether a terminal in the editor area is focused."
+        ))
+    ));
+    TerminalContextKeys.count = ( new RawContextKey("terminalCount" , 0, ( localize('terminalCountContextKey', "The current number of terminals."))));
+    TerminalContextKeys.groupCount = ( new RawContextKey("terminalGroupCount" , 0, true));
+    TerminalContextKeys.tabsNarrow = ( new RawContextKey(
+        "isTerminalTabsNarrow" ,
+        false,
+        true
+    ));
+    TerminalContextKeys.terminalHasFixedWidth = ( new RawContextKey(
+        "terminalHasFixedWidth" ,
+        false,
+        true
+    ));
+    TerminalContextKeys.tabsFocus = ( new RawContextKey(
+        "terminalTabsFocus" ,
+        false,
+        ( localize(
+            'terminalTabsFocusContextKey',
+            "Whether the terminal tabs widget is focused."
+        ))
+    ));
+    TerminalContextKeys.webExtensionContributedProfile = ( new RawContextKey(
+        "terminalWebExtensionContributedProfile" ,
+        false,
+        true
+    ));
+    TerminalContextKeys.terminalHasBeenCreated = ( new RawContextKey(
+        "terminalHasBeenCreated" ,
+        false,
+        true
+    ));
+    TerminalContextKeys.terminalEditorActive = ( new RawContextKey(
+        "terminalEditorActive" ,
+        false,
+        true
+    ));
+    TerminalContextKeys.tabsMouse = ( new RawContextKey("terminalTabsMouse" , false, true));
+    TerminalContextKeys.shellType = ( new RawContextKey(
+        "terminalShellType" ,
+        undefined,
+        { type: 'string', description: ( localize(
+            'terminalShellTypeContextKey',
+            "The shell type of the active terminal, this is set to the last known value when no terminals exist."
+        )) }
+    ));
+    TerminalContextKeys.altBufferActive = ( new RawContextKey(
+        "terminalAltBufferActive" ,
+        false,
+        ( localize('terminalAltBufferActive', "Whether the terminal's alt buffer is active."))
+    ));
+    TerminalContextKeys.suggestWidgetVisible = ( new RawContextKey(
+        "terminalSuggestWidgetVisible" ,
+        false,
+        ( localize(
+            'terminalSuggestWidgetVisible',
+            "Whether the terminal's suggest widget is visible."
+        ))
+    ));
+    TerminalContextKeys.notFocus = ( TerminalContextKeys.focus.toNegated());
+    TerminalContextKeys.viewShowing = ( new RawContextKey(
+        "terminalViewShowing" ,
+        false,
+        ( localize('terminalViewShowing', "Whether the terminal view is showing"))
+    ));
+    TerminalContextKeys.textSelected = ( new RawContextKey(
+        "terminalTextSelected" ,
+        false,
+        ( localize(
+            'terminalTextSelectedContextKey',
+            "Whether text is selected in the active terminal."
+        ))
+    ));
+    TerminalContextKeys.notTextSelected = ( TerminalContextKeys.textSelected.toNegated());
+    TerminalContextKeys.findVisible = ( new RawContextKey(
+        "terminalFindVisible" ,
+        false,
+        true
+    ));
+    TerminalContextKeys.notFindVisible = ( TerminalContextKeys.findVisible.toNegated());
+    TerminalContextKeys.findInputFocus = ( new RawContextKey(
+        "terminalFindInputFocused" ,
+        false,
+        true
+    ));
+    TerminalContextKeys.findFocus = ( new RawContextKey(
+        "terminalFindFocused" ,
+        false,
+        true
+    ));
+    TerminalContextKeys.notFindFocus = ( TerminalContextKeys.findInputFocus.toNegated());
+    TerminalContextKeys.processSupported = ( new RawContextKey(
+        "terminalProcessSupported" ,
+        false,
+        ( localize(
+            'terminalProcessSupportedContextKey',
+            "Whether terminal processes can be launched in the current workspace."
+        ))
+    ));
+    TerminalContextKeys.tabsSingularSelection = ( new RawContextKey(
+        "terminalTabsSingularSelection" ,
+        false,
+        ( localize(
+            'terminalTabsSingularSelectedContextKey',
+            "Whether one terminal is selected in the terminal tabs list."
+        ))
+    ));
+    TerminalContextKeys.splitTerminal = ( new RawContextKey(
+        "terminalSplitTerminal" ,
+        false,
+        ( localize(
+            'isSplitTerminalContextKey',
+            "Whether the focused tab's terminal is a split terminal."
+        ))
+    ));
+    TerminalContextKeys.inTerminalRunCommandPicker = ( new RawContextKey(
+        "inTerminalRunCommandPicker" ,
+        false,
+        ( localize(
+            'inTerminalRunCommandPickerContextKey',
+            "Whether the terminal run command picker is currently open."
+        ))
+    ));
+    TerminalContextKeys.terminalShellIntegrationEnabled = ( new RawContextKey(
+        "terminalShellIntegrationEnabled" ,
+        false,
+        ( localize(
+            'terminalShellIntegrationEnabled',
+            "Whether shell integration is enabled in the active terminal"
+        ))
+    ));
+})(TerminalContextKeys || (TerminalContextKeys = {})));
+export { TerminalContextKeys };

package/dist/vscode/vs/workbench/contrib/terminal/common/terminalEnvironment.js

@@ -0,0 +1,272 @@
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { sanitizeProcessEnvironment } from '../../../../base/common/processes.js';
+import { isWindows, language } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { escapeNonWindowsPath, sanitizeCwd } from '../../../../platform/terminal/common/terminalEnvironment.js';
+import { isString, withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+function mergeEnvironments(parent, other) {
+    if (!other) {
+        return;
+    }
+    if (isWindows) {
+        for (const configKey in other) {
+            let actualKey = configKey;
+            for (const envKey in parent) {
+                if (configKey.toLowerCase() === envKey.toLowerCase()) {
+                    actualKey = envKey;
+                    break;
+                }
+            }
+            const value = other[configKey];
+            if (value !== undefined) {
+                _mergeEnvironmentValue(parent, actualKey, value);
+            }
+        }
+    }
+    else {
+        ( Object.keys(other)).forEach((key) => {
+            const value = other[key];
+            if (value !== undefined) {
+                _mergeEnvironmentValue(parent, key, value);
+            }
+        });
+    }
+}
+function _mergeEnvironmentValue(env, key, value) {
+    if (typeof value === 'string') {
+        env[key] = value;
+    }
+    else {
+        delete env[key];
+    }
+}
+function addTerminalEnvironmentKeys(env, version, locale, detectLocale) {
+    env['TERM_PROGRAM'] = 'vscode';
+    if (version) {
+        env['TERM_PROGRAM_VERSION'] = version;
+    }
+    if (shouldSetLangEnvVariable(env, detectLocale)) {
+        env['LANG'] = getLangEnvVariable(locale);
+    }
+    env['COLORTERM'] = 'truecolor';
+}
+function mergeNonNullKeys(env, other) {
+    if (!other) {
+        return;
+    }
+    for (const key of ( Object.keys(other))) {
+        const value = other[key];
+        if (value !== undefined && value !== null) {
+            env[key] = value;
+        }
+    }
+}
+async function resolveConfigurationVariables(variableResolver, env) {
+    await Promise.all(( Object.entries(env).map(async ([key, value]) => {
+        if (typeof value === 'string') {
+            try {
+                env[key] = await variableResolver(value);
+            }
+            catch (e) {
+                env[key] = value;
+            }
+        }
+    })));
+    return env;
+}
+function shouldSetLangEnvVariable(env, detectLocale) {
+    if (detectLocale === 'on') {
+        return true;
+    }
+    if (detectLocale === 'auto') {
+        const lang = env['LANG'];
+        return !lang || (lang.search(/\.UTF\-8$/) === -1 && lang.search(/\.utf8$/) === -1 && lang.search(/\.euc.+/) === -1);
+    }
+    return false;
+}
+function getLangEnvVariable(locale) {
+    const parts = locale ? locale.split('-') : [];
+    const n = parts.length;
+    if (n === 0) {
+        return 'en_US.UTF-8';
+    }
+    if (n === 1) {
+        const languageVariants = {
+            af: 'ZA',
+            am: 'ET',
+            be: 'BY',
+            bg: 'BG',
+            ca: 'ES',
+            cs: 'CZ',
+            da: 'DK',
+            de: 'DE',
+            el: 'GR',
+            en: 'US',
+            es: 'ES',
+            et: 'EE',
+            eu: 'ES',
+            fi: 'FI',
+            fr: 'FR',
+            he: 'IL',
+            hr: 'HR',
+            hu: 'HU',
+            hy: 'AM',
+            is: 'IS',
+            it: 'IT',
+            ja: 'JP',
+            kk: 'KZ',
+            ko: 'KR',
+            lt: 'LT',
+            nl: 'NL',
+            no: 'NO',
+            pl: 'PL',
+            pt: 'BR',
+            ro: 'RO',
+            ru: 'RU',
+            sk: 'SK',
+            sl: 'SI',
+            sr: 'YU',
+            sv: 'SE',
+            tr: 'TR',
+            uk: 'UA',
+            zh: 'CN',
+        };
+        if (parts[0] in languageVariants) {
+            parts.push(languageVariants[parts[0]]);
+        }
+    }
+    else {
+        parts[1] = parts[1].toUpperCase();
+    }
+    return parts.join('_') + '.UTF-8';
+}
+async function getCwd(shell, userHome, variableResolver, root, customCwd, logService) {
+    if (shell.cwd) {
+        const unresolved = (typeof shell.cwd === 'object') ? shell.cwd.fsPath : shell.cwd;
+        const resolved = await _resolveCwd(unresolved, variableResolver);
+        return sanitizeCwd(resolved || unresolved);
+    }
+    let cwd;
+    if (!shell.ignoreConfigurationCwd && customCwd) {
+        if (variableResolver) {
+            customCwd = await _resolveCwd(customCwd, variableResolver, logService);
+        }
+        if (customCwd) {
+            if (path.isAbsolute(customCwd)) {
+                cwd = customCwd;
+            }
+            else if (root) {
+                cwd = path.join(root.fsPath, customCwd);
+            }
+        }
+    }
+    if (!cwd) {
+        cwd = root ? root.fsPath : userHome || '';
+    }
+    return sanitizeCwd(cwd);
+}
+async function _resolveCwd(cwd, variableResolver, logService) {
+    if (variableResolver) {
+        try {
+            return await variableResolver(cwd);
+        }
+        catch (e) {
+            logService?.error('Could not resolve terminal cwd', e);
+            return undefined;
+        }
+    }
+    return cwd;
+}
+function createVariableResolver(lastActiveWorkspace, env, configurationResolverService) {
+    if (!configurationResolverService) {
+        return undefined;
+    }
+    return (str) => configurationResolverService.resolveWithEnvironment(env, lastActiveWorkspace, str);
+}
+async function createTerminalEnvironment(shellLaunchConfig, envFromConfig, variableResolver, version, detectLocale, baseEnv) {
+    const env = {};
+    if (shellLaunchConfig.strictEnv) {
+        mergeNonNullKeys(env, shellLaunchConfig.env);
+    }
+    else {
+        mergeNonNullKeys(env, baseEnv);
+        const allowedEnvFromConfig = { ...envFromConfig };
+        if (variableResolver) {
+            if (allowedEnvFromConfig) {
+                await resolveConfigurationVariables(variableResolver, allowedEnvFromConfig);
+            }
+            if (shellLaunchConfig.env) {
+                await resolveConfigurationVariables(variableResolver, shellLaunchConfig.env);
+            }
+        }
+        sanitizeProcessEnvironment(env, 'VSCODE_IPC_HOOK_CLI');
+        mergeEnvironments(env, allowedEnvFromConfig);
+        mergeEnvironments(env, shellLaunchConfig.env);
+        addTerminalEnvironmentKeys(env, version, language, detectLocale);
+    }
+    return env;
+}
+async function preparePathForShell(resource, executable, title, shellType, backend, os, isWindowsFrontend = isWindows) {
+    let originalPath;
+    if (isString(resource)) {
+        originalPath = resource;
+    }
+    else {
+        originalPath = resource.fsPath;
+        if (isWindowsFrontend && os !== 1 ) {
+            originalPath = originalPath.replace(/\\/g, '\/');
+        }
+        else if (!isWindowsFrontend && os === 1 ) {
+            originalPath = originalPath.replace(/\//g, '\\');
+        }
+    }
+    if (!executable) {
+        return originalPath;
+    }
+    const hasSpace = originalPath.includes(' ');
+    const hasParens = originalPath.includes('(') || originalPath.includes(')');
+    const pathBasename = path.basename(executable, '.exe');
+    const isPowerShell = pathBasename === 'pwsh' ||
+        title === 'pwsh' ||
+        pathBasename === 'powershell' ||
+        title === 'powershell';
+    if (isPowerShell && (hasSpace || originalPath.includes('\''))) {
+        return `& '${originalPath.replace(/'/g, '\'\'')}'`;
+    }
+    if (hasParens && isPowerShell) {
+        return `& '${originalPath}'`;
+    }
+    if (os === 1 ) {
+        if (shellType !== undefined) {
+            if (shellType === "gitbash" ) {
+                return escapeNonWindowsPath(originalPath.replace(/\\/g, '/'));
+            }
+            else if (shellType === "wsl" ) {
+                return backend?.getWslPath(originalPath, 'win-to-unix') || originalPath;
+            }
+            else if (hasSpace) {
+                return `"${originalPath}"`;
+            }
+            return originalPath;
+        }
+        const lowerExecutable = executable.toLowerCase();
+        if (lowerExecutable.includes('wsl') || (lowerExecutable.includes('bash.exe') && !lowerExecutable.toLowerCase().includes('git'))) {
+            return backend?.getWslPath(originalPath, 'win-to-unix') || originalPath;
+        }
+        else if (hasSpace) {
+            return `"${originalPath}"`;
+        }
+        return originalPath;
+    }
+    return escapeNonWindowsPath(originalPath);
+}
+function getWorkspaceForTerminal(cwd, workspaceContextService, historyService) {
+    const cwdUri = typeof cwd === 'string' ? ( URI.parse(cwd)) : cwd;
+    let workspaceFolder = cwdUri ? withNullAsUndefined(workspaceContextService.getWorkspaceFolder(cwdUri)) : undefined;
+    if (!workspaceFolder) {
+        const activeWorkspaceRootUri = historyService.getLastActiveWorkspaceRoot();
+        workspaceFolder = activeWorkspaceRootUri ? withNullAsUndefined(workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri)) : undefined;
+    }
+    return workspaceFolder;
+}
+export { addTerminalEnvironmentKeys, createTerminalEnvironment, createVariableResolver, getCwd, getLangEnvVariable, getWorkspaceForTerminal, mergeEnvironments, preparePathForShell, shouldSetLangEnvVariable };

package/dist/vscode/vs/workbench/contrib/terminal/common/terminalExtensionPoints.js

@@ -0,0 +1,27 @@
+import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
+import { terminalContributionsDescriptor } from './terminal.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+const terminalsExtPoint = ( ExtensionsRegistry.registerExtensionPoint(terminalContributionsDescriptor));
+const ITerminalContributionService = ( createDecorator('terminalContributionsService'));
+class TerminalContributionService {
+    get terminalProfiles() { return this._terminalProfiles; }
+    constructor() {
+        this._terminalProfiles = [];
+        terminalsExtPoint.setHandler(contributions => {
+            this._terminalProfiles = ( contributions.map(c => {
+                return c.value?.profiles?.filter(p => hasValidTerminalIcon(p)).map(e => {
+                    return { ...e, extensionIdentifier: c.description.identifier.value };
+                }) || [];
+            })).flat();
+        });
+    }
+}
+function hasValidTerminalIcon(profile) {
+    return !profile.icon ||
+        (typeof profile.icon === 'string' ||
+            URI.isUri(profile.icon) ||
+            ('light' in profile.icon && 'dark' in profile.icon &&
+                URI.isUri(profile.icon.light) && URI.isUri(profile.icon.dark)));
+}
+export { ITerminalContributionService, TerminalContributionService };

package/dist/vscode/vs/workbench/contrib/terminal/common/terminalStrings.js

@@ -0,0 +1,86 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+const terminalStrings = {
+    terminal: ( localize('terminal', "Terminal")),
+    new: ( localize('terminal.new', "New Terminal")),
+    doNotShowAgain: ( localize('doNotShowAgain', 'Do Not Show Again')),
+    currentSessionCategory: ( localize('currentSessionCategory', 'current session')),
+    previousSessionCategory: ( localize('previousSessionCategory', 'previous session')),
+    actionCategory: {
+        value: ( localize('terminalCategory', "Terminal")),
+        original: 'Terminal'
+    },
+    focus: {
+        value: ( localize('workbench.action.terminal.focus', "Focus Terminal")),
+        original: 'Focus Terminal'
+    },
+    kill: {
+        value: ( localize('killTerminal', "Kill Terminal")),
+        original: 'Kill Terminal',
+        short: ( localize('killTerminal.short', "Kill")),
+    },
+    moveToEditor: {
+        value: ( localize('moveToEditor', "Move Terminal into Editor Area")),
+        original: 'Move Terminal into Editor Area',
+    },
+    moveToTerminalPanel: {
+        value: ( localize(
+            'workbench.action.terminal.moveToTerminalPanel',
+            "Move Terminal into Panel"
+        )),
+        original: 'Move Terminal into Panel'
+    },
+    changeIcon: {
+        value: ( localize('workbench.action.terminal.changeIcon', "Change Icon...")),
+        original: 'Change Icon...'
+    },
+    changeColor: {
+        value: ( localize('workbench.action.terminal.changeColor', "Change Color...")),
+        original: 'Change Color...'
+    },
+    split: {
+        value: ( localize('splitTerminal', "Split Terminal")),
+        original: 'Split Terminal',
+        short: ( localize('splitTerminal.short', "Split")),
+    },
+    unsplit: {
+        value: ( localize('unsplitTerminal', "Unsplit Terminal")),
+        original: 'Unsplit Terminal'
+    },
+    rename: {
+        value: ( localize('workbench.action.terminal.rename', "Rename...")),
+        original: 'Rename...'
+    },
+    toggleSizeToContentWidth: {
+        value: ( localize(
+            'workbench.action.terminal.sizeToContentWidthInstance',
+            "Toggle Size to Content Width"
+        )),
+        original: 'Toggle Size to Content Width'
+    },
+    focusHover: {
+        value: ( localize('workbench.action.terminal.focusHover', "Focus Hover")),
+        original: 'Focus Hover'
+    },
+    sendSequence: {
+        value: ( localize(
+            'workbench.action.terminal.sendSequence',
+            "Send Custom Sequence To Terminal"
+        )),
+        original: 'Send Custom Sequence To Terminal'
+    },
+    newWithCwd: {
+        value: ( localize(
+            'workbench.action.terminal.newWithCwd',
+            "Create New Terminal Starting in a Custom Working Directory"
+        )),
+        original: 'Create New Terminal Starting in a Custom Working Directory'
+    },
+    renameWithArgs: {
+        value: ( localize(
+            'workbench.action.terminal.renameWithArg',
+            "Rename the Currently Active Terminal"
+        )),
+        original: 'Rename the Currently Active Terminal'
+    }
+};
+export { terminalStrings };

package/dist/vscode/vs/workbench/contrib/terminal/electron-sandbox/terminalProfileResolverService.js

@@ -0,0 +1,46 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ITerminalInstanceService } from '../browser/terminal.js';
+import { BaseTerminalProfileResolverService } from '../browser/terminalProfileResolverService.js';
+import { ITerminalProfileService } from '../common/terminal.js';
+import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.js';
+import { IHistoryService } from '../../../services/history/common/history.js';
+import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
+let ElectronTerminalProfileResolverService = class ElectronTerminalProfileResolverService extends BaseTerminalProfileResolverService {
+    constructor(configurationResolverService, configurationService, historyService, logService, workspaceContextService, terminalProfileService, remoteAgentService, storageService, notificationService, terminalInstanceService) {
+        super({
+            getDefaultSystemShell: async (remoteAuthority, platform) => {
+                const backend = await terminalInstanceService.getBackend(remoteAuthority);
+                if (!backend) {
+                    throw new ErrorNoTelemetry(`Cannot get default system shell when there is no backend for remote authority '${remoteAuthority}'`);
+                }
+                return backend.getDefaultSystemShell(platform);
+            },
+            getEnvironment: async (remoteAuthority) => {
+                const backend = await terminalInstanceService.getBackend(remoteAuthority);
+                if (!backend) {
+                    throw new ErrorNoTelemetry(`Cannot get environment when there is no backend for remote authority '${remoteAuthority}'`);
+                }
+                return backend.getEnvironment();
+            }
+        }, configurationService, configurationResolverService, historyService, logService, terminalProfileService, workspaceContextService, remoteAgentService, storageService, notificationService);
+    }
+};
+ElectronTerminalProfileResolverService = ( __decorate([
+    ( __param(0, IConfigurationResolverService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IHistoryService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IWorkspaceContextService)),
+    ( __param(5, ITerminalProfileService)),
+    ( __param(6, IRemoteAgentService)),
+    ( __param(7, IStorageService)),
+    ( __param(8, INotificationService)),
+    ( __param(9, ITerminalInstanceService))
+], ElectronTerminalProfileResolverService));
+export { ElectronTerminalProfileResolverService };

package/dist/vscode/vs/workbench/contrib/terminalContrib/links/browser/links.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ITerminalLinkProviderService = ( createDecorator('terminalLinkProviderService'));
+export { ITerminalLinkProviderService };

package/dist/vscode/vs/workbench/contrib/terminalContrib/links/browser/terminalLinkProviderService.js

@@ -0,0 +1,26 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+class TerminalLinkProviderService {
+    constructor() {
+        this._linkProviders = ( new Set());
+        this._onDidAddLinkProvider = ( new Emitter());
+        this._onDidRemoveLinkProvider = ( new Emitter());
+    }
+    get linkProviders() { return this._linkProviders; }
+    get onDidAddLinkProvider() { return this._onDidAddLinkProvider.event; }
+    get onDidRemoveLinkProvider() { return this._onDidRemoveLinkProvider.event; }
+    registerLinkProvider(linkProvider) {
+        const disposables = [];
+        this._linkProviders.add(linkProvider);
+        this._onDidAddLinkProvider.fire(linkProvider);
+        return {
+            dispose: () => {
+                for (const disposable of disposables) {
+                    disposable.dispose();
+                }
+                this._linkProviders.delete(linkProvider);
+                this._onDidRemoveLinkProvider.fire(linkProvider);
+            }
+        };
+    }
+}
+export { TerminalLinkProviderService };

package/dist/vscode/vs/workbench/contrib/terminalContrib/quickFix/browser/quickFix.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ITerminalQuickFixService = ( createDecorator('terminalQuickFixService'));
+export { ITerminalQuickFixService };