@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/tasks/browser/abstractTaskService.js

@@ -0,0 +1,3857 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Action } from '../../../../base/common/actions.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { match } from '../../../../base/common/glob.js';
+import { parse as parse$1 } from '../../../../base/common/json.js';
+import { Disposable, dispose } from '../../../../base/common/lifecycle.js';
+import { LRUCache } from '../../../../base/common/map.js';
+import { deepClone } from '../../../../base/common/objects.js';
+import { ValidationStatus } from '../../../../base/common/parsers.js';
+import { isWeb, platform } from '../../../../base/common/platform.js';
+import { basename, joinPath, dirname, relativePath } from '../../../../base/common/resources.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { isString, isBoolean, isStringArray } from '../../../../base/common/types.js';
+import { URI } from '../../../../base/common/uri.js';
+import { generateUuid } from '../../../../base/common/uuid.js';
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
+import { CommandsRegistry, ICommandService } from '../../../../platform/commands/common/commands.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { IMarkerService } from '../../../../platform/markers/common/markers.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { ProblemMatcherRegistry } from '../common/problemMatcher.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { WorkspaceFolder, IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { Markers } from '../../markers/common/markers.js';
+import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IOutputService } from '../../../services/output/common/output.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+import { ITerminalService, ITerminalGroupService } from '../../terminal/browser/terminal.js';
+import { ITerminalProfileResolverService } from '../../terminal/common/terminal.js';
+import { TASK_RUNNING_STATE, TaskGroup, ConfiguringTask, TaskSourceKind, TaskDefinition, USER_TASKS_GROUP_KEY, ContributedTask, CustomTask, TaskSorter, InMemoryTask, KeyedTaskIdentifier, ExecutionEngine, RuntimeType } from '../common/tasks.js';
+import { TaskCommandsRegistered, ServerlessWebContext, CustomExecutionSupportedContext, ShellExecutionSupportedContext, ProcessExecutionSupportedContext, TaskExecutionSupportedContext } from '../common/taskService.js';
+import { TaskError } from '../common/taskSystem.js';
+import { getTemplates } from '../common/taskTemplates.js';
+import { createCustomTask, TaskConfigSource, GroupKind, parse, ExecutionEngine as ExecutionEngine$1, JsonSchemaVersion } from '../common/taskConfiguration.js';
+import { TerminalTaskSystem } from './terminalTaskSystem.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { TaskDefinitionRegistry } from '../common/taskDefinitionRegistry.js';
+import { raceTimeout } from '../../../../base/common/async.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { toFormattedString } from '../../../../base/common/jsonFormatter.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { TerminalExitReason } from '../../../../platform/terminal/common/terminal.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { IWorkspaceTrustRequestService, IWorkspaceTrustManagementService } from '../../../../platform/workspace/common/workspaceTrust.js';
+import { VirtualWorkspaceContext } from '../../../common/contextkeys.js';
+import { EditorResourceAccessor } from '../../../common/editor.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
+import { isWorkspaceFolder, QUICKOPEN_DETAIL_CONFIG, TaskQuickPick, QUICKOPEN_SKIP_CONFIG, configureTaskIcon } from './taskQuickPick.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
+import { IPathService } from '../../../services/path/common/pathService.js';
+import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
+import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+var AbstractTaskService_1;
+const QUICKOPEN_HISTORY_LIMIT_CONFIG = 'task.quickOpen.history';
+const PROBLEM_MATCHER_NEVER_CONFIG = 'task.problemMatchers.neverPrompt';
+const USE_SLOW_PICKER = 'task.quickOpen.showAll';
+var ConfigureTaskAction;
+( (function(ConfigureTaskAction) {
+    ConfigureTaskAction.ID = 'workbench.action.tasks.configureTaskRunner';
+    ConfigureTaskAction.TEXT = ( localize2WithPath(
+        'vs/workbench/contrib/tasks/browser/abstractTaskService',
+        'ConfigureTaskRunnerAction.label',
+        "Configure Task"
+    ));
+})(ConfigureTaskAction || (ConfigureTaskAction = {})));
+class ProblemReporter {
+    constructor(_outputChannel) {
+        this._outputChannel = _outputChannel;
+        this._validationStatus = ( new ValidationStatus());
+    }
+    info(message) {
+        this._validationStatus.state = 1 ;
+        this._outputChannel.append(message + '\n');
+    }
+    warn(message) {
+        this._validationStatus.state = 2 ;
+        this._outputChannel.append(message + '\n');
+    }
+    error(message) {
+        this._validationStatus.state = 3 ;
+        this._outputChannel.append(message + '\n');
+    }
+    fatal(message) {
+        this._validationStatus.state = 4 ;
+        this._outputChannel.append(message + '\n');
+    }
+    get status() {
+        return this._validationStatus;
+    }
+}
+class TaskMap {
+    constructor() {
+        this._store = ( new Map());
+    }
+    forEach(callback) {
+        this._store.forEach(callback);
+    }
+    static getKey(workspaceFolder) {
+        let key;
+        if (isString(workspaceFolder)) {
+            key = workspaceFolder;
+        }
+        else {
+            const uri = isWorkspaceFolder(workspaceFolder) ? workspaceFolder.uri : workspaceFolder.configuration;
+            key = uri ? ( uri.toString()) : '';
+        }
+        return key;
+    }
+    get(workspaceFolder) {
+        const key = TaskMap.getKey(workspaceFolder);
+        let result = this._store.get(key);
+        if (!result) {
+            result = [];
+            this._store.set(key, result);
+        }
+        return result;
+    }
+    add(workspaceFolder, ...task) {
+        const key = TaskMap.getKey(workspaceFolder);
+        let values = this._store.get(key);
+        if (!values) {
+            values = [];
+            this._store.set(key, values);
+        }
+        values.push(...task);
+    }
+    all() {
+        const result = [];
+        this._store.forEach((values) => result.push(...values));
+        return result;
+    }
+}
+let AbstractTaskService = class AbstractTaskService extends Disposable {
+    static { AbstractTaskService_1 = this; }
+    static { this.RecentlyUsedTasks_Key = 'workbench.tasks.recentlyUsedTasks'; }
+    static { this.RecentlyUsedTasks_KeyV2 = 'workbench.tasks.recentlyUsedTasks2'; }
+    static { this.PersistentTasks_Key = 'workbench.tasks.persistentTasks'; }
+    static { this.IgnoreTask010DonotShowAgain_key = 'workbench.tasks.ignoreTask010Shown'; }
+    static { this.OutputChannelId = 'tasks'; }
+    static { this.OutputChannelLabel = ( localizeWithPath('vs/workbench/contrib/tasks/browser/abstractTaskService', 'tasks', "Tasks")); }
+    static { this._nextHandle = 0; }
+    get isReconnected() { return this._tasksReconnected; }
+    constructor(_configurationService, _markerService, _outputService, _paneCompositeService, _viewsService, _commandService, _editorService, _fileService, _contextService, _telemetryService, _textFileService, _modelService, _extensionService, _quickInputService, _configurationResolverService, _terminalService, _terminalGroupService, _storageService, _progressService, _openerService, _dialogService, _notificationService, _contextKeyService, _environmentService, _terminalProfileResolverService, _pathService, _textModelResolverService, _preferencesService, _viewDescriptorService, _workspaceTrustRequestService, _workspaceTrustManagementService, _logService, _themeService, _lifecycleService, remoteAgentService, _instantiationService) {
+        super();
+        this._configurationService = _configurationService;
+        this._markerService = _markerService;
+        this._outputService = _outputService;
+        this._paneCompositeService = _paneCompositeService;
+        this._viewsService = _viewsService;
+        this._commandService = _commandService;
+        this._editorService = _editorService;
+        this._fileService = _fileService;
+        this._contextService = _contextService;
+        this._telemetryService = _telemetryService;
+        this._textFileService = _textFileService;
+        this._modelService = _modelService;
+        this._extensionService = _extensionService;
+        this._quickInputService = _quickInputService;
+        this._configurationResolverService = _configurationResolverService;
+        this._terminalService = _terminalService;
+        this._terminalGroupService = _terminalGroupService;
+        this._storageService = _storageService;
+        this._progressService = _progressService;
+        this._openerService = _openerService;
+        this._dialogService = _dialogService;
+        this._notificationService = _notificationService;
+        this._contextKeyService = _contextKeyService;
+        this._environmentService = _environmentService;
+        this._terminalProfileResolverService = _terminalProfileResolverService;
+        this._pathService = _pathService;
+        this._textModelResolverService = _textModelResolverService;
+        this._preferencesService = _preferencesService;
+        this._viewDescriptorService = _viewDescriptorService;
+        this._workspaceTrustRequestService = _workspaceTrustRequestService;
+        this._workspaceTrustManagementService = _workspaceTrustManagementService;
+        this._logService = _logService;
+        this._themeService = _themeService;
+        this._lifecycleService = _lifecycleService;
+        this._instantiationService = _instantiationService;
+        this._tasksReconnected = false;
+        this._taskSystemListeners = [];
+        this._onDidRegisterSupportedExecutions = ( new Emitter());
+        this._onDidRegisterAllSupportedExecutions = ( new Emitter());
+        this._onDidChangeTaskSystemInfo = ( new Emitter());
+        this._willRestart = false;
+        this.onDidChangeTaskSystemInfo = this._onDidChangeTaskSystemInfo.event;
+        this._onDidReconnectToTasks = ( new Emitter());
+        this.onDidReconnectToTasks = this._onDidReconnectToTasks.event;
+        this._onDidChangeTaskConfig = ( new Emitter());
+        this.onDidChangeTaskConfig = this._onDidChangeTaskConfig.event;
+        this._whenTaskSystemReady = Event.toPromise(this.onDidChangeTaskSystemInfo);
+        this._workspaceTasksPromise = undefined;
+        this._taskSystem = undefined;
+        this._taskSystemListeners = undefined;
+        this._outputChannel = this._outputService.getChannel(AbstractTaskService_1.OutputChannelId);
+        this._providers = ( new Map());
+        this._providerTypes = ( new Map());
+        this._taskSystemInfos = ( new Map());
+        this._register(this._contextService.onDidChangeWorkspaceFolders(() => {
+            const folderSetup = this._computeWorkspaceFolderSetup();
+            if (this.executionEngine !== folderSetup[2]) {
+                this._disposeTaskSystemListeners();
+                this._taskSystem = undefined;
+            }
+            this._updateSetup(folderSetup);
+            return this._updateWorkspaceTasks(2 );
+        }));
+        this._register(this._configurationService.onDidChangeConfiguration(async (e) => {
+            if (!e.affectsConfiguration('tasks') || (!this._taskSystem && !this._workspaceTasksPromise)) {
+                return;
+            }
+            if (!this._taskSystem || this._taskSystem instanceof TerminalTaskSystem) {
+                this._outputChannel.clear();
+            }
+            if (e.affectsConfiguration("task.reconnection" )) {
+                if (!this._configurationService.getValue("task.reconnection" )) {
+                    this._persistentTasks?.clear();
+                    this._storageService.remove(AbstractTaskService_1.PersistentTasks_Key, 1 );
+                }
+            }
+            this._setTaskLRUCacheLimit();
+            await this._updateWorkspaceTasks(3 );
+            this._onDidChangeTaskConfig.fire();
+        }));
+        this._taskRunningState = TASK_RUNNING_STATE.bindTo(_contextKeyService);
+        this._onDidStateChange = this._register(( new Emitter()));
+        this._registerCommands().then(() => TaskCommandsRegistered.bindTo(this._contextKeyService).set(true));
+        ServerlessWebContext.bindTo(this._contextKeyService).set(isWeb && !remoteAgentService.getConnection()?.remoteAuthority);
+        this._configurationResolverService.contributeVariable('defaultBuildTask', async () => {
+            let tasks = await this._getTasksForGroup(TaskGroup.Build);
+            if (tasks.length > 0) {
+                const defaults = this._getDefaultTasks(tasks);
+                if (defaults.length === 1) {
+                    return defaults[0]._label;
+                }
+                else if (defaults.length) {
+                    tasks = defaults;
+                }
+            }
+            let entry;
+            if (tasks && tasks.length > 0) {
+                entry = await this._showQuickPick(tasks, ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'TaskService.pickBuildTaskForLabel',
+                    'Select the build task (there is no default build task defined)'
+                )));
+            }
+            const task = entry ? entry.task : undefined;
+            if (!task) {
+                return undefined;
+            }
+            return task._label;
+        });
+        this._lifecycleService.onBeforeShutdown(e => {
+            this._willRestart = e.reason !== 3 ;
+        });
+        this._register(this.onDidStateChange(e => {
+            this._log(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'taskEvent',
+                'Task Event kind: {0}',
+                e.kind
+            )), true);
+            if (e.kind === "changed" ) ;
+            else if ((this._willRestart || (e.kind === "terminated"  && e.exitReason === TerminalExitReason.User)) && e.taskId) {
+                const key = e.__task.getKey();
+                if (key) {
+                    this.removePersistentTask(key);
+                }
+            }
+            else if (e.kind === "start"  && e.__task && e.__task.getWorkspaceFolder()) {
+                this._setPersistentTask(e.__task);
+            }
+        }));
+        this._waitForAllSupportedExecutions = ( new Promise(resolve => {
+            Event.once(this._onDidRegisterAllSupportedExecutions.event)(() => resolve());
+        }));
+        if (this._terminalService.getReconnectedTerminals('Task')?.length) {
+            this._attemptTaskReconnection();
+        }
+        else {
+            this._terminalService.whenConnected.then(() => {
+                if (this._terminalService.getReconnectedTerminals('Task')?.length) {
+                    this._attemptTaskReconnection();
+                }
+                else {
+                    this._tasksReconnected = true;
+                    this._onDidReconnectToTasks.fire();
+                }
+            });
+        }
+        this._upgrade();
+    }
+    registerSupportedExecutions(custom, shell, process) {
+        if (custom !== undefined) {
+            const customContext = CustomExecutionSupportedContext.bindTo(this._contextKeyService);
+            customContext.set(custom);
+        }
+        const isVirtual = !!VirtualWorkspaceContext.getValue(this._contextKeyService);
+        if (shell !== undefined) {
+            const shellContext = ShellExecutionSupportedContext.bindTo(this._contextKeyService);
+            shellContext.set(shell && !isVirtual);
+        }
+        if (process !== undefined) {
+            const processContext = ProcessExecutionSupportedContext.bindTo(this._contextKeyService);
+            processContext.set(process && !isVirtual);
+        }
+        this._workspaceTasksPromise = undefined;
+        this._onDidRegisterSupportedExecutions.fire();
+        if (custom && shell && process) {
+            this._onDidRegisterAllSupportedExecutions.fire();
+        }
+    }
+    _attemptTaskReconnection() {
+        if (this._lifecycleService.startupKind !== 3 ) {
+            this._log(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskService.skippingReconnection',
+                'Startup kind not window reload, setting connected and removing persistent tasks'
+            )), true);
+            this._tasksReconnected = true;
+            this._storageService.remove(AbstractTaskService_1.PersistentTasks_Key, 1 );
+        }
+        if (!this._configurationService.getValue("task.reconnection" ) || this._tasksReconnected) {
+            this._log(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskService.notConnecting',
+                'Setting tasks connected configured value {0}, tasks were already reconnected {1}',
+                this._configurationService.getValue("task.reconnection" ),
+                this._tasksReconnected
+            )), true);
+            this._tasksReconnected = true;
+            return;
+        }
+        this._log(( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TaskService.reconnecting',
+            'Reconnecting to running tasks...'
+        )), true);
+        this.getWorkspaceTasks(4 ).then(async () => {
+            this._tasksReconnected = await this._reconnectTasks();
+            this._log(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskService.reconnected',
+                'Reconnected to running tasks.'
+            )), true);
+            this._onDidReconnectToTasks.fire();
+        });
+    }
+    async _reconnectTasks() {
+        const tasks = await this.getSavedTasks('persistent');
+        if (!tasks.length) {
+            this._log(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskService.noTasks',
+                'No persistent tasks to reconnect.'
+            )), true);
+            return true;
+        }
+        const taskLabels = ( tasks.map(task => task._label)).join(', ');
+        this._log(( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TaskService.reconnectingTasks',
+            'Reconnecting to {0} tasks...',
+            taskLabels
+        )), true);
+        for (const task of tasks) {
+            if (ConfiguringTask.is(task)) {
+                const resolved = await this.tryResolveTask(task);
+                if (resolved) {
+                    this.run(resolved, undefined, 4 );
+                }
+            }
+            else {
+                this.run(task, undefined, 4 );
+            }
+        }
+        return true;
+    }
+    get onDidStateChange() {
+        return this._onDidStateChange.event;
+    }
+    get supportsMultipleTaskExecutions() {
+        return this.inTerminal();
+    }
+    async _registerCommands() {
+        CommandsRegistry.registerCommand({
+            id: 'workbench.action.tasks.runTask',
+            handler: async (accessor, arg) => {
+                if (await this._trust()) {
+                    await this._runTaskCommand(arg);
+                }
+            },
+            metadata: {
+                description: 'Run Task',
+                args: [{
+                        name: 'args',
+                        isOptional: true,
+                        description: ( localizeWithPath(
+                            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                            'runTask.arg',
+                            "Filters the tasks shown in the quickpick"
+                        )),
+                        schema: {
+                            anyOf: [
+                                {
+                                    type: 'string',
+                                    description: ( localizeWithPath(
+                                        'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                                        'runTask.label',
+                                        "The task's label or a term to filter by"
+                                    ))
+                                },
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        type: {
+                                            type: 'string',
+                                            description: ( localizeWithPath(
+                                                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                                                'runTask.type',
+                                                "The contributed task type"
+                                            ))
+                                        },
+                                        task: {
+                                            type: 'string',
+                                            description: ( localizeWithPath(
+                                                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                                                'runTask.task',
+                                                "The task's label or a term to filter by"
+                                            ))
+                                        }
+                                    }
+                                }
+                            ]
+                        }
+                    }]
+            }
+        });
+        CommandsRegistry.registerCommand('workbench.action.tasks.reRunTask', async (accessor, arg) => {
+            if (await this._trust()) {
+                this._reRunTaskCommand();
+            }
+        });
+        CommandsRegistry.registerCommand('workbench.action.tasks.restartTask', async (accessor, arg) => {
+            if (await this._trust()) {
+                this._runRestartTaskCommand(arg);
+            }
+        });
+        CommandsRegistry.registerCommand('workbench.action.tasks.terminate', async (accessor, arg) => {
+            if (await this._trust()) {
+                this._runTerminateCommand(arg);
+            }
+        });
+        CommandsRegistry.registerCommand('workbench.action.tasks.showLog', () => {
+            this._showOutput(undefined, true);
+        });
+        CommandsRegistry.registerCommand('workbench.action.tasks.build', async () => {
+            if (await this._trust()) {
+                this._runBuildCommand();
+            }
+        });
+        CommandsRegistry.registerCommand('workbench.action.tasks.test', async () => {
+            if (await this._trust()) {
+                this._runTestCommand();
+            }
+        });
+        CommandsRegistry.registerCommand('workbench.action.tasks.configureTaskRunner', async () => {
+            if (await this._trust()) {
+                this._runConfigureTasks();
+            }
+        });
+        CommandsRegistry.registerCommand('workbench.action.tasks.configureDefaultBuildTask', async () => {
+            if (await this._trust()) {
+                this._runConfigureDefaultBuildTask();
+            }
+        });
+        CommandsRegistry.registerCommand('workbench.action.tasks.configureDefaultTestTask', async () => {
+            if (await this._trust()) {
+                this._runConfigureDefaultTestTask();
+            }
+        });
+        CommandsRegistry.registerCommand('workbench.action.tasks.showTasks', async () => {
+            if (await this._trust()) {
+                return this.runShowTasks();
+            }
+        });
+        CommandsRegistry.registerCommand('workbench.action.tasks.toggleProblems', () => this._commandService.executeCommand(Markers.TOGGLE_MARKERS_VIEW_ACTION_ID));
+        CommandsRegistry.registerCommand('workbench.action.tasks.openUserTasks', async () => {
+            const resource = this._getResourceForKind(TaskSourceKind.User);
+            if (resource) {
+                this._openTaskFile(resource, TaskSourceKind.User);
+            }
+        });
+        CommandsRegistry.registerCommand('workbench.action.tasks.openWorkspaceFileTasks', async () => {
+            const resource = this._getResourceForKind(TaskSourceKind.WorkspaceFile);
+            if (resource) {
+                this._openTaskFile(resource, TaskSourceKind.WorkspaceFile);
+            }
+        });
+    }
+    get workspaceFolders() {
+        if (!this._workspaceFolders) {
+            this._updateSetup();
+        }
+        return this._workspaceFolders;
+    }
+    get ignoredWorkspaceFolders() {
+        if (!this._ignoredWorkspaceFolders) {
+            this._updateSetup();
+        }
+        return this._ignoredWorkspaceFolders;
+    }
+    get executionEngine() {
+        if (this._executionEngine === undefined) {
+            this._updateSetup();
+        }
+        return this._executionEngine;
+    }
+    get schemaVersion() {
+        if (this._schemaVersion === undefined) {
+            this._updateSetup();
+        }
+        return this._schemaVersion;
+    }
+    get showIgnoreMessage() {
+        if (this._showIgnoreMessage === undefined) {
+            this._showIgnoreMessage = !this._storageService.getBoolean(AbstractTaskService_1.IgnoreTask010DonotShowAgain_key, 1 , false);
+        }
+        return this._showIgnoreMessage;
+    }
+    _getActivationEvents(type) {
+        const result = [];
+        result.push('onCommand:workbench.action.tasks.runTask');
+        if (type) {
+            result.push(`onTaskType:${type}`);
+        }
+        else {
+            for (const definition of TaskDefinitionRegistry.all()) {
+                result.push(`onTaskType:${definition.taskType}`);
+            }
+        }
+        return result;
+    }
+    async _activateTaskProviders(type) {
+        await this._extensionService.whenInstalledExtensionsRegistered();
+        await raceTimeout(Promise.all(( this._getActivationEvents(type).map(activationEvent => this._extensionService.activateByEvent(activationEvent)))), 5000, () => console.warn('Timed out activating extensions for task providers'));
+    }
+    _updateSetup(setup) {
+        if (!setup) {
+            setup = this._computeWorkspaceFolderSetup();
+        }
+        this._workspaceFolders = setup[0];
+        if (this._ignoredWorkspaceFolders) {
+            if (this._ignoredWorkspaceFolders.length !== setup[1].length) {
+                this._showIgnoreMessage = undefined;
+            }
+            else {
+                const set = ( new Set());
+                this._ignoredWorkspaceFolders.forEach(folder => set.add(( folder.uri.toString())));
+                for (const folder of setup[1]) {
+                    if (!( set.has(( folder.uri.toString())))) {
+                        this._showIgnoreMessage = undefined;
+                        break;
+                    }
+                }
+            }
+        }
+        this._ignoredWorkspaceFolders = setup[1];
+        this._executionEngine = setup[2];
+        this._schemaVersion = setup[3];
+        this._workspace = setup[4];
+    }
+    _showOutput(runSource = 1 , userRequested) {
+        if (!VirtualWorkspaceContext.getValue(this._contextKeyService) && (((runSource === 1) ) || ((runSource === 3) ))) {
+            if (userRequested) {
+                this._outputService.showChannel(this._outputChannel.id, true);
+            }
+            else {
+                this._notificationService.prompt(Severity$1.Warning, ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'taskServiceOutputPrompt',
+                    'There are task errors. See the output for details.'
+                )), [{
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                            'showOutput',
+                            "Show output"
+                        )),
+                        run: () => {
+                            this._outputService.showChannel(this._outputChannel.id, true);
+                        }
+                    }]);
+            }
+        }
+    }
+    _disposeTaskSystemListeners() {
+        if (this._taskSystemListeners) {
+            dispose(this._taskSystemListeners);
+            this._taskSystemListeners = undefined;
+        }
+    }
+    registerTaskProvider(provider, type) {
+        if (!provider) {
+            return {
+                dispose: () => { }
+            };
+        }
+        const handle = AbstractTaskService_1._nextHandle++;
+        this._providers.set(handle, provider);
+        this._providerTypes.set(handle, type);
+        return {
+            dispose: () => {
+                this._providers.delete(handle);
+                this._providerTypes.delete(handle);
+            }
+        };
+    }
+    get hasTaskSystemInfo() {
+        const infosCount = Array.from(( this._taskSystemInfos.values())).flat().length;
+        if (this._environmentService.remoteAuthority) {
+            return infosCount > 1;
+        }
+        return infosCount > 0;
+    }
+    registerTaskSystem(key, info) {
+        if (info.platform === 0 ) {
+            key = this.workspaceFolders.length ? this.workspaceFolders[0].uri.scheme : key;
+        }
+        if (!( this._taskSystemInfos.has(key))) {
+            this._taskSystemInfos.set(key, [info]);
+        }
+        else {
+            const infos = this._taskSystemInfos.get(key);
+            if (info.platform === 0 ) {
+                infos.push(info);
+            }
+            else {
+                infos.unshift(info);
+            }
+        }
+        if (this.hasTaskSystemInfo) {
+            this._onDidChangeTaskSystemInfo.fire();
+        }
+    }
+    _getTaskSystemInfo(key) {
+        const infos = this._taskSystemInfos.get(key);
+        return (infos && infos.length) ? infos[0] : undefined;
+    }
+    extensionCallbackTaskComplete(task, result) {
+        if (!this._taskSystem) {
+            return Promise.resolve();
+        }
+        return this._taskSystem.customExecutionComplete(task, result);
+    }
+    async _findWorkspaceTasks(predicate) {
+        const result = [];
+        const tasks = await this.getWorkspaceTasks();
+        for (const [, workspaceTasks] of tasks) {
+            if (workspaceTasks.configurations) {
+                for (const taskName in workspaceTasks.configurations.byIdentifier) {
+                    const task = workspaceTasks.configurations.byIdentifier[taskName];
+                    if (predicate(task, workspaceTasks.workspaceFolder)) {
+                        result.push(task);
+                    }
+                }
+            }
+            if (workspaceTasks.set) {
+                for (const task of workspaceTasks.set.tasks) {
+                    if (predicate(task, workspaceTasks.workspaceFolder)) {
+                        result.push(task);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    async _findWorkspaceTasksInGroup(group, isDefault) {
+        return this._findWorkspaceTasks((task) => {
+            const taskGroup = task.configurationProperties.group;
+            if (taskGroup && typeof taskGroup !== 'string') {
+                return (taskGroup._id === group._id && (!isDefault || !!taskGroup.isDefault));
+            }
+            return false;
+        });
+    }
+    async getTask(folder, identifier, compareId = false, type = undefined) {
+        if (!(await this._trust())) {
+            return;
+        }
+        const name = isString(folder) ? folder : isWorkspaceFolder(folder) ? folder.name : folder.configuration ? basename(folder.configuration) : undefined;
+        if (( this.ignoredWorkspaceFolders.some(ignored => ignored.name === name))) {
+            return Promise.reject(( new Error(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskServer.folderIgnored',
+                'The folder {0} is ignored since it uses task version 0.1.0',
+                name
+            )))));
+        }
+        const key = !isString(identifier)
+            ? TaskDefinition.createTaskIdentifier(identifier, console)
+            : identifier;
+        if (key === undefined) {
+            return Promise.resolve(undefined);
+        }
+        const requestedFolder = TaskMap.getKey(folder);
+        const matchedTasks = await this._findWorkspaceTasks((task, workspaceFolder) => {
+            const taskFolder = TaskMap.getKey(workspaceFolder);
+            if (taskFolder !== requestedFolder && taskFolder !== USER_TASKS_GROUP_KEY) {
+                return false;
+            }
+            return task.matches(key, compareId);
+        });
+        matchedTasks.sort(task => task._source.kind === TaskSourceKind.Extension ? 1 : -1);
+        if (matchedTasks.length > 0) {
+            const task = matchedTasks[0];
+            if (ConfiguringTask.is(task)) {
+                return this.tryResolveTask(task);
+            }
+            else {
+                return task;
+            }
+        }
+        const map = await this._getGroupedTasks({ type });
+        let values = map.get(folder);
+        values = values.concat(map.get(USER_TASKS_GROUP_KEY));
+        if (!values) {
+            return undefined;
+        }
+        values = values.filter(task => task.matches(key, compareId)).sort(task => task._source.kind === TaskSourceKind.Extension ? 1 : -1);
+        return values.length > 0 ? values[0] : undefined;
+    }
+    async tryResolveTask(configuringTask) {
+        if (!(await this._trust())) {
+            return;
+        }
+        await this._activateTaskProviders(configuringTask.type);
+        let matchingProvider;
+        let matchingProviderUnavailable = false;
+        for (const [handle, provider] of this._providers) {
+            const providerType = this._providerTypes.get(handle);
+            if (configuringTask.type === providerType) {
+                if (providerType && !this._isTaskProviderEnabled(providerType)) {
+                    matchingProviderUnavailable = true;
+                    continue;
+                }
+                matchingProvider = provider;
+                break;
+            }
+        }
+        if (!matchingProvider) {
+            if (matchingProviderUnavailable) {
+                this._log(( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'TaskService.providerUnavailable',
+                    'Warning: {0} tasks are unavailable in the current environment.',
+                    configuringTask.configures.type
+                )));
+            }
+            return;
+        }
+        try {
+            const resolvedTask = await matchingProvider.resolveTask(configuringTask);
+            if (resolvedTask && (resolvedTask._id === configuringTask._id)) {
+                return createCustomTask(resolvedTask, configuringTask);
+            }
+        }
+        catch (error) {
+        }
+        const tasks = await this.tasks({ type: configuringTask.type });
+        for (const task of tasks) {
+            if (task._id === configuringTask._id) {
+                return createCustomTask(task, configuringTask);
+            }
+        }
+        return;
+    }
+    async tasks(filter) {
+        if (!(await this._trust())) {
+            return [];
+        }
+        if (!this._versionAndEngineCompatible(filter)) {
+            return Promise.resolve([]);
+        }
+        return this._getGroupedTasks(filter).then((map) => {
+            if (!filter || !filter.type) {
+                return map.all();
+            }
+            const result = [];
+            map.forEach((tasks) => {
+                for (const task of tasks) {
+                    if (ContributedTask.is(task) && ((task.defines.type === filter.type) || (task._source.label === filter.type))) {
+                        result.push(task);
+                    }
+                    else if (CustomTask.is(task)) {
+                        if (task.type === filter.type) {
+                            result.push(task);
+                        }
+                        else {
+                            const customizes = task.customizes();
+                            if (customizes && customizes.type === filter.type) {
+                                result.push(task);
+                            }
+                        }
+                    }
+                }
+            });
+            return result;
+        });
+    }
+    taskTypes() {
+        const types = [];
+        if (this._isProvideTasksEnabled()) {
+            for (const definition of TaskDefinitionRegistry.all()) {
+                if (this._isTaskProviderEnabled(definition.taskType)) {
+                    types.push(definition.taskType);
+                }
+            }
+        }
+        return types;
+    }
+    createSorter() {
+        return ( new TaskSorter(
+            this._contextService.getWorkspace() ? this._contextService.getWorkspace().folders : []
+        ));
+    }
+    _isActive() {
+        if (!this._taskSystem) {
+            return Promise.resolve(false);
+        }
+        return this._taskSystem.isActive();
+    }
+    async getActiveTasks() {
+        if (!this._taskSystem) {
+            return [];
+        }
+        return this._taskSystem.getActiveTasks();
+    }
+    async getBusyTasks() {
+        if (!this._taskSystem) {
+            return [];
+        }
+        return this._taskSystem.getBusyTasks();
+    }
+    getRecentlyUsedTasksV1() {
+        if (this._recentlyUsedTasksV1) {
+            return this._recentlyUsedTasksV1;
+        }
+        const quickOpenHistoryLimit = this._configurationService.getValue(QUICKOPEN_HISTORY_LIMIT_CONFIG);
+        this._recentlyUsedTasksV1 = ( new LRUCache(quickOpenHistoryLimit));
+        const storageValue = this._storageService.get(AbstractTaskService_1.RecentlyUsedTasks_Key, 1 );
+        if (storageValue) {
+            try {
+                const values = JSON.parse(storageValue);
+                if (Array.isArray(values)) {
+                    for (const value of values) {
+                        this._recentlyUsedTasksV1.set(value, value);
+                    }
+                }
+            }
+            catch (error) {
+            }
+        }
+        return this._recentlyUsedTasksV1;
+    }
+    _getTasksFromStorage(type) {
+        return type === 'persistent' ? this._getPersistentTasks() : this._getRecentTasks();
+    }
+    _getRecentTasks() {
+        if (this._recentlyUsedTasks) {
+            return this._recentlyUsedTasks;
+        }
+        const quickOpenHistoryLimit = this._configurationService.getValue(QUICKOPEN_HISTORY_LIMIT_CONFIG);
+        this._recentlyUsedTasks = ( new LRUCache(quickOpenHistoryLimit));
+        const storageValue = this._storageService.get(AbstractTaskService_1.RecentlyUsedTasks_KeyV2, 1 );
+        if (storageValue) {
+            try {
+                const values = JSON.parse(storageValue);
+                if (Array.isArray(values)) {
+                    for (const value of values) {
+                        this._recentlyUsedTasks.set(value[0], value[1]);
+                    }
+                }
+            }
+            catch (error) {
+            }
+        }
+        return this._recentlyUsedTasks;
+    }
+    _getPersistentTasks() {
+        if (this._persistentTasks) {
+            this._log(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'taskService.gettingCachedTasks',
+                'Returning cached tasks {0}',
+                this._persistentTasks.size
+            )), true);
+            return this._persistentTasks;
+        }
+        this._persistentTasks = ( new LRUCache(10));
+        const storageValue = this._storageService.get(AbstractTaskService_1.PersistentTasks_Key, 1 );
+        if (storageValue) {
+            try {
+                const values = JSON.parse(storageValue);
+                if (Array.isArray(values)) {
+                    for (const value of values) {
+                        this._persistentTasks.set(value[0], value[1]);
+                    }
+                }
+            }
+            catch (error) {
+            }
+        }
+        return this._persistentTasks;
+    }
+    _getFolderFromTaskKey(key) {
+        const keyValue = JSON.parse(key);
+        return {
+            folder: keyValue.folder, isWorkspaceFile: keyValue.id?.endsWith(TaskSourceKind.WorkspaceFile)
+        };
+    }
+    async getSavedTasks(type) {
+        const folderMap = Object.create(null);
+        this.workspaceFolders.forEach(folder => {
+            folderMap[( folder.uri.toString())] = folder;
+        });
+        const folderToTasksMap = ( new Map());
+        const workspaceToTaskMap = ( new Map());
+        const storedTasks = this._getTasksFromStorage(type);
+        const tasks = [];
+        this._log(( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'taskService.getSavedTasks',
+            'Fetching tasks from task storage.'
+        )), true);
+        function addTaskToMap(map, folder, task) {
+            if (folder && !( map.has(folder))) {
+                map.set(folder, []);
+            }
+            if (folder && (folderMap[folder] || (folder === USER_TASKS_GROUP_KEY)) && task) {
+                map.get(folder).push(task);
+            }
+        }
+        for (const entry of storedTasks.entries()) {
+            try {
+                const key = entry[0];
+                const task = JSON.parse(entry[1]);
+                const folderInfo = this._getFolderFromTaskKey(key);
+                this._log(( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'taskService.getSavedTasks.reading',
+                    'Reading tasks from task storage, {0}, {1}, {2}',
+                    key,
+                    task,
+                    folderInfo.folder
+                )), true);
+                addTaskToMap(folderInfo.isWorkspaceFile ? workspaceToTaskMap : folderToTasksMap, folderInfo.folder, task);
+            }
+            catch (error) {
+                this._log(( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'taskService.getSavedTasks.error',
+                    'Fetching a task from task storage failed: {0}.',
+                    error
+                )), true);
+            }
+        }
+        const readTasksMap = ( new Map());
+        async function readTasks(that, map, isWorkspaceFile) {
+            for (const key of ( map.keys())) {
+                const custom = [];
+                const customized = Object.create(null);
+                const taskConfigSource = (folderMap[key]
+                    ? (isWorkspaceFile
+                        ? TaskConfigSource.WorkspaceFile : TaskConfigSource.TasksJson)
+                    : TaskConfigSource.User);
+                await that._computeTasksForSingleConfig(folderMap[key] ?? (await that._getAFolder()), {
+                    version: '2.0.0',
+                    tasks: map.get(key)
+                }, 0 , custom, customized, taskConfigSource, true);
+                custom.forEach(task => {
+                    const taskKey = task.getKey();
+                    if (taskKey) {
+                        readTasksMap.set(taskKey, task);
+                    }
+                });
+                for (const configuration in customized) {
+                    const taskKey = customized[configuration].getKey();
+                    if (taskKey) {
+                        readTasksMap.set(taskKey, customized[configuration]);
+                    }
+                }
+            }
+        }
+        await readTasks(this, folderToTasksMap, false);
+        await readTasks(this, workspaceToTaskMap, true);
+        for (const key of ( storedTasks.keys())) {
+            if (( readTasksMap.has(key))) {
+                tasks.push(readTasksMap.get(key));
+                this._log(( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'taskService.getSavedTasks.resolved',
+                    'Resolved task {0}',
+                    key
+                )), true);
+            }
+            else {
+                this._log(( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'taskService.getSavedTasks.unresolved',
+                    'Unable to resolve task {0} ',
+                    key
+                )), true);
+            }
+        }
+        return tasks;
+    }
+    removeRecentlyUsedTask(taskRecentlyUsedKey) {
+        if (( this._getTasksFromStorage('historical').has(taskRecentlyUsedKey))) {
+            this._getTasksFromStorage('historical').delete(taskRecentlyUsedKey);
+            this._saveRecentlyUsedTasks();
+        }
+    }
+    removePersistentTask(key) {
+        this._log(( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'taskService.removePersistentTask',
+            'Removing persistent task {0}',
+            key
+        )), true);
+        if (( this._getTasksFromStorage('persistent').has(key))) {
+            this._getTasksFromStorage('persistent').delete(key);
+            this._savePersistentTasks();
+        }
+    }
+    _setTaskLRUCacheLimit() {
+        const quickOpenHistoryLimit = this._configurationService.getValue(QUICKOPEN_HISTORY_LIMIT_CONFIG);
+        if (this._recentlyUsedTasks) {
+            this._recentlyUsedTasks.limit = quickOpenHistoryLimit;
+        }
+    }
+    async _setRecentlyUsedTask(task) {
+        let key = task.getKey();
+        if (!InMemoryTask.is(task) && key) {
+            const customizations = this._createCustomizableTask(task);
+            if (ContributedTask.is(task) && customizations) {
+                const custom = [];
+                const customized = Object.create(null);
+                await this._computeTasksForSingleConfig(task._source.workspaceFolder ?? this.workspaceFolders[0], {
+                    version: '2.0.0',
+                    tasks: [customizations]
+                }, 0 , custom, customized, TaskConfigSource.TasksJson, true);
+                for (const configuration in customized) {
+                    key = customized[configuration].getKey();
+                }
+            }
+            this._getTasksFromStorage('historical').set(key, JSON.stringify(customizations));
+            this._saveRecentlyUsedTasks();
+        }
+    }
+    _saveRecentlyUsedTasks() {
+        if (!this._recentlyUsedTasks) {
+            return;
+        }
+        const quickOpenHistoryLimit = this._configurationService.getValue(QUICKOPEN_HISTORY_LIMIT_CONFIG);
+        if (quickOpenHistoryLimit === 0) {
+            return;
+        }
+        let keys = [...( this._recentlyUsedTasks.keys())];
+        if (keys.length > quickOpenHistoryLimit) {
+            keys = keys.slice(0, quickOpenHistoryLimit);
+        }
+        const keyValues = [];
+        for (const key of keys) {
+            keyValues.push([key, this._recentlyUsedTasks.get(key, 0 )]);
+        }
+        this._storageService.store(AbstractTaskService_1.RecentlyUsedTasks_KeyV2, JSON.stringify(keyValues), 1 , 1 );
+    }
+    async _setPersistentTask(task) {
+        if (!this._configurationService.getValue("task.reconnection" )) {
+            return;
+        }
+        let key = task.getKey();
+        if (!InMemoryTask.is(task) && key) {
+            const customizations = this._createCustomizableTask(task);
+            if (ContributedTask.is(task) && customizations) {
+                const custom = [];
+                const customized = Object.create(null);
+                await this._computeTasksForSingleConfig(task._source.workspaceFolder ?? this.workspaceFolders[0], {
+                    version: '2.0.0',
+                    tasks: [customizations]
+                }, 0 , custom, customized, TaskConfigSource.TasksJson, true);
+                for (const configuration in customized) {
+                    key = customized[configuration].getKey();
+                }
+            }
+            if (!task.configurationProperties.isBackground) {
+                return;
+            }
+            this._log(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'taskService.setPersistentTask',
+                'Setting persistent task {0}',
+                key
+            )), true);
+            this._getTasksFromStorage('persistent').set(key, JSON.stringify(customizations));
+            this._savePersistentTasks();
+        }
+    }
+    _savePersistentTasks() {
+        this._persistentTasks = this._getTasksFromStorage('persistent');
+        const keys = [...( this._persistentTasks.keys())];
+        const keyValues = [];
+        for (const key of keys) {
+            keyValues.push([key, this._persistentTasks.get(key, 0 )]);
+        }
+        this._log(( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'savePersistentTask',
+            'Saving persistent tasks: {0}',
+            keys.join(', ')
+        )), true);
+        this._storageService.store(AbstractTaskService_1.PersistentTasks_Key, JSON.stringify(keyValues), 1 , 1 );
+    }
+    _openDocumentation() {
+        this._openerService.open(( URI.parse(
+            'https://code.visualstudio.com/docs/editor/tasks#_defining-a-problem-matcher'
+        )));
+    }
+    async _findSingleWorkspaceTaskOfGroup(group) {
+        const tasksOfGroup = await this._findWorkspaceTasksInGroup(group, true);
+        if ((tasksOfGroup.length === 1) && (typeof tasksOfGroup[0].configurationProperties.group !== 'string') && tasksOfGroup[0].configurationProperties.group?.isDefault) {
+            let resolvedTask;
+            if (ConfiguringTask.is(tasksOfGroup[0])) {
+                resolvedTask = await this.tryResolveTask(tasksOfGroup[0]);
+            }
+            else {
+                resolvedTask = tasksOfGroup[0];
+            }
+            if (resolvedTask) {
+                return this.run(resolvedTask, undefined, 1 );
+            }
+        }
+        return undefined;
+    }
+    async _build() {
+        const tryBuildShortcut = await this._findSingleWorkspaceTaskOfGroup(TaskGroup.Build);
+        if (tryBuildShortcut) {
+            return tryBuildShortcut;
+        }
+        return this._getGroupedTasksAndExecute();
+    }
+    async _runTest() {
+        const tryTestShortcut = await this._findSingleWorkspaceTaskOfGroup(TaskGroup.Test);
+        if (tryTestShortcut) {
+            return tryTestShortcut;
+        }
+        return this._getGroupedTasksAndExecute(true);
+    }
+    async _getGroupedTasksAndExecute(test) {
+        const tasks = await this._getGroupedTasks();
+        const runnable = this._createRunnableTask(tasks, test ? TaskGroup.Test : TaskGroup.Build);
+        if (!runnable || !runnable.task) {
+            if (test) {
+                if (this.schemaVersion === 1 ) {
+                    throw new TaskError(Severity$1.Info, localizeWithPath('vs/workbench/contrib/tasks/browser/abstractTaskService', 'TaskService.noTestTask1', 'No test task defined. Mark a task with \'isTestCommand\' in the tasks.json file.'), 3 );
+                }
+                else {
+                    throw new TaskError(Severity$1.Info, localizeWithPath('vs/workbench/contrib/tasks/browser/abstractTaskService', 'TaskService.noTestTask2', 'No test task defined. Mark a task with as a \'test\' group in the tasks.json file.'), 3 );
+                }
+            }
+            else {
+                if (this.schemaVersion === 1 ) {
+                    throw new TaskError(Severity$1.Info, localizeWithPath('vs/workbench/contrib/tasks/browser/abstractTaskService', 'TaskService.noBuildTask1', 'No build task defined. Mark a task with \'isBuildCommand\' in the tasks.json file.'), 2 );
+                }
+                else {
+                    throw new TaskError(Severity$1.Info, localizeWithPath('vs/workbench/contrib/tasks/browser/abstractTaskService', 'TaskService.noBuildTask2', 'No build task defined. Mark a task with as a \'build\' group in the tasks.json file.'), 2 );
+                }
+            }
+        }
+        let executeTaskResult;
+        try {
+            executeTaskResult = await this._executeTask(runnable.task, runnable.resolver, 1 );
+        }
+        catch (error) {
+            this._handleError(error);
+            return Promise.reject(error);
+        }
+        return executeTaskResult;
+    }
+    async run(task, options, runSource = 0 ) {
+        if (!(await this._trust())) {
+            return;
+        }
+        if (!task) {
+            throw new TaskError(Severity$1.Info, localizeWithPath('vs/workbench/contrib/tasks/browser/abstractTaskService', 'TaskServer.noTask', 'Task to execute is undefined'), 5 );
+        }
+        const resolver = this._createResolver();
+        let executeTaskResult;
+        try {
+            if (options && options.attachProblemMatcher && this._shouldAttachProblemMatcher(task) && !InMemoryTask.is(task)) {
+                const taskToExecute = await this._attachProblemMatcher(task);
+                if (taskToExecute) {
+                    executeTaskResult = await this._executeTask(taskToExecute, resolver, runSource);
+                }
+            }
+            else {
+                executeTaskResult = await this._executeTask(task, resolver, runSource);
+            }
+            return executeTaskResult;
+        }
+        catch (error) {
+            this._handleError(error);
+            return Promise.reject(error);
+        }
+    }
+    _isProvideTasksEnabled() {
+        const settingValue = this._configurationService.getValue("task.autoDetect" );
+        return settingValue === 'on';
+    }
+    _isProblemMatcherPromptEnabled(type) {
+        const settingValue = this._configurationService.getValue(PROBLEM_MATCHER_NEVER_CONFIG);
+        if (isBoolean(settingValue)) {
+            return !settingValue;
+        }
+        if (type === undefined) {
+            return true;
+        }
+        const settingValueMap = settingValue;
+        return !settingValueMap[type];
+    }
+    _getTypeForTask(task) {
+        let type;
+        if (CustomTask.is(task)) {
+            const configProperties = task._source.config.element;
+            type = configProperties.type;
+        }
+        else {
+            type = task.getDefinition().type;
+        }
+        return type;
+    }
+    _shouldAttachProblemMatcher(task) {
+        const enabled = this._isProblemMatcherPromptEnabled(this._getTypeForTask(task));
+        if (enabled === false) {
+            return false;
+        }
+        if (!this._canCustomize(task)) {
+            return false;
+        }
+        if (task.configurationProperties.group !== undefined && task.configurationProperties.group !== TaskGroup.Build) {
+            return false;
+        }
+        if (task.configurationProperties.problemMatchers !== undefined && task.configurationProperties.problemMatchers.length > 0) {
+            return false;
+        }
+        if (ContributedTask.is(task)) {
+            return !task.hasDefinedMatchers && !!task.configurationProperties.problemMatchers && (task.configurationProperties.problemMatchers.length === 0);
+        }
+        if (CustomTask.is(task)) {
+            const configProperties = task._source.config.element;
+            return configProperties.problemMatcher === undefined && !task.hasDefinedMatchers;
+        }
+        return false;
+    }
+    async _updateNeverProblemMatcherSetting(type) {
+        const current = this._configurationService.getValue(PROBLEM_MATCHER_NEVER_CONFIG);
+        if (current === true) {
+            return;
+        }
+        let newValue;
+        if (current !== false) {
+            newValue = current;
+        }
+        else {
+            newValue = Object.create(null);
+        }
+        newValue[type] = true;
+        return this._configurationService.updateValue(PROBLEM_MATCHER_NEVER_CONFIG, newValue);
+    }
+    async _attachProblemMatcher(task) {
+        let entries = [];
+        for (const key of ( ProblemMatcherRegistry.keys())) {
+            const matcher = ProblemMatcherRegistry.get(key);
+            if (matcher.deprecated) {
+                continue;
+            }
+            if (matcher.name === matcher.label) {
+                entries.push({ label: matcher.name, matcher: matcher });
+            }
+            else {
+                entries.push({
+                    label: matcher.label,
+                    description: `$${matcher.name}`,
+                    matcher: matcher
+                });
+            }
+        }
+        if (entries.length === 0) {
+            return;
+        }
+        entries = entries.sort((a, b) => {
+            if (a.label && b.label) {
+                return a.label.localeCompare(b.label);
+            }
+            else {
+                return 0;
+            }
+        });
+        entries.unshift({ type: 'separator', label: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TaskService.associate',
+            'associate'
+        )) });
+        let taskType;
+        if (CustomTask.is(task)) {
+            const configProperties = task._source.config.element;
+            taskType = configProperties.type;
+        }
+        else {
+            taskType = task.getDefinition().type;
+        }
+        entries.unshift({ label: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TaskService.attachProblemMatcher.continueWithout',
+            'Continue without scanning the task output'
+        )), matcher: undefined }, { label: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TaskService.attachProblemMatcher.never',
+            'Never scan the task output for this task'
+        )), matcher: undefined, never: true }, { label: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TaskService.attachProblemMatcher.neverType',
+            'Never scan the task output for {0} tasks',
+            taskType
+        )), matcher: undefined, setting: taskType }, { label: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TaskService.attachProblemMatcher.learnMoreAbout',
+            'Learn more about scanning the task output'
+        )), matcher: undefined, learnMore: true });
+        const problemMatcher = await this._quickInputService.pick(entries, { placeHolder: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'selectProblemMatcher',
+            'Select for which kind of errors and warnings to scan the task output'
+        )) });
+        if (!problemMatcher) {
+            return task;
+        }
+        if (problemMatcher.learnMore) {
+            this._openDocumentation();
+            return undefined;
+        }
+        if (problemMatcher.never) {
+            this.customize(task, { problemMatcher: [] }, true);
+            return task;
+        }
+        if (problemMatcher.matcher) {
+            const newTask = task.clone();
+            const matcherReference = `$${problemMatcher.matcher.name}`;
+            const properties = { problemMatcher: [matcherReference] };
+            newTask.configurationProperties.problemMatchers = [matcherReference];
+            const matcher = ProblemMatcherRegistry.get(problemMatcher.matcher.name);
+            if (matcher && matcher.watching !== undefined) {
+                properties.isBackground = true;
+                newTask.configurationProperties.isBackground = true;
+            }
+            this.customize(task, properties, true);
+            return newTask;
+        }
+        if (problemMatcher.setting) {
+            await this._updateNeverProblemMatcherSetting(problemMatcher.setting);
+        }
+        return task;
+    }
+    async _getTasksForGroup(group) {
+        const groups = await this._getGroupedTasks();
+        const result = [];
+        groups.forEach(tasks => {
+            for (const task of tasks) {
+                const configTaskGroup = TaskGroup.from(task.configurationProperties.group);
+                if (configTaskGroup?._id === group._id) {
+                    result.push(task);
+                }
+            }
+        });
+        return result;
+    }
+    needsFolderQualification() {
+        return this._contextService.getWorkbenchState() === 3 ;
+    }
+    _canCustomize(task) {
+        if (this.schemaVersion !== 2 ) {
+            return false;
+        }
+        if (CustomTask.is(task)) {
+            return true;
+        }
+        if (ContributedTask.is(task)) {
+            return !!task.getWorkspaceFolder();
+        }
+        return false;
+    }
+    async _formatTaskForJson(resource, task) {
+        let reference;
+        let stringValue = '';
+        try {
+            reference = await this._textModelResolverService.createModelReference(resource);
+            const model = reference.object.textEditorModel;
+            const { tabSize, insertSpaces } = model.getOptions();
+            const eol = model.getEOL();
+            let stringified = toFormattedString(task, { eol, tabSize, insertSpaces });
+            const regex = ( new RegExp(eol + (insertSpaces ? ' '.repeat(tabSize) : '\\t'), 'g'));
+            stringified = stringified.replace(regex, eol + (insertSpaces ? ' '.repeat(tabSize * 3) : '\t\t\t'));
+            const twoTabs = insertSpaces ? ' '.repeat(tabSize * 2) : '\t\t';
+            stringValue = twoTabs + stringified.slice(0, stringified.length - 1) + twoTabs + stringified.slice(stringified.length - 1);
+        }
+        finally {
+            reference?.dispose();
+        }
+        return stringValue;
+    }
+    async _openEditorAtTask(resource, task, configIndex = -1) {
+        if (resource === undefined) {
+            return Promise.resolve(false);
+        }
+        const fileContent = await this._fileService.readFile(resource);
+        const content = fileContent.value;
+        if (!content || !task) {
+            return false;
+        }
+        const contentValue = ( content.toString());
+        let stringValue;
+        if (configIndex !== -1) {
+            const json = this._configurationService.getValue('tasks', { resource });
+            if (json.tasks && (json.tasks.length > configIndex)) {
+                stringValue = await this._formatTaskForJson(resource, json.tasks[configIndex]);
+            }
+        }
+        if (!stringValue) {
+            if (typeof task === 'string') {
+                stringValue = task;
+            }
+            else {
+                stringValue = await this._formatTaskForJson(resource, task);
+            }
+        }
+        const index = contentValue.indexOf(stringValue);
+        let startLineNumber = 1;
+        for (let i = 0; i < index; i++) {
+            if (contentValue.charAt(i) === '\n') {
+                startLineNumber++;
+            }
+        }
+        let endLineNumber = startLineNumber;
+        for (let i = 0; i < stringValue.length; i++) {
+            if (stringValue.charAt(i) === '\n') {
+                endLineNumber++;
+            }
+        }
+        const selection = startLineNumber > 1 ? { startLineNumber, startColumn: startLineNumber === endLineNumber ? 4 : 3, endLineNumber, endColumn: startLineNumber === endLineNumber ? undefined : 4 } : undefined;
+        await this._editorService.openEditor({
+            resource,
+            options: {
+                pinned: false,
+                forceReload: true,
+                selection,
+                selectionRevealType: 1
+            }
+        });
+        return !!selection;
+    }
+    _createCustomizableTask(task) {
+        let toCustomize;
+        const taskConfig = CustomTask.is(task) || ConfiguringTask.is(task) ? task._source.config : undefined;
+        if (taskConfig && taskConfig.element) {
+            toCustomize = { ...(taskConfig.element) };
+        }
+        else if (ContributedTask.is(task)) {
+            toCustomize = {};
+            const identifier = Object.assign(Object.create(null), task.defines);
+            delete identifier['_key'];
+            ( Object.keys(identifier)).forEach(key => toCustomize[key] = identifier[key]);
+            if (task.configurationProperties.problemMatchers && task.configurationProperties.problemMatchers.length > 0 && isStringArray(task.configurationProperties.problemMatchers)) {
+                toCustomize.problemMatcher = task.configurationProperties.problemMatchers;
+            }
+            if (task.configurationProperties.group) {
+                toCustomize.group = GroupKind.to(task.configurationProperties.group);
+            }
+        }
+        if (!toCustomize) {
+            return undefined;
+        }
+        if (toCustomize.problemMatcher === undefined && task.configurationProperties.problemMatchers === undefined || (task.configurationProperties.problemMatchers && task.configurationProperties.problemMatchers.length === 0)) {
+            toCustomize.problemMatcher = [];
+        }
+        if (task._source.label !== 'Workspace') {
+            toCustomize.label = task.configurationProperties.identifier;
+        }
+        else {
+            toCustomize.label = task._label;
+        }
+        toCustomize.detail = task.configurationProperties.detail;
+        return toCustomize;
+    }
+    async customize(task, properties, openConfig) {
+        if (!(await this._trust())) {
+            return;
+        }
+        const workspaceFolder = task.getWorkspaceFolder();
+        if (!workspaceFolder) {
+            return Promise.resolve(undefined);
+        }
+        const configuration = this._getConfiguration(workspaceFolder, task._source.kind);
+        if (configuration.hasParseErrors) {
+            this._notificationService.warn(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'customizeParseErrors',
+                'The current task configuration has errors. Please fix the errors first before customizing a task.'
+            )));
+            return Promise.resolve(undefined);
+        }
+        const fileConfig = configuration.config;
+        const toCustomize = this._createCustomizableTask(task);
+        if (!toCustomize) {
+            return Promise.resolve(undefined);
+        }
+        const index = CustomTask.is(task) ? task._source.config.index : undefined;
+        if (properties) {
+            for (const property of Object.getOwnPropertyNames(properties)) {
+                const value = properties[property];
+                if (value !== undefined && value !== null) {
+                    toCustomize[property] = value;
+                }
+            }
+        }
+        if (!fileConfig) {
+            const value = {
+                version: '2.0.0',
+                tasks: [toCustomize]
+            };
+            let content = [
+                '{',
+                ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'tasksJsonComment',
+                    '\t// See https://go.microsoft.com/fwlink/?LinkId=733558 \n\t// for the documentation about the tasks.json format'
+                )),
+            ].join('\n') + JSON.stringify(value, null, '\t').substr(1);
+            const editorConfig = this._configurationService.getValue();
+            if (editorConfig.editor.insertSpaces) {
+                content = content.replace(/(\n)(\t+)/g, (_, s1, s2) => s1 + ' '.repeat(s2.length * editorConfig.editor.tabSize));
+            }
+            await this._textFileService.create([{ resource: workspaceFolder.toResource('.vscode/tasks.json'), value: content }]);
+        }
+        else {
+            if ((index === -1) && properties) {
+                if (properties.problemMatcher !== undefined) {
+                    fileConfig.problemMatcher = properties.problemMatcher;
+                    await this._writeConfiguration(workspaceFolder, 'tasks.problemMatchers', fileConfig.problemMatcher, task._source.kind);
+                }
+                else if (properties.group !== undefined) {
+                    fileConfig.group = properties.group;
+                    await this._writeConfiguration(workspaceFolder, 'tasks.group', fileConfig.group, task._source.kind);
+                }
+            }
+            else {
+                if (!Array.isArray(fileConfig.tasks)) {
+                    fileConfig.tasks = [];
+                }
+                if (index === undefined) {
+                    fileConfig.tasks.push(toCustomize);
+                }
+                else {
+                    fileConfig.tasks[index] = toCustomize;
+                }
+                await this._writeConfiguration(workspaceFolder, 'tasks.tasks', fileConfig.tasks, task._source.kind);
+            }
+        }
+        if (openConfig) {
+            this._openEditorAtTask(this._getResourceForTask(task), toCustomize);
+        }
+    }
+    _writeConfiguration(workspaceFolder, key, value, source) {
+        let target = undefined;
+        switch (source) {
+            case TaskSourceKind.User:
+                target = 2 ;
+                break;
+            case TaskSourceKind.WorkspaceFile:
+                target = 5 ;
+                break;
+            default: if (this._contextService.getWorkbenchState() === 2 ) {
+                target = 5 ;
+            }
+            else if (this._contextService.getWorkbenchState() === 3 ) {
+                target = 6 ;
+            }
+        }
+        if (target) {
+            return this._configurationService.updateValue(key, value, { resource: workspaceFolder.uri }, target);
+        }
+        else {
+            return undefined;
+        }
+    }
+    _getResourceForKind(kind) {
+        this._updateSetup();
+        switch (kind) {
+            case TaskSourceKind.User: {
+                return joinPath(dirname(this._preferencesService.userSettingsResource), 'tasks.json');
+            }
+            case TaskSourceKind.WorkspaceFile: {
+                if (this._workspace && this._workspace.configuration) {
+                    return this._workspace.configuration;
+                }
+            }
+            default: {
+                return undefined;
+            }
+        }
+    }
+    _getResourceForTask(task) {
+        if (CustomTask.is(task)) {
+            let uri = this._getResourceForKind(task._source.kind);
+            if (!uri) {
+                const taskFolder = task.getWorkspaceFolder();
+                if (taskFolder) {
+                    uri = taskFolder.toResource(task._source.config.file);
+                }
+                else {
+                    uri = this.workspaceFolders[0].uri;
+                }
+            }
+            return uri;
+        }
+        else {
+            return task.getWorkspaceFolder().toResource('.vscode/tasks.json');
+        }
+    }
+    async openConfig(task) {
+        let resource;
+        if (task) {
+            resource = this._getResourceForTask(task);
+        }
+        else {
+            resource = (this._workspaceFolders && (this._workspaceFolders.length > 0)) ? this._workspaceFolders[0].toResource('.vscode/tasks.json') : undefined;
+        }
+        return this._openEditorAtTask(resource, task ? task._label : undefined, task ? task._source.config.index : -1);
+    }
+    _createRunnableTask(tasks, group) {
+        const resolverData = ( new Map());
+        const workspaceTasks = [];
+        const extensionTasks = [];
+        tasks.forEach((tasks, folder) => {
+            let data = resolverData.get(folder);
+            if (!data) {
+                data = {
+                    id: ( new Map()),
+                    label: ( new Map()),
+                    identifier: ( new Map())
+                };
+                resolverData.set(folder, data);
+            }
+            for (const task of tasks) {
+                data.id.set(task._id, task);
+                data.label.set(task._label, task);
+                if (task.configurationProperties.identifier) {
+                    data.identifier.set(task.configurationProperties.identifier, task);
+                }
+                if (group && task.configurationProperties.group === group) {
+                    if (task._source.kind === TaskSourceKind.Workspace) {
+                        workspaceTasks.push(task);
+                    }
+                    else {
+                        extensionTasks.push(task);
+                    }
+                }
+            }
+        });
+        const resolver = {
+            resolve: async (uri, alias) => {
+                const data = resolverData.get(typeof uri === 'string' ? uri : ( uri.toString()));
+                if (!data) {
+                    return undefined;
+                }
+                return data.id.get(alias) || data.label.get(alias) || data.identifier.get(alias);
+            }
+        };
+        if (workspaceTasks.length > 0) {
+            if (workspaceTasks.length > 1) {
+                this._log(( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'moreThanOneBuildTask',
+                    'There are many build tasks defined in the tasks.json. Executing the first one.'
+                )));
+            }
+            return { task: workspaceTasks[0], resolver };
+        }
+        if (extensionTasks.length === 0) {
+            return undefined;
+        }
+        if (extensionTasks.length === 1) {
+            return { task: extensionTasks[0], resolver };
+        }
+        else {
+            const id = generateUuid();
+            const task = ( new InMemoryTask(
+                id,
+                { kind: TaskSourceKind.InMemory, label: 'inMemory' },
+                id,
+                'inMemory',
+                { reevaluateOnRerun: true },
+                {
+                    identifier: id,
+                    dependsOn: ( extensionTasks.map(
+                        (extensionTask) => { return { uri: extensionTask.getWorkspaceFolder().uri, task: extensionTask._id }; }
+                    )),
+                    name: id
+                }
+            ));
+            return { task, resolver };
+        }
+    }
+    _createResolver(grouped) {
+        let resolverData;
+        async function quickResolve(that, uri, identifier) {
+            const foundTasks = await that._findWorkspaceTasks((task) => {
+                const taskUri = ((ConfiguringTask.is(task) || CustomTask.is(task)) ? task._source.config.workspaceFolder?.uri : undefined);
+                const originalUri = (typeof uri === 'string' ? uri : ( uri.toString()));
+                if (taskUri?.toString() !== originalUri) {
+                    return false;
+                }
+                if (isString(identifier)) {
+                    return ((task._label === identifier) || (task.configurationProperties.identifier === identifier));
+                }
+                else {
+                    const keyedIdentifier = task.getDefinition(true);
+                    const searchIdentifier = TaskDefinition.createTaskIdentifier(identifier, console);
+                    return (searchIdentifier && keyedIdentifier) ? (searchIdentifier._key === keyedIdentifier._key) : false;
+                }
+            });
+            if (foundTasks.length === 0) {
+                return undefined;
+            }
+            const task = foundTasks[0];
+            if (ConfiguringTask.is(task)) {
+                return that.tryResolveTask(task);
+            }
+            return task;
+        }
+        async function getResolverData(that) {
+            if (resolverData === undefined) {
+                resolverData = ( new Map());
+                (grouped || (await that._getGroupedTasks())).forEach((tasks, folder) => {
+                    let data = resolverData.get(folder);
+                    if (!data) {
+                        data = { label: ( new Map()), identifier: ( new Map()), taskIdentifier: ( new Map()) };
+                        resolverData.set(folder, data);
+                    }
+                    for (const task of tasks) {
+                        data.label.set(task._label, task);
+                        if (task.configurationProperties.identifier) {
+                            data.identifier.set(task.configurationProperties.identifier, task);
+                        }
+                        const keyedIdentifier = task.getDefinition(true);
+                        if (keyedIdentifier !== undefined) {
+                            data.taskIdentifier.set(keyedIdentifier._key, task);
+                        }
+                    }
+                });
+            }
+            return resolverData;
+        }
+        async function fullResolve(that, uri, identifier) {
+            const allResolverData = await getResolverData(that);
+            const data = allResolverData.get(typeof uri === 'string' ? uri : ( uri.toString()));
+            if (!data) {
+                return undefined;
+            }
+            if (isString(identifier)) {
+                return data.label.get(identifier) || data.identifier.get(identifier);
+            }
+            else {
+                const key = TaskDefinition.createTaskIdentifier(identifier, console);
+                return key !== undefined ? data.taskIdentifier.get(key._key) : undefined;
+            }
+        }
+        return {
+            resolve: async (uri, identifier) => {
+                if (!identifier) {
+                    return undefined;
+                }
+                if ((resolverData === undefined) && (grouped === undefined)) {
+                    return (await quickResolve(this, uri, identifier)) ?? fullResolve(this, uri, identifier);
+                }
+                else {
+                    return fullResolve(this, uri, identifier);
+                }
+            }
+        };
+    }
+    async _saveBeforeRun() {
+        let SaveBeforeRunConfigOptions;
+        ( (function(SaveBeforeRunConfigOptions) {
+            SaveBeforeRunConfigOptions["Always"] = "always";
+            SaveBeforeRunConfigOptions["Never"] = "never";
+            SaveBeforeRunConfigOptions["Prompt"] = "prompt";
+        })(SaveBeforeRunConfigOptions || (SaveBeforeRunConfigOptions = {})));
+        const saveBeforeRunTaskConfig = this._configurationService.getValue("task.saveBeforeRun" );
+        if (saveBeforeRunTaskConfig === SaveBeforeRunConfigOptions.Never) {
+            return false;
+        }
+        else if (saveBeforeRunTaskConfig === SaveBeforeRunConfigOptions.Prompt && ( this._editorService.editors.some(e => e.isDirty()))) {
+            const { confirmed } = await this._dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'TaskSystem.saveBeforeRun.prompt.title',
+                    "Save all editors?"
+                )),
+                detail: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'detail',
+                    "Do you want to save all editors before running the task?"
+                )),
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    { key: 'saveBeforeRun.save', comment: ['&& denotes a mnemonic'] },
+                    '&&Save'
+                )),
+                cancelButton: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    { key: 'saveBeforeRun.dontSave', comment: ['&& denotes a mnemonic'] },
+                    "Do&&n't Save"
+                )),
+            });
+            if (!confirmed) {
+                return false;
+            }
+        }
+        await this._editorService.saveAll({ reason: 2  });
+        return true;
+    }
+    async _executeTask(task, resolver, runSource) {
+        let taskToRun = task;
+        if (await this._saveBeforeRun()) {
+            await this._configurationService.reloadConfiguration();
+            await this._updateWorkspaceTasks();
+            const taskFolder = task.getWorkspaceFolder();
+            const taskIdentifier = task.configurationProperties.identifier;
+            const taskType = CustomTask.is(task) ? task.customizes()?.type : (ContributedTask.is(task) ? task.type : undefined);
+            taskToRun = ((taskFolder && taskIdentifier && ((runSource === 1) ))
+                ? await this.getTask(taskFolder, taskIdentifier, false, taskType) : task) ?? task;
+        }
+        await ProblemMatcherRegistry.onReady();
+        const executeResult = runSource === 4  ? this._getTaskSystem().reconnect(taskToRun, resolver) : this._getTaskSystem().run(taskToRun, resolver);
+        if (executeResult) {
+            return this._handleExecuteResult(executeResult, runSource);
+        }
+        return { exitCode: 0 };
+    }
+    async _handleExecuteResult(executeResult, runSource) {
+        if (runSource === 1 ) {
+            await this._setRecentlyUsedTask(executeResult.task);
+        }
+        if (executeResult.kind === 2 ) {
+            const active = executeResult.active;
+            if (active && active.same && runSource === 2  || runSource === 4 ) {
+                this._logService.debug('Ignoring task that is already active', executeResult.task);
+                return executeResult.promise;
+            }
+            if (active && active.same) {
+                if (this._taskSystem?.isTaskVisible(executeResult.task)) {
+                    const message = ( localizeWithPath(
+                        'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                        'TaskSystem.activeSame.noBackground',
+                        'The task \'{0}\' is already active.',
+                        executeResult.task.getQualifiedLabel()
+                    ));
+                    const lastInstance = this._getTaskSystem().getLastInstance(executeResult.task) ?? executeResult.task;
+                    this._notificationService.prompt(Severity$1.Warning, message, [{
+                            label: ( localizeWithPath(
+                                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                                'terminateTask',
+                                "Terminate Task"
+                            )),
+                            run: () => this.terminate(lastInstance)
+                        },
+                        {
+                            label: ( localizeWithPath(
+                                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                                'restartTask',
+                                "Restart Task"
+                            )),
+                            run: () => this._restart(lastInstance)
+                        }], { sticky: true });
+                }
+                else {
+                    this._taskSystem?.revealTask(executeResult.task);
+                }
+            }
+            else {
+                throw new TaskError(Severity$1.Warning, localizeWithPath('vs/workbench/contrib/tasks/browser/abstractTaskService', 'TaskSystem.active', 'There is already a task running. Terminate it first before executing another task.'), 1 );
+            }
+        }
+        this._setRecentlyUsedTask(executeResult.task);
+        return executeResult.promise;
+    }
+    async _restart(task) {
+        if (!this._taskSystem) {
+            return;
+        }
+        const response = await this._taskSystem.terminate(task);
+        if (response.success) {
+            try {
+                await this.run(task);
+            }
+            catch {
+            }
+        }
+        else {
+            this._notificationService.warn(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskSystem.restartFailed',
+                'Failed to terminate and restart task {0}',
+                isString(task) ? task : task.configurationProperties.name
+            )));
+        }
+    }
+    async terminate(task) {
+        if (!(await this._trust())) {
+            return { success: true, task: undefined };
+        }
+        if (!this._taskSystem) {
+            return { success: true, task: undefined };
+        }
+        return this._taskSystem.terminate(task);
+    }
+    _terminateAll() {
+        if (!this._taskSystem) {
+            return Promise.resolve([]);
+        }
+        return this._taskSystem.terminateAll();
+    }
+    _createTerminalTaskSystem() {
+        return ( new TerminalTaskSystem(
+            this._terminalService,
+            this._terminalGroupService,
+            this._outputService,
+            this._paneCompositeService,
+            this._viewsService,
+            this._markerService,
+            this._modelService,
+            this._configurationResolverService,
+            this._contextService,
+            this._environmentService,
+            AbstractTaskService_1.OutputChannelId,
+            this._fileService,
+            this._terminalProfileResolverService,
+            this._pathService,
+            this._viewDescriptorService,
+            this._logService,
+            this._notificationService,
+            this._instantiationService,
+            (workspaceFolder) => {
+                if (workspaceFolder) {
+                    return this._getTaskSystemInfo(workspaceFolder.uri.scheme);
+                }
+                else if (this._taskSystemInfos.size > 0) {
+                    const infos = Array.from(this._taskSystemInfos.entries());
+                    const notFile = infos.filter(info => info[0] !== Schemas.file);
+                    if (notFile.length > 0) {
+                        return notFile[0][1][0];
+                    }
+                    return infos[0][1][0];
+                }
+                else {
+                    return undefined;
+                }
+            }
+        ));
+    }
+    _isTaskProviderEnabled(type) {
+        const definition = TaskDefinitionRegistry.get(type);
+        return !definition || !definition.when || this._contextKeyService.contextMatchesRules(definition.when);
+    }
+    async _getGroupedTasks(filter) {
+        await this._waitForAllSupportedExecutions;
+        const type = filter?.type;
+        const needsRecentTasksMigration = this._needsRecentTasksMigration();
+        await this._activateTaskProviders(filter?.type);
+        const validTypes = Object.create(null);
+        TaskDefinitionRegistry.all().forEach(definition => validTypes[definition.taskType] = true);
+        validTypes['shell'] = true;
+        validTypes['process'] = true;
+        const contributedTaskSets = await ( new Promise(resolve => {
+            const result = [];
+            let counter = 0;
+            const done = (value) => {
+                if (value) {
+                    result.push(value);
+                }
+                if (--counter === 0) {
+                    resolve(result);
+                }
+            };
+            const error = (error) => {
+                try {
+                    if (error && isString(error.message)) {
+                        this._log(`Error: ${error.message}\n`);
+                        this._showOutput();
+                    }
+                    else {
+                        this._log('Unknown error received while collecting tasks from providers.');
+                        this._showOutput();
+                    }
+                }
+                finally {
+                    if (--counter === 0) {
+                        resolve(result);
+                    }
+                }
+            };
+            if (this._isProvideTasksEnabled() && ((this.schemaVersion === 2) ) && (this._providers.size > 0)) {
+                let foundAnyProviders = false;
+                for (const [handle, provider] of this._providers) {
+                    const providerType = this._providerTypes.get(handle);
+                    if ((type === undefined) || (type === providerType)) {
+                        if (providerType && !this._isTaskProviderEnabled(providerType)) {
+                            continue;
+                        }
+                        foundAnyProviders = true;
+                        counter++;
+                        raceTimeout(provider.provideTasks(validTypes).then((taskSet) => {
+                            for (const task of taskSet.tasks) {
+                                if (task.type !== this._providerTypes.get(handle)) {
+                                    this._log(( localizeWithPath(
+                                        'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                                        'unexpectedTaskType',
+                                        "The task provider for \"{0}\" tasks unexpectedly provided a task of type \"{1}\".\n",
+                                        this._providerTypes.get(handle),
+                                        task.type
+                                    )));
+                                    if ((task.type !== 'shell') && (task.type !== 'process')) {
+                                        this._showOutput();
+                                    }
+                                    break;
+                                }
+                            }
+                            return done(taskSet);
+                        }, error), 5000, () => {
+                            console.error('Timed out getting tasks from ', providerType);
+                            done(undefined);
+                        });
+                    }
+                }
+                if (!foundAnyProviders) {
+                    resolve(result);
+                }
+            }
+            else {
+                resolve(result);
+            }
+        }));
+        const result = ( new TaskMap());
+        const contributedTasks = ( new TaskMap());
+        for (const set of contributedTaskSets) {
+            for (const task of set.tasks) {
+                const workspaceFolder = task.getWorkspaceFolder();
+                if (workspaceFolder) {
+                    contributedTasks.add(workspaceFolder, task);
+                }
+            }
+        }
+        try {
+            const customTasks = await this.getWorkspaceTasks();
+            const customTasksKeyValuePairs = Array.from(customTasks);
+            const customTasksPromises = ( customTasksKeyValuePairs.map(async ([key, folderTasks]) => {
+                const contributed = contributedTasks.get(key);
+                if (!folderTasks.set) {
+                    if (contributed) {
+                        result.add(key, ...contributed);
+                    }
+                    return;
+                }
+                if (this._contextService.getWorkbenchState() === 1 ) {
+                    result.add(key, ...folderTasks.set.tasks);
+                }
+                else {
+                    const configurations = folderTasks.configurations;
+                    const legacyTaskConfigurations = folderTasks.set ? this._getLegacyTaskConfigurations(folderTasks.set) : undefined;
+                    const customTasksToDelete = [];
+                    if (configurations || legacyTaskConfigurations) {
+                        const unUsedConfigurations = ( new Set());
+                        if (configurations) {
+                            ( Object.keys(configurations.byIdentifier)).forEach(key => unUsedConfigurations.add(key));
+                        }
+                        for (const task of contributed) {
+                            if (!ContributedTask.is(task)) {
+                                continue;
+                            }
+                            if (configurations) {
+                                const configuringTask = configurations.byIdentifier[task.defines._key];
+                                if (configuringTask) {
+                                    unUsedConfigurations.delete(task.defines._key);
+                                    result.add(key, createCustomTask(task, configuringTask));
+                                }
+                                else {
+                                    result.add(key, task);
+                                }
+                            }
+                            else if (legacyTaskConfigurations) {
+                                const configuringTask = legacyTaskConfigurations[task.defines._key];
+                                if (configuringTask) {
+                                    result.add(key, createCustomTask(task, configuringTask));
+                                    customTasksToDelete.push(configuringTask);
+                                }
+                                else {
+                                    result.add(key, task);
+                                }
+                            }
+                            else {
+                                result.add(key, task);
+                            }
+                        }
+                        if (customTasksToDelete.length > 0) {
+                            const toDelete = customTasksToDelete.reduce((map, task) => {
+                                map[task._id] = true;
+                                return map;
+                            }, Object.create(null));
+                            for (const task of folderTasks.set.tasks) {
+                                if (toDelete[task._id]) {
+                                    continue;
+                                }
+                                result.add(key, task);
+                            }
+                        }
+                        else {
+                            result.add(key, ...folderTasks.set.tasks);
+                        }
+                        const unUsedConfigurationsAsArray = Array.from(unUsedConfigurations);
+                        const unUsedConfigurationPromises = ( unUsedConfigurationsAsArray.map(async (value) => {
+                            const configuringTask = configurations.byIdentifier[value];
+                            if (type && (type !== configuringTask.configures.type)) {
+                                return;
+                            }
+                            let requiredTaskProviderUnavailable = false;
+                            for (const [handle, provider] of this._providers) {
+                                const providerType = this._providerTypes.get(handle);
+                                if (configuringTask.type === providerType) {
+                                    if (providerType && !this._isTaskProviderEnabled(providerType)) {
+                                        requiredTaskProviderUnavailable = true;
+                                        continue;
+                                    }
+                                    try {
+                                        const resolvedTask = await provider.resolveTask(configuringTask);
+                                        if (resolvedTask && (resolvedTask._id === configuringTask._id)) {
+                                            result.add(key, createCustomTask(resolvedTask, configuringTask));
+                                            return;
+                                        }
+                                    }
+                                    catch (error) {
+                                    }
+                                }
+                            }
+                            if (requiredTaskProviderUnavailable) {
+                                this._log(( localizeWithPath(
+                                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                                    'TaskService.providerUnavailable',
+                                    'Warning: {0} tasks are unavailable in the current environment.',
+                                    configuringTask.configures.type
+                                )));
+                            }
+                            else {
+                                this._log(( localizeWithPath(
+                                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                                    'TaskService.noConfiguration',
+                                    'Error: The {0} task detection didn\'t contribute a task for the following configuration:\n{1}\nThe task will be ignored.',
+                                    configuringTask.configures.type,
+                                    JSON.stringify(configuringTask._source.config.element, undefined, 4)
+                                )));
+                                this._showOutput();
+                            }
+                        }));
+                        await Promise.all(unUsedConfigurationPromises);
+                    }
+                    else {
+                        result.add(key, ...folderTasks.set.tasks);
+                        result.add(key, ...contributed);
+                    }
+                }
+            }));
+            await Promise.all(customTasksPromises);
+            if (needsRecentTasksMigration) {
+                await this._migrateRecentTasks(result.all());
+            }
+            return result;
+        }
+        catch {
+            const result = ( new TaskMap());
+            for (const set of contributedTaskSets) {
+                for (const task of set.tasks) {
+                    const folder = task.getWorkspaceFolder();
+                    if (folder) {
+                        result.add(folder, task);
+                    }
+                }
+            }
+            return result;
+        }
+    }
+    _getLegacyTaskConfigurations(workspaceTasks) {
+        let result;
+        function getResult() {
+            if (result) {
+                return result;
+            }
+            result = Object.create(null);
+            return result;
+        }
+        for (const task of workspaceTasks.tasks) {
+            if (CustomTask.is(task)) {
+                const commandName = task.command && task.command.name;
+                if (commandName === 'gulp' || commandName === 'grunt' || commandName === 'jake') {
+                    const identifier = KeyedTaskIdentifier.create({
+                        type: commandName,
+                        task: task.configurationProperties.name
+                    });
+                    getResult()[identifier._key] = task;
+                }
+            }
+        }
+        return result;
+    }
+    async getWorkspaceTasks(runSource = 1 ) {
+        if (!(await this._trust())) {
+            return ( new Map());
+        }
+        await raceTimeout(this._waitForAllSupportedExecutions, 2000, () => {
+            this._logService.warn('Timed out waiting for all supported executions');
+        });
+        await this._whenTaskSystemReady;
+        if (this._workspaceTasksPromise) {
+            return this._workspaceTasksPromise;
+        }
+        return this._updateWorkspaceTasks(runSource);
+    }
+    _updateWorkspaceTasks(runSource = 1 ) {
+        this._workspaceTasksPromise = this._computeWorkspaceTasks(runSource);
+        return this._workspaceTasksPromise;
+    }
+    async _getAFolder() {
+        let folder = this.workspaceFolders.length > 0 ? this.workspaceFolders[0] : undefined;
+        if (!folder) {
+            const userhome = await this._pathService.userHome();
+            folder = ( new WorkspaceFolder({ uri: userhome, name: basename(userhome), index: 0 }));
+        }
+        return folder;
+    }
+    async _computeWorkspaceTasks(runSource = 1 ) {
+        const promises = [];
+        for (const folder of this.workspaceFolders) {
+            promises.push(this._computeWorkspaceFolderTasks(folder, runSource));
+        }
+        const values = await Promise.all(promises);
+        const result = ( new Map());
+        for (const value of values) {
+            if (value) {
+                result.set(( value.workspaceFolder.uri.toString()), value);
+            }
+        }
+        const folder = await this._getAFolder();
+        if (this._contextService.getWorkbenchState() !== 1 ) {
+            const workspaceFileTasks = await this._computeWorkspaceFileTasks(folder, runSource);
+            if (workspaceFileTasks && this._workspace && this._workspace.configuration) {
+                result.set(( this._workspace.configuration.toString()), workspaceFileTasks);
+            }
+        }
+        const userTasks = await this._computeUserTasks(folder, runSource);
+        if (userTasks) {
+            result.set(USER_TASKS_GROUP_KEY, userTasks);
+        }
+        return result;
+    }
+    get _jsonTasksSupported() {
+        return ShellExecutionSupportedContext.getValue(this._contextKeyService) === true && ProcessExecutionSupportedContext.getValue(this._contextKeyService) === true;
+    }
+    async _computeWorkspaceFolderTasks(workspaceFolder, runSource = 1 ) {
+        const workspaceFolderConfiguration = (this._executionEngine === ExecutionEngine.Process ? await this._computeLegacyConfiguration(workspaceFolder) : await this._computeConfiguration(workspaceFolder));
+        if (!workspaceFolderConfiguration || !workspaceFolderConfiguration.config || workspaceFolderConfiguration.hasErrors) {
+            return Promise.resolve({ workspaceFolder, set: undefined, configurations: undefined, hasErrors: workspaceFolderConfiguration ? workspaceFolderConfiguration.hasErrors : false });
+        }
+        await ProblemMatcherRegistry.onReady();
+        const taskSystemInfo = this._getTaskSystemInfo(workspaceFolder.uri.scheme);
+        const problemReporter = ( new ProblemReporter(this._outputChannel));
+        const parseResult = parse(workspaceFolder, undefined, taskSystemInfo ? taskSystemInfo.platform : platform, workspaceFolderConfiguration.config, problemReporter, TaskConfigSource.TasksJson, this._contextKeyService);
+        let hasErrors = false;
+        if (!parseResult.validationStatus.isOK() && ((parseResult.validationStatus.state !== 1) )) {
+            hasErrors = true;
+            this._showOutput(runSource);
+        }
+        if (problemReporter.status.isFatal()) {
+            problemReporter.fatal(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskSystem.configurationErrors',
+                'Error: the provided task configuration has validation errors and can\'t not be used. Please correct the errors first.'
+            )));
+            return { workspaceFolder, set: undefined, configurations: undefined, hasErrors };
+        }
+        let customizedTasks;
+        if (parseResult.configured && parseResult.configured.length > 0) {
+            customizedTasks = {
+                byIdentifier: Object.create(null)
+            };
+            for (const task of parseResult.configured) {
+                customizedTasks.byIdentifier[task.configures._key] = task;
+            }
+        }
+        if (!this._jsonTasksSupported && (parseResult.custom.length > 0)) {
+            console.warn('Custom workspace tasks are not supported.');
+        }
+        return { workspaceFolder, set: { tasks: this._jsonTasksSupported ? parseResult.custom : [] }, configurations: customizedTasks, hasErrors };
+    }
+    _testParseExternalConfig(config, location) {
+        if (!config) {
+            return { config: undefined, hasParseErrors: false };
+        }
+        const parseErrors = config.$parseErrors;
+        if (parseErrors) {
+            let isAffected = false;
+            for (const parseError of parseErrors) {
+                if (/tasks\.json$/.test(parseError)) {
+                    isAffected = true;
+                    break;
+                }
+            }
+            if (isAffected) {
+                this._log(( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    { key: 'TaskSystem.invalidTaskJsonOther', comment: ['Message notifies of an error in one of several places there is tasks related json, not necessarily in a file named tasks.json'] },
+                    'Error: The content of the tasks json in {0} has syntax errors. Please correct them before executing a task.',
+                    location
+                )));
+                this._showOutput();
+                return { config, hasParseErrors: true };
+            }
+        }
+        return { config, hasParseErrors: false };
+    }
+    _log(value, verbose) {
+        if (!verbose || this._configurationService.getValue("task.verboseLogging" )) {
+            this._outputChannel.append(value + '\n');
+        }
+    }
+    async _computeWorkspaceFileTasks(workspaceFolder, runSource = 1 ) {
+        if (this._executionEngine === ExecutionEngine.Process) {
+            return this._emptyWorkspaceTaskResults(workspaceFolder);
+        }
+        const workspaceFileConfig = this._getConfiguration(workspaceFolder, TaskSourceKind.WorkspaceFile);
+        const configuration = this._testParseExternalConfig(workspaceFileConfig.config, ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TasksSystem.locationWorkspaceConfig',
+            'workspace file'
+        )));
+        const customizedTasks = {
+            byIdentifier: Object.create(null)
+        };
+        const custom = [];
+        await this._computeTasksForSingleConfig(workspaceFolder, configuration.config, runSource, custom, customizedTasks.byIdentifier, TaskConfigSource.WorkspaceFile);
+        const engine = configuration.config ? ExecutionEngine$1.from(configuration.config) : ExecutionEngine.Terminal;
+        if (engine === ExecutionEngine.Process) {
+            this._notificationService.warn(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskSystem.versionWorkspaceFile',
+                'Only tasks version 2.0.0 permitted in workspace configuration files.'
+            )));
+            return this._emptyWorkspaceTaskResults(workspaceFolder);
+        }
+        return { workspaceFolder, set: { tasks: custom }, configurations: customizedTasks, hasErrors: configuration.hasParseErrors };
+    }
+    async _computeUserTasks(workspaceFolder, runSource = 1 ) {
+        if (this._executionEngine === ExecutionEngine.Process) {
+            return this._emptyWorkspaceTaskResults(workspaceFolder);
+        }
+        const userTasksConfig = this._getConfiguration(workspaceFolder, TaskSourceKind.User);
+        const configuration = this._testParseExternalConfig(userTasksConfig.config, ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TasksSystem.locationUserConfig',
+            'user settings'
+        )));
+        const customizedTasks = {
+            byIdentifier: Object.create(null)
+        };
+        const custom = [];
+        await this._computeTasksForSingleConfig(workspaceFolder, configuration.config, runSource, custom, customizedTasks.byIdentifier, TaskConfigSource.User);
+        const engine = configuration.config ? ExecutionEngine$1.from(configuration.config) : ExecutionEngine.Terminal;
+        if (engine === ExecutionEngine.Process) {
+            this._notificationService.warn(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskSystem.versionSettings',
+                'Only tasks version 2.0.0 permitted in user settings.'
+            )));
+            return this._emptyWorkspaceTaskResults(workspaceFolder);
+        }
+        return { workspaceFolder, set: { tasks: custom }, configurations: customizedTasks, hasErrors: configuration.hasParseErrors };
+    }
+    _emptyWorkspaceTaskResults(workspaceFolder) {
+        return { workspaceFolder, set: undefined, configurations: undefined, hasErrors: false };
+    }
+    async _computeTasksForSingleConfig(workspaceFolder, config, runSource, custom, customized, source, isRecentTask = false) {
+        if (!config) {
+            return false;
+        }
+        else if (!workspaceFolder) {
+            this._logService.trace('TaskService.computeTasksForSingleConfig: no workspace folder for worskspace', this._workspace?.id);
+            return false;
+        }
+        const taskSystemInfo = this._getTaskSystemInfo(workspaceFolder.uri.scheme);
+        const problemReporter = ( new ProblemReporter(this._outputChannel));
+        const parseResult = parse(workspaceFolder, this._workspace, taskSystemInfo ? taskSystemInfo.platform : platform, config, problemReporter, source, this._contextKeyService, isRecentTask);
+        let hasErrors = false;
+        if (!parseResult.validationStatus.isOK() && ((parseResult.validationStatus.state !== 1) )) {
+            this._showOutput(runSource);
+            hasErrors = true;
+        }
+        if (problemReporter.status.isFatal()) {
+            problemReporter.fatal(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskSystem.configurationErrors',
+                'Error: the provided task configuration has validation errors and can\'t not be used. Please correct the errors first.'
+            )));
+            return hasErrors;
+        }
+        if (parseResult.configured && parseResult.configured.length > 0) {
+            for (const task of parseResult.configured) {
+                customized[task.configures._key] = task;
+            }
+        }
+        if (!this._jsonTasksSupported && (parseResult.custom.length > 0)) {
+            console.warn('Custom workspace tasks are not supported.');
+        }
+        else {
+            for (const task of parseResult.custom) {
+                custom.push(task);
+            }
+        }
+        return hasErrors;
+    }
+    _computeConfiguration(workspaceFolder) {
+        const { config, hasParseErrors } = this._getConfiguration(workspaceFolder);
+        return Promise.resolve({ workspaceFolder, config, hasErrors: hasParseErrors });
+    }
+    _computeWorkspaceFolderSetup() {
+        const workspaceFolders = [];
+        const ignoredWorkspaceFolders = [];
+        let executionEngine = ExecutionEngine.Terminal;
+        let schemaVersion = 2 ;
+        let workspace;
+        if (this._contextService.getWorkbenchState() === 2 ) {
+            const workspaceFolder = this._contextService.getWorkspace().folders[0];
+            workspaceFolders.push(workspaceFolder);
+            executionEngine = this._computeExecutionEngine(workspaceFolder);
+            const telemetryData = {
+                executionEngineVersion: executionEngine
+            };
+            this._telemetryService.publicLog('taskService.engineVersion', telemetryData);
+            schemaVersion = this._computeJsonSchemaVersion(workspaceFolder);
+        }
+        else if (this._contextService.getWorkbenchState() === 3 ) {
+            workspace = this._contextService.getWorkspace();
+            for (const workspaceFolder of this._contextService.getWorkspace().folders) {
+                if (schemaVersion === this._computeJsonSchemaVersion(workspaceFolder)) {
+                    workspaceFolders.push(workspaceFolder);
+                }
+                else {
+                    ignoredWorkspaceFolders.push(workspaceFolder);
+                    this._log(( localizeWithPath(
+                        'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                        'taskService.ignoreingFolder',
+                        'Ignoring task configurations for workspace folder {0}. Multi folder workspace task support requires that all folders use task version 2.0.0',
+                        workspaceFolder.uri.fsPath
+                    )));
+                }
+            }
+        }
+        return [workspaceFolders, ignoredWorkspaceFolders, executionEngine, schemaVersion, workspace];
+    }
+    _computeExecutionEngine(workspaceFolder) {
+        const { config } = this._getConfiguration(workspaceFolder);
+        if (!config) {
+            return ExecutionEngine._default;
+        }
+        return ExecutionEngine$1.from(config);
+    }
+    _computeJsonSchemaVersion(workspaceFolder) {
+        const { config } = this._getConfiguration(workspaceFolder);
+        if (!config) {
+            return 2 ;
+        }
+        return JsonSchemaVersion.from(config);
+    }
+    _getConfiguration(workspaceFolder, source) {
+        let result;
+        if ((source !== TaskSourceKind.User) && ((this._contextService.getWorkbenchState() === 1) )) {
+            result = undefined;
+        }
+        else {
+            const wholeConfig = this._configurationService.inspect('tasks', { resource: workspaceFolder.uri });
+            switch (source) {
+                case TaskSourceKind.User: {
+                    if (wholeConfig.userValue !== wholeConfig.workspaceFolderValue) {
+                        result = deepClone(wholeConfig.userValue);
+                    }
+                    break;
+                }
+                case TaskSourceKind.Workspace:
+                    result = deepClone(wholeConfig.workspaceFolderValue);
+                    break;
+                case TaskSourceKind.WorkspaceFile: {
+                    if (((this._contextService.getWorkbenchState() === 3) )
+                        && (wholeConfig.workspaceFolderValue !== wholeConfig.workspaceValue)) {
+                        result = deepClone(wholeConfig.workspaceValue);
+                    }
+                    break;
+                }
+                default: result = deepClone(wholeConfig.workspaceFolderValue);
+            }
+        }
+        if (!result) {
+            return { config: undefined, hasParseErrors: false };
+        }
+        const parseErrors = result.$parseErrors;
+        if (parseErrors) {
+            let isAffected = false;
+            for (const parseError of parseErrors) {
+                if (/tasks\.json$/.test(parseError)) {
+                    isAffected = true;
+                    break;
+                }
+            }
+            if (isAffected) {
+                this._log(( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'TaskSystem.invalidTaskJson',
+                    'Error: The content of the tasks.json file has syntax errors. Please correct them before executing a task.'
+                )));
+                this._showOutput();
+                return { config: undefined, hasParseErrors: true };
+            }
+        }
+        return { config: result, hasParseErrors: false };
+    }
+    inTerminal() {
+        if (this._taskSystem) {
+            return this._taskSystem instanceof TerminalTaskSystem;
+        }
+        return this._executionEngine === ExecutionEngine.Terminal;
+    }
+    configureAction() {
+        const thisCapture = this;
+        return new (class extends Action {
+            constructor() {
+                super(ConfigureTaskAction.ID, ConfigureTaskAction.TEXT.value, undefined, true, () => { thisCapture._runConfigureTasks(); return Promise.resolve(undefined); });
+            }
+        });
+    }
+    _handleError(err) {
+        let showOutput = true;
+        if (err instanceof TaskError) {
+            const buildError = err;
+            const needsConfig = buildError.code === 0  || buildError.code === 2  || buildError.code === 3 ;
+            const needsTerminate = buildError.code === 1 ;
+            if (needsConfig || needsTerminate) {
+                this._notificationService.prompt(buildError.severity, buildError.message, [{
+                        label: needsConfig ? ConfigureTaskAction.TEXT.value : ( localizeWithPath(
+                            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                            'TerminateAction.label',
+                            "Terminate Task"
+                        )),
+                        run: () => {
+                            if (needsConfig) {
+                                this._runConfigureTasks();
+                            }
+                            else {
+                                this._runTerminateCommand();
+                            }
+                        }
+                    }]);
+            }
+            else {
+                this._notificationService.notify({ severity: buildError.severity, message: buildError.message });
+            }
+        }
+        else if (err instanceof Error) {
+            const error = err;
+            this._notificationService.error(error.message);
+            showOutput = false;
+        }
+        else if (isString(err)) {
+            this._notificationService.error(err);
+        }
+        else {
+            this._notificationService.error(( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskSystem.unknownError',
+                'An error has occurred while running a task. See task log for details.'
+            )));
+        }
+        if (showOutput) {
+            this._showOutput();
+        }
+    }
+    _showDetail() {
+        return this._configurationService.getValue(QUICKOPEN_DETAIL_CONFIG);
+    }
+    async _createTaskQuickPickEntries(tasks, group = false, sort = false, selectedEntry, includeRecents = true) {
+        let encounteredTasks = {};
+        if (tasks === undefined || tasks === null || tasks.length === 0) {
+            return [];
+        }
+        const TaskQuickPickEntry = (task) => {
+            const newEntry = { label: task._label, description: this.getTaskDescription(task), task, detail: this._showDetail() ? task.configurationProperties.detail : undefined };
+            if (encounteredTasks[task._id]) {
+                if (encounteredTasks[task._id].length === 1) {
+                    encounteredTasks[task._id][0].label += ' (1)';
+                }
+                newEntry.label = newEntry.label + ' (' + ( (encounteredTasks[task._id].length + 1).toString()) + ')';
+            }
+            else {
+                encounteredTasks[task._id] = [];
+            }
+            encounteredTasks[task._id].push(newEntry);
+            return newEntry;
+        };
+        function fillEntries(entries, tasks, groupLabel) {
+            if (tasks.length) {
+                entries.push({ type: 'separator', label: groupLabel });
+            }
+            for (const task of tasks) {
+                const entry = TaskQuickPickEntry(task);
+                entry.buttons = [{ iconClass: ThemeIcon.asClassName(configureTaskIcon), tooltip: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'configureTask',
+                    "Configure Task"
+                )) }];
+                if (selectedEntry && (task === selectedEntry.task)) {
+                    entries.unshift(selectedEntry);
+                }
+                else {
+                    entries.push(entry);
+                }
+            }
+        }
+        let entries;
+        if (group) {
+            entries = [];
+            if (tasks.length === 1) {
+                entries.push(TaskQuickPickEntry(tasks[0]));
+            }
+            else {
+                const recentlyUsedTasks = await this.getSavedTasks('historical');
+                const recent = [];
+                const recentSet = ( new Set());
+                let configured = [];
+                let detected = [];
+                const taskMap = Object.create(null);
+                tasks.forEach(task => {
+                    const key = task.getCommonTaskId();
+                    if (key) {
+                        taskMap[key] = task;
+                    }
+                });
+                recentlyUsedTasks.reverse().forEach(recentTask => {
+                    const key = recentTask.getCommonTaskId();
+                    if (key) {
+                        recentSet.add(key);
+                        const task = taskMap[key];
+                        if (task) {
+                            recent.push(task);
+                        }
+                    }
+                });
+                for (const task of tasks) {
+                    const key = task.getCommonTaskId();
+                    if (!key || !( recentSet.has(key))) {
+                        if ((task._source.kind === TaskSourceKind.Workspace) || (task._source.kind === TaskSourceKind.User)) {
+                            configured.push(task);
+                        }
+                        else {
+                            detected.push(task);
+                        }
+                    }
+                }
+                const sorter = this.createSorter();
+                if (includeRecents) {
+                    fillEntries(entries, recent, ( localizeWithPath(
+                        'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                        'recentlyUsed',
+                        'recently used tasks'
+                    )));
+                }
+                configured = configured.sort((a, b) => sorter.compare(a, b));
+                fillEntries(entries, configured, ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'configured',
+                    'configured tasks'
+                )));
+                detected = detected.sort((a, b) => sorter.compare(a, b));
+                fillEntries(entries, detected, ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'detected',
+                    'detected tasks'
+                )));
+            }
+        }
+        else {
+            if (sort) {
+                const sorter = this.createSorter();
+                tasks = tasks.sort((a, b) => sorter.compare(a, b));
+            }
+            entries = ( tasks.map(task => TaskQuickPickEntry(task)));
+        }
+        encounteredTasks = {};
+        return entries;
+    }
+    async _showTwoLevelQuickPick(placeHolder, defaultEntry, type, name) {
+        return this._instantiationService.createInstance(TaskQuickPick).show(placeHolder, defaultEntry, type, name);
+    }
+    async _showQuickPick(tasks, placeHolder, defaultEntry, group = false, sort = false, selectedEntry, additionalEntries, name) {
+        const resolvedTasks = await tasks;
+        const entries = await raceTimeout(this._createTaskQuickPickEntries(resolvedTasks, group, sort, selectedEntry), 200, () => undefined);
+        if (!entries) {
+            return undefined;
+        }
+        if (entries.length === 1 && this._configurationService.getValue(QUICKOPEN_SKIP_CONFIG)) {
+            return entries[0];
+        }
+        else if ((entries.length === 0) && defaultEntry) {
+            entries.push(defaultEntry);
+        }
+        else if (entries.length > 1 && additionalEntries && additionalEntries.length > 0) {
+            entries.push({ type: 'separator', label: '' });
+            entries.push(additionalEntries[0]);
+        }
+        const picker = this._quickInputService.createQuickPick();
+        picker.placeholder = placeHolder;
+        picker.matchOnDescription = true;
+        if (name) {
+            picker.value = name;
+        }
+        picker.onDidTriggerItemButton(context => {
+            const task = context.item.task;
+            this._quickInputService.cancel();
+            if (ContributedTask.is(task)) {
+                this.customize(task, undefined, true);
+            }
+            else if (CustomTask.is(task)) {
+                this.openConfig(task);
+            }
+        });
+        picker.items = entries;
+        picker.show();
+        return ( new Promise(resolve => {
+            this._register(picker.onDidAccept(async () => {
+                const selectedEntry = picker.selectedItems ? picker.selectedItems[0] : undefined;
+                picker.dispose();
+                if (!selectedEntry) {
+                    resolve(undefined);
+                }
+                resolve(selectedEntry);
+            }));
+        }));
+    }
+    _needsRecentTasksMigration() {
+        return (this.getRecentlyUsedTasksV1().size > 0) && (this._getTasksFromStorage('historical').size === 0);
+    }
+    async _migrateRecentTasks(tasks) {
+        if (!this._needsRecentTasksMigration()) {
+            return;
+        }
+        const recentlyUsedTasks = this.getRecentlyUsedTasksV1();
+        const taskMap = Object.create(null);
+        tasks.forEach(task => {
+            const key = task.getKey();
+            if (key) {
+                taskMap[key] = task;
+            }
+        });
+        const reversed = [...( recentlyUsedTasks.keys())].reverse();
+        for (const key in reversed) {
+            const task = taskMap[key];
+            if (task) {
+                await this._setRecentlyUsedTask(task);
+            }
+        }
+        this._storageService.remove(AbstractTaskService_1.RecentlyUsedTasks_Key, 1 );
+    }
+    _showIgnoredFoldersMessage() {
+        if (this.ignoredWorkspaceFolders.length === 0 || !this.showIgnoreMessage) {
+            return Promise.resolve(undefined);
+        }
+        this._notificationService.prompt(Severity$1.Info, ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TaskService.ignoredFolder',
+            'The following workspace folders are ignored since they use task version 0.1.0: {0}',
+            ( this.ignoredWorkspaceFolders.map(f => f.name)).join(', ')
+        )), [{
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'TaskService.notAgain',
+                    "Don't Show Again"
+                )),
+                isSecondary: true,
+                run: () => {
+                    this._storageService.store(AbstractTaskService_1.IgnoreTask010DonotShowAgain_key, true, 1 , 1 );
+                    this._showIgnoreMessage = false;
+                }
+            }]);
+        return Promise.resolve(undefined);
+    }
+    async _trust() {
+        if (ServerlessWebContext && !TaskExecutionSupportedContext) {
+            return false;
+        }
+        await this._workspaceTrustManagementService.workspaceTrustInitialized;
+        if (!this._workspaceTrustManagementService.isWorkspaceTrusted()) {
+            return (await this._workspaceTrustRequestService.requestWorkspaceTrust({
+                message: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'TaskService.requestTrust',
+                    "Listing and running tasks requires that some of the files in this workspace be executed as code."
+                ))
+            })) === true;
+        }
+        return true;
+    }
+    async _runTaskCommand(filter) {
+        if (!this._tasksReconnected) {
+            return;
+        }
+        if (!filter) {
+            return this._doRunTaskCommand();
+        }
+        const type = typeof filter === 'string' ? undefined : filter.type;
+        const taskName = typeof filter === 'string' ? filter : filter.task;
+        const grouped = await this._getGroupedTasks({ type });
+        const identifier = this._getTaskIdentifier(filter);
+        const tasks = grouped.all();
+        const resolver = this._createResolver(grouped);
+        const folderURIs = ( this._contextService.getWorkspace().folders.map(folder => folder.uri));
+        if (this._contextService.getWorkbenchState() === 3 ) {
+            folderURIs.push(this._contextService.getWorkspace().configuration);
+        }
+        folderURIs.push(USER_TASKS_GROUP_KEY);
+        if (identifier) {
+            for (const uri of folderURIs) {
+                const task = await resolver.resolve(uri, identifier);
+                if (task) {
+                    this.run(task);
+                    return;
+                }
+            }
+        }
+        const exactMatchTask = !taskName ? undefined : tasks.find(t => t.configurationProperties.identifier === taskName || t.getDefinition(true)?.configurationProperties?.identifier === taskName);
+        if (!exactMatchTask) {
+            return this._doRunTaskCommand(tasks, type, taskName);
+        }
+        for (const uri of folderURIs) {
+            const task = await resolver.resolve(uri, taskName);
+            if (task) {
+                await this.run(task, { attachProblemMatcher: true }, 1 );
+                return;
+            }
+        }
+    }
+    _tasksAndGroupedTasks(filter) {
+        if (!this._versionAndEngineCompatible(filter)) {
+            return { tasks: Promise.resolve([]), grouped: Promise.resolve(( new TaskMap())) };
+        }
+        const grouped = this._getGroupedTasks(filter);
+        const tasks = grouped.then((map) => {
+            if (!filter || !filter.type) {
+                return map.all();
+            }
+            const result = [];
+            map.forEach((tasks) => {
+                for (const task of tasks) {
+                    if (ContributedTask.is(task) && task.defines.type === filter.type) {
+                        result.push(task);
+                    }
+                    else if (CustomTask.is(task)) {
+                        if (task.type === filter.type) {
+                            result.push(task);
+                        }
+                        else {
+                            const customizes = task.customizes();
+                            if (customizes && customizes.type === filter.type) {
+                                result.push(task);
+                            }
+                        }
+                    }
+                }
+            });
+            return result;
+        });
+        return { tasks, grouped };
+    }
+    _doRunTaskCommand(tasks, type, name) {
+        const pickThen = (task) => {
+            if (task === undefined) {
+                return;
+            }
+            if (task === null) {
+                this._runConfigureTasks();
+            }
+            else {
+                this.run(task, { attachProblemMatcher: true }, 1 ).then(undefined, reason => {
+                });
+            }
+        };
+        const placeholder = ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TaskService.pickRunTask',
+            'Select the task to run'
+        ));
+        this._showIgnoredFoldersMessage().then(() => {
+            if (this._configurationService.getValue(USE_SLOW_PICKER)) {
+                let taskResult = undefined;
+                if (!tasks) {
+                    taskResult = this._tasksAndGroupedTasks();
+                }
+                this._showQuickPick(tasks ? tasks : taskResult.tasks, placeholder, {
+                    label: '$(plus) ' + ( localizeWithPath(
+                        'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                        'TaskService.noEntryToRun',
+                        'Configure a Task'
+                    )),
+                    task: null
+                }, true, undefined, undefined, undefined, name).
+                    then((entry) => {
+                    return pickThen(entry ? entry.task : undefined);
+                });
+            }
+            else {
+                this._showTwoLevelQuickPick(placeholder, {
+                    label: '$(plus) ' + ( localizeWithPath(
+                        'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                        'TaskService.noEntryToRun',
+                        'Configure a Task'
+                    )),
+                    task: null
+                }, type, name).
+                    then(pickThen);
+            }
+        });
+    }
+    _reRunTaskCommand() {
+        ProblemMatcherRegistry.onReady().then(() => {
+            return this._editorService.saveAll({ reason: 2  }).then(() => {
+                const executeResult = this._getTaskSystem().rerun();
+                if (executeResult) {
+                    return this._handleExecuteResult(executeResult);
+                }
+                else {
+                    if (!this._taskRunningState.get()) {
+                        this._doRunTaskCommand();
+                    }
+                    return Promise.resolve(undefined);
+                }
+            });
+        });
+    }
+    _getDefaultTasks(tasks, taskGlobsInList = false) {
+        const defaults = [];
+        for (const task of tasks) {
+            if (taskGlobsInList && typeof task.configurationProperties.group.isDefault === 'string') {
+                defaults.push(task);
+            }
+            else if (!taskGlobsInList && task.configurationProperties.group.isDefault === true) {
+                defaults.push(task);
+            }
+        }
+        return defaults;
+    }
+    _runTaskGroupCommand(taskGroup, strings, configure, legacyCommand) {
+        if (this.schemaVersion === 1 ) {
+            legacyCommand();
+            return;
+        }
+        const options = {
+            location: 10 ,
+            title: strings.fetching
+        };
+        const promise = (async () => {
+            let groupTasks = [];
+            async function runSingleTask(task, problemMatcherOptions, that) {
+                that.run(task, problemMatcherOptions, 1 ).then(undefined, reason => {
+                });
+            }
+            const chooseAndRunTask = (tasks) => {
+                this._showIgnoredFoldersMessage().then(() => {
+                    this._showQuickPick(tasks, strings.select, {
+                        label: strings.notFoundConfigure,
+                        task: null
+                    }, true).then((entry) => {
+                        const task = entry ? entry.task : undefined;
+                        if (task === undefined) {
+                            return;
+                        }
+                        if (task === null) {
+                            configure.apply(this);
+                            return;
+                        }
+                        runSingleTask(task, { attachProblemMatcher: true }, this);
+                    });
+                });
+            };
+            let globTasksDetected = false;
+            const absoluteURI = EditorResourceAccessor.getOriginalUri(this._editorService.activeEditor);
+            if (absoluteURI) {
+                const workspaceFolder = this._contextService.getWorkspaceFolder(absoluteURI);
+                if (workspaceFolder) {
+                    const configuredTasks = this._getConfiguration(workspaceFolder)?.config?.tasks;
+                    if (configuredTasks) {
+                        globTasksDetected = configuredTasks.filter(task => task.group && typeof task.group !== 'string' && typeof task.group.isDefault === 'string').length > 0;
+                        if (globTasksDetected) {
+                            const relativePath$1 = workspaceFolder?.uri ? (relativePath(workspaceFolder.uri, absoluteURI) ?? absoluteURI.path) : absoluteURI.path;
+                            groupTasks = await this._findWorkspaceTasks((task) => {
+                                const currentTaskGroup = task.configurationProperties.group;
+                                if (currentTaskGroup && typeof currentTaskGroup !== 'string' && typeof currentTaskGroup.isDefault === 'string') {
+                                    return (currentTaskGroup._id === taskGroup._id && match(currentTaskGroup.isDefault, relativePath$1));
+                                }
+                                return false;
+                            });
+                        }
+                    }
+                }
+            }
+            if (!globTasksDetected && groupTasks.length === 0) {
+                groupTasks = await this._findWorkspaceTasksInGroup(taskGroup, true);
+            }
+            const handleMultipleTasks = (areGlobTasks) => {
+                return this._getTasksForGroup(taskGroup).then((tasks) => {
+                    if (tasks.length > 0) {
+                        const defaults = this._getDefaultTasks(tasks, areGlobTasks);
+                        if (defaults.length === 1) {
+                            runSingleTask(defaults[0], undefined, this);
+                            return;
+                        }
+                        else if (defaults.length > 0) {
+                            tasks = defaults;
+                        }
+                    }
+                    chooseAndRunTask(tasks);
+                });
+            };
+            const resolveTaskAndRun = (taskGroupTask) => {
+                if (ConfiguringTask.is(taskGroupTask)) {
+                    this.tryResolveTask(taskGroupTask).then(resolvedTask => {
+                        runSingleTask(resolvedTask, undefined, this);
+                    });
+                }
+                else {
+                    runSingleTask(taskGroupTask, undefined, this);
+                }
+            };
+            if (groupTasks.length === 1) {
+                return resolveTaskAndRun(groupTasks[0]);
+            }
+            if (globTasksDetected && groupTasks.length > 1) {
+                return handleMultipleTasks(true);
+            }
+            if (!groupTasks.length) {
+                groupTasks = await this._findWorkspaceTasksInGroup(taskGroup, false);
+            }
+            if (groupTasks.length === 1) {
+                return resolveTaskAndRun(groupTasks[0]);
+            }
+            return handleMultipleTasks(false);
+        })();
+        this._progressService.withProgress(options, () => promise);
+    }
+    _runBuildCommand() {
+        if (!this._tasksReconnected) {
+            return;
+        }
+        return this._runTaskGroupCommand(TaskGroup.Build, {
+            fetching: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskService.fetchingBuildTasks',
+                'Fetching build tasks...'
+            )),
+            select: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskService.pickBuildTask',
+                'Select the build task to run'
+            )),
+            notFoundConfigure: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskService.noBuildTask',
+                'No build task to run found. Configure Build Task...'
+            ))
+        }, this._runConfigureDefaultBuildTask, this._build);
+    }
+    _runTestCommand() {
+        return this._runTaskGroupCommand(TaskGroup.Test, {
+            fetching: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskService.fetchingTestTasks',
+                'Fetching test tasks...'
+            )),
+            select: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskService.pickTestTask',
+                'Select the test task to run'
+            )),
+            notFoundConfigure: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskService.noTestTaskTerminal',
+                'No test task to run found. Configure Tasks...'
+            ))
+        }, this._runConfigureDefaultTestTask, this._runTest);
+    }
+    _runTerminateCommand(arg) {
+        if (arg === 'terminateAll') {
+            this._terminateAll();
+            return;
+        }
+        const runQuickPick = (promise) => {
+            this._showQuickPick(promise || this.getActiveTasks(), ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskService.taskToTerminate',
+                'Select a task to terminate'
+            )), {
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'TaskService.noTaskRunning',
+                    'No task is currently running'
+                )),
+                task: undefined
+            }, false, true, undefined, [{
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                        'TaskService.terminateAllRunningTasks',
+                        'All Running Tasks'
+                    )),
+                    id: 'terminateAll',
+                    task: undefined
+                }]).then(entry => {
+                if (entry && entry.id === 'terminateAll') {
+                    this._terminateAll();
+                }
+                const task = entry ? entry.task : undefined;
+                if (task === undefined || task === null) {
+                    return;
+                }
+                this.terminate(task);
+            });
+        };
+        if (this.inTerminal()) {
+            const identifier = this._getTaskIdentifier(arg);
+            let promise;
+            if (identifier !== undefined) {
+                promise = this.getActiveTasks();
+                promise.then((tasks) => {
+                    for (const task of tasks) {
+                        if (task.matches(identifier)) {
+                            this.terminate(task);
+                            return;
+                        }
+                    }
+                    runQuickPick(promise);
+                });
+            }
+            else {
+                runQuickPick();
+            }
+        }
+        else {
+            this._isActive().then((active) => {
+                if (active) {
+                    this._terminateAll().then((responses) => {
+                        const response = responses[0];
+                        if (response.success) {
+                            return;
+                        }
+                        if (response.code && response.code === 3 ) {
+                            this._notificationService.error(( localizeWithPath(
+                                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                                'TerminateAction.noProcess',
+                                'The launched process doesn\'t exist anymore. If the task spawned background tasks exiting VS Code might result in orphaned processes.'
+                            )));
+                        }
+                        else {
+                            this._notificationService.error(( localizeWithPath(
+                                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                                'TerminateAction.failed',
+                                'Failed to terminate running task'
+                            )));
+                        }
+                    });
+                }
+            });
+        }
+    }
+    async _runRestartTaskCommand(arg) {
+        const activeTasks = await this.getActiveTasks();
+        if (activeTasks.length === 1) {
+            this._restart(activeTasks[0]);
+            return;
+        }
+        if (this.inTerminal()) {
+            const identifier = this._getTaskIdentifier(arg);
+            if (identifier !== undefined) {
+                for (const task of activeTasks) {
+                    if (task.matches(identifier)) {
+                        this._restart(task);
+                        return;
+                    }
+                }
+            }
+            const entry = await this._showQuickPick(activeTasks, ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskService.taskToRestart',
+                'Select the task to restart'
+            )), {
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'TaskService.noTaskToRestart',
+                    'No task to restart'
+                )),
+                task: null
+            }, false, true);
+            if (entry && entry.task) {
+                this._restart(entry.task);
+            }
+        }
+        else {
+            if (activeTasks.length > 0) {
+                this._restart(activeTasks[0]);
+            }
+        }
+    }
+    _getTaskIdentifier(filter) {
+        let result = undefined;
+        if (isString(filter)) {
+            result = filter;
+        }
+        else if (filter && isString(filter.type)) {
+            result = TaskDefinition.createTaskIdentifier(filter, console);
+        }
+        return result;
+    }
+    _configHasTasks(taskConfig) {
+        return !!taskConfig && !!taskConfig.tasks && taskConfig.tasks.length > 0;
+    }
+    _openTaskFile(resource, taskSource) {
+        let configFileCreated = false;
+        this._fileService.stat(resource).then((stat) => stat, () => undefined).then(async (stat) => {
+            const fileExists = !!stat;
+            const configValue = this._configurationService.inspect('tasks');
+            let tasksExistInFile;
+            let target;
+            switch (taskSource) {
+                case TaskSourceKind.User:
+                    tasksExistInFile = this._configHasTasks(configValue.userValue);
+                    target = 2 ;
+                    break;
+                case TaskSourceKind.WorkspaceFile:
+                    tasksExistInFile = this._configHasTasks(configValue.workspaceValue);
+                    target = 5 ;
+                    break;
+                default:
+                    tasksExistInFile = this._configHasTasks(configValue.workspaceFolderValue);
+                    target = 6 ;
+            }
+            let content;
+            if (!tasksExistInFile) {
+                const pickTemplateResult = await this._quickInputService.pick(getTemplates(), { placeHolder: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'TaskService.template',
+                    'Select a Task Template'
+                )) });
+                if (!pickTemplateResult) {
+                    return Promise.resolve(undefined);
+                }
+                content = pickTemplateResult.content;
+                const editorConfig = this._configurationService.getValue();
+                if (editorConfig.editor.insertSpaces) {
+                    content = content.replace(/(\n)(\t+)/g, (_, s1, s2) => s1 + ' '.repeat(s2.length * editorConfig.editor.tabSize));
+                }
+                configFileCreated = true;
+            }
+            if (!fileExists && content) {
+                return this._textFileService.create([{ resource, value: content }]).then(result => {
+                    return result[0].resource;
+                });
+            }
+            else if (fileExists && (tasksExistInFile || content)) {
+                if (content) {
+                    this._configurationService.updateValue('tasks', parse$1(content), target);
+                }
+                return stat?.resource;
+            }
+            return undefined;
+        }).then((resource) => {
+            if (!resource) {
+                return;
+            }
+            this._editorService.openEditor({
+                resource,
+                options: {
+                    pinned: configFileCreated
+                }
+            });
+        });
+    }
+    _isTaskEntry(value) {
+        const candidate = value;
+        return candidate && !!candidate.task;
+    }
+    _isSettingEntry(value) {
+        const candidate = value;
+        return candidate && !!candidate.settingType;
+    }
+    _configureTask(task) {
+        if (ContributedTask.is(task)) {
+            this.customize(task, undefined, true);
+        }
+        else if (CustomTask.is(task)) {
+            this.openConfig(task);
+        }
+        else if (ConfiguringTask.is(task)) ;
+    }
+    _handleSelection(selection) {
+        if (!selection) {
+            return;
+        }
+        if (this._isTaskEntry(selection)) {
+            this._configureTask(selection.task);
+        }
+        else if (this._isSettingEntry(selection)) {
+            const taskQuickPick = this._instantiationService.createInstance(TaskQuickPick);
+            taskQuickPick.handleSettingOption(selection.settingType);
+        }
+        else if (selection.folder && ((this._contextService.getWorkbenchState() !== 1) )) {
+            this._openTaskFile(selection.folder.toResource('.vscode/tasks.json'), TaskSourceKind.Workspace);
+        }
+        else {
+            const resource = this._getResourceForKind(TaskSourceKind.User);
+            if (resource) {
+                this._openTaskFile(resource, TaskSourceKind.User);
+            }
+        }
+    }
+    getTaskDescription(task) {
+        let description;
+        if (task._source.kind === TaskSourceKind.User) {
+            description = ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'taskQuickPick.userSettings',
+                'User'
+            ));
+        }
+        else if (task._source.kind === TaskSourceKind.WorkspaceFile) {
+            description = task.getWorkspaceFileName();
+        }
+        else if (this.needsFolderQualification()) {
+            const workspaceFolder = task.getWorkspaceFolder();
+            if (workspaceFolder) {
+                description = workspaceFolder.name;
+            }
+        }
+        return description;
+    }
+    async _runConfigureTasks() {
+        if (!(await this._trust())) {
+            return;
+        }
+        let taskPromise;
+        if (this.schemaVersion === 2 ) {
+            taskPromise = this._getGroupedTasks();
+        }
+        else {
+            taskPromise = Promise.resolve(( new TaskMap()));
+        }
+        const stats = ( this._contextService.getWorkspace().folders.map((folder) => {
+            return this._fileService.stat(folder.toResource('.vscode/tasks.json')).then(stat => stat, () => undefined);
+        }));
+        const createLabel = ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TaskService.createJsonFile',
+            'Create tasks.json file from template'
+        ));
+        const openLabel = ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TaskService.openJsonFile',
+            'Open tasks.json file'
+        ));
+        const tokenSource = ( new CancellationTokenSource());
+        const cancellationToken = tokenSource.token;
+        const entries = Promise.all(stats).then((stats) => {
+            return taskPromise.then((taskMap) => {
+                const entries = [];
+                let configuredCount = 0;
+                let tasks = taskMap.all();
+                if (tasks.length > 0) {
+                    tasks = tasks.sort((a, b) => a._label.localeCompare(b._label));
+                    for (const task of tasks) {
+                        const entry = { label: TaskQuickPick.getTaskLabelWithIcon(task), task, description: this.getTaskDescription(task), detail: this._showDetail() ? task.configurationProperties.detail : undefined };
+                        TaskQuickPick.applyColorStyles(task, entry, this._themeService);
+                        entries.push(entry);
+                        if (!ContributedTask.is(task)) {
+                            configuredCount++;
+                        }
+                    }
+                }
+                const needsCreateOrOpen = (configuredCount === 0);
+                if (needsCreateOrOpen || (taskMap.get(USER_TASKS_GROUP_KEY).length === configuredCount)) {
+                    const label = stats[0] !== undefined ? openLabel : createLabel;
+                    if (entries.length) {
+                        entries.push({ type: 'separator' });
+                    }
+                    entries.push({ label, folder: this._contextService.getWorkspace().folders[0] });
+                }
+                if ((entries.length === 1) && !needsCreateOrOpen) {
+                    tokenSource.cancel();
+                }
+                return entries;
+            });
+        });
+        const timeout = await Promise.race([( new Promise((resolve) => {
+                entries.then(() => resolve(false));
+            })), ( new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    clearTimeout(timer);
+                    resolve(true);
+                }, 200);
+            }))]);
+        if (!timeout && ((await entries).length === 1) && this._configurationService.getValue(QUICKOPEN_SKIP_CONFIG)) {
+            const entry = ((await entries)[0]);
+            if (entry.task) {
+                this._handleSelection(entry);
+                return;
+            }
+        }
+        const entriesWithSettings = entries.then(resolvedEntries => {
+            resolvedEntries.push(...TaskQuickPick.allSettingEntries(this._configurationService));
+            return resolvedEntries;
+        });
+        this._quickInputService.pick(entriesWithSettings, { placeHolder: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'TaskService.pickTask',
+            'Select a task to configure'
+        )) }, cancellationToken).
+            then(async (selection) => {
+            if (cancellationToken.isCancellationRequested) {
+                const task = (await entries)[0];
+                if (task.task) {
+                    selection = task;
+                }
+            }
+            this._handleSelection(selection);
+        });
+    }
+    _runConfigureDefaultBuildTask() {
+        if (this.schemaVersion === 2 ) {
+            this.tasks().then((tasks => {
+                if (tasks.length === 0) {
+                    this._runConfigureTasks();
+                    return;
+                }
+                const entries = [];
+                let selectedTask;
+                let selectedEntry;
+                this._showIgnoredFoldersMessage().then(() => {
+                    for (const task of tasks) {
+                        const taskGroup = TaskGroup.from(task.configurationProperties.group);
+                        if (taskGroup && taskGroup.isDefault && taskGroup._id === TaskGroup.Build._id) {
+                            const label = ( localizeWithPath(
+                                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                                'TaskService.defaultBuildTaskExists',
+                                '{0} is already marked as the default build task',
+                                TaskQuickPick.getTaskLabelWithIcon(task, task.getQualifiedLabel())
+                            ));
+                            selectedTask = task;
+                            selectedEntry = { label, task, description: this.getTaskDescription(task), detail: this._showDetail() ? task.configurationProperties.detail : undefined };
+                            TaskQuickPick.applyColorStyles(task, selectedEntry, this._themeService);
+                        }
+                        else {
+                            const entry = { label: TaskQuickPick.getTaskLabelWithIcon(task), task, description: this.getTaskDescription(task), detail: this._showDetail() ? task.configurationProperties.detail : undefined };
+                            TaskQuickPick.applyColorStyles(task, entry, this._themeService);
+                            entries.push(entry);
+                        }
+                    }
+                    if (selectedEntry) {
+                        entries.unshift(selectedEntry);
+                    }
+                    const tokenSource = ( new CancellationTokenSource());
+                    const cancellationToken = tokenSource.token;
+                    this._quickInputService.pick(entries, { placeHolder: ( localizeWithPath(
+                        'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                        'TaskService.pickTask',
+                        'Select a task to configure'
+                    )) }, cancellationToken).
+                        then(async (entry) => {
+                        if (cancellationToken.isCancellationRequested) {
+                            const task = (await entries)[0];
+                            if (task.task) {
+                                entry = task;
+                            }
+                        }
+                        const task = entry && 'task' in entry ? entry.task : undefined;
+                        if ((task === undefined) || (task === null)) {
+                            return;
+                        }
+                        if (task === selectedTask && CustomTask.is(task)) {
+                            this.openConfig(task);
+                        }
+                        if (!InMemoryTask.is(task)) {
+                            this.customize(task, { group: { kind: 'build', isDefault: true } }, true).then(() => {
+                                if (selectedTask && (task !== selectedTask) && !InMemoryTask.is(selectedTask)) {
+                                    this.customize(selectedTask, { group: 'build' }, false);
+                                }
+                            });
+                        }
+                    });
+                    this._quickInputService.pick(entries, {
+                        placeHolder: ( localizeWithPath(
+                            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                            'TaskService.pickDefaultBuildTask',
+                            'Select the task to be used as the default build task'
+                        ))
+                    }).
+                        then((entry) => {
+                        const task = entry && 'task' in entry ? entry.task : undefined;
+                        if ((task === undefined) || (task === null)) {
+                            return;
+                        }
+                        if (task === selectedTask && CustomTask.is(task)) {
+                            this.openConfig(task);
+                        }
+                        if (!InMemoryTask.is(task)) {
+                            this.customize(task, { group: { kind: 'build', isDefault: true } }, true).then(() => {
+                                if (selectedTask && (task !== selectedTask) && !InMemoryTask.is(selectedTask)) {
+                                    this.customize(selectedTask, { group: 'build' }, false);
+                                }
+                            });
+                        }
+                    });
+                });
+            }));
+        }
+        else {
+            this._runConfigureTasks();
+        }
+    }
+    _runConfigureDefaultTestTask() {
+        if (this.schemaVersion === 2 ) {
+            this.tasks().then((tasks => {
+                if (tasks.length === 0) {
+                    this._runConfigureTasks();
+                    return;
+                }
+                let selectedTask;
+                let selectedEntry;
+                for (const task of tasks) {
+                    const taskGroup = TaskGroup.from(task.configurationProperties.group);
+                    if (taskGroup && taskGroup.isDefault && taskGroup._id === TaskGroup.Test._id) {
+                        selectedTask = task;
+                        break;
+                    }
+                }
+                if (selectedTask) {
+                    selectedEntry = {
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                            'TaskService.defaultTestTaskExists',
+                            '{0} is already marked as the default test task.',
+                            selectedTask.getQualifiedLabel()
+                        )),
+                        task: selectedTask,
+                        detail: this._showDetail() ? selectedTask.configurationProperties.detail : undefined
+                    };
+                }
+                this._showIgnoredFoldersMessage().then(() => {
+                    this._showQuickPick(tasks, ( localizeWithPath(
+                        'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                        'TaskService.pickDefaultTestTask',
+                        'Select the task to be used as the default test task'
+                    )), undefined, true, false, selectedEntry).then((entry) => {
+                        const task = entry ? entry.task : undefined;
+                        if (!task) {
+                            return;
+                        }
+                        if (task === selectedTask && CustomTask.is(task)) {
+                            this.openConfig(task);
+                        }
+                        if (!InMemoryTask.is(task)) {
+                            this.customize(task, { group: { kind: 'test', isDefault: true } }, true).then(() => {
+                                if (selectedTask && (task !== selectedTask) && !InMemoryTask.is(selectedTask)) {
+                                    this.customize(selectedTask, { group: 'test' }, false);
+                                }
+                            });
+                        }
+                    });
+                });
+            }));
+        }
+        else {
+            this._runConfigureTasks();
+        }
+    }
+    async runShowTasks() {
+        const activeTasksPromise = this.getActiveTasks();
+        const activeTasks = await activeTasksPromise;
+        let group;
+        if (activeTasks.length === 1) {
+            this._taskSystem.revealTask(activeTasks[0]);
+        }
+        else if (activeTasks.length && activeTasks.every((task) => {
+            if (InMemoryTask.is(task)) {
+                return false;
+            }
+            if (!group) {
+                group = task.command.presentation?.group;
+            }
+            return task.command.presentation?.group && (task.command.presentation.group === group);
+        })) {
+            this._taskSystem.revealTask(activeTasks[0]);
+        }
+        else {
+            this._showQuickPick(activeTasksPromise, ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'TaskService.pickShowTask',
+                'Select the task to show its output'
+            )), {
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'TaskService.noTaskIsRunning',
+                    'No task is running'
+                )),
+                task: null
+            }, false, true).then((entry) => {
+                const task = entry ? entry.task : undefined;
+                if (task === undefined || task === null) {
+                    return;
+                }
+                this._taskSystem.revealTask(task);
+            });
+        }
+    }
+    async _createTasksDotOld(folder) {
+        const tasksFile = folder.toResource('.vscode/tasks.json');
+        if (await this._fileService.exists(tasksFile)) {
+            const oldFile = tasksFile.with({ path: `${tasksFile.path}.old` });
+            await this._fileService.copy(tasksFile, oldFile, true);
+            return [oldFile, tasksFile];
+        }
+        return undefined;
+    }
+    _upgradeTask(task, suppressTaskName, globalConfig) {
+        if (!CustomTask.is(task)) {
+            return;
+        }
+        const configElement = {
+            label: task._label
+        };
+        const oldTaskTypes = ( new Set(['gulp', 'jake', 'grunt']));
+        if (isString(task.command.name) && ( oldTaskTypes.has(task.command.name))) {
+            configElement.type = task.command.name;
+            configElement.task = task.command.args[0];
+        }
+        else {
+            if (task.command.runtime === RuntimeType.Shell) {
+                configElement.type = ( RuntimeType.toString(RuntimeType.Shell));
+            }
+            if (task.command.name && !suppressTaskName && !globalConfig.windows?.command && !globalConfig.osx?.command && !globalConfig.linux?.command) {
+                configElement.command = task.command.name;
+            }
+            else if (suppressTaskName) {
+                configElement.command = task._source.config.element.command;
+            }
+            if (task.command.args && (!Array.isArray(task.command.args) || (task.command.args.length > 0))) {
+                if (!globalConfig.windows?.args && !globalConfig.osx?.args && !globalConfig.linux?.args) {
+                    configElement.args = task.command.args;
+                }
+                else {
+                    configElement.args = task._source.config.element.args;
+                }
+            }
+        }
+        if (task.configurationProperties.presentation) {
+            configElement.presentation = task.configurationProperties.presentation;
+        }
+        if (task.configurationProperties.isBackground) {
+            configElement.isBackground = task.configurationProperties.isBackground;
+        }
+        if (task.configurationProperties.problemMatchers) {
+            configElement.problemMatcher = task._source.config.element.problemMatcher;
+        }
+        if (task.configurationProperties.group) {
+            configElement.group = task.configurationProperties.group;
+        }
+        task._source.config.element = configElement;
+        const tempTask = ( new CustomTask(
+            task._id,
+            task._source,
+            task._label,
+            task.type,
+            task.command,
+            task.hasDefinedMatchers,
+            task.runOptions,
+            task.configurationProperties
+        ));
+        const configTask = this._createCustomizableTask(tempTask);
+        if (configTask) {
+            return configTask;
+        }
+        return;
+    }
+    async _upgrade() {
+        if (this.schemaVersion === 2 ) {
+            return;
+        }
+        if (!this._workspaceTrustManagementService.isWorkspaceTrusted()) {
+            this._register(Event.once(this._workspaceTrustManagementService.onDidChangeTrust)(isTrusted => {
+                if (isTrusted) {
+                    this._upgrade();
+                }
+            }));
+            return;
+        }
+        const tasks = await this._getGroupedTasks();
+        const fileDiffs = [];
+        for (const folder of this.workspaceFolders) {
+            const diff = await this._createTasksDotOld(folder);
+            if (diff) {
+                fileDiffs.push(diff);
+            }
+            if (!diff) {
+                continue;
+            }
+            const configTasks = [];
+            const suppressTaskName = !!this._configurationService.getValue("tasks.suppressTaskName" , { resource: folder.uri });
+            const globalConfig = {
+                windows: this._configurationService.getValue("tasks.windows" , { resource: folder.uri }),
+                osx: this._configurationService.getValue("tasks.osx" , { resource: folder.uri }),
+                linux: this._configurationService.getValue("tasks.linux" , { resource: folder.uri })
+            };
+            tasks.get(folder).forEach(task => {
+                const configTask = this._upgradeTask(task, suppressTaskName, globalConfig);
+                if (configTask) {
+                    configTasks.push(configTask);
+                }
+            });
+            this._taskSystem = undefined;
+            this._workspaceTasksPromise = undefined;
+            await this._writeConfiguration(folder, 'tasks.tasks', configTasks);
+            await this._writeConfiguration(folder, 'tasks.version', '2.0.0');
+            if (this._configurationService.getValue("tasks.showOutput" , { resource: folder.uri })) {
+                await this._configurationService.updateValue("tasks.showOutput" , undefined, { resource: folder.uri });
+            }
+            if (this._configurationService.getValue("tasks.isShellCommand" , { resource: folder.uri })) {
+                await this._configurationService.updateValue("tasks.isShellCommand" , undefined, { resource: folder.uri });
+            }
+            if (this._configurationService.getValue("tasks.suppressTaskName" , { resource: folder.uri })) {
+                await this._configurationService.updateValue("tasks.suppressTaskName" , undefined, { resource: folder.uri });
+            }
+        }
+        this._updateSetup();
+        this._notificationService.prompt(Severity$1.Warning, fileDiffs.length === 1 ?
+            ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                'taskService.upgradeVersion',
+                "The deprecated tasks version 0.1.0 has been removed. Your tasks have been upgraded to version 2.0.0. Open the diff to review the upgrade."
+            ))
+            : ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/abstractTaskService',
+            'taskService.upgradeVersionPlural',
+            "The deprecated tasks version 0.1.0 has been removed. Your tasks have been upgraded to version 2.0.0. Open the diffs to review the upgrade."
+        )), [{
+                label: fileDiffs.length === 1 ? ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'taskService.openDiff',
+                    "Open diff"
+                )) : ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/abstractTaskService',
+                    'taskService.openDiffs',
+                    "Open diffs"
+                )),
+                run: async () => {
+                    for (const upgrade of fileDiffs) {
+                        await this._editorService.openEditor({
+                            original: { resource: upgrade[0] },
+                            modified: { resource: upgrade[1] }
+                        });
+                    }
+                }
+            }]);
+    }
+};
+AbstractTaskService = AbstractTaskService_1 = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IMarkerService)),
+    ( __param(2, IOutputService)),
+    ( __param(3, IPaneCompositePartService)),
+    ( __param(4, IViewsService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, IEditorService)),
+    ( __param(7, IFileService)),
+    ( __param(8, IWorkspaceContextService)),
+    ( __param(9, ITelemetryService)),
+    ( __param(10, ITextFileService)),
+    ( __param(11, IModelService)),
+    ( __param(12, IExtensionService)),
+    ( __param(13, IQuickInputService)),
+    ( __param(14, IConfigurationResolverService)),
+    ( __param(15, ITerminalService)),
+    ( __param(16, ITerminalGroupService)),
+    ( __param(17, IStorageService)),
+    ( __param(18, IProgressService)),
+    ( __param(19, IOpenerService)),
+    ( __param(20, IDialogService)),
+    ( __param(21, INotificationService)),
+    ( __param(22, IContextKeyService)),
+    ( __param(23, IWorkbenchEnvironmentService)),
+    ( __param(24, ITerminalProfileResolverService)),
+    ( __param(25, IPathService)),
+    ( __param(26, ITextModelService)),
+    ( __param(27, IPreferencesService)),
+    ( __param(28, IViewDescriptorService)),
+    ( __param(29, IWorkspaceTrustRequestService)),
+    ( __param(30, IWorkspaceTrustManagementService)),
+    ( __param(31, ILogService)),
+    ( __param(32, IThemeService)),
+    ( __param(33, ILifecycleService)),
+    ( __param(34, IRemoteAgentService)),
+    ( __param(35, IInstantiationService))
+], AbstractTaskService));
+export { AbstractTaskService, ConfigureTaskAction };