export function massageSearchForScoring(searchValue: string): string {
	if (searchValue) {
		searchValue = stripWildcards(searchValue).replace(/\s/g, ''); // get rid of all wildcards and whitespace
		if (isWindows) {
			searchValue = searchValue.replace(/\//g, '\\'); // Help Windows users to search for paths when using slash
		}
	}

	return searchValue;
}

export function prepareQuery(original: string): IPreparedQuery {
	if (!original) {
		original = '';
	}

	let value = stripWildcards(original).replace(/\s/g, ''); // get rid of all wildcards and whitespace
	if (isWindows) {
		value = value.replace(/\//g, sep); // Help Windows users to search for paths when using slash
	}

	const lowercase = value.toLowerCase();
	const containsPathSeparator = value.indexOf(sep) >= 0;

	return { original, value, lowercase, containsPathSeparator };
}

export function prepareQuery(value: string): IPreparedQuery {
	let lowercase: string;
	let containsPathSeparator: boolean;

	if (value) {
		value = stripWildcards(value).replace(/\s/g, ''); // get rid of all wildcards and whitespace
		if (isWindows) {
			value = value.replace(/\//g, '\\'); // Help Windows users to search for paths when using slash
		}

		lowercase = value.toLowerCase();
		containsPathSeparator = value.indexOf(nativeSep) >= 0;
	}

	return { value, lowercase, containsPathSeparator };
}

	constructor(config: IFileQuery, maxFileSize?: number) {
		this.config = config;
		this.useRipgrep = config.useRipgrep !== false;
		this.filePattern = config.filePattern;
		this.includePattern = config.includePattern && glob.parse(config.includePattern);
		this.maxResults = config.maxResults || null;
		this.exists = config.exists;
		this.maxFilesize = maxFileSize || null;
		this.walkedPaths = Object.create(null);
		this.resultCount = 0;
		this.isLimitHit = false;
		this.directoriesWalked = 0;
		this.filesWalked = 0;
		this.traversal = Traversal.Node;
		this.errors = [];

		if (this.filePattern) {
			this.normalizedFilePatternLowercase = strings.stripWildcards(this.filePattern).toLowerCase();
		}

		this.globalExcludePattern = config.excludePattern && glob.parse(config.excludePattern);
		this.folderExcludePatterns = new Map<string, AbsoluteAndRelativeParsedExpression>();

		config.folderQueries.forEach(folderQuery => {
			const folderExcludeExpression: glob.IExpression = objects.assign({}, folderQuery.excludePattern || {}, this.config.excludePattern || {});

			// Add excludes for other root folders
			const fqPath = folderQuery.folder.fsPath;
			config.folderQueries
				.map(rootFolderQuery => rootFolderQuery.folder.fsPath)
				.filter(rootFolder => rootFolder !== fqPath)
				.forEach(otherRootFolder => {
					// Exclude nested root folders
					if (isEqualOrParent(otherRootFolder, fqPath)) {
						folderExcludeExpression[path.relative(fqPath, otherRootFolder)] = true;
					}
				});

			this.folderExcludePatterns.set(fqPath, new AbsoluteAndRelativeParsedExpression(folderExcludeExpression, fqPath));
		});
	}