@codingame/monaco-vscode-task-service-override 28.4.1 → 29.0.0

package/vscode/src/vs/workbench/contrib/tasks/common/taskConfiguration.js

@@ -0,0 +1,1798 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { deepClone } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { Platform } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { isString, isStringArray, isBoolean, isUndefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { ProblemMatcherParser, isNamedProblemMatcher, ProblemMatcherRegistry } from './problemMatcher.js';
+import { RunOnOptions as RunOnOptions$1, InstancePolicy as InstancePolicy$1, RevealKind, RevealProblemKind, PanelKind, ExecutionEngine as ExecutionEngine$1, ShellQuoting as ShellQuoting$1, JsonSchemaVersion as JsonSchemaVersion$1, RuntimeType, TaskGroup, USER_TASKS_GROUP_KEY, TaskDefinition, DependsOrder as DependsOrder$1, TaskSourceKind, ConfiguringTask as ConfiguringTask$1, CUSTOMIZED_TASK_TYPE, CustomTask as CustomTask$1, CommandString as CommandString$1 } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/tasks';
+import { TaskDefinitionRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskDefinitionRegistry';
+import { ProcessExecutionSupportedContext, ShellExecutionSupportedContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService';
+
+var ShellQuoting;
+(function(ShellQuoting) {
+    ShellQuoting[ShellQuoting["escape"] = 1] = "escape";
+    ShellQuoting[ShellQuoting["strong"] = 2] = "strong";
+    ShellQuoting[ShellQuoting["weak"] = 3] = "weak";
+})(ShellQuoting || (ShellQuoting = {}));
+var ITaskIdentifier;
+(function(ITaskIdentifier) {
+    function is(value) {
+        const candidate = value;
+        return candidate !== undefined && isString(value.type);
+    }
+    ITaskIdentifier.is = is;
+})(ITaskIdentifier || (ITaskIdentifier = {}));
+var CommandString;
+(function(CommandString) {
+    function value(value) {
+        if (isString(value)) {
+            return value;
+        } else if (isStringArray(value)) {
+            return value.join(" ");
+        } else {
+            if (isString(value.value)) {
+                return value.value;
+            } else {
+                return value.value.join(" ");
+            }
+        }
+    }
+    CommandString.value = value;
+})(CommandString || (CommandString = {}));
+var ProblemMatcherKind;
+(function(ProblemMatcherKind) {
+    ProblemMatcherKind[ProblemMatcherKind["Unknown"] = 0] = "Unknown";
+    ProblemMatcherKind[ProblemMatcherKind["String"] = 1] = "String";
+    ProblemMatcherKind[ProblemMatcherKind["ProblemMatcher"] = 2] = "ProblemMatcher";
+    ProblemMatcherKind[ProblemMatcherKind["Array"] = 3] = "Array";
+})(ProblemMatcherKind || (ProblemMatcherKind = {}));
+const EMPTY_ARRAY = [];
+function assignProperty(target, source, key) {
+    const sourceAtKey = source[key];
+    if (sourceAtKey !== undefined) {
+        target[key] = sourceAtKey;
+    }
+}
+function fillProperty(target, source, key) {
+    const sourceAtKey = source[key];
+    if (target[key] === undefined && sourceAtKey !== undefined) {
+        target[key] = sourceAtKey;
+    }
+}
+function _isEmpty(value, properties, allowEmptyArray = false) {
+    if (value === undefined || value === null || properties === undefined) {
+        return true;
+    }
+    for (const meta of properties) {
+        const property = value[meta.property];
+        if (property !== undefined && property !== null) {
+            if (meta.type !== undefined && !meta.type.isEmpty(property)) {
+                return false;
+            } else if (!Array.isArray(property) || (property.length > 0) || allowEmptyArray) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function _assignProperties(target, source, properties) {
+    if (!source || _isEmpty(source, properties)) {
+        return target;
+    }
+    if (!target || _isEmpty(target, properties)) {
+        return source;
+    }
+    for (const meta of properties) {
+        const property = meta.property;
+        let value;
+        if (meta.type !== undefined) {
+            value = meta.type.assignProperties(target[property], source[property]);
+        } else {
+            value = source[property];
+        }
+        if (value !== undefined && value !== null) {
+            target[property] = value;
+        }
+    }
+    return target;
+}
+function _fillProperties(target, source, properties, allowEmptyArray = false) {
+    if (!source || _isEmpty(source, properties)) {
+        return target;
+    }
+    if (!target || _isEmpty(target, properties, allowEmptyArray)) {
+        return source;
+    }
+    for (const meta of properties) {
+        const property = meta.property;
+        let value;
+        if (meta.type) {
+            value = meta.type.fillProperties(target[property], source[property]);
+        } else if (target[property] === undefined) {
+            value = source[property];
+        }
+        if (value !== undefined && value !== null) {
+            target[property] = value;
+        }
+    }
+    return target;
+}
+function _fillDefaults(target, defaults, properties, context) {
+    if (target && Object.isFrozen(target)) {
+        return target;
+    }
+    if (target === undefined || target === null || defaults === undefined || defaults === null) {
+        if (defaults !== undefined && defaults !== null) {
+            return deepClone(defaults);
+        } else {
+            return undefined;
+        }
+    }
+    for (const meta of properties) {
+        const property = meta.property;
+        if (target[property] !== undefined) {
+            continue;
+        }
+        let value;
+        if (meta.type) {
+            value = meta.type.fillDefaults(target[property], context);
+        } else {
+            value = defaults[property];
+        }
+        if (value !== undefined && value !== null) {
+            target[property] = value;
+        }
+    }
+    return target;
+}
+function _freeze(target, properties) {
+    if (target === undefined || target === null) {
+        return undefined;
+    }
+    if (Object.isFrozen(target)) {
+        return target;
+    }
+    for (const meta of properties) {
+        if (meta.type) {
+            const value = target[meta.property];
+            if (value) {
+                meta.type.freeze(value);
+            }
+        }
+    }
+    return target;
+}
+var RunOnOptions;
+(function(RunOnOptions) {
+    function fromString(value) {
+        if (!value) {
+            return RunOnOptions$1.default;
+        }
+        switch (value.toLowerCase()) {
+        case "folderopen":
+            return RunOnOptions$1.folderOpen;
+        case "worktreecreated":
+            return RunOnOptions$1.worktreeCreated;
+        case "default":
+        default:
+            return RunOnOptions$1.default;
+        }
+    }
+    RunOnOptions.fromString = fromString;
+})(RunOnOptions || (RunOnOptions = {}));
+var RunOptions;
+(function(RunOptions) {
+    const properties = [{
+        property: "reevaluateOnRerun"
+    }, {
+        property: "runOn"
+    }, {
+        property: "instanceLimit"
+    }, {
+        property: "instancePolicy"
+    }];
+    function fromConfiguration(value) {
+        return {
+            reevaluateOnRerun: value ? value.reevaluateOnRerun : true,
+            runOn: value ? RunOnOptions.fromString(value.runOn) : RunOnOptions$1.default,
+            instanceLimit: value?.instanceLimit ? Math.max(value.instanceLimit, 1) : 1,
+            instancePolicy: value ? InstancePolicy.fromString(value.instancePolicy) : InstancePolicy$1.prompt
+        };
+    }
+    RunOptions.fromConfiguration = fromConfiguration;
+    function assignProperties(target, source) {
+        return _assignProperties(target, source, properties);
+    }
+    RunOptions.assignProperties = assignProperties;
+    function fillProperties(target, source) {
+        return _fillProperties(target, source, properties);
+    }
+    RunOptions.fillProperties = fillProperties;
+})(RunOptions || (RunOptions = {}));
+var InstancePolicy;
+(function(InstancePolicy) {
+    function fromString(value) {
+        if (!value) {
+            return InstancePolicy$1.prompt;
+        }
+        switch (value.toLowerCase()) {
+        case "terminatenewest":
+            return InstancePolicy$1.terminateNewest;
+        case "terminateoldest":
+            return InstancePolicy$1.terminateOldest;
+        case "warn":
+            return InstancePolicy$1.warn;
+        case "silent":
+            return InstancePolicy$1.silent;
+        case "prompt":
+        default:
+            return InstancePolicy$1.prompt;
+        }
+    }
+    InstancePolicy.fromString = fromString;
+})(InstancePolicy || (InstancePolicy = {}));
+var ShellConfiguration;
+(function(ShellConfiguration) {
+    const properties = [{
+        property: "executable"
+    }, {
+        property: "args"
+    }, {
+        property: "quoting"
+    }];
+    function is(value) {
+        const candidate = value;
+        return candidate && (isString(candidate.executable) || isStringArray(candidate.args));
+    }
+    ShellConfiguration.is = is;
+    function from(config, context) {
+        if (!is(config)) {
+            return undefined;
+        }
+        const result = {};
+        if (config.executable !== undefined) {
+            result.executable = config.executable;
+        }
+        if (config.args !== undefined) {
+            result.args = config.args.slice();
+        }
+        if (config.quoting !== undefined) {
+            result.quoting = deepClone(config.quoting);
+        }
+        return result;
+    }
+    ShellConfiguration.from = from;
+    function isEmpty(value) {
+        return _isEmpty(value, properties, true);
+    }
+    ShellConfiguration.isEmpty = isEmpty;
+    function assignProperties(target, source) {
+        return _assignProperties(target, source, properties);
+    }
+    ShellConfiguration.assignProperties = assignProperties;
+    function fillProperties(target, source) {
+        return _fillProperties(target, source, properties, true);
+    }
+    ShellConfiguration.fillProperties = fillProperties;
+    function fillDefaults(value, context) {
+        return value;
+    }
+    ShellConfiguration.fillDefaults = fillDefaults;
+    function freeze(value) {
+        if (!value) {
+            return undefined;
+        }
+        return ( Object.freeze(value));
+    }
+    ShellConfiguration.freeze = freeze;
+})(ShellConfiguration || (ShellConfiguration = {}));
+var CommandOptions;
+(function(CommandOptions) {
+    const properties = [{
+        property: "cwd"
+    }, {
+        property: "env"
+    }, {
+        property: "shell",
+        type: ShellConfiguration
+    }];
+    const defaults = {
+        cwd: "${workspaceFolder}"
+    };
+    function from(options, context) {
+        const result = {};
+        if (options.cwd !== undefined) {
+            if (isString(options.cwd)) {
+                result.cwd = options.cwd;
+            } else {
+                context.taskLoadIssues.push(( localize(
+                    13227,
+                    "Warning: options.cwd must be of type string. Ignoring value {0}\n",
+                    options.cwd
+                )));
+            }
+        }
+        if (options.env !== undefined) {
+            result.env = deepClone(options.env);
+        }
+        result.shell = ShellConfiguration.from(options.shell, context);
+        return isEmpty(result) ? undefined : result;
+    }
+    CommandOptions.from = from;
+    function isEmpty(value) {
+        return _isEmpty(value, properties);
+    }
+    CommandOptions.isEmpty = isEmpty;
+    function assignProperties(target, source) {
+        if ((source === undefined) || isEmpty(source)) {
+            return target;
+        }
+        if ((target === undefined) || isEmpty(target)) {
+            return source;
+        }
+        assignProperty(target, source, "cwd");
+        if (target.env === undefined) {
+            target.env = source.env;
+        } else if (source.env !== undefined) {
+            const env = Object.create(null);
+            if (target.env !== undefined) {
+                ( Object.keys(target.env)).forEach(key => env[key] = target.env[key]);
+            }
+            if (source.env !== undefined) {
+                ( Object.keys(source.env)).forEach(key => env[key] = source.env[key]);
+            }
+            target.env = env;
+        }
+        target.shell = ShellConfiguration.assignProperties(target.shell, source.shell);
+        return target;
+    }
+    CommandOptions.assignProperties = assignProperties;
+    function fillProperties(target, source) {
+        return _fillProperties(target, source, properties);
+    }
+    CommandOptions.fillProperties = fillProperties;
+    function fillDefaults(value, context) {
+        return _fillDefaults(value, defaults, properties, context);
+    }
+    CommandOptions.fillDefaults = fillDefaults;
+    function freeze(value) {
+        return _freeze(value, properties);
+    }
+    CommandOptions.freeze = freeze;
+})(CommandOptions || (CommandOptions = {}));
+var CommandConfiguration;
+(function(CommandConfiguration) {
+    let PresentationOptions;
+    (function(PresentationOptions) {
+        const properties = [{
+            property: "echo"
+        }, {
+            property: "reveal"
+        }, {
+            property: "revealProblems"
+        }, {
+            property: "focus"
+        }, {
+            property: "panel"
+        }, {
+            property: "showReuseMessage"
+        }, {
+            property: "clear"
+        }, {
+            property: "group"
+        }, {
+            property: "close"
+        }, {
+            property: "preserveTerminalName"
+        }];
+        function from(config, context) {
+            let echo;
+            let reveal;
+            let revealProblems;
+            let focus;
+            let panel;
+            let showReuseMessage;
+            let clear;
+            let group;
+            let close;
+            let preserveTerminalName;
+            let hasProps = false;
+            if (isBoolean(config.echoCommand)) {
+                echo = config.echoCommand;
+                hasProps = true;
+            }
+            if (isString(config.showOutput)) {
+                reveal = RevealKind.fromString(config.showOutput);
+                hasProps = true;
+            }
+            const presentation = config.presentation || config.terminal;
+            if (presentation) {
+                if (isBoolean(presentation.echo)) {
+                    echo = presentation.echo;
+                }
+                if (isString(presentation.reveal)) {
+                    reveal = RevealKind.fromString(presentation.reveal);
+                }
+                if (isString(presentation.revealProblems)) {
+                    revealProblems = RevealProblemKind.fromString(presentation.revealProblems);
+                }
+                if (isBoolean(presentation.focus)) {
+                    focus = presentation.focus;
+                }
+                if (isString(presentation.panel)) {
+                    panel = PanelKind.fromString(presentation.panel);
+                }
+                if (isBoolean(presentation.showReuseMessage)) {
+                    showReuseMessage = presentation.showReuseMessage;
+                }
+                if (isBoolean(presentation.clear)) {
+                    clear = presentation.clear;
+                }
+                if (isString(presentation.group)) {
+                    group = presentation.group;
+                }
+                if (isBoolean(presentation.close)) {
+                    close = presentation.close;
+                }
+                if (isBoolean(presentation.preserveTerminalName)) {
+                    preserveTerminalName = presentation.preserveTerminalName;
+                }
+                hasProps = true;
+            }
+            if (!hasProps) {
+                return undefined;
+            }
+            return {
+                echo: echo,
+                reveal: reveal,
+                revealProblems: revealProblems,
+                focus: focus,
+                panel: panel,
+                showReuseMessage: showReuseMessage,
+                clear: clear,
+                group,
+                close: close,
+                preserveTerminalName
+            };
+        }
+        PresentationOptions.from = from;
+        function assignProperties(target, source) {
+            return _assignProperties(target, source, properties);
+        }
+        PresentationOptions.assignProperties = assignProperties;
+        function fillProperties(target, source) {
+            return _fillProperties(target, source, properties);
+        }
+        PresentationOptions.fillProperties = fillProperties;
+        function fillDefaults(value, context) {
+            const defaultEcho = context.engine === ExecutionEngine$1.Terminal ? true : false;
+            return _fillDefaults(value, {
+                echo: defaultEcho,
+                reveal: RevealKind.Always,
+                revealProblems: RevealProblemKind.Never,
+                focus: false,
+                panel: PanelKind.Shared,
+                showReuseMessage: true,
+                clear: false,
+                preserveTerminalName: false
+            }, properties, context);
+        }
+        PresentationOptions.fillDefaults = fillDefaults;
+        function freeze(value) {
+            return _freeze(value, properties);
+        }
+        PresentationOptions.freeze = freeze;
+        function isEmpty(value) {
+            return _isEmpty(value, properties);
+        }
+        PresentationOptions.isEmpty = isEmpty;
+    })(
+        PresentationOptions = CommandConfiguration.PresentationOptions || (CommandConfiguration.PresentationOptions = {})
+    );
+    let ShellString;
+    (function(ShellString) {
+        function from(value) {
+            if (value === undefined || value === null) {
+                return undefined;
+            }
+            if (isString(value)) {
+                return value;
+            } else if (isStringArray(value)) {
+                return value.join(" ");
+            } else {
+                const quoting = ShellQuoting$1.from(value.quoting);
+                const result = isString(value.value) ? value.value : isStringArray(value.value) ? value.value.join(" ") : undefined;
+                if (result) {
+                    return {
+                        value: result,
+                        quoting: quoting
+                    };
+                } else {
+                    return undefined;
+                }
+            }
+        }
+        ShellString.from = from;
+    })(ShellString || (ShellString = {}));
+    const properties = [{
+        property: "runtime"
+    }, {
+        property: "name"
+    }, {
+        property: "options",
+        type: CommandOptions
+    }, {
+        property: "args"
+    }, {
+        property: "taskSelector"
+    }, {
+        property: "suppressTaskName"
+    }, {
+        property: "presentation",
+        type: PresentationOptions
+    }];
+    function from(config, context) {
+        let result = fromBase(config, context);
+        let osConfig = undefined;
+        if (config.windows && context.platform === Platform.Windows) {
+            osConfig = fromBase(config.windows, context);
+        } else if (config.osx && context.platform === Platform.Mac) {
+            osConfig = fromBase(config.osx, context);
+        } else if (config.linux && context.platform === Platform.Linux) {
+            osConfig = fromBase(config.linux, context);
+        }
+        if (osConfig) {
+            result = assignProperties(result, osConfig, context.schemaVersion === JsonSchemaVersion$1.V2_0_0);
+        }
+        return isEmpty(result) ? undefined : result;
+    }
+    CommandConfiguration.from = from;
+    function fromBase(config, context) {
+        const name = ShellString.from(config.command);
+        let runtime;
+        if (isString(config.type)) {
+            if (config.type === "shell" || config.type === "process") {
+                runtime = RuntimeType.fromString(config.type);
+            }
+        }
+        if (isBoolean(config.isShellCommand) || ShellConfiguration.is(config.isShellCommand)) {
+            runtime = RuntimeType.Shell;
+        } else if (config.isShellCommand !== undefined) {
+            runtime = !!config.isShellCommand ? RuntimeType.Shell : RuntimeType.Process;
+        }
+        const result = {
+            name: name,
+            runtime: runtime,
+            presentation: PresentationOptions.from(config, context)
+        };
+        if (config.args !== undefined) {
+            result.args = [];
+            for (const arg of config.args) {
+                const converted = ShellString.from(arg);
+                if (converted !== undefined) {
+                    result.args.push(converted);
+                } else {
+                    context.taskLoadIssues.push(( localize(
+                        13228,
+                        "Error: command argument must either be a string or a quoted string. Provided value is:\n{0}",
+                        arg ? JSON.stringify(arg, undefined, 4) : "undefined"
+                    )));
+                }
+            }
+        }
+        if (config.options !== undefined) {
+            result.options = CommandOptions.from(config.options, context);
+            if (result.options && result.options.shell === undefined && ShellConfiguration.is(config.isShellCommand)) {
+                result.options.shell = ShellConfiguration.from(config.isShellCommand, context);
+                if (context.engine !== ExecutionEngine$1.Terminal) {
+                    context.taskLoadIssues.push(( localize(
+                        13229,
+                        "Warning: shell configuration is only supported when executing tasks in the terminal."
+                    )));
+                }
+            }
+        }
+        if (isString(config.taskSelector)) {
+            result.taskSelector = config.taskSelector;
+        }
+        if (isBoolean(config.suppressTaskName)) {
+            result.suppressTaskName = config.suppressTaskName;
+        }
+        return isEmpty(result) ? undefined : result;
+    }
+    function hasCommand(value) {
+        return value && !!value.name;
+    }
+    CommandConfiguration.hasCommand = hasCommand;
+    function isEmpty(value) {
+        return _isEmpty(value, properties);
+    }
+    CommandConfiguration.isEmpty = isEmpty;
+    function assignProperties(target, source, overwriteArgs) {
+        if (isEmpty(source)) {
+            return target;
+        }
+        if (isEmpty(target)) {
+            return source;
+        }
+        assignProperty(target, source, "name");
+        assignProperty(target, source, "runtime");
+        assignProperty(target, source, "taskSelector");
+        assignProperty(target, source, "suppressTaskName");
+        if (source.args !== undefined) {
+            if (target.args === undefined || overwriteArgs) {
+                target.args = source.args;
+            } else {
+                target.args = target.args.concat(source.args);
+            }
+        }
+        target.presentation = PresentationOptions.assignProperties(target.presentation, source.presentation);
+        target.options = CommandOptions.assignProperties(target.options, source.options);
+        return target;
+    }
+    CommandConfiguration.assignProperties = assignProperties;
+    function fillProperties(target, source) {
+        return _fillProperties(target, source, properties);
+    }
+    CommandConfiguration.fillProperties = fillProperties;
+    function fillGlobals(target, source, taskName) {
+        if ((source === undefined) || isEmpty(source)) {
+            return target;
+        }
+        target = target || {
+            name: undefined,
+            runtime: undefined,
+            presentation: undefined
+        };
+        if (target.name === undefined) {
+            fillProperty(target, source, "name");
+            fillProperty(target, source, "taskSelector");
+            fillProperty(target, source, "suppressTaskName");
+            let args = source.args ? source.args.slice() : [];
+            if (!target.suppressTaskName && taskName) {
+                if (target.taskSelector !== undefined) {
+                    args.push(target.taskSelector + taskName);
+                } else {
+                    args.push(taskName);
+                }
+            }
+            if (target.args) {
+                args = args.concat(target.args);
+            }
+            target.args = args;
+        }
+        fillProperty(target, source, "runtime");
+        target.presentation = PresentationOptions.fillProperties(target.presentation, source.presentation);
+        target.options = CommandOptions.fillProperties(target.options, source.options);
+        return target;
+    }
+    CommandConfiguration.fillGlobals = fillGlobals;
+    function fillDefaults(value, context) {
+        if (!value || Object.isFrozen(value)) {
+            return;
+        }
+        if (value.name !== undefined && value.runtime === undefined) {
+            value.runtime = RuntimeType.Process;
+        }
+        value.presentation = PresentationOptions.fillDefaults(value.presentation, context);
+        if (!isEmpty(value)) {
+            value.options = CommandOptions.fillDefaults(value.options, context);
+        }
+        if (value.args === undefined) {
+            value.args = EMPTY_ARRAY;
+        }
+        if (value.suppressTaskName === undefined) {
+            value.suppressTaskName = (context.schemaVersion === JsonSchemaVersion$1.V2_0_0);
+        }
+    }
+    CommandConfiguration.fillDefaults = fillDefaults;
+    function freeze(value) {
+        return _freeze(value, properties);
+    }
+    CommandConfiguration.freeze = freeze;
+})(CommandConfiguration || (CommandConfiguration = {}));
+var ProblemMatcherConverter;
+(function(ProblemMatcherConverter) {
+    function namedFrom(declares, context) {
+        const result = Object.create(null);
+        if (!Array.isArray(declares)) {
+            return result;
+        }
+        declares.forEach(value => {
+            const namedProblemMatcher = ( new ProblemMatcherParser(context.problemReporter)).parse(value);
+            if (isNamedProblemMatcher(namedProblemMatcher)) {
+                result[namedProblemMatcher.name] = namedProblemMatcher;
+            } else {
+                context.problemReporter.error(( localize(
+                    13230,
+                    "Error: Problem Matcher in declare scope must have a name:\n{0}\n",
+                    JSON.stringify(value, undefined, 4)
+                )));
+            }
+        });
+        return result;
+    }
+    ProblemMatcherConverter.namedFrom = namedFrom;
+    function fromWithOsConfig(external, context) {
+        let result = {};
+        const osExternal = external;
+        if (osExternal.windows?.problemMatcher && context.platform === Platform.Windows) {
+            result = from(osExternal.windows.problemMatcher, context);
+        } else if (osExternal.osx?.problemMatcher && context.platform === Platform.Mac) {
+            result = from(osExternal.osx.problemMatcher, context);
+        } else if (osExternal.linux?.problemMatcher && context.platform === Platform.Linux) {
+            result = from(osExternal.linux.problemMatcher, context);
+        } else if (external.problemMatcher) {
+            result = from(external.problemMatcher, context);
+        }
+        return result;
+    }
+    ProblemMatcherConverter.fromWithOsConfig = fromWithOsConfig;
+    function from(config, context) {
+        const result = [];
+        if (config === undefined) {
+            return {
+                value: result
+            };
+        }
+        const errors = [];
+        function addResult(matcher) {
+            if (matcher.value) {
+                result.push(matcher.value);
+            }
+            if (matcher.errors) {
+                errors.push(...matcher.errors);
+            }
+        }
+        const kind = getProblemMatcherKind(config);
+        if (kind === ProblemMatcherKind.Unknown) {
+            const error = ( localize(
+                13231,
+                "Warning: the defined problem matcher is unknown. Supported types are string | ProblemMatcher | Array<string | ProblemMatcher>.\n{0}\n",
+                JSON.stringify(config, null, 4)
+            ));
+            context.problemReporter.warn(error);
+        } else if (kind === ProblemMatcherKind.String || kind === ProblemMatcherKind.ProblemMatcher) {
+            addResult(resolveProblemMatcher(config, context));
+        } else if (kind === ProblemMatcherKind.Array) {
+            const problemMatchers = config;
+            problemMatchers.forEach(problemMatcher => {
+                addResult(resolveProblemMatcher(problemMatcher, context));
+            });
+        }
+        return {
+            value: result,
+            errors
+        };
+    }
+    ProblemMatcherConverter.from = from;
+    function getProblemMatcherKind(value) {
+        if (isString(value)) {
+            return ProblemMatcherKind.String;
+        } else if (Array.isArray(value)) {
+            return ProblemMatcherKind.Array;
+        } else if (!isUndefined(value)) {
+            return ProblemMatcherKind.ProblemMatcher;
+        } else {
+            return ProblemMatcherKind.Unknown;
+        }
+    }
+    function resolveProblemMatcher(value, context) {
+        if (isString(value)) {
+            let variableName = value;
+            if (variableName.length > 1 && variableName[0] === "$") {
+                variableName = variableName.substring(1);
+                const global = ProblemMatcherRegistry.get(variableName);
+                if (global) {
+                    return {
+                        value: deepClone(global)
+                    };
+                }
+                let localProblemMatcher = context.namedProblemMatchers[variableName];
+                if (localProblemMatcher) {
+                    localProblemMatcher = deepClone(localProblemMatcher);
+                    delete localProblemMatcher.name;
+                    return {
+                        value: localProblemMatcher
+                    };
+                }
+            }
+            return {
+                errors: [( localize(13232, "Error: Invalid problemMatcher reference: {0}\n", value))]
+            };
+        } else {
+            const json = value;
+            return {
+                value: ( new ProblemMatcherParser(context.problemReporter)).parse(json)
+            };
+        }
+    }
+})(ProblemMatcherConverter || (ProblemMatcherConverter = {}));
+var GroupKind;
+(function(GroupKind) {
+    function from(external) {
+        if (external === undefined) {
+            return undefined;
+        } else if (isString(external) && TaskGroup.is(external)) {
+            return {
+                _id: external,
+                isDefault: false
+            };
+        } else if (isString(external.kind) && TaskGroup.is(external.kind)) {
+            const group = external.kind;
+            const isDefault = isUndefined(external.isDefault) ? false : external.isDefault;
+            return {
+                _id: group,
+                isDefault
+            };
+        }
+        return undefined;
+    }
+    GroupKind.from = from;
+    function to(group) {
+        if (isString(group)) {
+            return group;
+        } else if (!group.isDefault) {
+            return group._id;
+        }
+        return {
+            kind: group._id,
+            isDefault: group.isDefault
+        };
+    }
+    GroupKind.to = to;
+})(GroupKind || (GroupKind = {}));
+var TaskDependency;
+(function(TaskDependency) {
+    function uriFromSource(context, source) {
+        switch (source) {
+        case TaskConfigSource.User:
+            return USER_TASKS_GROUP_KEY;
+        case TaskConfigSource.TasksJson:
+            return context.workspaceFolder.uri;
+        default:
+            return context.workspace && context.workspace.configuration ? context.workspace.configuration : context.workspaceFolder.uri;
+        }
+    }
+    function from(external, context, source) {
+        if (isString(external)) {
+            return {
+                uri: uriFromSource(context, source),
+                task: external
+            };
+        } else if (ITaskIdentifier.is(external)) {
+            return {
+                uri: uriFromSource(context, source),
+                task: TaskDefinition.createTaskIdentifier(external, context.problemReporter)
+            };
+        } else {
+            return undefined;
+        }
+    }
+    TaskDependency.from = from;
+})(TaskDependency || (TaskDependency = {}));
+var DependsOrder;
+(function(DependsOrder) {
+    function from(order) {
+        switch (order) {
+        case DependsOrder$1.sequence:
+            return DependsOrder$1.sequence;
+        case DependsOrder$1.parallel:
+        default:
+            return DependsOrder$1.parallel;
+        }
+    }
+    DependsOrder.from = from;
+})(DependsOrder || (DependsOrder = {}));
+var ConfigurationProperties;
+(function(ConfigurationProperties) {
+    const properties = [{
+        property: "name"
+    }, {
+        property: "identifier"
+    }, {
+        property: "group"
+    }, {
+        property: "isBackground"
+    }, {
+        property: "promptOnClose"
+    }, {
+        property: "dependsOn"
+    }, {
+        property: "presentation",
+        type: CommandConfiguration.PresentationOptions
+    }, {
+        property: "problemMatchers"
+    }, {
+        property: "options"
+    }, {
+        property: "icon"
+    }, {
+        property: "hide"
+    }, {
+        property: "inSessions"
+    }];
+    function from(external, context, includeCommandOptions, source, properties) {
+        if (!external) {
+            return {};
+        }
+        const result = {};
+        if (properties) {
+            for (const propertyName of ( Object.keys(properties))) {
+                if (external[propertyName] !== undefined) {
+                    result[propertyName] = deepClone(external[propertyName]);
+                }
+            }
+        }
+        if (isString(external.taskName)) {
+            result.name = external.taskName;
+        }
+        if (isString(external.label) && context.schemaVersion === JsonSchemaVersion$1.V2_0_0) {
+            result.name = external.label;
+        }
+        if (isString(external.identifier)) {
+            result.identifier = external.identifier;
+        }
+        result.icon = external.icon;
+        result.hide = external.hide;
+        result.inSessions = external.inSessions;
+        if (external.isBackground !== undefined) {
+            result.isBackground = !!external.isBackground;
+        }
+        if (external.promptOnClose !== undefined) {
+            result.promptOnClose = !!external.promptOnClose;
+        }
+        result.group = GroupKind.from(external.group);
+        if (external.dependsOn !== undefined) {
+            if (Array.isArray(external.dependsOn)) {
+                result.dependsOn = external.dependsOn.reduce((dependencies, item) => {
+                    const dependency = TaskDependency.from(item, context, source);
+                    if (dependency) {
+                        dependencies.push(dependency);
+                    }
+                    return dependencies;
+                }, []);
+            } else {
+                const dependsOnValue = TaskDependency.from(external.dependsOn, context, source);
+                result.dependsOn = dependsOnValue ? [dependsOnValue] : undefined;
+            }
+        }
+        result.dependsOrder = DependsOrder.from(external.dependsOrder);
+        if (includeCommandOptions && (external.presentation !== undefined || external.terminal !== undefined)) {
+            result.presentation = CommandConfiguration.PresentationOptions.from(external, context);
+        }
+        if (includeCommandOptions && (external.options !== undefined)) {
+            result.options = CommandOptions.from(external.options, context);
+        }
+        const configProblemMatcher = ProblemMatcherConverter.fromWithOsConfig(external, context);
+        if (configProblemMatcher.value !== undefined) {
+            result.problemMatchers = configProblemMatcher.value;
+        }
+        if (external.detail) {
+            result.detail = external.detail;
+        }
+        return isEmpty(result) ? {} : {
+            value: result,
+            errors: configProblemMatcher.errors
+        };
+    }
+    ConfigurationProperties.from = from;
+    function isEmpty(value) {
+        return _isEmpty(value, properties);
+    }
+    ConfigurationProperties.isEmpty = isEmpty;
+})(ConfigurationProperties || (ConfigurationProperties = {}));
+const label = "Workspace";
+var ConfiguringTask;
+(function(ConfiguringTask) {
+    const grunt = "grunt.";
+    const jake = "jake.";
+    const gulp = "gulp.";
+    const npm = "vscode.npm.";
+    const typescript = "vscode.typescript.";
+    function from(external, context, index, source, registry) {
+        if (!external) {
+            return undefined;
+        }
+        const type = external.type;
+        const customize = external.customize;
+        if (!type && !customize) {
+            context.problemReporter.error(( localize(
+                13233,
+                "Error: tasks configuration must have a type property. The configuration will be ignored.\n{0}\n",
+                JSON.stringify(external, null, 4)
+            )));
+            return undefined;
+        }
+        const typeDeclaration = type ? registry?.get?.(type) || TaskDefinitionRegistry.get(type) : undefined;
+        if (!typeDeclaration) {
+            const message = ( localize(
+                13234,
+                "Error: there is no registered task type '{0}'. Did you miss installing an extension that provides a corresponding task provider?",
+                type
+            ));
+            context.problemReporter.error(message);
+            return undefined;
+        }
+        let identifier;
+        if (isString(customize)) {
+            if (customize.indexOf(grunt) === 0) {
+                identifier = {
+                    type: "grunt",
+                    task: customize.substring(grunt.length)
+                };
+            } else if (customize.indexOf(jake) === 0) {
+                identifier = {
+                    type: "jake",
+                    task: customize.substring(jake.length)
+                };
+            } else if (customize.indexOf(gulp) === 0) {
+                identifier = {
+                    type: "gulp",
+                    task: customize.substring(gulp.length)
+                };
+            } else if (customize.indexOf(npm) === 0) {
+                identifier = {
+                    type: "npm",
+                    script: customize.substring(npm.length + 4)
+                };
+            } else if (customize.indexOf(typescript) === 0) {
+                identifier = {
+                    type: "typescript",
+                    tsconfig: customize.substring(typescript.length + 6)
+                };
+            }
+        } else {
+            if (isString(external.type)) {
+                identifier = external;
+            }
+        }
+        if (identifier === undefined) {
+            context.problemReporter.error(( localize(
+                13235,
+                "Error: the task configuration '{0}' is missing the required property 'type'. The task configuration will be ignored.",
+                JSON.stringify(external, undefined, 0)
+            )));
+            return undefined;
+        }
+        const taskIdentifier = TaskDefinition.createTaskIdentifier(identifier, context.problemReporter);
+        if (taskIdentifier === undefined) {
+            context.problemReporter.error(( localize(
+                13236,
+                "Error: the task configuration '{0}' is using an unknown type. The task configuration will be ignored.",
+                JSON.stringify(external, undefined, 0)
+            )));
+            return undefined;
+        }
+        const configElement = {
+            workspaceFolder: context.workspaceFolder,
+            file: ".vscode/tasks.json",
+            index,
+            element: external
+        };
+        let taskSource;
+        switch (source) {
+        case TaskConfigSource.User:
+            {
+                taskSource = {
+                    kind: TaskSourceKind.User,
+                    config: configElement,
+                    label
+                };
+                break;
+            }
+        case TaskConfigSource.WorkspaceFile:
+            {
+                taskSource = {
+                    kind: TaskSourceKind.WorkspaceFile,
+                    config: configElement,
+                    label
+                };
+                break;
+            }
+        default:
+            {
+                taskSource = {
+                    kind: TaskSourceKind.Workspace,
+                    config: configElement,
+                    label
+                };
+                break;
+            }
+        }
+        const result = new ConfiguringTask$1(
+            `${typeDeclaration.extensionId}.${taskIdentifier._key}`,
+            taskSource,
+            undefined,
+            type,
+            taskIdentifier,
+            RunOptions.fromConfiguration(external.runOptions),
+            {
+                hide: external.hide,
+                inSessions: external.inSessions
+            }
+        );
+        const configuration = ConfigurationProperties.from(external, context, true, source, typeDeclaration.properties);
+        result.addTaskLoadMessages(configuration.errors);
+        if (configuration.value) {
+            result.configurationProperties = Object.assign(result.configurationProperties, configuration.value);
+            if (result.configurationProperties.name) {
+                result._label = result.configurationProperties.name;
+            } else {
+                let label = result.configures.type;
+                if (typeDeclaration.required && typeDeclaration.required.length > 0) {
+                    for (const required of typeDeclaration.required) {
+                        const value = result.configures[required];
+                        if (value) {
+                            label = label + ": " + value;
+                            break;
+                        }
+                    }
+                }
+                result._label = label;
+            }
+            if (!result.configurationProperties.identifier) {
+                result.configurationProperties.identifier = taskIdentifier._key;
+            }
+        }
+        return result;
+    }
+    ConfiguringTask.from = from;
+})(ConfiguringTask || (ConfiguringTask = {}));
+var CustomTask;
+(function(CustomTask) {
+    function from(external, context, index, source) {
+        if (!external) {
+            return undefined;
+        }
+        let type = external.type;
+        if (type === undefined || type === null) {
+            type = CUSTOMIZED_TASK_TYPE;
+        }
+        if (type !== CUSTOMIZED_TASK_TYPE && type !== "shell" && type !== "process") {
+            context.problemReporter.error(( localize(
+                13237,
+                "Error: tasks is not declared as a custom task. The configuration will be ignored.\n{0}\n",
+                JSON.stringify(external, null, 4)
+            )));
+            return undefined;
+        }
+        let taskName = external.taskName;
+        if (isString(external.label) && context.schemaVersion === JsonSchemaVersion$1.V2_0_0) {
+            taskName = external.label;
+        }
+        if (!taskName) {
+            context.problemReporter.error(( localize(
+                13238,
+                "Error: a task must provide a label property. The task will be ignored.\n{0}\n",
+                JSON.stringify(external, null, 4)
+            )));
+            return undefined;
+        }
+        let taskSource;
+        switch (source) {
+        case TaskConfigSource.User:
+            {
+                taskSource = {
+                    kind: TaskSourceKind.User,
+                    config: {
+                        index,
+                        element: external,
+                        file: ".vscode/tasks.json",
+                        workspaceFolder: context.workspaceFolder
+                    },
+                    label
+                };
+                break;
+            }
+        case TaskConfigSource.WorkspaceFile:
+            {
+                taskSource = {
+                    kind: TaskSourceKind.WorkspaceFile,
+                    config: {
+                        index,
+                        element: external,
+                        file: ".vscode/tasks.json",
+                        workspaceFolder: context.workspaceFolder,
+                        workspace: context.workspace
+                    },
+                    label
+                };
+                break;
+            }
+        default:
+            {
+                taskSource = {
+                    kind: TaskSourceKind.Workspace,
+                    config: {
+                        index,
+                        element: external,
+                        file: ".vscode/tasks.json",
+                        workspaceFolder: context.workspaceFolder
+                    },
+                    label
+                };
+                break;
+            }
+        }
+        const result = new CustomTask$1(
+            context.uuidMap.getUUID(taskName),
+            taskSource,
+            taskName,
+            CUSTOMIZED_TASK_TYPE,
+            undefined,
+            false,
+            RunOptions.fromConfiguration(external.runOptions),
+            {
+                name: taskName,
+                identifier: taskName
+            }
+        );
+        const configuration = ConfigurationProperties.from(external, context, false, source);
+        result.addTaskLoadMessages(configuration.errors);
+        if (configuration.value) {
+            result.configurationProperties = Object.assign(result.configurationProperties, configuration.value);
+        }
+        {
+            const legacy = external;
+            if (result.configurationProperties.isBackground === undefined && legacy.isWatching !== undefined) {
+                result.configurationProperties.isBackground = !!legacy.isWatching;
+            }
+            if (result.configurationProperties.group === undefined) {
+                if (legacy.isBuildCommand === true) {
+                    result.configurationProperties.group = TaskGroup.Build;
+                } else if (legacy.isTestCommand === true) {
+                    result.configurationProperties.group = TaskGroup.Test;
+                }
+            }
+        }
+        const command = CommandConfiguration.from(external, context);
+        if (command) {
+            result.command = command;
+        }
+        if (external.command !== undefined) {
+            command.suppressTaskName = true;
+        }
+        return result;
+    }
+    CustomTask.from = from;
+    function fillGlobals(task, globals) {
+        if (CommandConfiguration.hasCommand(task.command) || task.configurationProperties.dependsOn === undefined) {
+            task.command = CommandConfiguration.fillGlobals(task.command, globals.command, task.configurationProperties.name);
+        }
+        if (task.configurationProperties.problemMatchers === undefined && globals.problemMatcher !== undefined) {
+            task.configurationProperties.problemMatchers = deepClone(globals.problemMatcher);
+            task.hasDefinedMatchers = true;
+        }
+        if (task.configurationProperties.promptOnClose === undefined && task.configurationProperties.isBackground === undefined && globals.promptOnClose !== undefined) {
+            task.configurationProperties.promptOnClose = globals.promptOnClose;
+        }
+    }
+    CustomTask.fillGlobals = fillGlobals;
+    function fillDefaults(task, context) {
+        CommandConfiguration.fillDefaults(task.command, context);
+        if (task.configurationProperties.promptOnClose === undefined) {
+            task.configurationProperties.promptOnClose = task.configurationProperties.isBackground !== undefined ? !task.configurationProperties.isBackground : true;
+        }
+        if (task.configurationProperties.isBackground === undefined) {
+            task.configurationProperties.isBackground = false;
+        }
+        if (task.configurationProperties.problemMatchers === undefined) {
+            task.configurationProperties.problemMatchers = EMPTY_ARRAY;
+        }
+    }
+    CustomTask.fillDefaults = fillDefaults;
+    function createCustomTask(contributedTask, configuredProps) {
+        const result = new CustomTask$1(configuredProps._id, Object.assign({}, configuredProps._source, {
+            customizes: contributedTask.defines
+        }), configuredProps.configurationProperties.name || contributedTask._label, CUSTOMIZED_TASK_TYPE, contributedTask.command, false, contributedTask.runOptions, {
+            name: configuredProps.configurationProperties.name || contributedTask.configurationProperties.name,
+            identifier: configuredProps.configurationProperties.identifier || contributedTask.configurationProperties.identifier,
+            icon: configuredProps.configurationProperties.icon,
+            hide: configuredProps.configurationProperties.hide,
+            inSessions: configuredProps.configurationProperties.inSessions
+        });
+        result.addTaskLoadMessages(configuredProps.taskLoadMessages);
+        const resultConfigProps = result.configurationProperties;
+        assignProperty(resultConfigProps, configuredProps.configurationProperties, "group");
+        assignProperty(resultConfigProps, configuredProps.configurationProperties, "isBackground");
+        assignProperty(resultConfigProps, configuredProps.configurationProperties, "dependsOn");
+        assignProperty(
+            resultConfigProps,
+            configuredProps.configurationProperties,
+            "problemMatchers"
+        );
+        assignProperty(
+            resultConfigProps,
+            configuredProps.configurationProperties,
+            "promptOnClose"
+        );
+        assignProperty(resultConfigProps, configuredProps.configurationProperties, "detail");
+        result.command.presentation = CommandConfiguration.PresentationOptions.assignProperties(
+            result.command.presentation,
+            configuredProps.configurationProperties.presentation
+        );
+        result.command.options = CommandOptions.assignProperties(result.command.options, configuredProps.configurationProperties.options);
+        result.runOptions = RunOptions.assignProperties(result.runOptions, configuredProps.runOptions);
+        const contributedConfigProps = contributedTask.configurationProperties;
+        fillProperty(resultConfigProps, contributedConfigProps, "group");
+        fillProperty(resultConfigProps, contributedConfigProps, "isBackground");
+        fillProperty(resultConfigProps, contributedConfigProps, "dependsOn");
+        fillProperty(resultConfigProps, contributedConfigProps, "problemMatchers");
+        fillProperty(resultConfigProps, contributedConfigProps, "promptOnClose");
+        fillProperty(resultConfigProps, contributedConfigProps, "detail");
+        result.command.presentation = CommandConfiguration.PresentationOptions.fillProperties(result.command.presentation, contributedConfigProps.presentation);
+        result.command.options = CommandOptions.fillProperties(result.command.options, contributedConfigProps.options);
+        result.runOptions = RunOptions.fillProperties(result.runOptions, contributedTask.runOptions);
+        if (contributedTask.hasDefinedMatchers === true) {
+            result.hasDefinedMatchers = true;
+        }
+        return result;
+    }
+    CustomTask.createCustomTask = createCustomTask;
+})(CustomTask || (CustomTask = {}));
+var TaskParser;
+(function(TaskParser) {
+    function isCustomTask(value) {
+        const type = value.type;
+        const customize = value.customize;
+        return customize === undefined && (type === undefined || type === null || type === CUSTOMIZED_TASK_TYPE || type === "shell" || type === "process");
+    }
+    const builtinTypeContextMap = {
+        shell: ShellExecutionSupportedContext,
+        process: ProcessExecutionSupportedContext
+    };
+    function from(externals, globals, context, source, registry) {
+        const result = {
+            custom: [],
+            configured: []
+        };
+        if (!externals) {
+            return result;
+        }
+        const defaultBuildTask = {
+            task: undefined,
+            rank: -1
+        };
+        const defaultTestTask = {
+            task: undefined,
+            rank: -1
+        };
+        const schema2_0_0 = context.schemaVersion === JsonSchemaVersion$1.V2_0_0;
+        const baseLoadIssues = deepClone(context.taskLoadIssues);
+        for (let index = 0; index < externals.length; index++) {
+            const external = externals[index];
+            const definition = external.type ? registry?.get?.(external.type) || TaskDefinitionRegistry.get(external.type) : undefined;
+            let typeNotSupported = false;
+            if (definition && definition.when && !context.contextKeyService.contextMatchesRules(definition.when)) {
+                typeNotSupported = true;
+            } else if (!definition && external.type) {
+                for (const key of ( Object.keys(builtinTypeContextMap))) {
+                    if (external.type === key) {
+                        typeNotSupported = !ShellExecutionSupportedContext.evaluate(context.contextKeyService.getContext(null));
+                        break;
+                    }
+                }
+            }
+            if (typeNotSupported) {
+                context.problemReporter.info(( localize(
+                    13239,
+                    "Warning: {0} tasks are unavailable in the current environment.\n",
+                    external.type
+                )));
+                continue;
+            }
+            if (isCustomTask(external)) {
+                const customTask = CustomTask.from(external, context, index, source);
+                if (customTask) {
+                    CustomTask.fillGlobals(customTask, globals);
+                    CustomTask.fillDefaults(customTask, context);
+                    if (schema2_0_0) {
+                        if ((customTask.command === undefined || customTask.command.name === undefined) && (customTask.configurationProperties.dependsOn === undefined || customTask.configurationProperties.dependsOn.length === 0)) {
+                            context.problemReporter.error(( localize(
+                                13240,
+                                "Error: the task '{0}' neither specifies a command nor a dependsOn property. The task will be ignored. Its definition is:\n{1}",
+                                customTask.configurationProperties.name,
+                                JSON.stringify(external, undefined, 4)
+                            )));
+                            continue;
+                        }
+                    } else {
+                        if (customTask.command === undefined || customTask.command.name === undefined) {
+                            context.problemReporter.warn(( localize(
+                                13241,
+                                "Error: the task '{0}' doesn't define a command. The task will be ignored. Its definition is:\n{1}",
+                                customTask.configurationProperties.name,
+                                JSON.stringify(external, undefined, 4)
+                            )));
+                            continue;
+                        }
+                    }
+                    if (customTask.configurationProperties.group === TaskGroup.Build && defaultBuildTask.rank < 2) {
+                        defaultBuildTask.task = customTask;
+                        defaultBuildTask.rank = 2;
+                    } else if (customTask.configurationProperties.group === TaskGroup.Test && defaultTestTask.rank < 2) {
+                        defaultTestTask.task = customTask;
+                        defaultTestTask.rank = 2;
+                    } else if (customTask.configurationProperties.name === "build" && defaultBuildTask.rank < 1) {
+                        defaultBuildTask.task = customTask;
+                        defaultBuildTask.rank = 1;
+                    } else if (customTask.configurationProperties.name === "test" && defaultTestTask.rank < 1) {
+                        defaultTestTask.task = customTask;
+                        defaultTestTask.rank = 1;
+                    }
+                    customTask.addTaskLoadMessages(context.taskLoadIssues);
+                    result.custom.push(customTask);
+                }
+            } else {
+                const configuredTask = ConfiguringTask.from(external, context, index, source, registry);
+                if (configuredTask) {
+                    configuredTask.addTaskLoadMessages(context.taskLoadIssues);
+                    result.configured.push(configuredTask);
+                }
+            }
+            context.taskLoadIssues = deepClone(baseLoadIssues);
+        }
+        const defaultBuildGroupName = isString(defaultBuildTask.task?.configurationProperties.group) ? defaultBuildTask.task?.configurationProperties.group : defaultBuildTask.task?.configurationProperties.group?._id;
+        const defaultTestTaskGroupName = isString(defaultTestTask.task?.configurationProperties.group) ? defaultTestTask.task?.configurationProperties.group : defaultTestTask.task?.configurationProperties.group?._id;
+        if ((defaultBuildGroupName !== TaskGroup.Build._id) && (defaultBuildTask.rank > -1) && (defaultBuildTask.rank < 2) && defaultBuildTask.task) {
+            defaultBuildTask.task.configurationProperties.group = TaskGroup.Build;
+        } else if ((defaultTestTaskGroupName !== TaskGroup.Test._id) && (defaultTestTask.rank > -1) && (defaultTestTask.rank < 2) && defaultTestTask.task) {
+            defaultTestTask.task.configurationProperties.group = TaskGroup.Test;
+        }
+        return result;
+    }
+    TaskParser.from = from;
+    function assignTasks(target, source) {
+        if (source === undefined || source.length === 0) {
+            return target;
+        }
+        if (target === undefined || target.length === 0) {
+            return source;
+        }
+        if (source) {
+            const map = Object.create(null);
+            target.forEach(task => {
+                map[task.configurationProperties.name] = task;
+            });
+            source.forEach(task => {
+                map[task.configurationProperties.name] = task;
+            });
+            const newTarget = [];
+            target.forEach(task => {
+                newTarget.push(map[task.configurationProperties.name]);
+                delete map[task.configurationProperties.name];
+            });
+            ( Object.keys(map)).forEach(key => newTarget.push(map[key]));
+            target = newTarget;
+        }
+        return target;
+    }
+    TaskParser.assignTasks = assignTasks;
+})(TaskParser || (TaskParser = {}));
+var Globals;
+(function(Globals) {
+    function from(config, context) {
+        let result = fromBase(config, context);
+        let osGlobals = undefined;
+        if (config.windows && context.platform === Platform.Windows) {
+            osGlobals = fromBase(config.windows, context);
+        } else if (config.osx && context.platform === Platform.Mac) {
+            osGlobals = fromBase(config.osx, context);
+        } else if (config.linux && context.platform === Platform.Linux) {
+            osGlobals = fromBase(config.linux, context);
+        }
+        if (osGlobals) {
+            result = Globals.assignProperties(result, osGlobals);
+        }
+        const command = CommandConfiguration.from(config, context);
+        if (command) {
+            result.command = command;
+        }
+        Globals.fillDefaults(result, context);
+        Globals.freeze(result);
+        return result;
+    }
+    Globals.from = from;
+    function fromBase(config, context) {
+        const result = {};
+        if (config.suppressTaskName !== undefined) {
+            result.suppressTaskName = !!config.suppressTaskName;
+        }
+        if (config.promptOnClose !== undefined) {
+            result.promptOnClose = !!config.promptOnClose;
+        }
+        if (config.problemMatcher) {
+            result.problemMatcher = ProblemMatcherConverter.from(config.problemMatcher, context).value;
+        }
+        return result;
+    }
+    Globals.fromBase = fromBase;
+    function isEmpty(value) {
+        return !value || value.command === undefined && value.promptOnClose === undefined && value.suppressTaskName === undefined;
+    }
+    Globals.isEmpty = isEmpty;
+    function assignProperties(target, source) {
+        if (isEmpty(source)) {
+            return target;
+        }
+        if (isEmpty(target)) {
+            return source;
+        }
+        assignProperty(target, source, "promptOnClose");
+        assignProperty(target, source, "suppressTaskName");
+        return target;
+    }
+    Globals.assignProperties = assignProperties;
+    function fillDefaults(value, context) {
+        if (!value) {
+            return;
+        }
+        CommandConfiguration.fillDefaults(value.command, context);
+        if (value.suppressTaskName === undefined) {
+            value.suppressTaskName = (context.schemaVersion === JsonSchemaVersion$1.V2_0_0);
+        }
+        if (value.promptOnClose === undefined) {
+            value.promptOnClose = true;
+        }
+    }
+    Globals.fillDefaults = fillDefaults;
+    function freeze(value) {
+        if (value.command) {
+            CommandConfiguration.freeze(value.command);
+        }
+    }
+    Globals.freeze = freeze;
+})(Globals || (Globals = {}));
+var ExecutionEngine;
+(function(ExecutionEngine) {
+    function from(config) {
+        const runner = config.runner || config._runner;
+        let result;
+        if (runner) {
+            switch (runner) {
+            case "terminal":
+                result = ExecutionEngine$1.Terminal;
+                break;
+            case "process":
+                result = ExecutionEngine$1.Process;
+                break;
+            }
+        }
+        const schemaVersion = JsonSchemaVersion.from(config);
+        if (schemaVersion === JsonSchemaVersion$1.V0_1_0) {
+            return result || ExecutionEngine$1.Process;
+        } else if (schemaVersion === JsonSchemaVersion$1.V2_0_0) {
+            return ExecutionEngine$1.Terminal;
+        } else {
+            throw ( new Error("Shouldn't happen."));
+        }
+    }
+    ExecutionEngine.from = from;
+})(ExecutionEngine || (ExecutionEngine = {}));
+var JsonSchemaVersion;
+(function(JsonSchemaVersion) {
+    const _default = JsonSchemaVersion$1.V2_0_0;
+    function from(config) {
+        const version = config.version;
+        if (!version) {
+            return _default;
+        }
+        switch (version) {
+        case "0.1.0":
+            return JsonSchemaVersion$1.V0_1_0;
+        case "2.0.0":
+            return JsonSchemaVersion$1.V2_0_0;
+        default:
+            return _default;
+        }
+    }
+    JsonSchemaVersion.from = from;
+})(JsonSchemaVersion || (JsonSchemaVersion = {}));
+class UUIDMap {
+    constructor(other) {
+        this.current = Object.create(null);
+        if (other) {
+            for (const key of ( Object.keys(other.current))) {
+                const value = other.current[key];
+                if (Array.isArray(value)) {
+                    this.current[key] = value.slice();
+                } else {
+                    this.current[key] = value;
+                }
+            }
+        }
+    }
+    start() {
+        this.last = this.current;
+        this.current = Object.create(null);
+    }
+    getUUID(identifier) {
+        const lastValue = this.last ? this.last[identifier] : undefined;
+        let result = undefined;
+        if (lastValue !== undefined) {
+            if (Array.isArray(lastValue)) {
+                result = lastValue.shift();
+                if (lastValue.length === 0) {
+                    delete this.last[identifier];
+                }
+            } else {
+                result = lastValue;
+                delete this.last[identifier];
+            }
+        }
+        if (result === undefined) {
+            result = generateUuid();
+        }
+        const currentValue = this.current[identifier];
+        if (currentValue === undefined) {
+            this.current[identifier] = result;
+        } else {
+            if (Array.isArray(currentValue)) {
+                currentValue.push(result);
+            } else {
+                const arrayValue = [currentValue];
+                arrayValue.push(result);
+                this.current[identifier] = arrayValue;
+            }
+        }
+        return result;
+    }
+    finish() {
+        this.last = undefined;
+    }
+}
+var TaskConfigSource;
+(function(TaskConfigSource) {
+    TaskConfigSource[TaskConfigSource["TasksJson"] = 0] = "TasksJson";
+    TaskConfigSource[TaskConfigSource["WorkspaceFile"] = 1] = "WorkspaceFile";
+    TaskConfigSource[TaskConfigSource["User"] = 2] = "User";
+})(TaskConfigSource || (TaskConfigSource = {}));
+class ConfigurationParser {
+    constructor(workspaceFolder, workspace, platform, problemReporter, uuidMap) {
+        this.workspaceFolder = workspaceFolder;
+        this.workspace = workspace;
+        this.platform = platform;
+        this.problemReporter = problemReporter;
+        this.uuidMap = uuidMap;
+    }
+    run(fileConfig, source, contextKeyService) {
+        const engine = ExecutionEngine.from(fileConfig);
+        const schemaVersion = JsonSchemaVersion.from(fileConfig);
+        const context = {
+            workspaceFolder: this.workspaceFolder,
+            workspace: this.workspace,
+            problemReporter: this.problemReporter,
+            uuidMap: this.uuidMap,
+            namedProblemMatchers: {},
+            engine,
+            schemaVersion,
+            platform: this.platform,
+            taskLoadIssues: [],
+            contextKeyService
+        };
+        const taskParseResult = this.createTaskRunnerConfiguration(fileConfig, context, source);
+        return {
+            validationStatus: this.problemReporter.status,
+            custom: taskParseResult.custom,
+            configured: taskParseResult.configured,
+            engine
+        };
+    }
+    createTaskRunnerConfiguration(fileConfig, context, source) {
+        const globals = Globals.from(fileConfig, context);
+        if (this.problemReporter.status.isFatal()) {
+            return {
+                custom: [],
+                configured: []
+            };
+        }
+        context.namedProblemMatchers = ProblemMatcherConverter.namedFrom(fileConfig.declares, context);
+        let globalTasks = undefined;
+        let externalGlobalTasks = undefined;
+        if (fileConfig.windows && context.platform === Platform.Windows) {
+            globalTasks = TaskParser.from(fileConfig.windows.tasks, globals, context, source).custom;
+            externalGlobalTasks = fileConfig.windows.tasks;
+        } else if (fileConfig.osx && context.platform === Platform.Mac) {
+            globalTasks = TaskParser.from(fileConfig.osx.tasks, globals, context, source).custom;
+            externalGlobalTasks = fileConfig.osx.tasks;
+        } else if (fileConfig.linux && context.platform === Platform.Linux) {
+            globalTasks = TaskParser.from(fileConfig.linux.tasks, globals, context, source).custom;
+            externalGlobalTasks = fileConfig.linux.tasks;
+        }
+        if (context.schemaVersion === JsonSchemaVersion$1.V2_0_0 && globalTasks && globalTasks.length > 0 && externalGlobalTasks && externalGlobalTasks.length > 0) {
+            const taskContent = [];
+            for (const task of externalGlobalTasks) {
+                taskContent.push(JSON.stringify(task, null, 4));
+            }
+            context.problemReporter.error(( localize(
+                13242,
+                "Task version 2.0.0 doesn't support global OS specific tasks. Convert them to a task with a OS specific command. Affected tasks are:\n{0}",
+                taskContent.join("\n")
+            )));
+        }
+        let result = {
+            custom: [],
+            configured: []
+        };
+        if (fileConfig.tasks) {
+            result = TaskParser.from(fileConfig.tasks, globals, context, source);
+        }
+        if (globalTasks) {
+            result.custom = TaskParser.assignTasks(result.custom, globalTasks);
+        }
+        if ((!result.custom || result.custom.length === 0) && (globals.command && globals.command.name)) {
+            const matchers = ProblemMatcherConverter.from(fileConfig.problemMatcher, context).value ?? [];
+            const isBackground = fileConfig.isBackground ? !!fileConfig.isBackground : fileConfig.isWatching ? !!fileConfig.isWatching : undefined;
+            const name = CommandString$1.value(globals.command.name);
+            const task = new CustomTask$1(context.uuidMap.getUUID(name), Object.assign({}, source, "workspace", {
+                config: {
+                    index: -1,
+                    element: fileConfig,
+                    workspaceFolder: context.workspaceFolder
+                }
+            }), name, CUSTOMIZED_TASK_TYPE, {
+                name: undefined,
+                runtime: undefined,
+                presentation: undefined,
+                suppressTaskName: true
+            }, false, {
+                reevaluateOnRerun: true
+            }, {
+                name: name,
+                identifier: name,
+                group: TaskGroup.Build,
+                isBackground: isBackground,
+                problemMatchers: matchers
+            });
+            const taskGroupKind = GroupKind.from(fileConfig.group);
+            if (taskGroupKind !== undefined) {
+                task.configurationProperties.group = taskGroupKind;
+            } else if (fileConfig.group === "none") {
+                task.configurationProperties.group = undefined;
+            }
+            CustomTask.fillGlobals(task, globals);
+            CustomTask.fillDefaults(task, context);
+            result.custom = [task];
+        }
+        result.custom = result.custom || [];
+        result.configured = result.configured || [];
+        return result;
+    }
+}
+const uuidMaps = ( new Map());
+const recentUuidMaps = ( new Map());
+function parse(
+    workspaceFolder,
+    workspace,
+    platform,
+    configuration,
+    logger,
+    source,
+    contextKeyService,
+    isRecents = false
+) {
+    const recentOrOtherMaps = isRecents ? recentUuidMaps : uuidMaps;
+    let selectedUuidMaps = recentOrOtherMaps.get(source);
+    if (!selectedUuidMaps) {
+        recentOrOtherMaps.set(source, ( new Map()));
+        selectedUuidMaps = recentOrOtherMaps.get(source);
+    }
+    let uuidMap = selectedUuidMaps.get(( workspaceFolder.uri.toString()));
+    if (!uuidMap) {
+        uuidMap = ( new UUIDMap());
+        selectedUuidMaps.set(( workspaceFolder.uri.toString()), uuidMap);
+    }
+    try {
+        uuidMap.start();
+        return ( new ConfigurationParser(workspaceFolder, workspace, platform, logger, uuidMap)).run(configuration, source, contextKeyService);
+    } finally {
+        uuidMap.finish();
+    }
+}
+function createCustomTask(contributedTask, configuredProps) {
+    return CustomTask.createCustomTask(contributedTask, configuredProps);
+}
+
+export { CommandString, ExecutionEngine, GroupKind, ITaskIdentifier, InstancePolicy, JsonSchemaVersion, ProblemMatcherConverter, RunOnOptions, RunOptions, ShellQuoting, TaskConfigSource, TaskParser, UUIDMap, createCustomTask, parse };