jiebi/CodeConvo huggingface dataset:
// Add default items const productLabel = this.productService.nameLong; const marketPlaceLabel = localize("reportExtensionMarketplace", "Extension Marketplace"); <del> issuePicksConst.push( { label: productLabel, ariaLabel: productLabel, accept: () => this.commandService.executeCommand('workbench.action.openIssueReporter', { issueSource: IssueSource.VSCode }) }, { label: marketPlaceLabel, ariaLabel: marketPlaceLabel, accept: () => this.commandService.executeCommand('workbench.action.openIssueReporter', { issueSource: IssueSource.Marketplace }) }, { type: 'separator', label: localize('extensions', "Extensions") } ); </del> <ins> const productFilter = matchesFuzzy(filter, productLabel, true); const marketPlaceFilter = matchesFuzzy(filter, marketPlaceLabel, true); // Add product pick if product filter matches if (productFilter) { issuePicksConst.push({ label: productLabel, ariaLabel: productLabel, highlights: { label: productFilter }, accept: () => this.commandService.executeCommand('workbench.action.openIssueReporter', { issueSource: IssueSource.VSCode }) }); } // Add marketplace pick if marketplace filter matches if (marketPlaceFilter) { issuePicksConst.push({ label: marketPlaceLabel, ariaLabel: marketPlaceLabel, highlights: { label: marketPlaceFilter }, accept: () => this.commandService.executeCommand('workbench.action.openIssueReporter', { issueSource: IssueSource.Marketplace }) }); } issuePicksConst.push({ type: 'separator', label: localize('extensions', "Extensions") }); </ins> // creates menu from contributed const menu = this.menuService.createMenu(MenuId.IssueReporter, this.contextKeyService);
focus(): void { this._inlineChatWidget.focus(); } <del> focusResponse(): void { const responseElement = this._inlineChatWidget.domNode.querySelector(ChatElementSelectors.ResponseEditor) || this._inlineChatWidget.domNode.querySelector(ChatElementSelectors.ResponseMessage); if (responseElement instanceof HTMLElement) { responseElement.focus(); } } </del> hasFocus(): boolean { return this._inlineChatWidget.hasFocus(); }
// Import the effects we need import { Color } from 'vs/base/common/color'; <del> import { registerColor, darken, lighten, ifDefinedThenElse, transparent } from 'vs/platform/theme/common/colorUtils'; </del> <ins> import { registerColor, darken, lighten, transparent } from 'vs/platform/theme/common/colorUtils'; </ins> // Import the colors we need import { foreground, contrastBorder, activeContrastBorder, focusBorder, iconForeground } from 'vs/platform/theme/common/colors/baseColors';
nls.localize('highlight', 'List/Tree foreground color of the match highlights when searching inside the list/tree.')); export const listFocusHighlightForeground = registerColor('list.focusHighlightForeground', <del> { dark: listHighlightForeground, light: ifDefinedThenElse(listActiveSelectionBackground, listHighlightForeground, '#BBE7FF'), hcDark: listHighlightForeground, hcLight: listHighlightForeground }, </del> <ins> { dark: listHighlightForeground, light: listHighlightForeground, hcDark: listHighlightForeground, hcLight: listHighlightForeground }, </ins> nls.localize('listFocusHighlightForeground', 'List/Tree foreground color of the match highlights on actively focused items when searching inside the list/tree.')); export const listInvalidItemForeground = registerColor('list.invalidItemForeground',
import { Emitter, Event } from 'vs/base/common/event'; import { DisposableStore } from 'vs/base/common/lifecycle'; import { IPosition, Position } from 'vs/editor/common/core/position'; <del> import { clamp } from 'vs/base/common/numbers'; </del> import { renderLabelWithIcons } from 'vs/base/browser/ui/iconLabel/iconLabels'; import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; import { inlineChatBackground } from 'vs/workbench/contrib/inlineChat/common/inlineChat';
beforeRender(): IDimension | null { <del> const contentWidth = this._editor.getLayoutInfo().contentWidth; const minWidth = Math.round(contentWidth * 0.38); const maxWidth = Math.round(contentWidth * 0.82); const width = clamp(220, minWidth, maxWidth); </del> <ins> const maxHeight = this._widget.input.inputEditor.getOption(EditorOption.lineHeight) * 5; </ins> const inputEditorHeight = this._widget.inputEditor.getContentHeight(); <del> this._widget.inputEditor.layout(new dom.Dimension(width, inputEditorHeight)); </del> <ins> this._widget.inputEditor.layout(new dom.Dimension(360, Math.min(maxHeight, inputEditorHeight))); </ins> // const actualHeight = this._widget.inputPartHeight; // return new dom.Dimension(width, actualHeight);
import { Codicon } from 'vs/base/common/codicons'; import { ThemeIcon } from 'vs/base/common/themables'; import { onUnexpectedExternalError } from 'vs/base/common/errors'; <del> import { getDefaultHoverDelegate } from 'vs/base/browser/ui/hover/hoverDelegateFactory'; </del> import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; <del> import { ClickAction, KeyDownAction } from 'vs/base/browser/ui/hover/hoverWidget'; </del> <ins> import { ClickAction, HoverPosition, KeyDownAction } from 'vs/base/browser/ui/hover/hoverWidget'; </ins> import { KeyCode } from 'vs/base/common/keyCodes'; <del> import { IHoverService } from 'vs/platform/hover/browser/hover'; </del> <ins> import { IHoverService, WorkbenchHoverDelegate } from 'vs/platform/hover/browser/hover'; </ins> import { AsyncIterableObject } from 'vs/base/common/async'; import { LanguageFeatureRegistry } from 'vs/editor/common/languageFeatureRegistry'; import { getHoverProviderResultsAsAsyncIterable } from 'vs/editor/contrib/hover/browser/getHover';
const isActionIncrease = action === HoverVerbosityAction.Increase; const actionElement = dom.append(container, $(ThemeIcon.asCSSSelector(isActionIncrease ? increaseHoverVerbosityIcon : decreaseHoverVerbosityIcon))); actionElement.tabIndex = 0; <ins> const hoverDelegate = new WorkbenchHoverDelegate('mouse', false, { target: container, position: { hoverPosition: HoverPosition.LEFT } }, this._configurationService, this._hoverService); </ins> if (isActionIncrease) { const kb = this._keybindingService.lookupKeybinding(INCREASE_HOVER_VERBOSITY_ACTION_ID); <del> store.add(this._hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), actionElement, kb ? </del> <ins> store.add(this._hoverService.setupUpdatableHover(hoverDelegate, actionElement, kb ? </ins> nls.localize('increaseVerbosityWithKb', "Increase Verbosity ({0})", kb.getLabel()) : nls.localize('increaseVerbosity', "Increase Verbosity"))); } else { const kb = this._keybindingService.lookupKeybinding(DECREASE_HOVER_VERBOSITY_ACTION_ID); <del> store.add(this._hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), actionElement, kb ? </del> <ins> store.add(this._hoverService.setupUpdatableHover(hoverDelegate, actionElement, kb ? </ins> nls.localize('decreaseVerbosityWithKb', "Decrease Verbosity ({0})", kb.getLabel()) : nls.localize('decreaseVerbosity', "Decrease Verbosity"))); }
comment: ['Label for action that will increase the hover verbosity level.'] }, "Increase Hover Verbosity Level"), alias: 'Increase Hover Verbosity Level', <del> precondition: EditorContextKeys.hoverFocused, kbOpts: { kbExpr: EditorContextKeys.hoverFocused, primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.KeyP), weight: KeybindingWeight.EditorContrib } </del> <ins> precondition: EditorContextKeys.hoverFocused </ins> }); }
comment: ['Label for action that will decrease the hover verbosity level.'] }, "Decrease Hover Verbosity Level"), alias: 'Decrease Hover Verbosity Level', <del> precondition: EditorContextKeys.hoverFocused, kbOpts: { kbExpr: EditorContextKeys.hoverFocused, primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.KeyM), weight: KeybindingWeight.EditorContrib } </del> <ins> precondition: EditorContextKeys.hoverFocused </ins> }); }
const fullscreen = isFullscreen(this.window); return { ...state, <del> bounds: this.maximized ? undefined : state.bounds, // ignore if maximized (fullscreen is not yet supported!) </del> <ins> bounds: state.bounds, </ins> mode: this.maximized ? AuxiliaryWindowMode.Maximized : fullscreen ? AuxiliaryWindowMode.Fullscreen : AuxiliaryWindowMode.Normal }; }
let customEditorLabelDescription = localize('workbench.editor.label.patterns', "Controls the rendering of the editor label. Each __Item__ is a pattern that matches a file path. Both relative and absolute file paths are supported. In case multiple patterns match, the longest matching path will be picked. Each __Value__ is the template for the rendered editor when the __Item__ matches. Variables are substituted based on the context:"); customEditorLabelDescription += 'n- ' + [ localize('workbench.editor.label.dirname', "`${dirname}`: name of the folder in which the file is located (e.g. `root/folder/file.txt -> folder`)."), <del> localize('workbench.editor.label.nthdirname', "`${dirname(N)}`: name of the nth parent folder in which the file is located (e.g. `N=1: root/folder/file.txt -> root`)."), </del> <ins> localize('workbench.editor.label.nthdirname', "`${dirname(N)}`: name of the nth parent folder in which the file is located (e.g. `N=1: root/folder/file.txt -> root`). Folders can be picked from the start of the path by using negative numbers (e.g. `N=-1: root/folder/file.txt -> root`). If the __Item__ is an absolute pattern path, the first folder (`N=-1`) refers to the first folder in the absoulte path, otherwise it corresponds to the workspace folder."), </ins> localize('workbench.editor.label.filename', "`${filename}`: name of the file without the file extension (e.g. `root/folder/file.txt -> file`)."), localize('workbench.editor.label.extname', "`${extname}`: the file extension (e.g. `root/folder/file.txt -> txt`)."), ].join('n- '); // intentionally concatenated to not produce a string that is too long for translations
import { MainThreadTunnelServiceShape, MainContext, ExtHostContext, ExtHostTunnelServiceShape, CandidatePortSource, PortAttributesSelector, TunnelDto } from 'vs/workbench/api/common/extHost.protocol'; import { TunnelDtoConverter } from 'vs/workbench/api/common/extHostTunnelService'; import { extHostNamedCustomer, IExtHostContext } from 'vs/workbench/services/extensions/common/extHostCustomers'; <del> import { IRemoteExplorerService, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_OUTPUT } from 'vs/workbench/services/remote/common/remoteExplorerService'; </del> <ins> import { IRemoteExplorerService, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_HYBRID, PORT_AUTO_SOURCE_SETTING_OUTPUT } from 'vs/workbench/services/remote/common/remoteExplorerService'; </ins> import { ITunnelProvider, ITunnelService, TunnelCreationOptions, TunnelProviderFeatures, TunnelOptions, RemoteTunnel, ProvidedPortAttributes, PortAttributesProvider, TunnelProtocol } from 'vs/platform/tunnel/common/tunnel'; import { Disposable } from 'vs/base/common/lifecycle'; import type { TunnelDescription } from 'vs/platform/remote/common/remoteAuthorityResolver';
.registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPortsSource': PORT_AUTO_SOURCE_SETTING_OUTPUT } }]); break; } <ins> case CandidatePortSource.Hybrid: { Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration) .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPortsSource': PORT_AUTO_SOURCE_SETTING_HYBRID } }]); break; } </ins> default: // Do nothing, the defaults for these settings should be used. } }).catch(() => {
"--vscode-editorStickyScroll-scrollableWidth", "--vscode-editorStickyScroll-foldingOpacityTransition", "--window-border-color", <ins> "--vscode-parameterHintsWidget-editorFontFamily", "--vscode-parameterHintsWidget-editorFontFamilyDefault", </ins> "--workspace-trust-check-color", "--workspace-trust-selected-color", "--workspace-trust-unselected-color",
border-bottom: 1px solid var(--vscode-editorHoverWidget-border); } <ins> .monaco-editor .parameter-hints-widget .code { font-family: var(--vscode-parameterHintsWidget-editorFontFamily), var(--vscode-parameterHintsWidget-editorFontFamilyDefault); } </ins> .monaco-editor .parameter-hints-widget .docs { padding: 0 10px 0 5px; white-space: pre-wrap;
import { assertIsDefined } from 'vs/base/common/types'; import 'vs/css!./parameterHints'; import { ContentWidgetPositionPreference, ICodeEditor, IContentWidget, IContentWidgetPosition } from 'vs/editor/browser/editorBrowser'; <del> import { EditorOption } from 'vs/editor/common/config/editorOptions'; </del> <ins> import { EDITOR_FONT_DEFAULTS, EditorOption } from 'vs/editor/common/config/editorOptions'; </ins> import * as languages from 'vs/editor/common/languages'; import { ILanguageService } from 'vs/editor/common/languages/language'; import { IMarkdownRenderResult, MarkdownRenderer } from 'vs/editor/browser/widget/markdownRenderer/browser/markdownRenderer';
if (!this.domNodes) { return; } const fontInfo = this.editor.getOption(EditorOption.fontInfo); <del> this.domNodes.element.style.fontSize = `${fontInfo.fontSize}px`; this.domNodes.element.style.lineHeight = `${fontInfo.lineHeight / fontInfo.fontSize}`; </del> <ins> const element = this.domNodes.element; element.style.fontSize = `${fontInfo.fontSize}px`; element.style.lineHeight = `${fontInfo.lineHeight / fontInfo.fontSize}`; element.style.setProperty('--vscode-parameterHintsWidget-editorFontFamily', fontInfo.fontFamily); element.style.setProperty('--vscode-parameterHintsWidget-editorFontFamilyDefault', EDITOR_FONT_DEFAULTS.fontFamily); </ins> }; updateFont();
} const code = dom.append(this.domNodes.signature, $('.code')); <del> const fontInfo = this.editor.getOption(EditorOption.fontInfo); code.style.fontSize = `${fontInfo.fontSize}px`; code.style.fontFamily = fontInfo.fontFamily; </del> const hasParameters = signature.parameters.length > 0; const activeParameterIndex = signature.activeParameter ?? hints.activeParameter;
function Global:__VSCode-Escape-Value([string]$value) { # NOTE: In PowerShell v6.1+, this can be written `$value -replace '…', { … }` instead of `[regex]::Replace`. # Replace any non-alphanumeric characters. <del> [regex]::Replace($value, "[$([char]0x1b)n;]", { param($match) </del> <ins> [regex]::Replace($value, "[$([char]0x00)-$([char]0x1f)n;]", { param($match) </ins> # Encode the (ascii) matches as `x<hex>` -Join ( [System.Text.Encoding]::UTF8.GetBytes($match.Value) | ForEach-Object { 'x{0:x2}' -f $_ }
this._scanDevelopedExtensions(language, extensionDevelopmentPath) ]); <del> return dedupExtensions(builtinExtensions, [...installedExtensions, ...workspaceInstalledExtensions], developedExtensions, this._logService); </del> <ins> return dedupExtensions(builtinExtensions, installedExtensions, workspaceInstalledExtensions, developedExtensions, this._logService); </ins> } private async _scanDevelopedExtensions(language: string, extensionDevelopmentPaths?: string[]): Promise<IExtensionDescription[]> {
all.push(...await this.workbenchExtensionManagementService.getInstalledWorkspaceExtensions(true)); } <del> // dedup user and system extensions by giving priority to user extensions. </del> <ins> // dedup workspace, user and system extensions by giving priority to workspace first and then to user extension. </ins> const installed = groupByExtension(all, r => r.identifier).reduce((result, extensions) => { <del> const extension = extensions.length === 1 ? extensions[0] : extensions.find(e => e.type === ExtensionType.User) || extensions.find(e => e.type === ExtensionType.System); result.push(extension!); </del> <ins> if (extensions.length === 1) { result.push(extensions[0]); } else { let workspaceExtension: ILocalExtension | undefined, userExtension: ILocalExtension | undefined, systemExtension: ILocalExtension | undefined; for (const extension of extensions) { if (extension.isWorkspaceScoped) { workspaceExtension = extension; } else if (extension.type === ExtensionType.User) { userExtension = extension; } else { systemExtension = extension; } } const extension = workspaceExtension ?? userExtension ?? systemExtension; if (extension) { result.push(extension); } } </ins> return result; }, []);
if (isUninstalled) { const canRemoveRunningExtension = runningExtension && this.extensionService.canRemoveExtension(runningExtension); <del> const isSameExtensionRunning = runningExtension && (!extension.server || extension.server === this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension))); </del> <ins> const isSameExtensionRunning = runningExtension && (!extension.server || extension.server === this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension))) && (!extension.resourceExtension || this.uriIdentityService.extUri.isEqual(extension.resourceExtension.location, runningExtension.extensionLocation)); </ins> if (!canRemoveRunningExtension && isSameExtensionRunning && !runningExtension.isUnderDevelopment) { return { action: reloadAction, reason: nls.localize('postUninstallTooltip', "Please {0} to complete the uninstallation of this extension.", reloadActionLabel) }; }
import * as semver from 'vs/base/common/semver/semver'; // TODO: @sandy081 merge this with deduping in extensionsScannerService.ts <del> export function dedupExtensions(system: IExtensionDescription[], user: IExtensionDescription[], development: IExtensionDescription[], logService: ILogService): IExtensionDescription[] { </del> <ins> export function dedupExtensions(system: IExtensionDescription[], user: IExtensionDescription[], workspace: IExtensionDescription[], development: IExtensionDescription[], logService: ILogService): IExtensionDescription[] { </ins> const result = new ExtensionIdentifierMap<IExtensionDescription>(); system.forEach((systemExtension) => { const extension = result.get(systemExtension.identifier);
} result.set(userExtension.identifier, userExtension); }); <ins> workspace.forEach(workspaceExtension => { const extension = result.get(workspaceExtension.identifier); if (extension) { logService.warn(localize('overwritingWithWorkspaceExtension', "Overwriting {0} with Workspace Extension {1}.", extension.extensionLocation.fsPath, workspaceExtension.extensionLocation.fsPath)); } result.set(workspaceExtension.identifier, workspaceExtension); }); </ins> development.forEach(developedExtension => { logService.info(localize('extensionUnderDevelopment', "Loading development extension at {0}", developedExtension.extensionLocation.fsPath)); const extension = result.get(developedExtension.identifier);
} const system = scannedSystemExtensions.map(e => toExtensionDescriptionFromScannedExtension(e, false)); <del> const userGlobal = scannedUserExtensions.map(e => toExtensionDescriptionFromScannedExtension(e, false)); const userWorkspace = workspaceExtensions.map(e => toExtensionDescription(e, false)); </del> <ins> const user = scannedUserExtensions.map(e => toExtensionDescriptionFromScannedExtension(e, false)); const workspace = workspaceExtensions.map(e => toExtensionDescription(e, false)); </ins> const development = scannedDevelopedExtensions.map(e => toExtensionDescriptionFromScannedExtension(e, true)); <del> const r = dedupExtensions(system, [...userGlobal, ...userWorkspace], development, this._logService); </del> <ins> const r = dedupExtensions(system, user, workspace, development, this._logService); </ins> if (!hasErrors) { const disposable = this._extensionsScannerService.onDidChangeCache(() => {
} else if (this._collectContextKeysForSubmenus) { // recursively collect context keys from submenus so that this // menu fires events when context key changes affect submenus <del> MenuRegistry.getMenuItems(item.submenu).forEach(this._collectContextKeys, this); </del> <ins> MenuRegistry.getMenuItems(item.submenu).forEach(this._collectContextKeysAndSubmenuIds, this); this._allMenuIds.add(item.submenu); </ins> } }
}, options.eventDebounceDelay); this._disposables.add(rebuildMenuSoon); this._disposables.add(MenuRegistry.onDidChangeMenu(e => { <del> if (e.has(id)) { rebuildMenuSoon.schedule(); </del> <ins> for (const id of this._menuInfo.allMenuIds) { if (e.has(id)) { rebuildMenuSoon.schedule(); break; } </ins> } }));
import { CommandOptions, ForkOptions, Source, SuccessData, TerminateResponse, TerminateResponseCode } from 'vs/base/common/processes'; import * as Types from 'vs/base/common/types'; import * as pfs from 'vs/base/node/pfs'; <del> export { CommandOptions, ForkOptions, SuccessData, Source, TerminateResponse, TerminateResponseCode }; </del> <ins> export { type CommandOptions, type ForkOptions, type SuccessData, Source, type TerminateResponse, TerminateResponseCode }; </ins> export type ValueCallback<T> = (value: T | Promise<T>) => void; export type ErrorCallback = (error?: any) => void;
import { RawContextKey } from 'vs/platform/contextkey/common/contextkey'; import { workbenchConfigurationNodeBase, Extensions as WorkbenchExtensions, IConfigurationMigrationRegistry, ConfigurationKeyValuePairs, ConfigurationMigration } from 'vs/workbench/common/configuration'; import { AccessibilitySignal } from 'vs/platform/accessibilitySignal/browser/accessibilitySignalService'; <del> import { ISpeechService, SPEECH_LANGUAGES, SPEECH_LANGUAGE_CONFIG } from 'vs/workbench/contrib/speech/common/speechService'; </del> <ins> import { AccessibilityVoiceSettingId, ISpeechService, SPEECH_LANGUAGES } from 'vs/workbench/contrib/speech/common/speechService'; </ins> import { Disposable } from 'vs/base/common/lifecycle'; import { IWorkbenchContribution } from 'vs/workbench/common/contributions'; import { Event } from 'vs/base/common/event';
}); } <del> export const enum AccessibilityVoiceSettingId { SpeechTimeout = 'accessibility.voice.speechTimeout', AutoSynthesize = 'accessibility.voice.autoSynthesize', SpeechLanguage = SPEECH_LANGUAGE_CONFIG } </del> <ins> export { AccessibilityVoiceSettingId } </ins> export const SpeechTimeoutDefault = 1200; export class DynamicSpeechAccessibilityConfiguration extends Disposable implements IWorkbenchContribution {
export const INLINE_CHAT_ID = 'interactiveEditor'; export const INTERACTIVE_EDITOR_ACCESSIBILITY_HELP_ID = 'interactiveEditorAccessiblityHelp'; <ins> export const enum EditMode { Live = 'live', Preview = 'preview' } </ins> export const CTX_INLINE_CHAT_HAS_PROVIDER = new RawContextKey<boolean>('inlineChatHasProvider', false, localize('inlineChatHasProvider', "Whether a provider for interactive editors exists")); export const CTX_INLINE_CHAT_VISIBLE = new RawContextKey<boolean>('inlineChatVisible', false, localize('inlineChatVisible', "Whether the interactive editor input is visible")); export const CTX_INLINE_CHAT_FOCUSED = new RawContextKey<boolean>('inlineChatFocused', false, localize('inlineChatFocused', "Whether the interactive editor input is focused"));
recognizeKeyword(token: CancellationToken): Promise<KeywordRecognitionStatus>; } <del> export const SPEECH_LANGUAGE_CONFIG = 'accessibility.voice.speechLanguage'; </del> <ins> export const enum AccessibilityVoiceSettingId { SpeechTimeout = 'accessibility.voice.speechTimeout', AutoSynthesize = 'accessibility.voice.autoSynthesize', SpeechLanguage = 'accessibility.voice.speechLanguage', } export const SPEECH_LANGUAGE_CONFIG = AccessibilityVoiceSettingId.SpeechLanguage; </ins> export const SPEECH_LANGUAGES = { ['da-DK']: {
import { IStringDictionary } from 'vs/base/common/collections'; import { RawContextKey, ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey'; <del> export { ITaskSummary, Task, ITaskTerminateResponse as TaskTerminateResponse }; </del> <ins> export type { ITaskSummary, Task, ITaskTerminateResponse as TaskTerminateResponse }; </ins> export const CustomExecutionSupportedContext = new RawContextKey<boolean>('customExecutionSupported', false, nls.localize('tasks.customExecutionSupported', "Whether CustomExecution tasks are supported. Consider using in the when clause of a 'taskDefinition' contribution.")); export const ShellExecutionSupportedContext = new RawContextKey<boolean>('shellExecutionSupported', false, nls.localize('tasks.shellExecutionSupported', "Whether ShellExecution tasks are supported. Consider using in the when clause of a 'taskDefinition' contribution."));