Require Node.js 12.20 and move to ESM (#181)

Author: antongolub

.github/workflows/main.yml

@@ -10,16 +10,16 @@ jobs:
       fail-fast: false
       matrix:
         node-version:
+          - 16
           - 14
           - 12
-          - 10
         os:
           - ubuntu-latest
           - macos-latest
           - windows-latest
     steps:
       - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/setup-node@v2
         with:
           node-version: ${{ matrix.node-version }}
       - run: npm install

bench.js

@@ -1,95 +1,100 @@
-'use strict';
 /* global after, before, bench, suite */
-const fs = require('fs');
-const rimraf = require('rimraf');
-const globbyMainBranch = require('globby');
-const gs = require('glob-stream');
-const fastGlob = require('fast-glob');
-const globby = require('.');
+import fs from 'node:fs';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import rimraf from 'rimraf';
+import globbyMainBranch from 'globby';
+import gs from 'glob-stream';
+import fastGlob from 'fast-glob';
+import {globby, globbySync} from './index.js';
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const BENCH_DIR = 'bench';
 
 const runners = [{
 	name: 'globby async (working directory)',
 	run: async (patterns, callback) => {
 		await globby(patterns);
 		callback();
-	}
+	},
 }, {
 	name: 'globby async (upstream/main)',
 	run: async (patterns, callback) => {
 		await globbyMainBranch(patterns);
 		callback();
-	}
+	},
 }, {
 	name: 'globby sync (working directory)',
 	run: patterns => {
-		globby.sync(patterns);
-	}
+		globbySync(patterns);
+	},
 }, {
 	name: 'globby sync (upstream/main)',
 	run: patterns => {
 		globbyMainBranch.sync(patterns);
-	}
+	},
 }, {
 	name: 'glob-stream',
 	run: (patterns, cb) => {
 		gs(patterns).on('data', () => {}).on('end', cb);
-	}
+	},
 }, {
 	name: 'fast-glob async',
 	run: async (patterns, callback) => {
 		await fastGlob(patterns);
 		callback();
-	}
+	},
 }, {
 	name: 'fast-glob sync',
 	run: patterns => {
 		fastGlob.sync(patterns);
-	}
+	},
 }];
 const benchs = [{
 	name: 'negative globs (some files inside dir)',
 	patterns: [
 		'a/*',
-		'!a/c*'
-	]
+		'!a/c*',
+	],
 }, {
 	name: 'negative globs (whole dir)',
 	patterns: [
 		'a/*',
-		'!a/**'
-	]
+		'!a/**',
+	],
 }, {
 	name: 'multiple positive globs',
 	patterns: [
 		'a/*',
-		'b/*'
-	]
+		'b/*',
+	],
 }];
 
 before(() => {
 	process.chdir(__dirname);
 	rimraf.sync(BENCH_DIR);
 	fs.mkdirSync(BENCH_DIR);
 	process.chdir(BENCH_DIR);
-	['a', 'b']
-		.map(directory => `${directory}/`)
-		.forEach(directory => {
-			fs.mkdirSync(directory);
-			for (let i = 0; i < 500; i++) {
-				fs.writeFileSync(directory + (i < 100 ? 'c' : 'd') + i, '');
-			}
-		});
+	const directories = ['a', 'b']
+		.map(directory => `${directory}/`);
+
+	for (const directory of directories) {
+		fs.mkdirSync(directory);
+		for (let i = 0; i < 500; i++) {
+			fs.writeFileSync(directory + (i < 100 ? 'c' : 'd') + i, '');
+		}
+	}
 });
 
 after(() => {
 	process.chdir(__dirname);
 	rimraf.sync(BENCH_DIR);
 });
 
-benchs.forEach(benchmark => {
+for (const benchmark of benchs) {
 	suite(benchmark.name, () => {
-		runners.forEach(runner => bench(runner.name, runner.run.bind(null, benchmark.patterns)));
+		for (const runner of runners) {
+			bench(runner.name, runner.run.bind(null, benchmark.patterns));
+		}
 	});
-});
+}

gitignore.js

@@ -1,16 +1,15 @@
-'use strict';
-const {promisify} = require('util');
-const fs = require('fs');
-const path = require('path');
-const fastGlob = require('fast-glob');
-const gitIgnore = require('ignore');
-const slash = require('slash');
+import {promisify} from 'node:util';
+import fs from 'node:fs';
+import path from 'node:path';
+import fastGlob from 'fast-glob';
+import gitIgnore from 'ignore';
+import slash from 'slash';
 
 const DEFAULT_IGNORE = [
 	'**/node_modules/**',
 	'**/flow-typed/**',
 	'**/coverage/**',
-	'**/.git'
+	'**/.git',
 ];
 
 const readFileP = promisify(fs.readFile);
