return files.filter(f => {
   if (f == null) return false
   if (ignoreHidden && /^\./.test(f)) return false
   for (let p of ignorePatterns) {
     if (minimatch(f, p, { dot: true })) return false
   }
   return true
 })

function score1(selector: DocumentSelector[0], candidateUri: string, candidateLanguage: string): number {
    if (typeof selector === 'string') {
        // Shorthand notation: "mylang" -> {language: "mylang"}, "*" -> {language: "*""}.
        if (selector === '*') {
            return 5
        } else if (selector === candidateLanguage) {
            return 10
        } else {
            return 0
        }
    }

    const { language, scheme, pattern } = selector
    let ret = 0
    if (scheme) {
        if (candidateUri.startsWith(scheme + ':')) {
            ret = 10
        } else if (scheme === '*') {
            ret = 5
        } else {
            return 0
        }
    }
    if (language) {
        if (language === candidateLanguage) {
            ret = 10
        } else if (language === '*') {
            ret = Math.max(ret, 5)
        } else {
            return 0
        }
    }
    if (pattern) {
        if (pattern === candidateUri || candidateUri.endsWith(pattern) || minimatch(candidateUri, pattern)) {
            ret = 10
        } else if (minimatch(candidateUri, '**/' + pattern)) {
            ret = 5
        } else {
            return 0
        }
    }
    return ret
}

export function multiGlobMatches(patterns: string[], path: string): boolean {

	let matched = false;
	for (const p of patterns) {
		const isExclude = p[0] === '!';
		if (matched !== isExclude) {
			break;
		}
		matched = minimatch(path, p);
	}
	return matched;
}

    protected static isExcluded(file: string, excludes: string[]) {
        if (excludes.length === 0) {
            return false;
        }

        for (const exclude of excludes) {
            if (minimatch(file, exclude)) {
                return true;
            }
        }

        return false;
    }

    protected static isIncluded(file: string, includes: string[]) {
        if (includes.length === 0) {
            return true;
        }

        for (const include of includes) {
            if (minimatch(file, include)) {
                return true;
            }
        }

        return false;
    }

 parsers.forEach((parser) => {
   if (minimatch(path, parser.glob)) {
     fs.readFile(path, { encoding: 'utf-8' }, function(err, source) {
       if (err)
         return cache.error({
           message: err.message,
           stack: err.stack && err.stack.toString(),
           link: null
         })
       var artifact = parser.parse(source)
       cache.saveAST(project, path, artifact)
     })
   }
 });

 var fileMatches = files.some((filePath) => minimatch(changedFilePath, filePath));

 && configData.revisedFiles.some(revisedFile => minimatch(filePath, revisedFile))) {

 return gitIgnore.some(line => minimatch(p, line));