@codingame/monaco-vscode-api 28.4.1 → 29.1.0

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

@@ -1,1796 +0,0 @@
-
-import { localize } from '../../../../nls.js';
-import { deepClone } from '../../../../base/common/objects.js';
-import { Platform } from '../../../../base/common/platform.js';
-import { isString, isStringArray, isBoolean, isUndefined } from '../../../../base/common/types.js';
-import { generateUuid } from '../../../../base/common/uuid.js';
-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 './tasks.js';
-import { TaskDefinitionRegistry } from './taskDefinitionRegistry.js';
-import { ProcessExecutionSupportedContext, ShellExecutionSupportedContext } from './taskService.js';
-
-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 "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(
-                    12978,
-                    "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(
-                        12979,
-                        "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(
-                        12980,
-                        "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(
-                    12981,
-                    "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(
-                12982,
-                "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(12983, "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(
-                12984,
-                "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(
-                12985,
-                "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(
-                12986,
-                "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(
-                12987,
-                "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(
-                12988,
-                "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(
-                12989,
-                "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(
-                    12990,
-                    "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(
-                                12991,
-                                "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(
-                                12992,
-                                "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(
-                12993,
-                "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 };