@@ -38,7 +37,7 @@ const reduceIgnore = files => {
 	for (const file of files) {
 		ignores.add(parseGitIgnore(file.content, {
 			cwd: file.cwd,
-			fileName: file.filePath
+			fileName: file.filePath,
 		}));
 	}
 
@@ -58,9 +57,7 @@ const ensureAbsolutePathForCwd = (cwd, p) => {
 	return path.join(cwd, p);
 };
 
-const getIsIgnoredPredecate = (ignores, cwd) => {
-	return p => ignores.ignores(slash(path.relative(cwd, ensureAbsolutePathForCwd(cwd, p.path || p))));
-};
+const getIsIgnoredPredicate = (ignores, cwd) => p => ignores.ignores(slash(path.relative(cwd, ensureAbsolutePathForCwd(cwd, p.path || p))));
 
 const getFile = async (file, cwd) => {
 	const filePath = path.join(cwd, file);
@@ -69,7 +66,7 @@ const getFile = async (file, cwd) => {
 	return {
 		cwd,
 		filePath,
-		content
+		content,
 	};
 };
 
@@ -80,41 +77,40 @@ const getFileSync = (file, cwd) => {
 	return {
 		cwd,
 		filePath,
-		content
+		content,
 	};
 };
 
 const normalizeOptions = ({
 	ignore = [],
-	cwd = slash(process.cwd())
-} = {}) => {
-	return {ignore, cwd};
-};
+	cwd = slash(process.cwd()),
+} = {}) => ({ignore, cwd});
 
