@codingame/monaco-vscode-api 26.2.2 → 28.0.0

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

@@ -0,0 +1,1637 @@
+
+import { localize } from '../../../../nls.js';
+import { deepClone, mixin } from '../../../../base/common/objects.js';
+import { trim, equalsIgnoreCase } from '../../../../base/common/strings.js';
+import { ok } from '../../../../base/common/assert.js';
+import { join, normalize } from '../../../../base/common/path.js';
+import { isString, isUndefined, isStringArray, isUndefinedOrNull, isBoolean, isNumber } from '../../../../base/common/types.js';
+import { generateUuid } from '../../../../base/common/uuid.js';
+import { OS, OperatingSystem } from '../../../../base/common/platform.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { URI } from '../../../../base/common/uri.js';
+import { Parser, ValidationStatus, ValidationState } from '../../../../base/common/parsers.js';
+import { asArray } from '../../../../base/common/arrays.js';
+import { Schemas as Schemas$1 } from '../../../../base/common/network.js';
+import { MarkerSeverity } from '../../../../platform/markers/common/markers.js';
+import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { FileType } from '../../../../platform/files/common/files.js';
+
+var FileLocationKind;
+(function(FileLocationKind) {
+    FileLocationKind[FileLocationKind["Default"] = 0] = "Default";
+    FileLocationKind[FileLocationKind["Relative"] = 1] = "Relative";
+    FileLocationKind[FileLocationKind["Absolute"] = 2] = "Absolute";
+    FileLocationKind[FileLocationKind["AutoDetect"] = 3] = "AutoDetect";
+    FileLocationKind[FileLocationKind["Search"] = 4] = "Search";
+})(FileLocationKind || (FileLocationKind = {}));
+(function(FileLocationKind) {
+    function fromString(value) {
+        value = value.toLowerCase();
+        if (value === "absolute") {
+            return FileLocationKind.Absolute;
+        } else if (value === "relative") {
+            return FileLocationKind.Relative;
+        } else if (value === "autodetect") {
+            return FileLocationKind.AutoDetect;
+        } else if (value === "search") {
+            return FileLocationKind.Search;
+        } else {
+            return undefined;
+        }
+    }
+    FileLocationKind.fromString = fromString;
+})(FileLocationKind || (FileLocationKind = {}));
+var ProblemLocationKind;
+(function(ProblemLocationKind) {
+    ProblemLocationKind[ProblemLocationKind["File"] = 0] = "File";
+    ProblemLocationKind[ProblemLocationKind["Location"] = 1] = "Location";
+})(ProblemLocationKind || (ProblemLocationKind = {}));
+(function(ProblemLocationKind) {
+    function fromString(value) {
+        value = value.toLowerCase();
+        if (value === "file") {
+            return ProblemLocationKind.File;
+        } else if (value === "location") {
+            return ProblemLocationKind.Location;
+        } else {
+            return undefined;
+        }
+    }
+    ProblemLocationKind.fromString = fromString;
+})(ProblemLocationKind || (ProblemLocationKind = {}));
+var ApplyToKind;
+(function(ApplyToKind) {
+    ApplyToKind[ApplyToKind["allDocuments"] = 0] = "allDocuments";
+    ApplyToKind[ApplyToKind["openDocuments"] = 1] = "openDocuments";
+    ApplyToKind[ApplyToKind["closedDocuments"] = 2] = "closedDocuments";
+})(ApplyToKind || (ApplyToKind = {}));
+(function(ApplyToKind) {
+    function fromString(value) {
+        value = value.toLowerCase();
+        if (value === "alldocuments") {
+            return ApplyToKind.allDocuments;
+        } else if (value === "opendocuments") {
+            return ApplyToKind.openDocuments;
+        } else if (value === "closeddocuments") {
+            return ApplyToKind.closedDocuments;
+        } else {
+            return undefined;
+        }
+    }
+    ApplyToKind.fromString = fromString;
+})(ApplyToKind || (ApplyToKind = {}));
+function isNamedProblemMatcher(value) {
+    return value && isString(value.name) ? true : false;
+}
+async function getResource(filename, matcher, fileService) {
+    const kind = matcher.fileLocation;
+    let fullPath;
+    if (kind === FileLocationKind.Absolute) {
+        fullPath = filename;
+    } else if ((kind === FileLocationKind.Relative) && matcher.filePrefix && isString(matcher.filePrefix)) {
+        fullPath = join(matcher.filePrefix, filename);
+    } else if (kind === FileLocationKind.AutoDetect) {
+        const matcherClone = deepClone(matcher);
+        matcherClone.fileLocation = FileLocationKind.Relative;
+        if (fileService) {
+            const relative = await getResource(filename, matcherClone);
+            let stat = undefined;
+            try {
+                stat = await fileService.stat(relative);
+            } catch (ex) {}
+            if (stat) {
+                return relative;
+            }
+        }
+        matcherClone.fileLocation = FileLocationKind.Absolute;
+        return getResource(filename, matcherClone);
+    } else if (kind === FileLocationKind.Search && fileService) {
+        const fsProvider = fileService.getProvider(Schemas$1.file);
+        if (fsProvider) {
+            const uri = await searchForFileLocation(filename, fsProvider, matcher.filePrefix);
+            fullPath = uri?.path;
+        }
+        if (!fullPath) {
+            const absoluteMatcher = deepClone(matcher);
+            absoluteMatcher.fileLocation = FileLocationKind.Absolute;
+            return getResource(filename, absoluteMatcher);
+        }
+    }
+    if (fullPath === undefined) {
+        throw ( new Error(
+            "FileLocationKind is not actionable. Does the matcher have a filePrefix? This should never happen."
+        ));
+    }
+    fullPath = normalize(fullPath);
+    fullPath = fullPath.replace(/\\/g, "/");
+    if (fullPath[0] !== "/") {
+        fullPath = "/" + fullPath;
+    }
+    if (matcher.uriProvider !== undefined) {
+        return matcher.uriProvider(fullPath);
+    } else {
+        return URI.file(fullPath);
+    }
+}
+async function searchForFileLocation(filename, fsProvider, args) {
+    const exclusions = ( new Set(( asArray(args.exclude || []).map(x => URI.file(x).path))));
+    async function search(dir) {
+        if (( exclusions.has(dir.path))) {
+            return undefined;
+        }
+        const entries = await fsProvider.readdir(dir);
+        const subdirs = [];
+        for (const [name, fileType] of entries) {
+            if (fileType === FileType.Directory) {
+                subdirs.push(URI.joinPath(dir, name));
+                continue;
+            }
+            if (fileType === FileType.File) {
+                const fullUri = URI.joinPath(dir, name);
+                if (fullUri.path.endsWith(filename)) {
+                    return fullUri;
+                }
+            }
+        }
+        for (const subdir of subdirs) {
+            const result = await search(subdir);
+            if (result) {
+                return result;
+            }
+        }
+        return undefined;
+    }
+    for (const dir of asArray(args.include || [])) {
+        const hit = await search(URI.file(dir));
+        if (hit) {
+            return hit;
+        }
+    }
+    return undefined;
+}
+function createLineMatcher(matcher, fileService, logService) {
+    const pattern = matcher.pattern;
+    if (Array.isArray(pattern)) {
+        return ( new MultiLineMatcher(matcher, fileService, logService));
+    } else {
+        return ( new SingleLineMatcher(matcher, fileService, logService));
+    }
+}
+const endOfLine = OS === OperatingSystem.Windows ? "\r\n" : "\n";
+class AbstractLineMatcher {
+    constructor(matcher, fileService, logService) {
+        this.matcher = matcher;
+        this.fileService = fileService;
+        this.logService = logService;
+    }
+    handle(lines, start = 0) {
+        return {
+            match: null,
+            continue: false
+        };
+    }
+    next(line) {
+        return null;
+    }
+    regexpExec(regexp, line) {
+        const start = Date.now();
+        const result = regexp.exec(line);
+        const elapsed = Date.now() - start;
+        if (elapsed > 5) {
+            this.logService?.trace(`ProblemMatcher: slow regexp took ${elapsed}ms to execute`, regexp.source);
+        }
+        return result;
+    }
+    fillProblemData(data, pattern, matches) {
+        if (data) {
+            this.fillProperty(data, "file", pattern, matches, true);
+            this.appendProperty(data, "message", pattern, matches, true);
+            this.fillProperty(data, "code", pattern, matches, true);
+            this.fillProperty(data, "severity", pattern, matches, true);
+            this.fillProperty(data, "location", pattern, matches, true);
+            this.fillProperty(data, "line", pattern, matches);
+            this.fillProperty(data, "character", pattern, matches);
+            this.fillProperty(data, "endLine", pattern, matches);
+            this.fillProperty(data, "endCharacter", pattern, matches);
+            return true;
+        } else {
+            return false;
+        }
+    }
+    appendProperty(data, property, pattern, matches, trim$1 = false) {
+        const patternProperty = pattern[property];
+        if (isUndefined(data[property])) {
+            this.fillProperty(data, property, pattern, matches, trim$1);
+        } else if (!isUndefined(patternProperty) && patternProperty < matches.length) {
+            let value = matches[patternProperty];
+            if (trim$1) {
+                value = trim(value);
+            }
+            data[property] = data[property] + endOfLine + value;
+        }
+    }
+    fillProperty(data, property, pattern, matches, trim$1 = false) {
+        const patternAtProperty = pattern[property];
+        if (isUndefined(data[property]) && !isUndefined(patternAtProperty) && patternAtProperty < matches.length) {
+            let value = matches[patternAtProperty];
+            if (value !== undefined) {
+                if (trim$1) {
+                    value = trim(value);
+                }
+                data[property] = value;
+            }
+        }
+    }
+    getMarkerMatch(data) {
+        try {
+            const location = this.getLocation(data);
+            if (data.file && location && data.message) {
+                const marker = {
+                    severity: this.getSeverity(data),
+                    startLineNumber: location.startLineNumber,
+                    startColumn: location.startCharacter,
+                    endLineNumber: location.endLineNumber,
+                    endColumn: location.endCharacter,
+                    message: data.message
+                };
+                if (data.code !== undefined) {
+                    marker.code = data.code;
+                }
+                if (this.matcher.source !== undefined) {
+                    marker.source = this.matcher.source;
+                }
+                return {
+                    description: this.matcher,
+                    resource: this.getResource(data.file),
+                    marker: marker
+                };
+            }
+        } catch (err) {
+            console.error(`Failed to convert problem data into match: ${JSON.stringify(data)}`);
+        }
+        return undefined;
+    }
+    getResource(filename) {
+        return getResource(filename, this.matcher, this.fileService);
+    }
+    getLocation(data) {
+        if (data.kind === ProblemLocationKind.File) {
+            return this.createLocation(0, 0, 0, 0);
+        }
+        if (data.location) {
+            return this.parseLocationInfo(data.location);
+        }
+        if (!data.line) {
+            return null;
+        }
+        const startLine = parseInt(data.line);
+        const startColumn = data.character ? parseInt(data.character) : undefined;
+        const endLine = data.endLine ? parseInt(data.endLine) : undefined;
+        const endColumn = data.endCharacter ? parseInt(data.endCharacter) : undefined;
+        return this.createLocation(startLine, startColumn, endLine, endColumn);
+    }
+    parseLocationInfo(value) {
+        if (!value || !value.match(/(\d+|\d+,\d+|\d+,\d+,\d+,\d+)/)) {
+            return null;
+        }
+        const parts = value.split(",");
+        const startLine = parseInt(parts[0]);
+        const startColumn = parts.length > 1 ? parseInt(parts[1]) : undefined;
+        if (parts.length > 3) {
+            return this.createLocation(startLine, startColumn, parseInt(parts[2]), parseInt(parts[3]));
+        } else {
+            return this.createLocation(startLine, startColumn, undefined, undefined);
+        }
+    }
+    createLocation(startLine, startColumn, endLine, endColumn) {
+        if (startColumn !== undefined && endColumn !== undefined) {
+            return {
+                startLineNumber: startLine,
+                startCharacter: startColumn,
+                endLineNumber: endLine || startLine,
+                endCharacter: endColumn
+            };
+        }
+        if (startColumn !== undefined) {
+            return {
+                startLineNumber: startLine,
+                startCharacter: startColumn,
+                endLineNumber: startLine,
+                endCharacter: startColumn
+            };
+        }
+        return {
+            startLineNumber: startLine,
+            startCharacter: 1,
+            endLineNumber: startLine,
+            endCharacter: 2 ** 31 - 1
+        };
+    }
+    getSeverity(data) {
+        let result = null;
+        if (data.severity) {
+            const value = data.severity;
+            if (value) {
+                result = Severity$1.fromValue(value);
+                if (result === Severity$1.Ignore) {
+                    if (value === "E") {
+                        result = Severity$1.Error;
+                    } else if (value === "W") {
+                        result = Severity$1.Warning;
+                    } else if (value === "I") {
+                        result = Severity$1.Info;
+                    } else if (equalsIgnoreCase(value, "hint")) {
+                        result = Severity$1.Info;
+                    } else if (equalsIgnoreCase(value, "note")) {
+                        result = Severity$1.Info;
+                    }
+                }
+            }
+        }
+        if (result === null || result === Severity$1.Ignore) {
+            result = this.matcher.severity || Severity$1.Error;
+        }
+        return MarkerSeverity.fromSeverity(result);
+    }
+}
+class SingleLineMatcher extends AbstractLineMatcher {
+    constructor(matcher, fileService, logService) {
+        super(matcher, fileService, logService);
+        this.pattern = matcher.pattern;
+    }
+    get matchLength() {
+        return 1;
+    }
+    handle(lines, start = 0) {
+        ok(lines.length - start === 1);
+        const data = Object.create(null);
+        if (this.pattern.kind !== undefined) {
+            data.kind = this.pattern.kind;
+        }
+        const matches = this.regexpExec(this.pattern.regexp, lines[start]);
+        if (matches) {
+            this.fillProblemData(data, this.pattern, matches);
+            if (data.kind === ProblemLocationKind.Location && !data.location && !data.line && data.file) {
+                data.kind = ProblemLocationKind.File;
+            }
+            const match = this.getMarkerMatch(data);
+            if (match) {
+                return {
+                    match: match,
+                    continue: false
+                };
+            }
+        }
+        return {
+            match: null,
+            continue: false
+        };
+    }
+    next(line) {
+        return null;
+    }
+}
+class MultiLineMatcher extends AbstractLineMatcher {
+    constructor(matcher, fileService, logService) {
+        super(matcher, fileService, logService);
+        this.patterns = matcher.pattern;
+    }
+    get matchLength() {
+        return this.patterns.length;
+    }
+    handle(lines, start = 0) {
+        ok(lines.length - start === this.patterns.length);
+        this.data = Object.create(null);
+        let data = this.data;
+        data.kind = this.patterns[0].kind;
+        for (let i = 0; i < this.patterns.length; i++) {
+            const pattern = this.patterns[i];
+            const matches = this.regexpExec(pattern.regexp, lines[i + start]);
+            if (!matches) {
+                return {
+                    match: null,
+                    continue: false
+                };
+            } else {
+                if (pattern.loop && i === this.patterns.length - 1) {
+                    data = deepClone(data);
+                }
+                this.fillProblemData(data, pattern, matches);
+            }
+        }
+        const loop = !!this.patterns[this.patterns.length - 1].loop;
+        if (!loop) {
+            this.data = undefined;
+        }
+        const markerMatch = data ? this.getMarkerMatch(data) : null;
+        return {
+            match: markerMatch ? markerMatch : null,
+            continue: loop
+        };
+    }
+    next(line) {
+        const pattern = this.patterns[this.patterns.length - 1];
+        ok(pattern.loop === true && this.data !== null);
+        const matches = this.regexpExec(pattern.regexp, line);
+        if (!matches) {
+            this.data = undefined;
+            return null;
+        }
+        const data = deepClone(this.data);
+        let problemMatch;
+        if (this.fillProblemData(data, pattern, matches)) {
+            problemMatch = this.getMarkerMatch(data);
+        }
+        return problemMatch ? problemMatch : null;
+    }
+}
+var Config;
+(function(Config) {
+    (function(CheckedProblemPattern) {
+        function is(value) {
+            const candidate = value;
+            return candidate && isString(candidate.regexp);
+        }
+        CheckedProblemPattern.is = is;
+    })(
+        Config.CheckedProblemPattern || (Config.CheckedProblemPattern = {})
+    );
+    let NamedProblemPattern;
+    (function(NamedProblemPattern) {
+        function is(value) {
+            const candidate = value;
+            return candidate && isString(candidate.name);
+        }
+        NamedProblemPattern.is = is;
+    })(
+        NamedProblemPattern = Config.NamedProblemPattern || (Config.NamedProblemPattern = {})
+    );
+    (function(NamedCheckedProblemPattern) {
+        function is(value) {
+            const candidate = value;
+            return candidate && NamedProblemPattern.is(candidate) && isString(candidate.regexp);
+        }
+        NamedCheckedProblemPattern.is = is;
+    })(
+        Config.NamedCheckedProblemPattern || (Config.NamedCheckedProblemPattern = {})
+    );
+    let MultiLineProblemPattern;
+    (function(MultiLineProblemPattern) {
+        function is(value) {
+            return Array.isArray(value);
+        }
+        MultiLineProblemPattern.is = is;
+    })(
+        MultiLineProblemPattern = Config.MultiLineProblemPattern || (Config.MultiLineProblemPattern = {})
+    );
+    let MultiLineCheckedProblemPattern;
+    (function(MultiLineCheckedProblemPattern) {
+        function is(value) {
+            if (!MultiLineProblemPattern.is(value)) {
+                return false;
+            }
+            for (const element of value) {
+                if (!Config.CheckedProblemPattern.is(element)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        MultiLineCheckedProblemPattern.is = is;
+    })(
+        MultiLineCheckedProblemPattern = Config.MultiLineCheckedProblemPattern || (Config.MultiLineCheckedProblemPattern = {})
+    );
+    (function(NamedMultiLineCheckedProblemPattern) {
+        function is(value) {
+            const candidate = value;
+            return candidate && isString(candidate.name) && Array.isArray(candidate.patterns) && MultiLineCheckedProblemPattern.is(candidate.patterns);
+        }
+        NamedMultiLineCheckedProblemPattern.is = is;
+    })(
+        Config.NamedMultiLineCheckedProblemPattern || (Config.NamedMultiLineCheckedProblemPattern = {})
+    );
+    function isNamedProblemMatcher(value) {
+        return isString(value.name);
+    }
+    Config.isNamedProblemMatcher = isNamedProblemMatcher;
+})(Config || (Config = {}));
+class ProblemPatternParser extends Parser {
+    constructor(logger) {
+        super(logger);
+    }
+    parse(value) {
+        if (Config.NamedMultiLineCheckedProblemPattern.is(value)) {
+            return this.createNamedMultiLineProblemPattern(value);
+        } else if (Config.MultiLineCheckedProblemPattern.is(value)) {
+            return this.createMultiLineProblemPattern(value);
+        } else if (Config.NamedCheckedProblemPattern.is(value)) {
+            const result = this.createSingleProblemPattern(value);
+            result.name = value.name;
+            return result;
+        } else if (Config.CheckedProblemPattern.is(value)) {
+            return this.createSingleProblemPattern(value);
+        } else {
+            this.error(( localize(12910, "The problem pattern is missing a regular expression.")));
+            return null;
+        }
+    }
+    createSingleProblemPattern(value) {
+        const result = this.doCreateSingleProblemPattern(value, true);
+        if (result === undefined) {
+            return null;
+        } else if (result.kind === undefined) {
+            result.kind = ProblemLocationKind.Location;
+        }
+        return this.validateProblemPattern([result]) ? result : null;
+    }
+    createNamedMultiLineProblemPattern(value) {
+        const validPatterns = this.createMultiLineProblemPattern(value.patterns);
+        if (!validPatterns) {
+            return null;
+        }
+        const result = {
+            name: value.name,
+            label: value.label ? value.label : value.name,
+            patterns: validPatterns
+        };
+        return result;
+    }
+    createMultiLineProblemPattern(values) {
+        const result = [];
+        for (let i = 0; i < values.length; i++) {
+            const pattern = this.doCreateSingleProblemPattern(values[i], false);
+            if (pattern === undefined) {
+                return null;
+            }
+            if (i < values.length - 1) {
+                if (!isUndefined(pattern.loop) && pattern.loop) {
+                    pattern.loop = false;
+                    this.error(( localize(12911, "The loop property is only supported on the last line matcher.")));
+                }
+            }
+            result.push(pattern);
+        }
+        if (!result || result.length === 0) {
+            this.error(( localize(
+                12912,
+                "The problem pattern is invalid. It must contain at least one pattern."
+            )));
+            return null;
+        }
+        if (result[0].kind === undefined) {
+            result[0].kind = ProblemLocationKind.Location;
+        }
+        return this.validateProblemPattern(result) ? result : null;
+    }
+    doCreateSingleProblemPattern(value, setDefaults) {
+        const regexp = this.createRegularExpression(value.regexp);
+        if (regexp === undefined) {
+            return undefined;
+        }
+        let result = {
+            regexp
+        };
+        if (value.kind) {
+            result.kind = ProblemLocationKind.fromString(value.kind);
+        }
+        function copyProperty(result, source, resultKey, sourceKey) {
+            const value = source[sourceKey];
+            if (typeof value === "number") {
+                result[resultKey] = value;
+            }
+        }
+        copyProperty(result, value, "file", "file");
+        copyProperty(result, value, "location", "location");
+        copyProperty(result, value, "line", "line");
+        copyProperty(result, value, "character", "column");
+        copyProperty(result, value, "endLine", "endLine");
+        copyProperty(result, value, "endCharacter", "endColumn");
+        copyProperty(result, value, "severity", "severity");
+        copyProperty(result, value, "code", "code");
+        copyProperty(result, value, "message", "message");
+        if (value.loop === true || value.loop === false) {
+            result.loop = value.loop;
+        }
+        if (setDefaults) {
+            if (result.location || result.kind === ProblemLocationKind.File) {
+                const defaultValue = {
+                    file: 1,
+                    message: 0
+                };
+                result = mixin(result, defaultValue, false);
+            } else {
+                const defaultValue = {
+                    file: 1,
+                    line: 2,
+                    character: 3,
+                    message: 0
+                };
+                result = mixin(result, defaultValue, false);
+            }
+        }
+        return result;
+    }
+    validateProblemPattern(values) {
+        if (!values || values.length === 0) {
+            this.error(( localize(
+                12912,
+                "The problem pattern is invalid. It must contain at least one pattern."
+            )));
+            return false;
+        }
+        let file = false, message = false, location = false, line = false;
+        const locationKind = (values[0].kind === undefined) ? ProblemLocationKind.Location : values[0].kind;
+        values.forEach((pattern, i) => {
+            if (i !== 0 && pattern.kind) {
+                this.error(( localize(
+                    12913,
+                    "The problem pattern is invalid. The kind property must be provided only in the first element"
+                )));
+            }
+            file = file || !isUndefined(pattern.file);
+            message = message || !isUndefined(pattern.message);
+            location = location || !isUndefined(pattern.location);
+            line = line || !isUndefined(pattern.line);
+        });
+        if (!(file && message)) {
+            this.error(( localize(
+                12914,
+                "The problem pattern is invalid. It must have at least have a file and a message."
+            )));
+            return false;
+        }
+        if (locationKind === ProblemLocationKind.Location && !(location || line)) {
+            this.error(( localize(
+                12915,
+                "The problem pattern is invalid. It must either have kind: \"file\" or have a line or location match group."
+            )));
+            return false;
+        }
+        return true;
+    }
+    createRegularExpression(value) {
+        let result;
+        try {
+            result = ( new RegExp(value));
+        } catch (err) {
+            this.error(( localize(12916, "Error: The string {0} is not a valid regular expression.\n", value)));
+        }
+        return result;
+    }
+}
+class ExtensionRegistryReporter {
+    constructor(
+        _collector,
+        _validationStatus = ( new ValidationStatus())
+    ) {
+        this._collector = _collector;
+        this._validationStatus = _validationStatus;
+    }
+    info(message) {
+        this._validationStatus.state = ValidationState.Info;
+        this._collector.info(message);
+    }
+    warn(message) {
+        this._validationStatus.state = ValidationState.Warning;
+        this._collector.warn(message);
+    }
+    error(message) {
+        this._validationStatus.state = ValidationState.Error;
+        this._collector.error(message);
+    }
+    fatal(message) {
+        this._validationStatus.state = ValidationState.Fatal;
+        this._collector.error(message);
+    }
+    get status() {
+        return this._validationStatus;
+    }
+}
+var Schemas;
+(function(Schemas) {
+    Schemas.ProblemPattern = {
+        default: {
+            regexp: "^([^\\\\s].*)\\\\((\\\\d+,\\\\d+)\\\\):\\\\s*(.*)$",
+            file: 1,
+            location: 2,
+            message: 3
+        },
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            regexp: {
+                type: "string",
+                description: ( localize(
+                    12917,
+                    "The regular expression to find an error, warning or info in the output."
+                ))
+            },
+            kind: {
+                type: "string",
+                description: ( localize(
+                    12918,
+                    "whether the pattern matches a location (file and line) or only a file."
+                ))
+            },
+            file: {
+                type: "integer",
+                description: ( localize(12919, "The match group index of the filename. If omitted 1 is used."))
+            },
+            location: {
+                type: "integer",
+                description: ( localize(
+                    12920,
+                    "The match group index of the problem's location. Valid location patterns are: (line), (line,column) and (startLine,startColumn,endLine,endColumn). If omitted (line,column) is assumed."
+                ))
+            },
+            line: {
+                type: "integer",
+                description: ( localize(12921, "The match group index of the problem's line. Defaults to 2"))
+            },
+            column: {
+                type: "integer",
+                description: ( localize(
+                    12922,
+                    "The match group index of the problem's line character. Defaults to 3"
+                ))
+            },
+            endLine: {
+                type: "integer",
+                description: ( localize(
+                    12923,
+                    "The match group index of the problem's end line. Defaults to undefined"
+                ))
+            },
+            endColumn: {
+                type: "integer",
+                description: ( localize(
+                    12924,
+                    "The match group index of the problem's end line character. Defaults to undefined"
+                ))
+            },
+            severity: {
+                type: "integer",
+                description: ( localize(
+                    12925,
+                    "The match group index of the problem's severity. Defaults to undefined"
+                ))
+            },
+            code: {
+                type: "integer",
+                description: ( localize(
+                    12926,
+                    "The match group index of the problem's code. Defaults to undefined"
+                ))
+            },
+            message: {
+                type: "integer",
+                description: ( localize(
+                    12927,
+                    "The match group index of the message. If omitted it defaults to 4 if location is specified. Otherwise it defaults to 5."
+                ))
+            },
+            loop: {
+                type: "boolean",
+                description: ( localize(
+                    12928,
+                    "In a multi line matcher loop indicated whether this pattern is executed in a loop as long as it matches. Can only specified on a last pattern in a multi line pattern."
+                ))
+            }
+        }
+    };
+    Schemas.NamedProblemPattern = deepClone(Schemas.ProblemPattern);
+    Schemas.NamedProblemPattern.properties = deepClone(Schemas.NamedProblemPattern.properties) || {};
+    Schemas.NamedProblemPattern.properties["name"] = {
+        type: "string",
+        description: ( localize(12929, "The name of the problem pattern."))
+    };
+    Schemas.MultiLineProblemPattern = {
+        type: "array",
+        items: Schemas.ProblemPattern
+    };
+    Schemas.NamedMultiLineProblemPattern = {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            name: {
+                type: "string",
+                description: ( localize(12930, "The name of the problem multi line problem pattern."))
+            },
+            patterns: {
+                type: "array",
+                description: ( localize(12931, "The actual patterns.")),
+                items: Schemas.ProblemPattern
+            }
+        }
+    };
+    Schemas.WatchingPattern = {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            regexp: {
+                type: "string",
+                description: ( localize(
+                    12932,
+                    "The regular expression to detect the begin or end of a background task."
+                ))
+            },
+            file: {
+                type: "integer",
+                description: ( localize(12933, "The match group index of the filename. Can be omitted."))
+            }
+        }
+    };
+    Schemas.PatternType = {
+        anyOf: [{
+            type: "string",
+            description: ( localize(12934, "The name of a contributed or predefined pattern"))
+        }, Schemas.ProblemPattern, Schemas.MultiLineProblemPattern],
+        description: ( localize(
+            12935,
+            "A problem pattern or the name of a contributed or predefined problem pattern. Can be omitted if base is specified."
+        ))
+    };
+    Schemas.ProblemMatcher = {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            base: {
+                type: "string",
+                description: ( localize(12936, "The name of a base problem matcher to use."))
+            },
+            owner: {
+                type: "string",
+                description: ( localize(
+                    12937,
+                    "The owner of the problem inside Code. Can be omitted if base is specified. Defaults to 'external' if omitted and base is not specified."
+                ))
+            },
+            source: {
+                type: "string",
+                description: ( localize(
+                    12938,
+                    "A human-readable string describing the source of this diagnostic, e.g. 'typescript' or 'super lint'."
+                ))
+            },
+            severity: {
+                type: "string",
+                enum: ["error", "warning", "info"],
+                description: ( localize(
+                    12939,
+                    "The default severity for captures problems. Is used if the pattern doesn't define a match group for severity."
+                ))
+            },
+            applyTo: {
+                type: "string",
+                enum: ["allDocuments", "openDocuments", "closedDocuments"],
+                description: ( localize(
+                    12940,
+                    "Controls if a problem reported on a text document is applied only to open, closed or all documents."
+                ))
+            },
+            pattern: Schemas.PatternType,
+            fileLocation: {
+                oneOf: [{
+                    type: "string",
+                    enum: ["absolute", "relative", "autoDetect", "search"]
+                }, {
+                    type: "array",
+                    prefixItems: [{
+                        type: "string",
+                        enum: ["absolute", "relative", "autoDetect", "search"]
+                    }],
+                    minItems: 1,
+                    maxItems: 1,
+                    additionalItems: false
+                }, {
+                    type: "array",
+                    prefixItems: [{
+                        type: "string",
+                        enum: ["relative", "autoDetect"]
+                    }, {
+                        type: "string"
+                    }],
+                    minItems: 2,
+                    maxItems: 2,
+                    additionalItems: false,
+                    examples: [["relative", "${workspaceFolder}"], ["autoDetect", "${workspaceFolder}"]]
+                }, {
+                    type: "array",
+                    prefixItems: [{
+                        type: "string",
+                        enum: ["search"]
+                    }, {
+                        type: "object",
+                        properties: {
+                            "include": {
+                                oneOf: [{
+                                    type: "string"
+                                }, {
+                                    type: "array",
+                                    items: {
+                                        type: "string"
+                                    }
+                                }]
+                            },
+                            "exclude": {
+                                oneOf: [{
+                                    type: "string"
+                                }, {
+                                    type: "array",
+                                    items: {
+                                        type: "string"
+                                    }
+                                }]
+                            }
+                        },
+                        required: ["include"]
+                    }],
+                    minItems: 2,
+                    maxItems: 2,
+                    additionalItems: false,
+                    examples: [["search", {
+                        "include": ["${workspaceFolder}"]
+                    }], ["search", {
+                        "include": ["${workspaceFolder}"],
+                        "exclude": []
+                    }]]
+                }],
+                description: ( localize(
+                    12941,
+                    "Defines how file names reported in a problem pattern should be interpreted. A relative fileLocation may be an array, where the second element of the array is the path of the relative file location. The search fileLocation mode, performs a deep (and, possibly, heavy) file system search within the directories specified by the include/exclude properties of the second element (or the current workspace directory if not specified)."
+                ))
+            },
+            background: {
+                type: "object",
+                additionalProperties: false,
+                description: ( localize(
+                    12942,
+                    "Patterns to track the begin and end of a matcher active on a background task."
+                )),
+                properties: {
+                    activeOnStart: {
+                        type: "boolean",
+                        description: ( localize(
+                            12943,
+                            "If set to true the background monitor starts in active mode. This is the same as outputting a line that matches beginsPattern when the task starts."
+                        ))
+                    },
+                    beginsPattern: {
+                        oneOf: [{
+                            type: "string"
+                        }, Schemas.WatchingPattern],
+                        description: ( localize(
+                            12944,
+                            "If matched in the output the start of a background task is signaled."
+                        ))
+                    },
+                    endsPattern: {
+                        oneOf: [{
+                            type: "string"
+                        }, Schemas.WatchingPattern],
+                        description: ( localize(
+                            12945,
+                            "If matched in the output the end of a background task is signaled."
+                        ))
+                    }
+                }
+            },
+            watching: {
+                type: "object",
+                additionalProperties: false,
+                deprecationMessage: ( localize(12946, "The watching property is deprecated. Use background instead.")),
+                description: ( localize(12947, "Patterns to track the begin and end of a watching matcher.")),
+                properties: {
+                    activeOnStart: {
+                        type: "boolean",
+                        description: ( localize(
+                            12948,
+                            "If set to true the watcher starts in active mode. This is the same as outputting a line that matches beginsPattern when the task starts."
+                        ))
+                    },
+                    beginsPattern: {
+                        oneOf: [{
+                            type: "string"
+                        }, Schemas.WatchingPattern],
+                        description: ( localize(
+                            12949,
+                            "If matched in the output the start of a watching task is signaled."
+                        ))
+                    },
+                    endsPattern: {
+                        oneOf: [{
+                            type: "string"
+                        }, Schemas.WatchingPattern],
+                        description: ( localize(12950, "If matched in the output the end of a watching task is signaled."))
+                    }
+                }
+            }
+        }
+    };
+    Schemas.LegacyProblemMatcher = deepClone(Schemas.ProblemMatcher);
+    Schemas.LegacyProblemMatcher.properties = deepClone(Schemas.LegacyProblemMatcher.properties) || {};
+    Schemas.LegacyProblemMatcher.properties["watchedTaskBeginsRegExp"] = {
+        type: "string",
+        deprecationMessage: ( localize(12951, "This property is deprecated. Use the watching property instead.")),
+        description: ( localize(
+            12952,
+            "A regular expression signaling that a watched tasks begins executing triggered through file watching."
+        ))
+    };
+    Schemas.LegacyProblemMatcher.properties["watchedTaskEndsRegExp"] = {
+        type: "string",
+        deprecationMessage: ( localize(12953, "This property is deprecated. Use the watching property instead.")),
+        description: ( localize(
+            12954,
+            "A regular expression signaling that a watched tasks ends executing."
+        ))
+    };
+    Schemas.NamedProblemMatcher = deepClone(Schemas.ProblemMatcher);
+    Schemas.NamedProblemMatcher.properties = deepClone(Schemas.NamedProblemMatcher.properties) || {};
+    Schemas.NamedProblemMatcher.properties.name = {
+        type: "string",
+        description: ( localize(12955, "The name of the problem matcher used to refer to it."))
+    };
+    Schemas.NamedProblemMatcher.properties.label = {
+        type: "string",
+        description: ( localize(12956, "A human readable label of the problem matcher."))
+    };
+})(Schemas || (Schemas = {}));
+const problemPatternExtPoint = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: "problemPatterns",
+    jsonSchema: {
+        description: ( localize(12957, "Contributes problem patterns")),
+        type: "array",
+        items: {
+            anyOf: [Schemas.NamedProblemPattern, Schemas.NamedMultiLineProblemPattern]
+        }
+    }
+});
+class ProblemPatternRegistryImpl {
+    constructor() {
+        this.patterns = Object.create(null);
+        this.fillDefaults();
+        this.readyPromise = ( new Promise((resolve, reject) => {
+            problemPatternExtPoint.setHandler((extensions, delta) => {
+                try {
+                    delta.removed.forEach(extension => {
+                        const problemPatterns = extension.value;
+                        for (const pattern of problemPatterns) {
+                            if (this.patterns[pattern.name]) {
+                                delete this.patterns[pattern.name];
+                            }
+                        }
+                    });
+                    delta.added.forEach(extension => {
+                        const problemPatterns = extension.value;
+                        const parser = ( new ProblemPatternParser(( new ExtensionRegistryReporter(extension.collector))));
+                        for (const pattern of problemPatterns) {
+                            if (Config.NamedMultiLineCheckedProblemPattern.is(pattern)) {
+                                const result = parser.parse(pattern);
+                                if (parser.problemReporter.status.state < ValidationState.Error) {
+                                    this.add(result.name, result.patterns);
+                                } else {
+                                    extension.collector.error(( localize(12958, "Invalid problem pattern. The pattern will be ignored.")));
+                                    extension.collector.error(JSON.stringify(pattern, undefined, 4));
+                                }
+                            } else if (Config.NamedProblemPattern.is(pattern)) {
+                                const result = parser.parse(pattern);
+                                if (parser.problemReporter.status.state < ValidationState.Error) {
+                                    this.add(pattern.name, result);
+                                } else {
+                                    extension.collector.error(( localize(12958, "Invalid problem pattern. The pattern will be ignored.")));
+                                    extension.collector.error(JSON.stringify(pattern, undefined, 4));
+                                }
+                            }
+                            parser.reset();
+                        }
+                    });
+                } catch (error) {}
+                resolve(undefined);
+            });
+        }));
+    }
+    onReady() {
+        return this.readyPromise;
+    }
+    add(key, value) {
+        this.patterns[key] = value;
+    }
+    get(key) {
+        return this.patterns[key];
+    }
+    fillDefaults() {
+        this.add("msCompile", {
+            regexp: /^\s*(?:\s*\d+>)?(\S.*?)(?:\((\d+|\d+,\d+|\d+,\d+,\d+,\d+)\))?\s*:\s+(?:(\S+)\s+)?((?:fatal +)?error|warning|info)\s+(\w+\d+)?\s*:\s*(.*)$/,
+            kind: ProblemLocationKind.Location,
+            file: 1,
+            location: 2,
+            severity: 4,
+            code: 5,
+            message: 6
+        });
+        this.add("gulp-tsc", {
+            regexp: /^([^\s].*)\((\d+|\d+,\d+|\d+,\d+,\d+,\d+)\):\s+(\d+)\s+(.*)$/,
+            kind: ProblemLocationKind.Location,
+            file: 1,
+            location: 2,
+            code: 3,
+            message: 4
+        });
+        this.add("cpp", {
+            regexp: /^(\S.*)\((\d+|\d+,\d+|\d+,\d+,\d+,\d+)\):\s+(error|warning|info)\s+(C\d+)\s*:\s*(.*)$/,
+            kind: ProblemLocationKind.Location,
+            file: 1,
+            location: 2,
+            severity: 3,
+            code: 4,
+            message: 5
+        });
+        this.add("csc", {
+            regexp: /^(\S.*)\((\d+|\d+,\d+|\d+,\d+,\d+,\d+)\):\s+(error|warning|info)\s+(CS\d+)\s*:\s*(.*)$/,
+            kind: ProblemLocationKind.Location,
+            file: 1,
+            location: 2,
+            severity: 3,
+            code: 4,
+            message: 5
+        });
+        this.add("vb", {
+            regexp: /^(\S.*)\((\d+|\d+,\d+|\d+,\d+,\d+,\d+)\):\s+(error|warning|info)\s+(BC\d+)\s*:\s*(.*)$/,
+            kind: ProblemLocationKind.Location,
+            file: 1,
+            location: 2,
+            severity: 3,
+            code: 4,
+            message: 5
+        });
+        this.add("lessCompile", {
+            regexp: /^\s*(.*) in file (.*) line no. (\d+)$/,
+            kind: ProblemLocationKind.Location,
+            message: 1,
+            file: 2,
+            line: 3
+        });
+        this.add("jshint", {
+            regexp: /^(.*):\s+line\s+(\d+),\s+col\s+(\d+),\s(.+?)(?:\s+\((\w)(\d+)\))?$/,
+            kind: ProblemLocationKind.Location,
+            file: 1,
+            line: 2,
+            character: 3,
+            message: 4,
+            severity: 5,
+            code: 6
+        });
+        this.add("jshint-stylish", [{
+            regexp: /^(.+)$/,
+            kind: ProblemLocationKind.Location,
+            file: 1
+        }, {
+            regexp: /^\s+line\s+(\d+)\s+col\s+(\d+)\s+(.+?)(?:\s+\((\w)(\d+)\))?$/,
+            line: 1,
+            character: 2,
+            message: 3,
+            severity: 4,
+            code: 5,
+            loop: true
+        }]);
+        this.add("eslint-compact", {
+            regexp: /^(.+):\sline\s(\d+),\scol\s(\d+),\s(Error|Warning|Info)\s-\s(.+)\s\((.+)\)$/,
+            file: 1,
+            kind: ProblemLocationKind.Location,
+            line: 2,
+            character: 3,
+            severity: 4,
+            message: 5,
+            code: 6
+        });
+        this.add("eslint-stylish", [{
+            regexp: /^((?:[a-zA-Z]:)*[./\\]+.*?)$/,
+            kind: ProblemLocationKind.Location,
+            file: 1
+        }, {
+            regexp: /^\s+(\d+):(\d+)\s+(error|warning|info)\s+(.+?)(?:\s\s+(.*))?$/,
+            line: 1,
+            character: 2,
+            severity: 3,
+            message: 4,
+            code: 5,
+            loop: true
+        }]);
+        this.add("go", {
+            regexp: /^([^:]*: )?((.:)?[^:]*):(\d+)(:(\d+))?: (.*)$/,
+            kind: ProblemLocationKind.Location,
+            file: 2,
+            line: 4,
+            character: 6,
+            message: 7
+        });
+    }
+}
+const ProblemPatternRegistry = ( new ProblemPatternRegistryImpl());
+class ProblemMatcherParser extends Parser {
+    constructor(logger) {
+        super(logger);
+    }
+    parse(json) {
+        const result = this.createProblemMatcher(json);
+        if (!this.checkProblemMatcherValid(json, result)) {
+            return undefined;
+        }
+        this.addWatchingMatcher(json, result);
+        return result;
+    }
+    checkProblemMatcherValid(externalProblemMatcher, problemMatcher) {
+        if (!problemMatcher) {
+            this.error(( localize(
+                12959,
+                "Error: the description can't be converted into a problem matcher:\n{0}\n",
+                JSON.stringify(externalProblemMatcher, null, 4)
+            )));
+            return false;
+        }
+        if (!problemMatcher.pattern) {
+            this.error(( localize(
+                12960,
+                "Error: the description doesn't define a valid problem pattern:\n{0}\n",
+                JSON.stringify(externalProblemMatcher, null, 4)
+            )));
+            return false;
+        }
+        if (!problemMatcher.owner) {
+            this.error(( localize(
+                12961,
+                "Error: the description doesn't define an owner:\n{0}\n",
+                JSON.stringify(externalProblemMatcher, null, 4)
+            )));
+            return false;
+        }
+        if (isUndefined(problemMatcher.fileLocation)) {
+            this.error(( localize(
+                12962,
+                "Error: the description doesn't define a file location:\n{0}\n",
+                JSON.stringify(externalProblemMatcher, null, 4)
+            )));
+            return false;
+        }
+        return true;
+    }
+    createProblemMatcher(description) {
+        let result = null;
+        const owner = isString(description.owner) ? description.owner : generateUuid();
+        const source = isString(description.source) ? description.source : undefined;
+        let applyTo = isString(description.applyTo) ? ApplyToKind.fromString(description.applyTo) : ApplyToKind.allDocuments;
+        if (!applyTo) {
+            applyTo = ApplyToKind.allDocuments;
+        }
+        let fileLocation = undefined;
+        let filePrefix = undefined;
+        let kind;
+        if (isUndefined(description.fileLocation)) {
+            fileLocation = FileLocationKind.Relative;
+            filePrefix = "${workspaceFolder}";
+        } else if (isString(description.fileLocation)) {
+            kind = FileLocationKind.fromString(description.fileLocation);
+            if (kind) {
+                fileLocation = kind;
+                if ((kind === FileLocationKind.Relative) || (kind === FileLocationKind.AutoDetect)) {
+                    filePrefix = "${workspaceFolder}";
+                } else if (kind === FileLocationKind.Search) {
+                    filePrefix = {
+                        include: ["${workspaceFolder}"]
+                    };
+                }
+            }
+        } else if (isStringArray(description.fileLocation)) {
+            const values = description.fileLocation;
+            if (values.length > 0) {
+                kind = FileLocationKind.fromString(values[0]);
+                if (values.length === 1 && kind === FileLocationKind.Absolute) {
+                    fileLocation = kind;
+                } else if (values.length === 2 && (kind === FileLocationKind.Relative || kind === FileLocationKind.AutoDetect) && values[1]) {
+                    fileLocation = kind;
+                    filePrefix = values[1];
+                }
+            }
+        } else if (Array.isArray(description.fileLocation)) {
+            const kind = FileLocationKind.fromString(description.fileLocation[0]);
+            if (kind === FileLocationKind.Search) {
+                fileLocation = FileLocationKind.Search;
+                filePrefix = description.fileLocation[1] ?? {
+                    include: ["${workspaceFolder}"]
+                };
+            }
+        }
+        const pattern = description.pattern ? this.createProblemPattern(description.pattern) : undefined;
+        let severity = description.severity ? Severity$1.fromValue(description.severity) : undefined;
+        if (severity === Severity$1.Ignore) {
+            this.info(( localize(
+                12963,
+                "Info: unknown severity {0}. Valid values are error, warning and info.\n",
+                description.severity
+            )));
+            severity = Severity$1.Error;
+        }
+        if (isString(description.base)) {
+            const variableName = description.base;
+            if (variableName.length > 1 && variableName[0] === "$") {
+                const base = ProblemMatcherRegistry.get(variableName.substring(1));
+                if (base) {
+                    result = deepClone(base);
+                    if (description.owner !== undefined && owner !== undefined) {
+                        result.owner = owner;
+                    }
+                    if (description.source !== undefined && source !== undefined) {
+                        result.source = source;
+                    }
+                    if (description.fileLocation !== undefined && fileLocation !== undefined) {
+                        result.fileLocation = fileLocation;
+                        result.filePrefix = filePrefix;
+                    }
+                    if (description.pattern !== undefined && pattern !== undefined && pattern !== null) {
+                        result.pattern = pattern;
+                    }
+                    if (description.severity !== undefined && severity !== undefined) {
+                        result.severity = severity;
+                    }
+                    if (description.applyTo !== undefined && applyTo !== undefined) {
+                        result.applyTo = applyTo;
+                    }
+                }
+            }
+        } else if (fileLocation && pattern) {
+            result = {
+                owner: owner,
+                applyTo: applyTo,
+                fileLocation: fileLocation,
+                pattern: pattern
+            };
+            if (source) {
+                result.source = source;
+            }
+            if (filePrefix) {
+                result.filePrefix = filePrefix;
+            }
+            if (severity) {
+                result.severity = severity;
+            }
+        }
+        if (Config.isNamedProblemMatcher(description)) {
+            result.name = description.name;
+            result.label = isString(description.label) ? description.label : description.name;
+        }
+        return result;
+    }
+    createProblemPattern(value) {
+        if (isString(value)) {
+            const variableName = value;
+            if (variableName.length > 1 && variableName[0] === "$") {
+                const result = ProblemPatternRegistry.get(variableName.substring(1));
+                if (!result) {
+                    this.error(( localize(
+                        12964,
+                        "Error: the pattern with the identifier {0} doesn't exist.",
+                        variableName
+                    )));
+                }
+                return result;
+            } else {
+                if (variableName.length === 0) {
+                    this.error(( localize(12965, "Error: the pattern property refers to an empty identifier.")));
+                } else {
+                    this.error(( localize(
+                        12966,
+                        "Error: the pattern property {0} is not a valid pattern variable name.",
+                        variableName
+                    )));
+                }
+            }
+        } else if (value) {
+            const problemPatternParser = ( new ProblemPatternParser(this.problemReporter));
+            if (Array.isArray(value)) {
+                return problemPatternParser.parse(value);
+            } else {
+                return problemPatternParser.parse(value);
+            }
+        }
+        return null;
+    }
+    addWatchingMatcher(external, internal) {
+        const oldBegins = this.createRegularExpression(external.watchedTaskBeginsRegExp);
+        const oldEnds = this.createRegularExpression(external.watchedTaskEndsRegExp);
+        if (oldBegins && oldEnds) {
+            internal.watching = {
+                activeOnStart: false,
+                beginsPattern: {
+                    regexp: oldBegins
+                },
+                endsPattern: {
+                    regexp: oldEnds
+                }
+            };
+            return;
+        }
+        const backgroundMonitor = external.background || external.watching;
+        if (isUndefinedOrNull(backgroundMonitor)) {
+            return;
+        }
+        const begins = this.createWatchingPattern(backgroundMonitor.beginsPattern);
+        const ends = this.createWatchingPattern(backgroundMonitor.endsPattern);
+        if (begins && ends) {
+            internal.watching = {
+                activeOnStart: isBoolean(backgroundMonitor.activeOnStart) ? backgroundMonitor.activeOnStart : false,
+                beginsPattern: begins,
+                endsPattern: ends
+            };
+            return;
+        }
+        if (begins || ends) {
+            this.error(( localize(
+                12967,
+                "A problem matcher must define both a begin pattern and an end pattern for watching."
+            )));
+        }
+    }
+    createWatchingPattern(external) {
+        if (isUndefinedOrNull(external)) {
+            return null;
+        }
+        let regexp;
+        let file;
+        if (isString(external)) {
+            regexp = this.createRegularExpression(external);
+        } else {
+            regexp = this.createRegularExpression(external.regexp);
+            if (isNumber(external.file)) {
+                file = external.file;
+            }
+        }
+        if (!regexp) {
+            return null;
+        }
+        return file ? {
+            regexp,
+            file
+        } : {
+            regexp,
+            file: 1
+        };
+    }
+    createRegularExpression(value) {
+        let result = null;
+        if (!value) {
+            return result;
+        }
+        try {
+            result = ( new RegExp(value));
+        } catch (err) {
+            this.error(( localize(12968, "Error: The string {0} is not a valid regular expression.\n", value)));
+        }
+        return result;
+    }
+}
+const problemMatchersExtPoint = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: "problemMatchers",
+    deps: [problemPatternExtPoint],
+    jsonSchema: {
+        description: ( localize(12969, "Contributes problem matchers")),
+        type: "array",
+        items: Schemas.NamedProblemMatcher
+    }
+});
+class ProblemMatcherRegistryImpl {
+    constructor() {
+        this._onMatchersChanged = ( new Emitter());
+        this.onMatcherChanged = this._onMatchersChanged.event;
+        this.matchers = Object.create(null);
+        this.fillDefaults();
+        this.readyPromise = ( new Promise((resolve, reject) => {
+            problemMatchersExtPoint.setHandler((extensions, delta) => {
+                try {
+                    delta.removed.forEach(extension => {
+                        const problemMatchers = extension.value;
+                        for (const matcher of problemMatchers) {
+                            if (this.matchers[matcher.name]) {
+                                delete this.matchers[matcher.name];
+                            }
+                        }
+                    });
+                    delta.added.forEach(extension => {
+                        const problemMatchers = extension.value;
+                        const parser = ( new ProblemMatcherParser(( new ExtensionRegistryReporter(extension.collector))));
+                        for (const matcher of problemMatchers) {
+                            const result = parser.parse(matcher);
+                            if (result && isNamedProblemMatcher(result)) {
+                                this.add(result);
+                            }
+                        }
+                    });
+                    if ((delta.removed.length > 0) || (delta.added.length > 0)) {
+                        this._onMatchersChanged.fire();
+                    }
+                } catch (error) {}
+                const matcher = this.get("tsc-watch");
+                if (matcher) {
+                    matcher.tscWatch = true;
+                }
+                resolve(undefined);
+            });
+        }));
+    }
+    onReady() {
+        ProblemPatternRegistry.onReady();
+        return this.readyPromise;
+    }
+    add(matcher) {
+        this.matchers[matcher.name] = matcher;
+    }
+    get(name) {
+        return this.matchers[name];
+    }
+    keys() {
+        return ( Object.keys(this.matchers));
+    }
+    fillDefaults() {
+        this.add({
+            name: "msCompile",
+            label: ( localize(12970, "Microsoft compiler problems")),
+            owner: "msCompile",
+            source: "cpp",
+            applyTo: ApplyToKind.allDocuments,
+            fileLocation: FileLocationKind.Absolute,
+            pattern: ProblemPatternRegistry.get("msCompile")
+        });
+        this.add({
+            name: "lessCompile",
+            label: ( localize(12971, "Less problems")),
+            deprecated: true,
+            owner: "lessCompile",
+            source: "less",
+            applyTo: ApplyToKind.allDocuments,
+            fileLocation: FileLocationKind.Absolute,
+            pattern: ProblemPatternRegistry.get("lessCompile"),
+            severity: Severity$1.Error
+        });
+        this.add({
+            name: "gulp-tsc",
+            label: ( localize(12972, "Gulp TSC Problems")),
+            owner: "typescript",
+            source: "ts",
+            applyTo: ApplyToKind.closedDocuments,
+            fileLocation: FileLocationKind.Relative,
+            filePrefix: "${workspaceFolder}",
+            pattern: ProblemPatternRegistry.get("gulp-tsc")
+        });
+        this.add({
+            name: "jshint",
+            label: ( localize(12973, "JSHint problems")),
+            owner: "jshint",
+            source: "jshint",
+            applyTo: ApplyToKind.allDocuments,
+            fileLocation: FileLocationKind.Absolute,
+            pattern: ProblemPatternRegistry.get("jshint")
+        });
+        this.add({
+            name: "jshint-stylish",
+            label: ( localize(12974, "JSHint stylish problems")),
+            owner: "jshint",
+            source: "jshint",
+            applyTo: ApplyToKind.allDocuments,
+            fileLocation: FileLocationKind.Absolute,
+            pattern: ProblemPatternRegistry.get("jshint-stylish")
+        });
+        this.add({
+            name: "eslint-compact",
+            label: ( localize(12975, "ESLint compact problems")),
+            owner: "eslint",
+            source: "eslint",
+            applyTo: ApplyToKind.allDocuments,
+            fileLocation: FileLocationKind.Absolute,
+            filePrefix: "${workspaceFolder}",
+            pattern: ProblemPatternRegistry.get("eslint-compact")
+        });
+        this.add({
+            name: "eslint-stylish",
+            label: ( localize(12976, "ESLint stylish problems")),
+            owner: "eslint",
+            source: "eslint",
+            applyTo: ApplyToKind.allDocuments,
+            fileLocation: FileLocationKind.Absolute,
+            pattern: ProblemPatternRegistry.get("eslint-stylish")
+        });
+        this.add({
+            name: "go",
+            label: ( localize(12977, "Go problems")),
+            owner: "go",
+            source: "go",
+            applyTo: ApplyToKind.allDocuments,
+            fileLocation: FileLocationKind.Relative,
+            filePrefix: "${workspaceFolder}",
+            pattern: ProblemPatternRegistry.get("go")
+        });
+    }
+}
+const ProblemMatcherRegistry = ( new ProblemMatcherRegistryImpl());
+
+export { ApplyToKind, Config, ExtensionRegistryReporter, FileLocationKind, ProblemLocationKind, ProblemMatcherParser, ProblemMatcherRegistry, ProblemPatternParser, ProblemPatternRegistry, Schemas, createLineMatcher, getResource, isNamedProblemMatcher };