ava 4.0.0-alpha.1 → 4.0.1

package/lib/globs.js

@@ -1,54 +1,36 @@
-'use strict';
-const path = require('path');
-const globby = require('globby');
-const ignoreByDefault = require('ignore-by-default');
-const picomatch = require('picomatch');
-const slash = require('slash');
-const providerManager = require('./provider-manager');
-
-const defaultIgnorePatterns = [...ignoreByDefault.directories(), '**/node_modules'];
-const defaultPicomatchIgnorePatterns = [
-	...defaultIgnorePatterns,
-	// Unlike globby(), picomatch needs a complete pattern when ignoring directories.
-	...defaultIgnorePatterns.map(pattern => `${pattern}/**/*`)
-];
-
-const defaultMatchNoIgnore = picomatch(defaultPicomatchIgnorePatterns);
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {globby, globbySync} from 'globby';
+
+import {
+	defaultIgnorePatterns,
+	hasExtension,
+	normalizeFileForMatching,
+	normalizePatterns,
+	processMatchingPatterns,
+} from './glob-helpers.cjs';
+
+export {
+	classify,
+	isHelperish,
+	matches,
+	normalizePattern,
+	defaultIgnorePatterns,
+	hasExtension,
+	normalizeFileForMatching,
+	normalizePatterns,
+} from './glob-helpers.cjs';
 
 const defaultIgnoredByWatcherPatterns = [
 	'**/*.snap.md', // No need to rerun tests when the Markdown files change.
 	'ava.config.js', // Config is not reloaded so avoid rerunning tests when it changes.
-	'ava.config.cjs' // Config is not reloaded so avoid rerunning tests when it changes.
+	'ava.config.cjs', // Config is not reloaded so avoid rerunning tests when it changes.
 ];
 
 const buildExtensionPattern = extensions => extensions.length === 1 ? extensions[0] : `{${extensions.join(',')}}`;
 