-module.exports = async options => {
+export const isGitIgnored = async options => {
 	options = normalizeOptions(options);
 
 	const paths = await fastGlob('**/.gitignore', {
 		ignore: DEFAULT_IGNORE.concat(options.ignore),
-		cwd: options.cwd
+		cwd: options.cwd,
 	});
 
 	const files = await Promise.all(paths.map(file => getFile(file, options.cwd)));
 	const ignores = reduceIgnore(files);
 
-	return getIsIgnoredPredecate(ignores, options.cwd);
+	return getIsIgnoredPredicate(ignores, options.cwd);
 };
 
-module.exports.sync = options => {
+export const isGitIgnoredSync = options => {
 	options = normalizeOptions(options);
 
 	const paths = fastGlob.sync('**/.gitignore', {
 		ignore: DEFAULT_IGNORE.concat(options.ignore),
-		cwd: options.cwd
+		cwd: options.cwd,
 	});
 
 	const files = paths.map(file => getFileSync(file, options.cwd));
 	const ignores = reduceIgnore(files);
 
-	return getIsIgnoredPredecate(ignores, options.cwd);
+	return getIsIgnoredPredicate(ignores, options.cwd);
 };
+

gitignore.test.js

@@ -1,31 +1,34 @@
-const path = require('path');
-const test = require('ava');
-const slash = require('slash');
-const gitignore = require('./gitignore');
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import test from 'ava';
+import slash from 'slash';
+import {isGitIgnored, isGitIgnoredSync} from './gitignore.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 test('gitignore', async t => {
 	const cwd = path.join(__dirname, 'fixtures/gitignore');
-	const isIgnored = await gitignore({cwd});
+	const isIgnored = await isGitIgnored({cwd});
 	const actual = ['foo.js', 'bar.js'].filter(file => !isIgnored(file));
 	const expected = ['bar.js'];
 	t.deepEqual(actual, expected);
 });
 
 test('gitignore - mixed path styles', async t => {
 	const cwd = path.join(__dirname, 'fixtures/gitignore');
-	const isIgnored = await gitignore({cwd});
+	const isIgnored = await isGitIgnored({cwd});
 	t.true(isIgnored(slash(path.resolve(cwd, 'foo.js'))));
 });
 
 test('gitignore - os paths', async t => {
 	const cwd = path.join(__dirname, 'fixtures/gitignore');
-	const isIgnored = await gitignore({cwd});
+	const isIgnored = await isGitIgnored({cwd});
 	t.true(isIgnored(path.resolve(cwd, 'foo.js')));
 });
 
 test('gitignore - sync', t => {
 	const cwd = path.join(__dirname, 'fixtures/gitignore');
-	const isIgnored = gitignore.sync({cwd});
+	const isIgnored = isGitIgnoredSync({cwd});
 	const actual = ['foo.js', 'bar.js'].filter(file => !isIgnored(file));
 	const expected = ['bar.js'];
 	t.deepEqual(actual, expected);
@@ -35,7 +38,7 @@ test('ignore ignored .gitignore', async t => {
 	const cwd = path.join(__dirname, 'fixtures/gitignore');
 	const ignore = ['**/.gitignore'];
 
-	const isIgnored = await gitignore({cwd, ignore});
+	const isIgnored = await isGitIgnored({cwd, ignore});
 	const actual = ['foo.js', 'bar.js'].filter(file => !isIgnored(file));
 	const expected = ['foo.js', 'bar.js'];
 	t.deepEqual(actual, expected);
@@ -45,37 +48,37 @@ test('ignore ignored .gitignore - sync', t => {
 	const cwd = path.join(__dirname, 'fixtures/gitignore');
 	const ignore = ['**/.gitignore'];
 
-	const isIgnored = gitignore.sync({cwd, ignore});
+	const isIgnored = isGitIgnoredSync({cwd, ignore});
 	const actual = ['foo.js', 'bar.js'].filter(file => !isIgnored(file));
 	const expected = ['foo.js', 'bar.js'];
 	t.deepEqual(actual, expected);
 });
 
 test('negative gitignore', async t => {
 	const cwd = path.join(__dirname, 'fixtures/negative');
-	const isIgnored = await gitignore({cwd});
+	const isIgnored = await isGitIgnored({cwd});
 	const actual = ['foo.js', 'bar.js'].filter(file => !isIgnored(file));
 	const expected = ['foo.js'];
 	t.deepEqual(actual, expected);
 });
 
 test('negative gitignore - sync', t => {
 	const cwd = path.join(__dirname, 'fixtures/negative');
-	const isIgnored = gitignore.sync({cwd});
+	const isIgnored = isGitIgnoredSync({cwd});
 	const actual = ['foo.js', 'bar.js'].filter(file => !isIgnored(file));
 	const expected = ['foo.js'];
 	t.deepEqual(actual, expected);
 });
 
 test('multiple negation', async t => {
 	const cwd = path.join(__dirname, 'fixtures/multiple-negation');
-	const isIgnored = await gitignore({cwd});
+	const isIgnored = await isGitIgnored({cwd});
 
 	const actual = [
 		'!!!unicorn.js',
 		'!!unicorn.js',
 		'!unicorn.js',
-		'unicorn.js'
+		'unicorn.js',
 	].filter(file => !isIgnored(file));
 
 	const expected = ['!!unicorn.js', '!unicorn.js'];
@@ -84,13 +87,13 @@ test('multiple negation', async t => {
 
 test('multiple negation - sync', t => {
 	const cwd = path.join(__dirname, 'fixtures/multiple-negation');
-	const isIgnored = gitignore.sync({cwd});
+	const isIgnored = isGitIgnoredSync({cwd});
 
 	const actual = [
 		'!!!unicorn.js',
 		'!!unicorn.js',
 		'!unicorn.js',
-		'unicorn.js'
+		'unicorn.js',
 	].filter(file => !isIgnored(file));
 
 	const expected = ['!!unicorn.js', '!unicorn.js'];

index.d.ts

@@ -1,15 +1,14 @@
 import {Options as FastGlobOptions, Entry as FastGlobEntry} from 'fast-glob';
 
-declare namespace globby {
-	type ExpandDirectoriesOption =
-		| boolean
-		| readonly string[]
-		| {files?: readonly string[]; extensions?: readonly string[]};
+type ExpandDirectoriesOption =
+	| boolean
+	| readonly string[]
+	| {files?: readonly string[]; extensions?: readonly string[]};
 
-	type Entry = FastGlobEntry;
+type GlobbyEntry = FastGlobEntry;
 
-	interface GlobbyOptions extends FastGlobOptions {
-		/**
+interface GlobbyOptions extends FastGlobOptions {
+	/**
 		If set to `true`, `globby` will automatically glob directories for you. If you define an `Array` it will only glob files that matches the patterns inside the `Array`. You can also define an `Object` with `files` and `extensions` like in the example below.
 
 		Note that if you set this option to `false`, you won't get back matched directories unless you set `onlyFiles: false`.
@@ -18,7 +17,7 @@ declare namespace globby {
 
 		@example
 		```
-		import globby = require('globby');
+		import {globby} from 'globby';
 
 		(async () => {
 			const paths = await globby('images', {
@@ -32,73 +31,69 @@ declare namespace globby {
 			//=> ['cat.png', 'unicorn.png', 'cow.jpg', 'rainbow.jpg']
 		})();
 		```
-		*/
-		readonly expandDirectories?: ExpandDirectoriesOption;
+	 */
+	readonly expandDirectories?: ExpandDirectoriesOption;
 
-		/**
+	/**
 		Respect ignore patterns in `.gitignore` files that apply to the globbed files.
 
 		@default false
-		*/
-		readonly gitignore?: boolean;
-	}
-
-	interface GlobTask {
-		readonly pattern: string;
-		readonly options: GlobbyOptions;
-	}
+	 */
+	readonly gitignore?: boolean;
+}
 
-	interface GitignoreOptions {
-		readonly cwd?: string;
-		readonly ignore?: readonly string[];
-	}
+interface GlobTask {
+	readonly pattern: string;
+	readonly options: GlobbyOptions;
+}
 
-	type FilterFunction = (path: string) => boolean;
+interface GitignoreOptions {
+	readonly cwd?: string;
+	readonly ignore?: readonly string[];
 }
 
-interface Gitignore {
-	/**
-	@returns A filter function indicating whether a given path is ignored via a `.gitignore` file.
-	*/
-	sync: (options?: globby.GitignoreOptions) => globby.FilterFunction;
+type GlobbyFilterFunction = (path: string) => boolean;
 
-	/**
+/**
 	`.gitignore` files matched by the ignore config are not used for the resulting filter function.
 
 	@returns A filter function indicating whether a given path is ignored via a `.gitignore` file.
 
 	@example
 	```
-	import {gitignore} from 'globby';
+	import {isGitIgnored} from 'globby';
 
 	(async () => {
-		const isIgnored = await gitignore();
+		const isIgnored = await isGitIgnored();
 		console.log(isIgnored('some/file'));
 	})();
 	```
-	*/
-	(options?: globby.GitignoreOptions): Promise<globby.FilterFunction>;
-}
+ */
+declare const isGitIgnored: (options?: GitignoreOptions) => Promise<GlobbyFilterFunction>;
 
-declare const globby: {
-	/**
+/**
+	@returns A filter function indicating whether a given path is ignored via a `.gitignore` file.
+ */
+declare const isGitIgnoredSync: (options?: GitignoreOptions) => GlobbyFilterFunction;
+
+/**
 	Find files and directories using glob patterns.
 
 	Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
 
 	@param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
 	@param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.
 	@returns The matching paths.
-	*/
-	sync: ((
-		patterns: string | readonly string[],
-		options: globby.GlobbyOptions & {objectMode: true}
-	) => globby.Entry[]) & ((
-		patterns: string | readonly string[],
-		options?: globby.GlobbyOptions
-	) => string[]);
-
-	/**
+ */
+declare const globbySync: ((
+	patterns: string | readonly string[],
+	options: GlobbyOptions & {objectMode: true}
+) => GlobbyEntry[]) & ((
+	patterns: string | readonly string[],
+	options?: GlobbyOptions
+) => string[]);
+
+/**
 	Find files and directories using glob patterns.
 
 	Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
@@ -109,52 +104,51 @@ declare const globby: {
 
 	@example
 	```
-	import globby = require('globby');
+	import {globbyStream} from 'globby';
 
 	(async () => {
-		for await (const path of globby.stream('*.tmp')) {
+		for await (const path of globbyStream('*.tmp')) {
 			console.log(path);
 		}
 	})();
 	```
-	*/
-	stream: (
-		patterns: string | readonly string[],
-		options?: globby.GlobbyOptions
-	) => NodeJS.ReadableStream;
+ */
+declare const globbyStream: (
+	patterns: string | readonly string[],
+	options?: GlobbyOptions
+) => NodeJS.ReadableStream;
 
-	/**
+/**
 	Note that you should avoid running the same tasks multiple times as they contain a file system cache. Instead, run this method each time to ensure file system changes are taken into consideration.
 
 	@param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
 	@param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.
 	@returns An object in the format `{pattern: string, options: object}`, which can be passed as arguments to [`fast-glob`](https://github.com/mrmlnc/fast-glob). This is useful for other globbing-related packages.
-	*/
-	generateGlobTasks: (
-		patterns: string | readonly string[],
-		options?: globby.GlobbyOptions
-	) => globby.GlobTask[];
+ */
+declare const generateGlobTasks: (
+	patterns: string | readonly string[],
+	options?: GlobbyOptions
+) => GlobTask[];
 
-	/**
+/**
 	Note that the options affect the results.
 
 	This function is backed by [`fast-glob`](https://github.com/mrmlnc/fast-glob#isdynamicpatternpattern-options).
 
 	@param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
 	@param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3).
 	@returns Whether there are any special glob characters in the `patterns`.
-	*/
-	hasMagic: (
-		patterns: string | readonly string[],
-		options?: FastGlobOptions
-	) => boolean;
-
-	readonly gitignore: Gitignore;
+ */
+declare const isDynamicPattern: (
+	patterns: string | readonly string[],
+	options?: FastGlobOptions
+) => boolean;
 
+declare const globby: {
 	(
 		patterns: string | readonly string[],
-		options: globby.GlobbyOptions & {objectMode: true}
-	): Promise<globby.Entry[]>;
+		options: GlobbyOptions & {objectMode: true}
+	): Promise<GlobbyEntry[]>;
 
 	/**
 	Find files and directories using glob patterns.
@@ -167,7 +161,7 @@ declare const globby: {
 
 	@example
 	```
-	import globby = require('globby');
+	import {globby} from 'globby';
 
 	(async () => {
 		const paths = await globby(['*', '!cake']);
@@ -179,8 +173,6 @@ declare const globby: {
 	*/
 	(
 		patterns: string | readonly string[],
-		options?: globby.GlobbyOptions
+		options?: GlobbyOptions
 	): Promise<string[]>;
 };
-
-export = globby;

index.js

@@ -1,11 +1,10 @@
-'use strict';
-const fs = require('fs');
-const arrayUnion = require('array-union');
-const merge2 = require('merge2');
-const fastGlob = require('fast-glob');
-const dirGlob = require('dir-glob');
-const gitignore = require('./gitignore');
-const {FilterStream, UniqueStream} = require('./stream-utils');
+import fs from 'node:fs';
+import arrayUnion from 'array-union';
+import merge2 from 'merge2';
+import fastGlob from 'fast-glob';
+import dirGlob from 'dir-glob';
+import {isGitIgnored, isGitIgnoredSync} from './gitignore.js';
+import {FilterStream, UniqueStream} from './stream-utils.js';
 
 const DEFAULT_FILTER = () => false;
 
@@ -36,8 +35,8 @@ const checkCwdOption = (options = {}) => {
 
 const getPathString = p => p.stats instanceof fs.Stats ? p.path : p;
 
-const generateGlobTasks = (patterns, taskOptions) => {
-	patterns = arrayUnion([].concat(patterns));
+export const generateGlobTasks = (patterns, taskOptions) => {
+	patterns = arrayUnion([patterns].flat());
 	assertPatternsInput(patterns);
 	checkCwdOption(taskOptions);
 
@@ -46,7 +45,7 @@ const generateGlobTasks = (patterns, taskOptions) => {
 	taskOptions = {
 		ignore: [],
 		expandDirectories: true,
-		...taskOptions
+		...taskOptions,
 	};
 
 	for (const [index, pattern] of patterns.entries()) {
@@ -61,7 +60,7 @@ const generateGlobTasks = (patterns, taskOptions) => {
 
 		const options = {
 			...taskOptions,
-			ignore: taskOptions.ignore.concat(ignore)
+			ignore: [...taskOptions.ignore, ...ignore],
 		};
 
 		globTasks.push({pattern, options});
@@ -79,12 +78,12 @@ const globDirs = (task, fn) => {
 	if (Array.isArray(task.options.expandDirectories)) {
 		options = {
 			...options,
-			files: task.options.expandDirectories
+			files: task.options.expandDirectories,
 		};
 	} else if (typeof task.options.expandDirectories === 'object') {
 		options = {
 			...options,
-			...task.options.expandDirectories
+			...task.options.expandDirectories,
 		};
 	}
 
@@ -93,11 +92,9 @@ const globDirs = (task, fn) => {
 
 const getPattern = (task, fn) => task.options.expandDirectories ? globDirs(task, fn) : [task.pattern];
 
-const getFilterSync = options => {
-	return options && options.gitignore ?
-		gitignore.sync({cwd: options.cwd, ignore: options.ignore}) :
-		DEFAULT_FILTER;
-};
+const getFilterSync = options => options && options.gitignore
+	? isGitIgnoredSync({cwd: options.cwd, ignore: options.ignore})
+	: DEFAULT_FILTER;
 
 const globToTask = task => glob => {
 	const {options} = task;
@@ -107,18 +104,16 @@ const globToTask = task => glob => {
 
 	return {
 		pattern: glob,
-		options
+		options,
 	};
 };
 
-module.exports = async (patterns, options) => {
+export const globby = async (patterns, options) => {
 	const globTasks = generateGlobTasks(patterns, options);
 
-	const getFilter = async () => {
-		return options && options.gitignore ?
-			gitignore({cwd: options.cwd, ignore: options.ignore}) :
-			DEFAULT_FILTER;
-	};
+	const getFilter = async () => options && options.gitignore
+		? isGitIgnored({cwd: options.cwd, ignore: options.ignore})
+		: DEFAULT_FILTER;
 
 	const getTasks = async () => {
 		const tasks = await Promise.all(globTasks.map(async task => {
@@ -135,7 +130,7 @@ module.exports = async (patterns, options) => {
 	return arrayUnion(...paths).filter(path_ => !filter(getPathString(path_)));
 };
 
-module.exports.sync = (patterns, options) => {
+export const globbySync = (patterns, options) => {
 	const globTasks = generateGlobTasks(patterns, options);
 
 	const tasks = [];
@@ -154,7 +149,7 @@ module.exports.sync = (patterns, options) => {
 	return matches.filter(path_ => !filter(path_));
 };
 
-module.exports.stream = (patterns, options) => {
+export const globbyStream = (patterns, options) => {
 	const globTasks = generateGlobTasks(patterns, options);
 
 	const tasks = [];
@@ -172,10 +167,10 @@ module.exports.stream = (patterns, options) => {
 		.pipe(uniqueStream);
 };
 
-module.exports.generateGlobTasks = generateGlobTasks;
-
-module.exports.hasMagic = (patterns, options) => []
-	.concat(patterns)
+export const isDynamicPattern = (patterns, options) => [patterns].flat()
 	.some(pattern => fastGlob.isDynamicPattern(pattern, options));
 
-module.exports.gitignore = gitignore;
+export {
+	isGitIgnored,
+	isGitIgnoredSync,
+};

index.test-d.ts

@@ -1,34 +1,40 @@
+import {dirname} from 'node:path';
+import {fileURLToPath} from 'node:url';
 import {expectType} from 'tsd';
-import globby = require('.');
 import {
 	GlobTask,
-	FilterFunction,
-	sync as globbySync,
-	stream as globbyStream,
+	GlobbyEntry,
+	GlobbyFilterFunction,
+	globby,
+	globbySync,
+	globbyStream,
 	generateGlobTasks,
-	hasMagic,
-	gitignore
-} from '.';
+	isDynamicPattern,
+	isGitIgnored,
+	isGitIgnoredSync,
+} from './index.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
 
 // Globby
 expectType<Promise<string[]>>(globby('*.tmp'));
 expectType<Promise<string[]>>(globby(['a.tmp', '*.tmp', '!{c,d,e}.tmp']));
 
 expectType<Promise<string[]>>(globby('*.tmp', {expandDirectories: false}));
 expectType<Promise<string[]>>(
-	globby('*.tmp', {expandDirectories: ['a*', 'b*']})
+	globby('*.tmp', {expandDirectories: ['a*', 'b*']}),
 );
 expectType<Promise<string[]>>(
 	globby('*.tmp', {
 		expandDirectories: {
 			files: ['a', 'b'],
-			extensions: ['tmp']
-		}
-	})
+			extensions: ['tmp'],
+		},
+	}),
 );
 expectType<Promise<string[]>>(globby('*.tmp', {gitignore: true}));
 expectType<Promise<string[]>>(globby('*.tmp', {ignore: ['**/b.tmp']}));
-expectType<Promise<globby.Entry[]>>(globby('*.tmp', {objectMode: true}));
+expectType<Promise<GlobbyEntry[]>>(globby('*.tmp', {objectMode: true}));
 
 // Globby (sync)
 expectType<string[]>(globbySync('*.tmp'));
@@ -40,13 +46,13 @@ expectType<string[]>(
 	globbySync('*.tmp', {
 		expandDirectories: {
 			files: ['a', 'b'],
-			extensions: ['tmp']
-		}
-	})
+			extensions: ['tmp'],
+		},
+	}),
 );
 expectType<string[]>(globbySync('*.tmp', {gitignore: true}));
 expectType<string[]>(globbySync('*.tmp', {ignore: ['**/b.tmp']}));
-expectType<globby.Entry[]>(globbySync('*.tmp', {objectMode: true}));
+expectType<GlobbyEntry[]>(globbySync('*.tmp', {objectMode: true}));
 
 // Globby (stream)
 expectType<NodeJS.ReadableStream>(globbyStream('*.tmp'));
@@ -58,9 +64,9 @@ expectType<NodeJS.ReadableStream>(
 	globbyStream('*.tmp', {
 		expandDirectories: {
 			files: ['a', 'b'],
-			extensions: ['tmp']
-		}
-	})
+			extensions: ['tmp'],
+		},
+	}),
 );
 expectType<NodeJS.ReadableStream>(globbyStream('*.tmp', {gitignore: true}));
 expectType<NodeJS.ReadableStream>(globbyStream('*.tmp', {ignore: ['**/b.tmp']}));
@@ -82,46 +88,46 @@ expectType<GlobTask[]>(generateGlobTasks(['a.tmp', '*.tmp', '!{c,d,e}.tmp']));
 
 expectType<GlobTask[]>(generateGlobTasks('*.tmp', {expandDirectories: false}));
 expectType<GlobTask[]>(
-	generateGlobTasks('*.tmp', {expandDirectories: ['a*', 'b*']})
+	generateGlobTasks('*.tmp', {expandDirectories: ['a*', 'b*']}),
 );
 expectType<GlobTask[]>(
 	generateGlobTasks('*.tmp', {
 		expandDirectories: {
 			files: ['a', 'b'],
-			extensions: ['tmp']
-		}
-	})
+			extensions: ['tmp'],
+		},
+	}),
 );
 expectType<GlobTask[]>(generateGlobTasks('*.tmp', {gitignore: true}));
 expectType<GlobTask[]>(generateGlobTasks('*.tmp', {ignore: ['**/b.tmp']}));
 
-// HasMagic
-expectType<boolean>(hasMagic('**'));
-expectType<boolean>(hasMagic(['**', 'path1', 'path2']));
-expectType<boolean>(hasMagic(['**', 'path1', 'path2'], {extglob: false}));
+// IsDynamicPattern
+expectType<boolean>(isDynamicPattern('**'));
+expectType<boolean>(isDynamicPattern(['**', 'path1', 'path2']));
+expectType<boolean>(isDynamicPattern(['**', 'path1', 'path2'], {extglob: false}));
 
-// Gitignore
-expectType<Promise<FilterFunction>>(gitignore());
-expectType<Promise<FilterFunction>>(
-	gitignore({
-		cwd: __dirname
-	})
+// IsGitIgnored
+expectType<Promise<GlobbyFilterFunction>>(isGitIgnored());
+expectType<Promise<GlobbyFilterFunction>>(
+	isGitIgnored({
+		cwd: __dirname,
+	}),
 );
-expectType<Promise<FilterFunction>>(
-	gitignore({
-		ignore: ['**/b.tmp']
-	})
+expectType<Promise<GlobbyFilterFunction>>(
+	isGitIgnored({
+		ignore: ['**/b.tmp'],
+	}),
 );
 
-// Gitignore (sync)
-expectType<FilterFunction>(gitignore.sync());
-expectType<FilterFunction>(
-	gitignore.sync({
-		cwd: __dirname
-	})
+// IsGitIgnoredSync
+expectType<GlobbyFilterFunction>(isGitIgnoredSync());
+expectType<GlobbyFilterFunction>(
+	isGitIgnoredSync({
+		cwd: __dirname,
+	}),
 );
-expectType<FilterFunction>(
-	gitignore.sync({
-		ignore: ['**/b.tmp']
-	})
+expectType<GlobbyFilterFunction>(
+	isGitIgnoredSync({
+		ignore: ['**/b.tmp'],
+	}),
 );

package.json

@@ -11,8 +11,10 @@
 		"url": "https://sindresorhus.com"
 	},
 	"engines": {
-		"node": ">=10"
+		"node": ">=12.20"
 	},
+	"type": "module",
+	"exports": "./index.js",
 	"scripts": {
 		"bench": "npm update glob-stream fast-glob && matcha bench.js",
 		"test": "xo && ava && tsd"
@@ -57,22 +59,29 @@
 		"git"
 	],
 	"dependencies": {
-		"array-union": "^2.1.0",
+		"array-union": "^3.0.1",
 		"dir-glob": "^3.0.1",
-		"fast-glob": "^3.1.1",
-		"ignore": "^5.1.4",
-		"merge2": "^1.3.0",
-		"slash": "^3.0.0"
+		"fast-glob": "^3.2.7",
+		"ignore": "^5.1.8",
+		"merge2": "^1.4.1",
+		"slash": "^4.0.0"
 	},
 	"devDependencies": {
-		"ava": "^3.13.0",
-		"get-stream": "^6.0.0",
+		"@types/node": "^16.3.3",
+		"ava": "^3.15.0",
+		"get-stream": "^6.0.1",
 		"glob-stream": "^6.1.0",
 		"globby": "sindresorhus/globby#main",
 		"matcha": "^0.7.0",
 		"rimraf": "^3.0.2",
-		"tsd": "^0.13.1",
-		"xo": "^0.33.1"
+		"typescript": "^4.3.5",
+		"tsd": "^0.17.0",
+		"xo": "^0.42.0"
+	},
+	"tsd": {
+		"compilerOptions": {
+			"module": "es2020"
+		}
 	},
 	"xo": {
 		"ignores": [

readme.md

@@ -27,7 +27,7 @@ $ npm install globby
 ```
 
 ```js
-const globby = require('globby');
+import {globby} from 'globby';
 
 (async () => {
 	const paths = await globby(['*', '!cake']);
@@ -65,7 +65,7 @@ Default: `true`
 If set to `true`, `globby` will automatically glob directories for you. If you define an `Array` it will only glob files that matches the patterns inside the `Array`. You can also define an `object` with `files` and `extensions` like below:
 
 ```js
-const globby = require('globby');
+import {globby} from 'globby';
 
 (async () => {
 	const paths = await globby('images', {
@@ -89,60 +89,60 @@ Default: `false`
 
 Respect ignore patterns in `.gitignore` files that apply to the globbed files.
 
-### globby.sync(patterns, options?)
+### globbySync(patterns, options?)
 
 Returns `string[]` of matching paths.
 
-### globby.stream(patterns, options?)
+### globbyStream(patterns, options?)
 
 Returns a [`stream.Readable`](https://nodejs.org/api/stream.html#stream_readable_streams) of matching paths.
 
 Since Node.js 10, [readable streams are iterable](https://nodejs.org/api/stream.html#stream_readable_symbol_asynciterator), so you can loop over glob matches in a [`for await...of` loop](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of) like this:
 
 ```js
-const globby = require('globby');
+import {globbyStream} from 'globby';
 
 (async () => {
-	for await (const path of globby.stream('*.tmp')) {
+	for await (const path of globbyStream('*.tmp')) {
 		console.log(path);
 	}
 })();
 ```
 
-### globby.generateGlobTasks(patterns, options?)
+### generateGlobTasks(patterns, options?)
 
 Returns an `object[]` in the format `{pattern: string, options: Object}`, which can be passed as arguments to [`fast-glob`](https://github.com/mrmlnc/fast-glob). This is useful for other globbing-related packages.
 
 Note that you should avoid running the same tasks multiple times as they contain a file system cache. Instead, run this method each time to ensure file system changes are taken into consideration.
 
-### globby.hasMagic(patterns, options?)
+### isDynamicPattern(patterns, options?)
 
 Returns a `boolean` of whether there are any special glob characters in the `patterns`.
 
 Note that the options affect the results.
 
 This function is backed by [`fast-glob`](https://github.com/mrmlnc/fast-glob#isdynamicpatternpattern-options).
 
-### globby.gitignore(options?)
+### isGitIgnored(options?)
 
 Returns a `Promise<(path: string) => boolean>` indicating whether a given path is ignored via a `.gitignore` file.
 
 Takes `cwd?: string` and `ignore?: string[]` as options. `.gitignore` files matched by the ignore config are not used for the resulting filter function.
 
 ```js
-const {gitignore} = require('globby');
+import {isGitIgnored} from 'globby';
 
 (async () => {
-	const isIgnored = await gitignore();
+	const isIgnored = await isGitIgnored();
 	console.log(isIgnored('some/file'));
 })();
 ```
 
-### globby.gitignore.sync(options?)
+### isGitIgnoredSync(options?)
 
 Returns a `(path: string) => boolean` indicating whether a given path is ignored via a `.gitignore` file.
 
-Takes the same options as `globby.gitignore`.
+Takes the same options as `isGitIgnored`.
 
 ## Globbing patterns
 

stream-utils.js

@@ -1,10 +1,9 @@
-'use strict';
-const {Transform} = require('stream');
+import {Transform} from 'node:stream';
 
 class ObjectTransform extends Transform {
 	constructor() {
 		super({
-			objectMode: true
+			objectMode: true,
 		});
 	}
 }
@@ -40,7 +39,7 @@ class UniqueStream extends ObjectTransform {
 	}
 }
 
-module.exports = {
+export {
 	FilterStream,
-	UniqueStream
+	UniqueStream,
 };