diff --git a/index.js b/index.js
index bf8b0c3..0961820 100644
--- a/index.js
+++ b/index.js
@@ -36,6 +36,21 @@ const checkCwdOption = options => {
 	}
 };
 
+const normalizeOptions = (options = {}) => {
+	options = {
+		ignore: [],
+		expandDirectories: true,
+		...options,
+		cwd: toPath(options.cwd),
+	};
+
+	checkCwdOption(options);
+
+	return options;
+};
+
+const normalizeArguments = fn => (patterns, options) => fn(toPatternsArray(patterns), normalizeOptions(options));
+
 const getFilter = async options => createFilterFunction(
 	options.gitignore && await isGitIgnored({cwd: options.cwd, ignore: options.ignore}),
 );
@@ -56,17 +71,7 @@ const createFilterFunction = isIgnored => {
 const unionFastGlobResults = (results, filter) => results.flat().filter(fastGlobResult => filter(fastGlobResult));
 const unionFastGlobStreams = (streams, filter) => merge2(streams).pipe(new FilterStream(fastGlobResult => filter(fastGlobResult)));
 
-export const generateGlobTasks = (patterns, taskOptions = {}) => {
-	patterns = toPatternsArray(patterns);
-
-	taskOptions = {
-		ignore: [],
-		expandDirectories: true,
-		...taskOptions,
-		cwd: toPath(taskOptions.cwd),
-	};
-	checkCwdOption(taskOptions);
-
+const generateGlobTasksInternal = (patterns, taskOptions) => {
 	const globTasks = [];
 	for (const [index, pattern] of patterns.entries()) {
 		if (isNegative(pattern)) {
@@ -110,86 +115,85 @@ const globDirectories = (task, fn) => {
 	return fn(task.pattern, options);
 };
 
-const getPattern = (task, fn) => task.options.expandDirectories ? globDirectories(task, fn) : [task.pattern];
+const generateTasks = async (patterns, options) => {
+	const globTasks = generateGlobTasksInternal(patterns, options);
 
-const globToTask = task => async glob => {
-	const {options} = task;
-	if (options.ignore && Array.isArray(options.ignore) && options.expandDirectories) {
-		options.ignore = await dirGlob(options.ignore);
+	if (!options.expandDirectories) {
+		return globTasks;
 	}
 
-	return {
-		pattern: glob,
-		options,
-	};
-};
-
-const globToTaskSync = task => glob => {
-	const {options} = task;
-	if (options.ignore && Array.isArray(options.ignore) && options.expandDirectories) {
-		options.ignore = dirGlob.sync(options.ignore);
-	}
+	const tasks = await Promise.all(
+		globTasks.map(async task => {
+			const {options} = task;
+
+			const [
+				patterns,
+				ignore,
+			] = await Promise.all([
+				globDirectories(task, dirGlob),
+				dirGlob(options.ignore),
+			]);
+
+			options.ignore = ignore;
+			return patterns.map(pattern => ({pattern, options}));
+		}),
+	);
 
-	return {
-		pattern: glob,
-		options,
-	};
+	return tasks.flat();
 };
 
-export const globby = async (patterns, options = {}) => {
-	const globTasks = generateGlobTasks(patterns, options);
+const generateTasksSync = (patterns, options) => {
+	const globTasks = generateGlobTasksInternal(patterns, options);
 
-	const getTasks = async () => {
-		const tasks = await Promise.all(globTasks.map(async task => {
-			const globs = await getPattern(task, dirGlob);
-			return Promise.all(globs.map(globToTask(task)));
-		}));
+	if (!options.expandDirectories) {
+		return globTasks;
+	}
 
-		return tasks.flat();
-	};
+	return globTasks.flatMap(task => {
+		const {options} = task;
+		const patterns = globDirectories(task, dirGlob.sync);
+		options.ignore = dirGlob.sync(options.ignore);
+		return patterns.map(pattern => ({pattern, options}));
+	});
+};
 
-	const [filter, tasks] = await Promise.all([getFilter(options), getTasks()]);
+export const globby = async (patterns, options) => {
+	patterns = toPatternsArray(patterns);
+	options = normalizeOptions(options);
+
+	const [
+		tasks,
+		filter,
+	] = await Promise.all([
+		generateTasks(patterns, options),
+		getFilter(options),
+	]);
 	const results = await Promise.all(tasks.map(task => fastGlob(task.pattern, task.options)));
 
 	return unionFastGlobResults(results, filter);
 };
 
-export const globbySync = (patterns, options = {}) => {
-	const globTasks = generateGlobTasks(patterns, options);
-
-	const tasks = globTasks.flatMap(
-		task => getPattern(task, dirGlob.sync).map(globToTaskSync(task)),
-	);
-
+export const globbySync = normalizeArguments((patterns, options) => {
+	const tasks = generateTasksSync(patterns, options);
 	const filter = getFilterSync(options);
 	const results = tasks.map(task => fastGlob.sync(task.pattern, task.options));
 
 	return unionFastGlobResults(results, filter);
-};
-
-export const globbyStream = (patterns, options = {}) => {
-	const globTasks = generateGlobTasks(patterns, options);
-
-	const tasks = globTasks.flatMap(
-		task => getPattern(task, dirGlob.sync).map(globToTaskSync(task)),
-	);
+});
 
+export const globbyStream = normalizeArguments((patterns, options) => {
+	const tasks = generateTasksSync(patterns, options);
 	const filter = getFilterSync(options);
 	const streams = tasks.map(task => fastGlob.stream(task.pattern, task.options));
 
 	return unionFastGlobStreams(streams, filter);
-};
+});
 
-export const isDynamicPattern = (patterns, options = {}) => {
-	patterns = toPatternsArray(patterns);
-	options = {
-		...options,
-		cwd: toPath(options.cwd),
-	};
-	checkCwdOption(options);
+export const isDynamicPattern = normalizeArguments(
+	(patterns, options) => patterns.some(pattern => fastGlob.isDynamicPattern(pattern, options)),
+);
 
-	return patterns.some(pattern => fastGlob.isDynamicPattern(pattern, options));
-};
+export const generateGlobTasks = normalizeArguments(generateGlobTasksInternal);
 
 export {
 	isGitIgnored,