-function normalizePattern(pattern) {
-	// Always use `/` in patterns, harmonizing matching across platforms
-	if (process.platform === 'win32') {
-		pattern = slash(pattern);
-	}
-
-	if (pattern.startsWith('./')) {
-		return pattern.slice(2);
-	}
-
-	if (pattern.startsWith('!./')) {
-		return `!${pattern.slice(3)}`;
-	}
-
-	return pattern;
-}
-
-exports.normalizePattern = normalizePattern;
-
-function normalizePatterns(patterns) {
-	return patterns.map(pattern => normalizePattern(pattern));
-}
-
-exports.normalizePatterns = normalizePatterns;
-
-function normalizeGlobs({extensions, files: filePatterns, ignoredByWatcher: ignoredByWatcherPatterns, providers}) {
+export function normalizeGlobs({extensions, files: filePatterns, ignoredByWatcher: ignoredByWatcherPatterns, providers}) {
 	if (filePatterns !== undefined && (!Array.isArray(filePatterns) || filePatterns.length === 0)) {
 		throw new Error('The ’files’ configuration must be an array containing glob patterns.');
 	}
@@ -68,7 +50,7 @@ function normalizeGlobs({extensions, files: filePatterns, ignoredByWatcher: igno
 		`**/test/**/*.${extensionPattern}`,
 		`**/tests/**/*.${extensionPattern}`,
 		'!**/__tests__/**/__{helper,fixture}?(s)__/**/*',
-		'!**/test?(s)/**/{helper,fixture}?(s)/**/*'
+		'!**/test?(s)/**/{helper,fixture}?(s)/**/*',
 	];
 
 	if (filePatterns) {
@@ -84,40 +66,36 @@ function normalizeGlobs({extensions, files: filePatterns, ignoredByWatcher: igno
 
 	ignoredByWatcherPatterns = ignoredByWatcherPatterns ? [...defaultIgnoredByWatcherPatterns, ...normalizePatterns(ignoredByWatcherPatterns)] : [...defaultIgnoredByWatcherPatterns];
 
-	for (const {level, main} of providers) {
-		if (level >= providerManager.levels.pathRewrites) {
-			({filePatterns, ignoredByWatcherPatterns} = main.updateGlobs({filePatterns, ignoredByWatcherPatterns}));
-		}
+	for (const {main} of providers) {
+		({filePatterns, ignoredByWatcherPatterns} = main.updateGlobs({filePatterns, ignoredByWatcherPatterns}));
 	}
 
 	return {extensions, filePatterns, ignoredByWatcherPatterns};
 }
 
-exports.normalizeGlobs = normalizeGlobs;
-
-const hasExtension = (extensions, file) => extensions.includes(path.extname(file).slice(1));
-
-exports.hasExtension = hasExtension;
+const globOptions = {
+	// Globs should work relative to the cwd value only (this should be the
+	// project directory that AVA is run in).
+	absolute: false,
+	braceExpansion: true,
+	caseSensitiveMatch: false,
+	dot: false,
+	expandDirectories: false,
+	extglob: true,
+	followSymbolicLinks: true,
+	gitignore: false,
+	globstar: true,
+	ignore: defaultIgnorePatterns,
+	baseNameMatch: false,
+	stats: false,
+	unique: true,
+};
 
 const globFiles = async (cwd, patterns) => {
 	const files = await globby(patterns, {
-		// Globs should work relative to the cwd value only (this should be the
-		// project directory that AVA is run in).
-		absolute: false,
-		braceExpansion: true,
-		caseSensitiveMatch: false,
+		...globOptions,
 		cwd,
-		dot: false,
-		expandDirectories: false,
-		extglob: true,
-		followSymbolicLinks: true,
-		gitignore: false,
-		globstar: true,
-		ignore: defaultIgnorePatterns,
-		baseNameMatch: false,
 		onlyFiles: true,
-		stats: false,
-		unique: true
 	});
 
 	// Return absolute file paths. This has the side-effect of normalizing paths
@@ -125,119 +103,114 @@ const globFiles = async (cwd, patterns) => {
 	return files.map(file => path.join(cwd, file));
 };
 
-async function findFiles({cwd, extensions, filePatterns}) {
-	return (await globFiles(cwd, filePatterns)).filter(file => hasExtension(extensions, file));
-}
+const globDirectoriesSync = (cwd, patterns) => {
+	const files = globbySync(patterns, {
+		...globOptions,
+		cwd,
+		onlyDirectories: true,
+	});
 
-exports.findFiles = findFiles;
+	// Return absolute file paths. This has the side-effect of normalizing paths
+	// on Windows.
+	return files.map(file => path.join(cwd, file));
+};
 
-async function findTests({cwd, extensions, filePatterns}) {
-	return (await findFiles({cwd, extensions, filePatterns})).filter(file => !path.basename(file).startsWith('_'));
+export async function findFiles({cwd, extensions, filePatterns}) {
+	const files = await globFiles(cwd, filePatterns);
+	return files.filter(file => hasExtension(extensions, file));
 }
 
-exports.findTests = findTests;
+export async function findTests({cwd, extensions, filePatterns}) {
+	const files = await findFiles({cwd, extensions, filePatterns});
+	return files.filter(file => !path.basename(file).startsWith('_'));
+}
 
-function getChokidarIgnorePatterns({ignoredByWatcherPatterns}) {
+export function getChokidarIgnorePatterns({ignoredByWatcherPatterns}) {
 	return [
 		...defaultIgnorePatterns.map(pattern => `${pattern}/**/*`),
-		...ignoredByWatcherPatterns.filter(pattern => !pattern.startsWith('!'))
+		...ignoredByWatcherPatterns.filter(pattern => !pattern.startsWith('!')),
 	];
 }
 
-exports.getChokidarIgnorePatterns = getChokidarIgnorePatterns;
-
-const matchingCache = new WeakMap();
-const processMatchingPatterns = input => {
-	let result = matchingCache.get(input);
-	if (!result) {
-		const ignore = [...defaultPicomatchIgnorePatterns];
-		const patterns = input.filter(pattern => {
-			if (pattern.startsWith('!')) {
-				// Unlike globby(), picomatch needs a complete pattern when ignoring directories.
-				ignore.push(pattern.slice(1), `${pattern.slice(1)}/**/*`);
-				return false;
+export function applyTestFileFilter({ // eslint-disable-line complexity
+	cwd,
+	expandDirectories = true,
+	filter,
+	providers = [],
+	testFiles,
+	treatFilterPatternsAsFiles = true,
+}) {
+	const {individualMatchers} = processMatchingPatterns(filter);
+	const normalizedFiles = testFiles.map(file => ({file, matcheable: normalizeFileForMatching(cwd, file)}));
+
+	const selected = new Set();
+	const unmatchedPatterns = new Set(individualMatchers.map(({pattern}) => pattern));
+
+	for (const {pattern, match} of individualMatchers) {
+		for (const {file, matcheable} of normalizedFiles) {
+			if (match(matcheable)) {
+				unmatchedPatterns.delete(pattern);
+				selected.add(file);
 			}
-
-			return true;
-		});
-
-		result = {
-			match: picomatch(patterns, {ignore}),
-			matchNoIgnore: picomatch(patterns)
-		};
-		matchingCache.set(input, result);
-	}
-
-	return result;
-};
-
-function matches(file, patterns) {
-	const {match} = processMatchingPatterns(patterns);
-	return match(file);
-}
-
-exports.matches = matches;
-
-const matchesIgnorePatterns = (file, patterns) => {
-	const {matchNoIgnore} = processMatchingPatterns(patterns);
-	return matchNoIgnore(file) || defaultMatchNoIgnore(file);
-};
-
-function normalizeFileForMatching(cwd, file) {
-	if (process.platform === 'win32') {
-		cwd = slash(cwd);
-		file = slash(file);
+		}
 	}
 
-	if (!cwd) { // TODO: Ensure tests provide an actual value.
-		return file;
-	}
+	if (expandDirectories && unmatchedPatterns.size > 0) {
+		const expansion = [];
+		for (const pattern of unmatchedPatterns) {
+			const directories = globDirectoriesSync(cwd, pattern);
+			if (directories.length > 0) {
+				unmatchedPatterns.delete(pattern);
+				expansion.push(directories);
+			}
+		}
 
-	// TODO: If `file` is outside `cwd` we can't normalize it. Need to figure
-	// out if that's a real-world scenario, but we may have to ensure the file
-	// isn't even selected.
-	if (!file.startsWith(cwd)) {
-		return file;
+		const directories = expansion.flat();
+		if (directories.length > 0) {
+			for (const file of testFiles) {
+				if (selected.has(file)) {
+					continue;
+				}
+
+				for (const dir of directories) {
+					if (file.startsWith(dir + path.sep)) { // eslint-disable-line max-depth
+						selected.add(file);
+					}
+				}
+			}
+		}
 	}
 
-	// Assume `cwd` does *not* end in a slash.
-	return file.slice(cwd.length + 1);
-}
-
-exports.normalizeFileForMatching = normalizeFileForMatching;
+	const ignoredFilterPatternFiles = [];
+	if (treatFilterPatternsAsFiles && unmatchedPatterns.size > 0) {
+		const providerExtensions = new Set(providers.flatMap(({main}) => main.extensions));
+		for (const pattern of unmatchedPatterns) {
+			const file = path.join(cwd, pattern);
+			try {
+				const stats = fs.statSync(file);
+				if (!stats.isFile()) {
+					continue;
+				}
+			} catch (error) {
+				if (error.code === 'ENOENT') {
+					continue;
+				}
+
+				throw error;
+			}
 
-function isHelperish(file) { // Assume file has been normalized already.
-	// File names starting with an underscore are deemed "helpers".
-	if (path.basename(file).startsWith('_')) {
-		return true;
-	}
+			if (
+				path.basename(file).startsWith('_')
+				|| providerExtensions.has(path.extname(file).slice(1))
+				|| file.split(path.sep).includes('node_modules')
+			) {
+				ignoredFilterPatternFiles.push(pattern);
+				continue;
+			}
 
-	// This function assumes the file has been normalized. If it couldn't be,
-	// don't check if it's got a parent directory that starts with an underscore.
-	// Deem it not a "helper".
-	if (path.isAbsolute(file)) {
-		return false;
+			selected.add(file);
+		}
 	}
 
-	// If the file has a parent directory that starts with only a single
-	// underscore, it's deemed a "helper".
-	return path.dirname(file).split('/').some(dir => /^_(?:$|[^_])/.test(dir));
+	return Object.assign([...selected], {ignoredFilterPatternFiles});
 }
-
-exports.isHelperish = isHelperish;
-
-function classify(file, {cwd, extensions, filePatterns, ignoredByWatcherPatterns}) {
-	file = normalizeFileForMatching(cwd, file);
-	return {
-		isIgnoredByWatcher: matchesIgnorePatterns(file, ignoredByWatcherPatterns),
-		isTest: hasExtension(extensions, file) && !isHelperish(file) && filePatterns.length > 0 && matches(file, filePatterns)
-	};
-}
-
-exports.classify = classify;
-
-function applyTestFileFilter({cwd, filter, testFiles}) {
-	return testFiles.filter(file => matches(normalizeFileForMatching(cwd, file), filter));
-}
-
-exports.applyTestFileFilter = applyTestFileFilter;

package/lib/{ipc-flow-control.js → ipc-flow-control.cjs}

@@ -1,3 +1,4 @@
+'use strict';
 function controlFlow(channel) {
 	let errored = false;
 	let deliverImmediately = true;

package/lib/is-ci.js

@@ -1,5 +1,7 @@
-const info = require('ci-info');
+import process from 'node:process';
+
+import info from 'ci-info';
 
 const {AVA_FORCE_CI} = process.env;
 
-module.exports = AVA_FORCE_CI === 'not-ci' ? false : AVA_FORCE_CI === 'ci' || info.isCI;
+export default AVA_FORCE_CI === 'not-ci' ? false : AVA_FORCE_CI === 'ci' || info.isCI;

package/lib/like-selector.js

@@ -1,17 +1,13 @@
-'use strict';
-function isLikeSelector(selector) {
-	return selector !== null &&
-		typeof selector === 'object' &&
-		Reflect.getPrototypeOf(selector) === Object.prototype &&
-		Reflect.ownKeys(selector).length > 0;
+export function isLikeSelector(selector) {
+	return selector !== null
+		&& typeof selector === 'object'
+		&& Reflect.getPrototypeOf(selector) === Object.prototype
+		&& Reflect.ownKeys(selector).length > 0;
 }
 
-exports.isLikeSelector = isLikeSelector;
+export const CIRCULAR_SELECTOR = new Error('Encountered a circular selector');
 
-const CIRCULAR_SELECTOR = new Error('Encountered a circular selector');
-exports.CIRCULAR_SELECTOR = CIRCULAR_SELECTOR;
-
-function selectComparable(lhs, selector, circular = new Set()) {
+export function selectComparable(lhs, selector, circular = new Set()) {
 	if (circular.has(selector)) {
 		throw CIRCULAR_SELECTOR;
 	}
@@ -33,5 +29,3 @@ function selectComparable(lhs, selector, circular = new Set()) {
 
 	return comparable;
 }
-
-exports.selectComparable = selectComparable;

package/lib/line-numbers.js

@@ -1,7 +1,4 @@
-'use strict';
-
-const picomatch = require('picomatch');
-const flatten = require('lodash/flatten');
+import picomatch from 'picomatch';
 
 const NUMBER_REGEX = /^\d+$/;
 const RANGE_REGEX = /^(?<startGroup>\d+)-(?<endGroup>\d+)$/;
@@ -19,8 +16,8 @@ const parseNumber = string => Number.parseInt(string, 10);
 const removeAllWhitespace = string => string.replace(/\s/g, '');
 const range = (start, end) => Array.from({length: end - start + 1}).fill(start).map((element, index) => element + index);
 
-const parseLineNumbers = suffix => sortNumbersAscending(distinctArray(flatten(
-	suffix.split(',').map(part => {
+const parseLineNumbers = suffix => sortNumbersAscending(distinctArray(
+	suffix.split(',').flatMap(part => {
 		if (NUMBER_REGEX.test(part)) {
 			return parseNumber(part);
 		}
@@ -34,10 +31,10 @@ const parseLineNumbers = suffix => sortNumbersAscending(distinctArray(flatten(
 		}
 
 		return range(start, end);
-	})
-)));
+	}),
+));
 
-function splitPatternAndLineNumbers(pattern) {
+export function splitPatternAndLineNumbers(pattern) {
 	const parts = pattern.split(DELIMITER);
 	if (parts.length === 1) {
 		return {pattern, lineNumbers: null};
@@ -51,14 +48,10 @@ function splitPatternAndLineNumbers(pattern) {
 	return {pattern: parts.join(DELIMITER), lineNumbers: parseLineNumbers(suffix)};
 }
 
-exports.splitPatternAndLineNumbers = splitPatternAndLineNumbers;
-
-function getApplicableLineNumbers(normalizedFilePath, filter) {
-	return sortNumbersAscending(distinctArray(flatten(
+export function getApplicableLineNumbers(normalizedFilePath, filter) {
+	return sortNumbersAscending(distinctArray(
 		filter
 			.filter(({pattern, lineNumbers}) => lineNumbers && picomatch.isMatch(normalizedFilePath, pattern))
-			.map(({lineNumbers}) => lineNumbers)
-	)));
+			.flatMap(({lineNumbers}) => lineNumbers),
+	));
 }
-
-exports.getApplicableLineNumbers = getApplicableLineNumbers;

package/lib/load-config.js

@@ -1,16 +1,14 @@
-'use strict';
-const fs = require('fs');
-const path = require('path');
-const url = require('url');
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import url from 'node:url';
 
-const {isPlainObject} = require('is-plain-object');
-const pkgConf = require('pkg-conf');
+import {isPlainObject} from 'is-plain-object';
+import {packageConfig, packageJsonPath} from 'pkg-conf';
 
 const NO_SUCH_FILE = Symbol('no ava.config.js file');
 const MISSING_DEFAULT_EXPORT = Symbol('missing default export');
-const EXPERIMENTS = new Set([
-	'sharedWorkers'
-]);
+const EXPERIMENTS = new Set();
 
 const importConfig = async ({configFile, fileForErrorMessage}) => {
 	const {default: config = MISSING_DEFAULT_EXPORT} = await import(url.pathToFileURL(configFile)); // eslint-disable-line node/no-unsupported-features/es-syntax
@@ -21,51 +19,22 @@ const importConfig = async ({configFile, fileForErrorMessage}) => {
 	return config;
 };
 
-const loadJsConfig = async ({projectDir, configFile = path.join(projectDir, 'ava.config.js')}) => {
-	if (!configFile.endsWith('.js') || !fs.existsSync(configFile)) {
+const loadConfigFile = async ({projectDir, configFile}) => {
+	if (!fs.existsSync(configFile)) {
 		return null;
 	}
 
 	const fileForErrorMessage = path.relative(projectDir, configFile);
 	try {
-		return {config: await importConfig({configFile, fileForErrorMessage}), fileForErrorMessage};
+		return {config: await importConfig({configFile, fileForErrorMessage}), configFile, fileForErrorMessage};
 	} catch (error) {
 		throw Object.assign(new Error(`Error loading ${fileForErrorMessage}: ${error.message}`), {parent: error});
 	}
 };
 
-const loadCjsConfig = async ({projectDir, configFile = path.join(projectDir, 'ava.config.cjs')}) => {
-	if (!configFile.endsWith('.cjs') || !fs.existsSync(configFile)) {
-		return null;
-	}
-
-	const fileForErrorMessage = path.relative(projectDir, configFile);
-	try {
-		return {config: await require(configFile), fileForErrorMessage};
-	} catch (error) {
-		throw Object.assign(new Error(`Error loading ${fileForErrorMessage}`), {parent: error});
-	}
-};
-
-const loadMjsConfig = async ({projectDir, configFile = path.join(projectDir, 'ava.config.mjs')}) => {
-	if (!configFile.endsWith('.mjs') || !fs.existsSync(configFile)) {
-		return null;
-	}
-
-	const fileForErrorMessage = path.relative(projectDir, configFile);
-	try {
-		return {config: await importConfig({configFile, fileForErrorMessage}), fileForErrorMessage};
-	} catch (error) {
-		throw Object.assign(new Error(`Error loading ${fileForErrorMessage}`), {parent: error});
-	}
-};
-
-function resolveConfigFile(projectDir, configFile) {
+function resolveConfigFile(configFile) {
 	if (configFile) {
 		configFile = path.resolve(configFile); // Relative to CWD
-		if (path.basename(configFile) !== path.relative(projectDir, configFile)) {
-			throw new Error('Config files must be located next to the package.json file');
-		}
 
 		if (!configFile.endsWith('.js') && !configFile.endsWith('.cjs') && !configFile.endsWith('.mjs')) {
 			throw new Error('Config files must have .js, .cjs or .mjs extensions');
@@ -75,20 +44,59 @@ function resolveConfigFile(projectDir, configFile) {
 	return configFile;
 }
 
-async function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {}} = {}) {
-	let packageConf = await pkgConf('ava', {cwd: resolveFrom});
-	const filepath = pkgConf.filepath(packageConf);
-	const projectDir = filepath === null ? resolveFrom : path.dirname(filepath);
+const gitScmFile = process.env.AVA_FAKE_SCM_ROOT || '.git';
+
+async function findRepoRoot(fromDir) {
+	const {root} = path.parse(fromDir);
+	let dir = fromDir;
+	while (root !== dir) {
+		try {
+			const stat = await fs.promises.stat(path.join(dir, gitScmFile)); // eslint-disable-line no-await-in-loop
+			if (stat.isFile() || stat.isDirectory()) {
+				return dir;
+			}
+		} catch {}
+
+		dir = path.dirname(dir);
+	}
 
-	configFile = resolveConfigFile(projectDir, configFile);
+	return root;
+}
+
+export async function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {}} = {}) {
+	let packageConf = await packageConfig('ava', {cwd: resolveFrom});
+	const filepath = packageJsonPath(packageConf);
+	const projectDir = filepath === undefined ? resolveFrom : path.dirname(filepath);
+
+	const repoRoot = await findRepoRoot(projectDir);
+
+	// Conflicts are only allowed when an explicit config file is provided.
 	const allowConflictWithPackageJson = Boolean(configFile);
+	configFile = resolveConfigFile(configFile);
 
-	// TODO: Refactor resolution logic to implement https://github.com/avajs/ava/issues/2285.
-	let [{config: fileConf, fileForErrorMessage} = {config: NO_SUCH_FILE, fileForErrorMessage: undefined}, ...conflicting] = (await Promise.all([
-		loadJsConfig({projectDir, configFile}, true),
-		loadCjsConfig({projectDir, configFile}),
-		loadMjsConfig({projectDir, configFile}, true)
-	])).filter(result => result !== null);
+	let fileConf = NO_SUCH_FILE;
+	let fileForErrorMessage;
+	let conflicting = [];
+	if (configFile) {
+		const loaded = await loadConfigFile({projectDir, configFile});
+		if (loaded !== null) {
+			({config: fileConf, fileForErrorMessage} = loaded);
+		}
+	} else {
+		let searchDir = projectDir;
+		const stopAt = path.dirname(repoRoot);
+		do {
+			const results = await Promise.all([ // eslint-disable-line no-await-in-loop
+				loadConfigFile({projectDir, configFile: path.join(searchDir, 'ava.config.js')}),
+				loadConfigFile({projectDir, configFile: path.join(searchDir, 'ava.config.cjs')}),
+				loadConfigFile({projectDir, configFile: path.join(searchDir, 'ava.config.mjs')}),
+			]);
+
+			[{config: fileConf, fileForErrorMessage, configFile} = {config: NO_SUCH_FILE, fileForErrorMessage: undefined}, ...conflicting] = results.filter(result => result !== null);
+
+			searchDir = path.dirname(searchDir);
+		} while (fileConf === NO_SUCH_FILE && searchDir !== stopAt);
+	}
 
 	if (conflicting.length > 0) {
 		throw new Error(`Conflicting configuration in ${fileForErrorMessage} and ${conflicting.map(({fileForErrorMessage}) => fileForErrorMessage).join(' & ')}`);
@@ -118,7 +126,7 @@ async function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {
 		}
 	}
 
-	const config = {...defaults, nonSemVerExperiments: {}, ...fileConf, ...packageConf, projectDir};
+	const config = {...defaults, nonSemVerExperiments: {}, ...fileConf, ...packageConf, projectDir, configFile};
 
 	const {nonSemVerExperiments: experiments} = config;
 	if (!isPlainObject(experiments)) {
@@ -133,5 +141,3 @@ async function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {
 
 	return config;
 }
-
-exports.loadConfig = loadConfig;

package/lib/module-types.js

@@ -54,12 +54,12 @@ const deriveFromArray = (extensions, defaultModuleType) => {
 	return moduleTypes;
 };
 
-module.exports = (configuredExtensions, defaultModuleType) => {
+export default function moduleTypes(configuredExtensions, defaultModuleType) {
 	if (configuredExtensions === undefined) {
 		return {
 			cjs: 'commonjs',
 			mjs: 'module',
-			js: defaultModuleType
+			js: defaultModuleType,
 		};
 	}
 
@@ -68,4 +68,4 @@ module.exports = (configuredExtensions, defaultModuleType) => {
 	}
 
 	return deriveFromObject(configuredExtensions, defaultModuleType);
-};
+}

package/lib/node-arguments.js

@@ -1,7 +1,8 @@
-'use strict';
-const arrgv = require('arrgv');
+import process from 'node:process';
 
-function normalizeNodeArguments(fromConf = [], fromArgv = '') {
+import arrgv from 'arrgv';
+
+export default function normalizeNodeArguments(fromConf = [], fromArgv = '') {
 	let parsedArgv = [];
 	if (fromArgv !== '') {
 		try {
@@ -13,5 +14,3 @@ function normalizeNodeArguments(fromConf = [], fromArgv = '') {
 
 	return [...process.execArgv, ...fromConf, ...parsedArgv];
 }
-
-module.exports = normalizeNodeArguments;