@opensumi/ide-task 2.12.1-next-079c1930

package/lib/browser/task-config.js

@@ -0,0 +1,1427 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCustomTask = exports.parse = exports.JsonSchemaVersion = exports.ExecutionEngine = exports.RunOptions = exports.RunOnOptions = exports.CommandString = exports.TaskIdentifier = void 0;
+const tslib_1 = require("tslib");
+const ide_core_common_1 = require("@opensumi/ide-core-common");
+const TaskTypes = (0, tslib_1.__importStar)(require("../common/task"));
+const parser_1 = require("./parser");
+var TaskIdentifier;
+(function (TaskIdentifier) {
+    function is(value) {
+        const candidate = value;
+        return candidate !== undefined && (0, ide_core_common_1.isString)(value.type);
+    }
+    TaskIdentifier.is = is;
+})(TaskIdentifier = exports.TaskIdentifier || (exports.TaskIdentifier = {}));
+var CommandString;
+(function (CommandString) {
+    function value(value) {
+        if ((0, ide_core_common_1.isString)(value)) {
+            return value;
+        }
+        else if ((0, ide_core_common_1.isStringArray)(value)) {
+            return value.join(' ');
+        }
+        else {
+            if ((0, ide_core_common_1.isString)(value.value)) {
+                return value.value;
+            }
+            else {
+                return value.value.join(' ');
+            }
+        }
+    }
+    CommandString.value = value;
+})(CommandString = exports.CommandString || (exports.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 = [];
+Object.freeze(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) {
+    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) {
+                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) {
+    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) {
+            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 (0, ide_core_common_1.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);
+            }
+        }
+    }
+    Object.freeze(target);
+    return target;
+}
+var RunOnOptions;
+(function (RunOnOptions) {
+    function fromString(value) {
+        if (!value) {
+            return TaskTypes.RunOnOptions.default;
+        }
+        switch (value.toLowerCase()) {
+            case 'folderopen':
+                return TaskTypes.RunOnOptions.folderOpen;
+            case 'default':
+            default:
+                return TaskTypes.RunOnOptions.default;
+        }
+    }
+    RunOnOptions.fromString = fromString;
+})(RunOnOptions = exports.RunOnOptions || (exports.RunOnOptions = {}));
+var RunOptions;
+(function (RunOptions) {
+    function fromConfiguration(value) {
+        return {
+            reevaluateOnRerun: value ? value.reevaluateOnRerun : true,
+            runOn: value ? RunOnOptions.fromString(value.runOn) : TaskTypes.RunOnOptions.default,
+        };
+    }
+    RunOptions.fromConfiguration = fromConfiguration;
+})(RunOptions = exports.RunOptions || (exports.RunOptions = {}));
+class ParseContext {
+}
+var ShellConfiguration;
+(function (ShellConfiguration) {
+    const properties = [{ property: 'executable' }, { property: 'args' }, { property: 'quoting' }];
+    function is(value) {
+        const candidate = value;
+        return candidate && ((0, ide_core_common_1.isString)(candidate.executable) || (0, ide_core_common_1.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 = (0, ide_core_common_1.deepClone)(config.quoting);
+        }
+        return result;
+    }
+    ShellConfiguration.from = from;
+    function isEmpty(value) {
+        return _isEmpty(value, properties);
+    }
+    ShellConfiguration.isEmpty = isEmpty;
+    function assignProperties(target, source) {
+        return _assignProperties(target, source, properties);
+    }
+    ShellConfiguration.assignProperties = assignProperties;
+    function fillProperties(target, source) {
+        return _fillProperties(target, source, properties);
+    }
+    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 ((0, ide_core_common_1.isString)(options.cwd)) {
+                result.cwd = options.cwd;
+            }
+            else {
+                context.taskLoadIssues.push((0, ide_core_common_1.formatLocalize)('ConfigurationParser.invalidCWD', 'Warning: options.cwd must be of type string. Ignoring value {0}\n', options.cwd));
+            }
+        }
+        if (options.env !== undefined) {
+            result.env = (0, ide_core_common_1.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' }];
+        function from(config, context) {
+            let echo;
+            let reveal;
+            let revealProblems;
+            let focus;
+            let panel;
+            let showReuseMessage;
+            let clear;
+            let group;
+            let hasProps = false;
+            if ((0, ide_core_common_1.isBoolean)(config.echoCommand)) {
+                echo = config.echoCommand;
+                hasProps = true;
+            }
+            if ((0, ide_core_common_1.isString)(config.showOutput)) {
+                reveal = TaskTypes.RevealKind.fromString(config.showOutput);
+                hasProps = true;
+            }
+            const presentation = config.presentation || config.terminal;
+            if (presentation) {
+                if ((0, ide_core_common_1.isBoolean)(presentation.echo)) {
+                    echo = presentation.echo;
+                }
+                if ((0, ide_core_common_1.isString)(presentation.reveal)) {
+                    reveal = TaskTypes.RevealKind.fromString(presentation.reveal);
+                }
+                if ((0, ide_core_common_1.isString)(presentation.revealProblems)) {
+                    revealProblems = TaskTypes.RevealProblemKind.fromString(presentation.revealProblems);
+                }
+                if ((0, ide_core_common_1.isBoolean)(presentation.focus)) {
+                    focus = presentation.focus;
+                }
+                if ((0, ide_core_common_1.isString)(presentation.panel)) {
+                    panel = TaskTypes.PanelKind.fromString(presentation.panel);
+                }
+                if ((0, ide_core_common_1.isBoolean)(presentation.showReuseMessage)) {
+                    showReuseMessage = presentation.showReuseMessage;
+                }
+                if ((0, ide_core_common_1.isBoolean)(presentation.clear)) {
+                    clear = presentation.clear;
+                }
+                if ((0, ide_core_common_1.isString)(presentation.group)) {
+                    group = presentation.group;
+                }
+                hasProps = true;
+            }
+            if (!hasProps) {
+                return undefined;
+            }
+            return { echo: echo, reveal: reveal, revealProblems: revealProblems, focus: focus, panel: panel, showReuseMessage: showReuseMessage, clear: clear, group };
+        }
+        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 === TaskTypes.ExecutionEngine.Terminal ? true : false;
+            return _fillDefaults(value, { echo: defaultEcho, reveal: TaskTypes.RevealKind.Always, revealProblems: TaskTypes.RevealProblemKind.Never, focus: false, panel: TaskTypes.PanelKind.Shared, showReuseMessage: true, clear: 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 ((0, ide_core_common_1.isString)(value)) {
+                return value;
+            }
+            else if ((0, ide_core_common_1.isStringArray)(value)) {
+                return value.join(' ');
+            }
+            else {
+                const quoting = TaskTypes.ShellQuoting.from(value.quoting);
+                const result = (0, ide_core_common_1.isString)(value.value) ? value.value : (0, ide_core_common_1.isStringArray)(value.value) ? value.value.join(' ') : undefined;
+                if (result) {
+                    return {
+                        value: result,
+                        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;
+        if (config.windows && context.platform === 3 /* Windows */) {
+            osConfig = fromBase(config.windows, context);
+        }
+        else if (config.osx && context.platform === 1 /* Mac */) {
+            osConfig = fromBase(config.osx, context);
+        }
+        else if (config.linux && context.platform === 2 /* Linux */) {
+            osConfig = fromBase(config.linux, context);
+        }
+        if (osConfig) {
+            result = assignProperties(result, osConfig, context.schemaVersion === 2 /* V2_0_0 */);
+        }
+        return isEmpty(result) ? undefined : result;
+    }
+    CommandConfiguration.from = from;
+    function fromBase(config, context) {
+        const name = ShellString.from(config.command);
+        let runtime;
+        if ((0, ide_core_common_1.isString)(config.type)) {
+            if (config.type === 'shell' || config.type === 'process') {
+                runtime = TaskTypes.RuntimeType.fromString(config.type);
+            }
+        }
+        const isShellConfiguration = ShellConfiguration.is(config.isShellCommand);
+        if ((0, ide_core_common_1.isBoolean)(config.isShellCommand) || isShellConfiguration) {
+            runtime = TaskTypes.RuntimeType.Shell;
+        }
+        else if (config.isShellCommand !== undefined) {
+            runtime = !!config.isShellCommand ? TaskTypes.RuntimeType.Shell : TaskTypes.RuntimeType.Process;
+        }
+        const result = {
+            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((0, ide_core_common_1.formatLocalize)('ConfigurationParser.inValidArg', '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 && isShellConfiguration) {
+                result.options.shell = ShellConfiguration.from(config.isShellCommand, context);
+                if (context.engine !== TaskTypes.ExecutionEngine.Terminal) {
+                    context.taskLoadIssues.push((0, ide_core_common_1.formatLocalize)('ConfigurationParser.noShell', 'Warning: shell configuration is only supported when executing tasks in the terminal.'));
+                }
+            }
+        }
+        if ((0, ide_core_common_1.isString)(config.taskSelector)) {
+            result.taskSelector = config.taskSelector;
+        }
+        if ((0, ide_core_common_1.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 = TaskTypes.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 === 2 /* 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 (!(0, ide_core_common_1.isArray)(declares)) {
+            return result;
+        }
+        declares.forEach((value) => {
+            const namedProblemMatcher = (new parser_1.ProblemMatcherParser(context.problemReporter)).parse(value, context.getProblemPattern, context.getProblemMatcher);
+            // @ts-ignore
+            if (parser_1.Config.isNamedProblemMatcher(namedProblemMatcher)) {
+                result[namedProblemMatcher.name] = namedProblemMatcher;
+            }
+            else {
+                context.problemReporter.error((0, ide_core_common_1.formatLocalize)('ConfigurationParser.noName', 'Error: Problem Matcher in declare scope must have a name:\n{0}\n', JSON.stringify(value, undefined, 4)));
+            }
+        });
+        return result;
+    }
+    ProblemMatcherConverter.namedFrom = namedFrom;
+    function from(config, context) {
+        const result = [];
+        if (config === undefined) {
+            return result;
+        }
+        const kind = getProblemMatcherKind(config);
+        if (kind === ProblemMatcherKind.Unknown) {
+            context.problemReporter.warn((0, ide_core_common_1.formatLocalize)('ConfigurationParser.unknownMatcherKind', 'Warning: the defined problem matcher is unknown. Supported types are string | ProblemMatcher | Array<string | ProblemMatcher>.\n{0}\n', JSON.stringify(config, null, 4)));
+            return result;
+        }
+        else if (kind === ProblemMatcherKind.String || kind === ProblemMatcherKind.ProblemMatcher) {
+            const matcher = resolveProblemMatcher(config, context);
+            if (matcher) {
+                result.push(matcher);
+            }
+        }
+        else if (kind === ProblemMatcherKind.Array) {
+            const problemMatchers = config;
+            problemMatchers.forEach((problemMatcher) => {
+                const matcher = resolveProblemMatcher(problemMatcher, context);
+                if (matcher) {
+                    result.push(matcher);
+                }
+            });
+        }
+        return result;
+    }
+    ProblemMatcherConverter.from = from;
+    function getProblemMatcherKind(value) {
+        if ((0, ide_core_common_1.isString)(value)) {
+            return ProblemMatcherKind.String;
+        }
+        else if ((0, ide_core_common_1.isArray)(value)) {
+            return ProblemMatcherKind.Array;
+        }
+        else if (!(0, ide_core_common_1.isUndefined)(value)) {
+            return ProblemMatcherKind.ProblemMatcher;
+        }
+        else {
+            return ProblemMatcherKind.Unknown;
+        }
+    }
+    function resolveProblemMatcher(value, context) {
+        if ((0, ide_core_common_1.isString)(value)) {
+            let variableName = value;
+            if (variableName.length > 1 && variableName[0] === '$') {
+                variableName = variableName.substring(1);
+                const global = context.getProblemMatcher(variableName);
+                if (global) {
+                    return (0, ide_core_common_1.deepClone)(global);
+                }
+                let localProblemMatcher = context.namedProblemMatchers[variableName];
+                if (localProblemMatcher) {
+                    localProblemMatcher = (0, ide_core_common_1.deepClone)(localProblemMatcher);
+                    // remove the name attr
+                    // 让他从一个 NamedProblemMatcher 到 ProblemMatcher
+                    delete localProblemMatcher.name;
+                    return localProblemMatcher;
+                }
+            }
+            context.taskLoadIssues.push((0, ide_core_common_1.formatLocalize)('ConfigurationParser.invalidVariableReference', 'Error: Invalid problemMatcher reference: {0}\n', value));
+            return undefined;
+        }
+        else {
+            const json = value;
+            return new parser_1.ProblemMatcherParser(context.problemReporter).parse(json, context.getProblemPattern, context.getProblemMatcher);
+        }
+    }
+})(ProblemMatcherConverter || (ProblemMatcherConverter = {}));
+const source = {
+    kind: TaskTypes.TaskSourceKind.Workspace,
+    label: 'Workspace',
+    config: undefined,
+};
+var GroupKind;
+(function (GroupKind) {
+    function from(external) {
+        if (external === undefined) {
+            return undefined;
+        }
+        if ((0, ide_core_common_1.isString)(external)) {
+            if (TaskTypes.TaskGroup.is(external)) {
+                return [external, "user" /* user */];
+            }
+            else {
+                return undefined;
+            }
+        }
+        if (!(0, ide_core_common_1.isString)(external.kind) || !TaskTypes.TaskGroup.is(external.kind)) {
+            return undefined;
+        }
+        const group = external.kind;
+        const isDefault = !!external.isDefault;
+        return [group, isDefault ? "default" /* default */ : "user" /* user */];
+    }
+    GroupKind.from = from;
+})(GroupKind || (GroupKind = {}));
+var TaskDependency;
+(function (TaskDependency) {
+    function from(external, context) {
+        if ((0, ide_core_common_1.isString)(external)) {
+            return { workspaceFolder: context.workspaceFolder, task: external };
+        }
+        else if (TaskIdentifier.is(external)) {
+            return { workspaceFolder: context.workspaceFolder, task: context.createTaskIdentifier(external, context.problemReporter) };
+        }
+        else {
+            return undefined;
+        }
+    }
+    TaskDependency.from = from;
+})(TaskDependency || (TaskDependency = {}));
+var DependsOrder;
+(function (DependsOrder) {
+    function from(order) {
+        switch (order) {
+            case "sequence" /* sequence */:
+                return "sequence" /* sequence */;
+            case "parallel" /* parallel */:
+            default:
+                return "parallel" /* 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' },
+    ];
+    function from(external, context, includeCommandOptions, properties) {
+        if (!external) {
+            return undefined;
+        }
+        const result = {};
+        if (properties) {
+            for (const propertyName of Object.keys(properties)) {
+                if (external[propertyName] !== undefined) {
+                    result[propertyName] = (0, ide_core_common_1.deepClone)(external[propertyName]);
+                }
+            }
+        }
+        if ((0, ide_core_common_1.isString)(external.taskName)) {
+            result.name = external.taskName;
+        }
+        if ((0, ide_core_common_1.isString)(external.label) && context.schemaVersion === 2 /* V2_0_0 */) {
+            result.name = external.label;
+        }
+        if ((0, ide_core_common_1.isString)(external.identifier)) {
+            result.identifier = external.identifier;
+        }
+        if (external.isBackground !== undefined) {
+            result.isBackground = !!external.isBackground;
+        }
+        if (external.promptOnClose !== undefined) {
+            result.promptOnClose = !!external.promptOnClose;
+        }
+        if (external.group !== undefined) {
+            if ((0, ide_core_common_1.isString)(external.group) && TaskTypes.TaskGroup.is(external.group)) {
+                result.group = external.group;
+                result.groupType = "user" /* user */;
+            }
+            else {
+                const values = GroupKind.from(external.group);
+                if (values) {
+                    result.group = values[0];
+                    result.groupType = values[1];
+                }
+            }
+        }
+        if (external.dependsOn !== undefined) {
+            if ((0, ide_core_common_1.isArray)(external.dependsOn)) {
+                result.dependsOn = external.dependsOn.reduce((dependencies, item) => {
+                    const dependency = TaskDependency.from(item, context);
+                    if (dependency) {
+                        dependencies.push(dependency);
+                    }
+                    return dependencies;
+                }, []);
+            }
+            else {
+                const dependsOnValue = TaskDependency.from(external.dependsOn, context);
+                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);
+        }
+        if (external.problemMatcher) {
+            result.problemMatchers = ProblemMatcherConverter.from(external.problemMatcher, context);
+        }
+        return isEmpty(result) ? undefined : result;
+    }
+    ConfigurationProperties.from = from;
+    function isEmpty(value) {
+        return _isEmpty(value, properties);
+    }
+    ConfigurationProperties.isEmpty = isEmpty;
+})(ConfigurationProperties || (ConfigurationProperties = {}));
+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, taskDefinitionRegister) {
+        if (!external) {
+            return undefined;
+        }
+        const type = external.type;
+        const customize = external.customize;
+        if (!type && !customize) {
+            context.problemReporter.error((0, ide_core_common_1.formatLocalize)('ConfigurationParser.noTaskType', '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 ? taskDefinitionRegister.get(type) : undefined;
+        if (!typeDeclaration) {
+            const message = (0, ide_core_common_1.formatLocalize)('ConfigurationParser.noTypeDefinition', 'Error: there is no registered task type \'{0}\'. Did you miss to install an extension that provides a corresponding task provider?', type);
+            context.problemReporter.error(message);
+            return undefined;
+        }
+        let identifier;
+        if ((0, ide_core_common_1.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 ((0, ide_core_common_1.isString)(external.type)) {
+                identifier = external;
+            }
+        }
+        if (identifier === undefined) {
+            context.problemReporter.error((0, ide_core_common_1.formatLocalize)('ConfigurationParsTaskTypes.er.missingType', '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 = context.createTaskIdentifier(identifier, context.problemReporter);
+        if (taskIdentifier === undefined) {
+            context.problemReporter.error((0, ide_core_common_1.formatLocalize)('ConfigurationParTaskTypes.ser.incorrectType', '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/json',
+            index,
+            element: external,
+        };
+        const result = new TaskTypes.ConfiguringTask(`${typeDeclaration.extensionId}.${taskIdentifier._key}`, Object.assign({}, source, { config: configElement }), undefined, type, taskIdentifier, RunOptions.fromConfiguration(external.runOptions), {});
+        const configuration = ConfigurationProperties.from(external, context, true, typeDeclaration.properties);
+        if (configuration) {
+            result.configurationProperties = Object.assign(result.configurationProperties, configuration);
+            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) {
+        if (!external) {
+            return undefined;
+        }
+        let type = external.type;
+        if (type === undefined || type === null) {
+            type = TaskTypes.CUSTOMIZED_TASK_TYPE;
+        }
+        if (type !== TaskTypes.CUSTOMIZED_TASK_TYPE && type !== 'shell' && type !== 'process') {
+            context.problemReporter.error((0, ide_core_common_1.formatLocalize)('ConfigurationParser.notCustom', '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 ((0, ide_core_common_1.isString)(external.label) && context.schemaVersion === 2 /* V2_0_0 */) {
+            taskName = external.label;
+        }
+        if (!taskName) {
+            context.problemReporter.error((0, ide_core_common_1.formatLocalize)('ConfigurationParser.noTaskName', 'Error: a task must provide a label property. The task will be ignored.\n{0}\n', JSON.stringify(external, null, 4)));
+            return undefined;
+        }
+        const result = new TaskTypes.CustomTask(context.uuidMap.getUUID(taskName), Object.assign({}, source, { config: { index, element: external, file: '.vscode/json', workspaceFolder: context.workspaceFolder } }), taskName, TaskTypes.CUSTOMIZED_TASK_TYPE, undefined, false, RunOptions.fromConfiguration(external.runOptions), {
+            name: taskName,
+            identifier: taskName,
+        });
+        const configuration = ConfigurationProperties.from(external, context, false);
+        if (configuration) {
+            result.configurationProperties = Object.assign(result.configurationProperties, configuration);
+        }
+        const supportLegacy = true; // context.schemaVersion === JsonSchemaVersion.V2_0_0;
+        if (supportLegacy) {
+            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 = TaskTypes.TaskGroup.Build;
+                }
+                else if (legacy.isTestCommand === true) {
+                    result.configurationProperties.group = TaskTypes.TaskGroup.Test;
+                }
+            }
+        }
+        const command = CommandConfiguration.from(external, context);
+        if (command) {
+            result.command = command;
+        }
+        if (external.command !== undefined) {
+            // if the task has its own command then we suppress the
+            // task name by default.
+            command.suppressTaskName = true;
+        }
+        return result;
+    }
+    CustomTask.from = from;
+    function fillGlobals(task, globals) {
+        // We only merge a command from a global definition if there is no dependsOn
+        // or there is a dependsOn and a defined command.
+        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 = (0, ide_core_common_1.deepClone)(globals.problemMatcher);
+            task.hasDefinedMatchers = true;
+        }
+        // promptOnClose is inferred from isBackground if available
+        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;
+        }
+        if (task.configurationProperties.group !== undefined && task.configurationProperties.groupType === undefined) {
+            task.configurationProperties.groupType = "user" /* user */;
+        }
+    }
+    CustomTask.fillDefaults = fillDefaults;
+    function createCustomTask(contributedTask, configuredProps) {
+        const result = new TaskTypes.CustomTask(configuredProps._id, Object.assign({}, configuredProps._source, { customizes: contributedTask.defines }), configuredProps.configurationProperties.name || contributedTask._label, TaskTypes.CUSTOMIZED_TASK_TYPE, contributedTask.command, false, contributedTask.runOptions, {
+            name: configuredProps.configurationProperties.name || contributedTask.configurationProperties.name,
+            identifier: configuredProps.configurationProperties.identifier || contributedTask.configurationProperties.identifier,
+        });
+        result.addTaskLoadMessages(configuredProps.taskLoadMessages);
+        const resultConfigProps = result.configurationProperties;
+        assignProperty(resultConfigProps, configuredProps.configurationProperties, 'group');
+        assignProperty(resultConfigProps, configuredProps.configurationProperties, 'groupType');
+        assignProperty(resultConfigProps, configuredProps.configurationProperties, 'isBackground');
+        assignProperty(resultConfigProps, configuredProps.configurationProperties, 'dependsOn');
+        assignProperty(resultConfigProps, configuredProps.configurationProperties, 'problemMatchers');
+        assignProperty(resultConfigProps, configuredProps.configurationProperties, 'promptOnClose');
+        result.command.presentation = CommandConfiguration.PresentationOptions.assignProperties(result.command.presentation, configuredProps.configurationProperties.presentation);
+        result.command.options = CommandOptions.assignProperties(result.command.options, configuredProps.configurationProperties.options);
+        const contributedConfigProps = contributedTask.configurationProperties;
+        fillProperty(resultConfigProps, contributedConfigProps, 'group');
+        fillProperty(resultConfigProps, contributedConfigProps, 'groupType');
+        fillProperty(resultConfigProps, contributedConfigProps, 'isBackground');
+        fillProperty(resultConfigProps, contributedConfigProps, 'dependsOn');
+        fillProperty(resultConfigProps, contributedConfigProps, 'problemMatchers');
+        fillProperty(resultConfigProps, contributedConfigProps, 'promptOnClose');
+        result.command.presentation = CommandConfiguration.PresentationOptions.fillProperties(result.command.presentation, contributedConfigProps.presentation);
+        result.command.options = CommandOptions.fillProperties(result.command.options, contributedConfigProps.options);
+        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 === TaskTypes.CUSTOMIZED_TASK_TYPE || type === 'shell' || type === 'process');
+    }
+    function from(externals, globals, context, taskDefinitionRegister) {
+        const result = { custom: [], configured: [] };
+        if (!externals) {
+            return result;
+        }
+        const defaultBuildTask = { task: undefined, rank: -1 };
+        const defaultTestTask = { task: undefined, rank: -1 };
+        // tslint:disable-next-line: variable-name
+        const schema2_0_0 = context.schemaVersion === 2 /* V2_0_0 */;
+        const baseLoadIssues = (0, ide_core_common_1.deepClone)(context.taskLoadIssues);
+        for (let index = 0; index < externals.length; index++) {
+            const external = externals[index];
+            if (isCustomTask(external)) {
+                const customTask = CustomTask.from(external, context, index);
+                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((0, ide_core_common_1.formatLocalize)('taskConfiguration.noCommandOrDependsOn', '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((0, ide_core_common_1.formatLocalize)('taskConfiguration.noCommand', '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 === TaskTypes.TaskGroup.Build && defaultBuildTask.rank < 2) {
+                        defaultBuildTask.task = customTask;
+                        defaultBuildTask.rank = 2;
+                    }
+                    else if (customTask.configurationProperties.group === TaskTypes.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, taskDefinitionRegister);
+                if (configuredTask) {
+                    configuredTask.addTaskLoadMessages(context.taskLoadIssues);
+                    result.configured.push(configuredTask);
+                }
+            }
+            context.taskLoadIssues = (0, ide_core_common_1.deepClone)(baseLoadIssues);
+        }
+        if ((defaultBuildTask.rank > -1) && (defaultBuildTask.rank < 2) && defaultBuildTask.task) {
+            defaultBuildTask.task.configurationProperties.group = TaskTypes.TaskGroup.Build;
+            defaultBuildTask.task.configurationProperties.groupType = "user" /* user */;
+        }
+        else if ((defaultTestTask.rank > -1) && (defaultTestTask.rank < 2) && defaultTestTask.task) {
+            defaultTestTask.task.configurationProperties.group = TaskTypes.TaskGroup.Test;
+            defaultTestTask.task.configurationProperties.groupType = "user" /* user */;
+        }
+        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) {
+            // Tasks are keyed by ID but we need to merge by name
+            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;
+        if (config.windows && context.platform === 3 /* Windows */) {
+            osGlobals = fromBase(config.windows, context);
+        }
+        else if (config.osx && context.platform === 1 /* Mac */) {
+            osGlobals = fromBase(config.osx, context);
+        }
+        else if (config.linux && context.platform === 2 /* 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);
+        }
+        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 === 2 /* V2_0_0 */);
+        }
+        if (value.promptOnClose === undefined) {
+            value.promptOnClose = true;
+        }
+    }
+    Globals.fillDefaults = fillDefaults;
+    function freeze(value) {
+        Object.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 = TaskTypes.ExecutionEngine.Terminal;
+                    break;
+                case 'process':
+                    result = TaskTypes.ExecutionEngine.Process;
+                    break;
+            }
+        }
+        const schemaVersion = JsonSchemaVersion.from(config);
+        if (schemaVersion === 1 /* V0_1_0 */) {
+            return result || TaskTypes.ExecutionEngine.Process;
+        }
+        else if (schemaVersion === 2 /* V2_0_0 */) {
+            return TaskTypes.ExecutionEngine.Terminal;
+        }
+        else {
+            throw new Error('Shouldn\'t happen.');
+        }
+    }
+    ExecutionEngine.from = from;
+})(ExecutionEngine = exports.ExecutionEngine || (exports.ExecutionEngine = {}));
+var JsonSchemaVersion;
+(function (JsonSchemaVersion) {
+    const _default = 2 /* V2_0_0 */;
+    function from(config) {
+        const version = config.version;
+        if (!version) {
+            return _default;
+        }
+        switch (version) {
+            case '0.1.0':
+                return 1 /* V0_1_0 */;
+            case '2.0.0':
+                return 2 /* V2_0_0 */;
+            default:
+                return _default;
+        }
+    }
+    JsonSchemaVersion.from = from;
+})(JsonSchemaVersion = exports.JsonSchemaVersion || (exports.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;
+        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 = (0, ide_core_common_1.uuid)();
+        }
+        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;
+    }
+}
+class ConfigurationParser {
+    constructor(workspaceFolder, platform, problemReporter, uuidMap, createTaskIdentifier, getProblemMatcher, getProblemPattern) {
+        this.createTaskIdentifier = createTaskIdentifier;
+        this.getProblemMatcher = getProblemMatcher;
+        this.getProblemPattern = getProblemPattern;
+        this.workspaceFolder = workspaceFolder;
+        this.platform = platform;
+        this.problemReporter = problemReporter;
+        this.uuidMap = uuidMap;
+    }
+    run(fileConfig, taskDefinitionRegister) {
+        const engine = ExecutionEngine.from(fileConfig);
+        const schemaVersion = JsonSchemaVersion.from(fileConfig);
+        const context = {
+            workspaceFolder: this.workspaceFolder,
+            problemReporter: this.problemReporter,
+            uuidMap: this.uuidMap,
+            namedProblemMatchers: {},
+            engine,
+            schemaVersion,
+            platform: this.platform,
+            taskLoadIssues: [],
+            createTaskIdentifier: this.createTaskIdentifier,
+            getProblemMatcher: this.getProblemMatcher,
+            getProblemPattern: this.getProblemPattern,
+        };
+        const taskParseResult = this.createTaskRunnerConfiguration(fileConfig, context, taskDefinitionRegister);
+        return {
+            validationStatus: this.problemReporter.status,
+            custom: taskParseResult.custom,
+            configured: taskParseResult.configured,
+            engine,
+        };
+    }
+    createTaskRunnerConfiguration(fileConfig, context, taskDefinitionRegister) {
+        const globals = Globals.from(fileConfig, context);
+        if (this.problemReporter.status.isFatal()) {
+            return { custom: [], configured: [] };
+        }
+        context.namedProblemMatchers = ProblemMatcherConverter.namedFrom(fileConfig.declares, context);
+        let globalTasks;
+        let externalGlobalTasks;
+        if (fileConfig.windows && context.platform === 3 /* Windows */) {
+            globalTasks = TaskParser.from(fileConfig.windows.tasks, globals, context, taskDefinitionRegister).custom;
+            externalGlobalTasks = fileConfig.windows.tasks;
+        }
+        else if (fileConfig.osx && context.platform === 1 /* Mac */) {
+            globalTasks = TaskParser.from(fileConfig.osx.tasks, globals, context, taskDefinitionRegister).custom;
+            externalGlobalTasks = fileConfig.osx.tasks;
+        }
+        else if (fileConfig.linux && context.platform === 2 /* Linux */) {
+            globalTasks = TaskParser.from(fileConfig.linux.tasks, globals, context, taskDefinitionRegister).custom;
+            externalGlobalTasks = fileConfig.linux.tasks;
+        }
+        if (context.schemaVersion === 2 /* 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((0, ide_core_common_1.formatLocalize)('TaskParse.noOsSpecificGlobalTasks', 'Task version 2.0.0 doesn\'t support global OS specific  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, taskDefinitionRegister);
+        }
+        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);
+            const isBackground = fileConfig.isBackground ? !!fileConfig.isBackground : fileConfig.isWatching ? !!fileConfig.isWatching : undefined;
+            const name = TaskTypes.CommandString.value(globals.command.name);
+            const task = new TaskTypes.CustomTask(context.uuidMap.getUUID(name), Object.assign({}, source, { config: { index: -1, element: fileConfig, workspaceFolder: context.workspaceFolder } }), name, TaskTypes.CUSTOMIZED_TASK_TYPE, {
+                name: undefined,
+                runtime: undefined,
+                presentation: undefined,
+                suppressTaskName: true,
+            }, false, { reevaluateOnRerun: true }, {
+                name,
+                identifier: name,
+                group: TaskTypes.TaskGroup.Build,
+                isBackground,
+                problemMatchers: matchers,
+            });
+            const value = GroupKind.from(fileConfig.group);
+            if (value) {
+                task.configurationProperties.group = value[0];
+                task.configurationProperties.groupType = value[1];
+            }
+            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();
+function parse(workspaceFolder, platform, configuration, logger, taskDefinitionRegister, problemMatcherRegister, problemPatternRegister) {
+    let uuidMap = uuidMaps.get(workspaceFolder.uri.toString());
+    if (!uuidMap) {
+        uuidMap = new UUIDMap();
+        uuidMaps.set(workspaceFolder.uri.toString(), uuidMap);
+    }
+    try {
+        uuidMap.start();
+        return (new ConfigurationParser(workspaceFolder, platform, logger, uuidMap, taskDefinitionRegister.createTaskIdentifier, problemMatcherRegister.get, problemPatternRegister.get)).run(configuration, taskDefinitionRegister);
+    }
+    finally {
+        uuidMap.finish();
+    }
+}
+exports.parse = parse;
+function createCustomTask(contributedTask, configuredProps) {
+    return CustomTask.createCustomTask(contributedTask, configuredProps);
+}
+exports.createCustomTask = createCustomTask;
+//# sourceMappingURL=task-config.js.map