xo 0.43.0 → 0.46.1

package/lib/options-manager.js

@@ -1,30 +1,26 @@
+import {existsSync, promises as fs} from 'node:fs';
 import process from 'node:process';
 import os from 'node:os';
 import path from 'node:path';
-import fsExtra from 'fs-extra';
 import arrify from 'arrify';
-import {mergeWith, groupBy, flow, pick} from 'lodash-es';
-import pathExists from 'path-exists';
-import findUp from 'find-up';
+import {mergeWith, flow, pick} from 'lodash-es';
+import {findUpSync} from 'find-up';
 import findCacheDir from 'find-cache-dir';
 import prettier from 'prettier';
 import semver from 'semver';
-import {cosmiconfig, cosmiconfigSync, defaultLoaders} from 'cosmiconfig';
-import pReduce from 'p-reduce';
+import {cosmiconfig, defaultLoaders} from 'cosmiconfig';
 import micromatch from 'micromatch';
 import JSON5 from 'json5';
 import toAbsoluteGlob from 'to-absolute-glob';
 import stringify from 'json-stable-stringify-without-jsonify';
 import murmur from 'imurmurhash';
-import isPathInside from 'is-path-inside';
-import eslintrc from '@eslint/eslintrc';
+import {Legacy} from '@eslint/eslintrc';
 import createEsmUtils from 'esm-utils';
 import {
 	DEFAULT_IGNORES,
 	DEFAULT_EXTENSION,
 	TYPESCRIPT_EXTENSION,
 	ENGINE_RULES,
-	PRETTIER_CONFIG_OVERRIDE,
 	MODULE_NAME,
 	CONFIG_FILES,
 	MERGE_OPTIONS_CONCAT,
@@ -33,10 +29,8 @@ import {
 } from './constants.js';
 
 const {__dirname, json, require} = createEsmUtils(import.meta);
-const pkg = json.loadSync('../package.json');
-const {outputJson, outputJsonSync} = fsExtra;
-const {normalizePackageName} = eslintrc.Legacy.naming;
-const resolveModule = eslintrc.Legacy.ModuleResolver.resolve;
+const {normalizePackageName} = Legacy.naming;
+const resolveModule = Legacy.ModuleResolver.resolve;
 
 const resolveFrom = (moduleId, fromDirectory = process.cwd()) => resolveModule(moduleId, path.join(fromDirectory, '__placeholder__.js'));
 
@@ -56,6 +50,7 @@ const DEFAULT_CONFIG = {
 	cache: true,
 	cacheLocation: path.join(cacheLocation(), 'xo-cache.json'),
 	globInputPaths: false,
+	resolvePluginsRelativeTo: __dirname,
 	baseConfig: {
 		extends: [
 			resolveLocalConfig('xo'),
@@ -105,111 +100,90 @@ const isTypescript = file => TYPESCRIPT_EXTENSION.includes(path.extname(file).sl
 Find config for `lintText`.
 The config files are searched starting from `options.filePath` if defined or `options.cwd` otherwise.
 */
-const mergeWithFileConfig = options => {
+const mergeWithFileConfig = async options => {
 	options.cwd = path.resolve(options.cwd || process.cwd());
-	const configExplorer = cosmiconfigSync(MODULE_NAME, {searchPlaces: CONFIG_FILES, loaders: {noExt: defaultLoaders['.json']}, stopDir: options.cwd});
-	const pkgConfigExplorer = cosmiconfigSync('engines', {searchPlaces: ['package.json'], stopDir: options.cwd});
+	const configExplorer = cosmiconfig(MODULE_NAME, {searchPlaces: CONFIG_FILES, loaders: {noExt: defaultLoaders['.json']}, stopDir: options.cwd});
+	const pkgConfigExplorer = cosmiconfig('engines', {searchPlaces: ['package.json'], stopDir: options.cwd});
 	if (options.filePath) {
 		options.filePath = path.resolve(options.cwd, options.filePath);
 	}
 
 	const searchPath = options.filePath || options.cwd;
 
-	const {config: xoOptions, filepath: xoConfigPath} = configExplorer.search(searchPath) || {};
-	const {config: enginesOptions} = pkgConfigExplorer.search(searchPath) || {};
+	const {config: xoOptions, filepath: xoConfigPath} = (await configExplorer.search(searchPath)) || {};
+	const {config: enginesOptions} = (await pkgConfigExplorer.search(searchPath)) || {};
 
 	options = mergeOptions(options, xoOptions, enginesOptions);
 	options.cwd = xoConfigPath && path.dirname(xoConfigPath) !== options.cwd ? path.resolve(options.cwd, path.dirname(xoConfigPath)) : options.cwd;
 
+	// Very simple way to ensure eslint is ran minimal times across
+	// all linted files, once for each unique configuration - xo config path + override hash + tsconfig path
+	let eslintConfigId = xoConfigPath;
 	if (options.filePath) {
-		({options} = applyOverrides(options.filePath, options));
-	}
-
-	const prettierOptions = options.prettier ? prettier.resolveConfig.sync(searchPath, {editorconfig: true}) || {} : {};
-
-	if (options.filePath && isTypescript(options.filePath)) {
-		const tsConfigExplorer = cosmiconfigSync([], {searchPlaces: ['tsconfig.json'], loaders: {'.json': (_, content) => JSON5.parse(content)}});
-		const {config: tsConfig, filepath: tsConfigPath} = tsConfigExplorer.search(options.filePath) || {};
+		const overrides = applyOverrides(options.filePath, options);
+		options = overrides.options;
 
-		options.tsConfigPath = getTsConfigCachePath([options.filePath], options.tsConfigPath, options.cwd);
-		options.ts = true;
-		outputJsonSync(options.tsConfigPath, makeTSConfig(tsConfig, tsConfigPath, [options.filePath]));
+		if (overrides.hash) {
+			eslintConfigId += overrides.hash;
+		}
 	}
 
-	return {options, prettierOptions};
-};
-
-/**
-Find config for each files found by `lintFiles`.
-The config files are searched starting from each files.
-*/
-const mergeWithFileConfigs = async (files, options, configFiles) => {
-	configFiles = configFiles.sort((a, b) => b.filepath.split(path.sep).length - a.filepath.split(path.sep).length);
-	const tsConfigs = {};
-
-	const groups = [...(await pReduce(files, async (configs, file) => {
-		const pkgConfigExplorer = cosmiconfig('engines', {searchPlaces: ['package.json'], stopDir: options.cwd});
-
-		const {config: xoOptions, filepath: xoConfigPath} = findApplicableConfig(file, configFiles) || {};
-		const {config: enginesOptions, filepath: enginesConfigPath} = await pkgConfigExplorer.search(file) || {};
+	const prettierOptions = options.prettier ? await prettier.resolveConfig(searchPath, {editorconfig: true}) || {} : {};
 
-		let fileOptions = mergeOptions(options, xoOptions, enginesOptions);
-		fileOptions.cwd = xoConfigPath && path.dirname(xoConfigPath) !== fileOptions.cwd ? path.resolve(fileOptions.cwd, path.dirname(xoConfigPath)) : fileOptions.cwd;
-
-		const {hash, options: optionsWithOverrides} = applyOverrides(file, fileOptions);
-		fileOptions = optionsWithOverrides;
-
-		const prettierOptions = fileOptions.prettier ? await prettier.resolveConfig(file, {editorconfig: true}) || {} : {};
+	if (options.filePath && isTypescript(options.filePath)) {
+		// We can skip looking up the tsconfig if we have it defined
+		// in our parser options already. Otherwise we can look it up and create it as normal
+		const {project: tsConfigProjectPath, tsconfigRootDir} = options.parserOptions || {};
 
+		let tsConfig;
 		let tsConfigPath;
-		if (isTypescript(file)) {
-			let tsConfig;
-			const tsConfigExplorer = cosmiconfig([], {searchPlaces: ['tsconfig.json'], loaders: {'.json': (_, content) => JSON5.parse(content)}});
-			({config: tsConfig, filepath: tsConfigPath} = await tsConfigExplorer.search(file) || {});
-
-			fileOptions.tsConfigPath = tsConfigPath;
-			tsConfigs[tsConfigPath || ''] = tsConfig;
-			fileOptions.ts = true;
+		if (tsConfigProjectPath) {
+			tsConfigPath = path.resolve(options.cwd, tsConfigProjectPath);
+			tsConfig = await json.load(tsConfigPath);
+		} else {
+			const tsConfigExplorer = cosmiconfig([], {
+				searchPlaces: ['tsconfig.json'],
+				loaders: {'.json': (_, content) => JSON5.parse(content)},
+				stopDir: tsconfigRootDir,
+			});
+			const searchResults = (await tsConfigExplorer.search(options.filePath)) || {};
+			tsConfigPath = searchResults.filepath;
+			tsConfig = searchResults.config;
 		}
 
-		const cacheKey = stringify({xoConfigPath, enginesConfigPath, prettierOptions, hash, tsConfigPath: fileOptions.tsConfigPath, ts: fileOptions.ts});
-		const cachedGroup = configs.get(cacheKey);
-
-		configs.set(cacheKey, {
-			files: [file, ...(cachedGroup ? cachedGroup.files : [])],
-			options: cachedGroup ? cachedGroup.options : fileOptions,
-			prettierOptions,
-		});
-
-		return configs;
-	}, new Map())).values()];
-
-	await Promise.all(Object.entries(groupBy(groups.filter(({options}) => Boolean(options.ts)), group => group.options.tsConfigPath || '')).map(
-		([tsConfigPath, groups]) => {
-			const files = groups.flatMap(group => group.files);
-			const cachePath = getTsConfigCachePath(files, tsConfigPath, options.cwd);
-
-			for (const group of groups) {
-				group.options.tsConfigPath = cachePath;
-			}
+		if (tsConfigPath) {
+			options.tsConfigPath = tsConfigPath;
+			eslintConfigId += tsConfigPath;
+		} else {
+			const {path: tsConfigCachePath, hash: tsConfigHash} = await getTsConfigCachePath([eslintConfigId], tsConfigPath, options.cwd);
+			eslintConfigId += tsConfigHash;
+			options.tsConfigPath = tsConfigCachePath;
+			const config = makeTSConfig(tsConfig, tsConfigPath, [options.filePath]);
+			await fs.mkdir(path.dirname(options.tsConfigPath), {recursive: true});
+			await fs.writeFile(options.tsConfigPath, JSON.stringify(config));
+		}
 
-			return outputJson(cachePath, makeTSConfig(tsConfigs[tsConfigPath], tsConfigPath, files));
-		},
-	));
+		options.ts = true;
+	}
 
-	return groups;
+	return {options, prettierOptions, eslintConfigId};
 };
 
-const findApplicableConfig = (file, configFiles) => configFiles.find(({filepath}) => isPathInside(file, path.dirname(filepath)));
-
 /**
 Generate a unique and consistent path for the temporary `tsconfig.json`.
 Hashing based on https://github.com/eslint/eslint/blob/cf38d0d939b62f3670cdd59f0143fd896fccd771/lib/cli-engine/lint-result-cache.js#L30
 */
-const getTsConfigCachePath = (files, tsConfigPath, cwd) => path.join(
-	cacheLocation(cwd),
-	`tsconfig.${murmur(`${pkg.version}_${nodeVersion}_${stringify({files: files.sort(), tsConfigPath})}`).result().toString(36)}.json`,
-);
+const getTsConfigCachePath = async (files, tsConfigPath, cwd) => {
+	const {version} = await json.load('../package.json');
+	const tsConfigHash = murmur(`${version}_${nodeVersion}_${stringify({files: files.sort(), tsConfigPath})}`).result().toString(36);
+	return {
+		path: path.join(
+			cacheLocation(cwd),
+			`tsconfig.${tsConfigHash}.json`,
+		),
+		hash: tsConfigHash,
+	};
+};
 
 const makeTSConfig = (tsConfig, tsConfigPath, files) => {
 	const config = {files: files.filter(file => isTypescript(file))};
@@ -271,7 +245,7 @@ const mergeOptions = (options, xoOptions = {}, enginesOptions = {}) => {
 		...options,
 	});
 
-	mergedOptions.extensions = DEFAULT_EXTENSION.concat(mergedOptions.extensions || []);
+	mergedOptions.extensions = [...DEFAULT_EXTENSION, ...(mergedOptions.extensions || [])];
 	mergedOptions.ignores = getIgnores(mergedOptions);
 
 	return mergedOptions;
@@ -414,6 +388,10 @@ const buildXOConfig = options => config => {
 
 		// Does not work when the TS definition exports a default const.
 		config.baseConfig.rules['import/default'] = 'off';
+
+		// Disabled as it doesn't work with TypeScript.
+		// This issue and some others: https://github.com/benmosher/eslint-plugin-import/issues/1341
+		config.baseConfig.rules['import/named'] = 'off';
 	}
 
 	config.baseConfig.settings['import/resolver'] = gatherImportResolvers(options);
@@ -425,7 +403,7 @@ const buildExtendsConfig = options => config => {
 	if (options.extends && options.extends.length > 0) {
 		const configs = options.extends.map(name => {
 			// Don't do anything if it's a filepath
-			if (pathExists.sync(name)) {
+			if (existsSync(name)) {
 				return name;
 			}
 
@@ -454,19 +432,11 @@ const buildPrettierConfig = (options, prettierConfig) => config => {
 		// The prettier plugin uses Prettier to format the code with `--fix`
 		config.baseConfig.plugins.push('prettier');
 
-		// The prettier config overrides ESLint stylistic rules that are handled by Prettier
-		config.baseConfig.extends.push('prettier');
+		// The prettier plugin overrides ESLint stylistic rules that are handled by Prettier
+		config.baseConfig.extends.push('plugin:prettier/recommended');
 
 		// The `prettier/prettier` rule reports errors if the code is not formatted in accordance to Prettier
 		config.baseConfig.rules['prettier/prettier'] = ['error', mergeWithPrettierConfig(options, prettierConfig)];
-
-		// If the user has the React, Flowtype, or Standard plugin, add the corresponding Prettier rule overrides
-		// See https://github.com/prettier/eslint-config-prettier for the list of plugins overrrides
-		for (const [plugin, prettierConfig] of Object.entries(PRETTIER_CONFIG_OVERRIDE)) {
-			if (options.cwd && resolveFrom.silent(plugin, options.cwd)) {
-				config.baseConfig.extends.push(prettierConfig);
-			}
-		}
 	}
 
 	return config;
@@ -492,8 +462,8 @@ const mergeWithPrettierConfig = (options, prettierOptions) => {
 		{
 			singleQuote: true,
 			bracketSpacing: false,
-			jsxBracketSameLine: false,
-			trailingComma: 'none',
+			bracketSameLine: false,
+			trailingComma: 'all',
 			tabWidth: normalizeSpaces(options),
 			useTabs: !options.space,
 			semi: options.semicolon !== false,
@@ -505,7 +475,7 @@ const mergeWithPrettierConfig = (options, prettierOptions) => {
 
 const buildTSConfig = options => config => {
 	if (options.ts) {
-		config.baseConfig.extends.push('xo-typescript');
+		config.baseConfig.extends.push(require.resolve('eslint-config-xo-typescript'));
 		config.baseConfig.parser = require.resolve('@typescript-eslint/parser');
 		config.baseConfig.parserOptions = {
 			...config.baseConfig.parserOptions,
@@ -551,11 +521,11 @@ const findApplicableOverrides = (path, overrides) => {
 	const applicable = [];
 
 	for (const override of overrides) {
-		hash <<= 1;
+		hash <<= 1; // eslint-disable-line no-bitwise
 
 		if (micromatch.isMatch(path, override.files)) {
 			applicable.push(override);
-			hash |= 1;
+			hash |= 1; // eslint-disable-line no-bitwise
 		}
 	}
 
@@ -565,7 +535,7 @@ const findApplicableOverrides = (path, overrides) => {
 	};
 };
 
-const getIgnores = ({ignores}) => DEFAULT_IGNORES.concat(ignores || []);
+const getIgnores = ({ignores}) => [...DEFAULT_IGNORES, ...(ignores || [])];
 
 const gatherImportResolvers = options => {
 	let resolvers = {};
@@ -585,7 +555,7 @@ const gatherImportResolvers = options => {
 		webpackResolverSettings = options.webpack === true ? {} : options.webpack;
 	} else if (!(options.webpack === false || resolvers.webpack)) {
 		// If a webpack config file exists, add the import resolver automatically
-		const webpackConfigPath = findUp.sync('webpack.config.js', {cwd: options.cwd});
+		const webpackConfigPath = findUpSync('webpack.config.js', {cwd: options.cwd});
 		if (webpackConfigPath) {
 			webpackResolverSettings = {config: webpackConfigPath};
 		}
@@ -604,14 +574,28 @@ const gatherImportResolvers = options => {
 	return resolvers;
 };
 
+const parseOptions = async options => {
+	options = normalizeOptions(options);
+	const {options: foundOptions, prettierOptions, eslintConfigId} = await mergeWithFileConfig(options);
+	const {filePath, warnIgnored, ...eslintOptions} = buildConfig(foundOptions, prettierOptions);
+	return {
+		filePath,
+		warnIgnored,
+		isQuiet: options.quiet,
+		eslintOptions,
+		eslintConfigId,
+	};
+};
+
 export {
+	parseOptions,
+	getIgnores,
+	mergeWithFileConfig,
+
+	// For tests
+	applyOverrides,
 	findApplicableOverrides,
 	mergeWithPrettierConfig,
 	normalizeOptions,
-	getIgnores,
-	mergeWithFileConfigs,
-	mergeWithFileConfig,
 	buildConfig,
-	applyOverrides,
-	mergeOptions,
 };

package/lib/report.js

@@ -0,0 +1,84 @@
+import defineLazyProperty from 'define-lazy-prop';
+import {ESLint} from 'eslint';
+
+/** Merge multiple reports into a single report */
+const mergeReports = reports => {
+	const report = {
+		results: [],
+		errorCount: 0,
+		warningCount: 0,
+	};
+
+	for (const currentReport of reports) {
+		report.results.push(...currentReport.results);
+		report.errorCount += currentReport.errorCount;
+		report.warningCount += currentReport.warningCount;
+	}
+
+	return report;
+};
+
+const processReport = (report, {isQuiet = false} = {}) => {
+	if (isQuiet) {
+		report = ESLint.getErrorResults(report);
+	}
+
+	const result = {
+		results: report,
+		...getReportStatistics(report),
+	};
+
+	defineLazyProperty(result, 'usedDeprecatedRules', () => {
+		const seenRules = new Set();
+		const rules = [];
+
+		for (const {usedDeprecatedRules} of report) {
+			for (const rule of usedDeprecatedRules) {
+				if (seenRules.has(rule.ruleId)) {
+					continue;
+				}
+
+				seenRules.add(rule.ruleId);
+				rules.push(rule);
+			}
+		}
+
+		return rules;
+	});
+
+	return result;
+};
+
+const getReportStatistics = results => {
+	const statistics = {
+		errorCount: 0,
+		warningCount: 0,
+		fixableErrorCount: 0,
+		fixableWarningCount: 0,
+	};
+
+	for (const result of results) {
+		statistics.errorCount += result.errorCount;
+		statistics.warningCount += result.warningCount;
+		statistics.fixableErrorCount += result.fixableErrorCount;
+		statistics.fixableWarningCount += result.fixableWarningCount;
+	}
+
+	return statistics;
+};
+
+const getIgnoredReport = filePath => ({
+	errorCount: 0,
+	warningCount: 0,
+	results: [
+		{
+			errorCount: 0,
+			warningCount: 0,
+			filePath,
+			messages: [],
+		},
+	],
+	isIgnored: true,
+});
+
+export {mergeReports, processReport, getIgnoredReport};

package/node_modules/@nodelib/fs.scandir/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Denis Malinochkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@nodelib/fs.scandir/README.md

@@ -0,0 +1,171 @@
+# @nodelib/fs.scandir
+
+> List files and directories inside the specified directory.
+
+## :bulb: Highlights
+
+The package is aimed at obtaining information about entries in the directory.
+
+* :moneybag: Returns useful information: `name`, `path`, `dirent` and `stats` (optional).
+* :gear: On Node.js 10.10+ uses the mechanism without additional calls to determine the entry type. See [`old` and `modern` mode](#old-and-modern-mode).
+* :link: Can safely work with broken symbolic links.
+
+## Install
+
+```console
+npm install @nodelib/fs.scandir
+```
+
+## Usage
+
+```ts
+import * as fsScandir from '@nodelib/fs.scandir';
+
+fsScandir.scandir('path', (error, stats) => { /* … */ });
+```
+
+## API
+
+### .scandir(path, [optionsOrSettings], callback)
+
+Returns an array of plain objects ([`Entry`](#entry)) with information about entry for provided path with standard callback-style.
+
+```ts
+fsScandir.scandir('path', (error, entries) => { /* … */ });
+fsScandir.scandir('path', {}, (error, entries) => { /* … */ });
+fsScandir.scandir('path', new fsScandir.Settings(), (error, entries) => { /* … */ });
+```
+
+### .scandirSync(path, [optionsOrSettings])
+
+Returns an array of plain objects ([`Entry`](#entry)) with information about entry for provided path.
+
+```ts
+const entries = fsScandir.scandirSync('path');
+const entries = fsScandir.scandirSync('path', {});
+const entries = fsScandir.scandirSync(('path', new fsScandir.Settings());
+```
+
+#### path
+
+* Required: `true`
+* Type: `string | Buffer | URL`
+
+A path to a file. If a URL is provided, it must use the `file:` protocol.
+
+#### optionsOrSettings
+
+* Required: `false`
+* Type: `Options | Settings`
+* Default: An instance of `Settings` class
+
+An [`Options`](#options) object or an instance of [`Settings`](#settingsoptions) class.
+
+> :book: When you pass a plain object, an instance of the `Settings` class will be created automatically. If you plan to call the method frequently, use a pre-created instance of the `Settings` class.
+
+### Settings([options])
+
+A class of full settings of the package.
+
+```ts
+const settings = new fsScandir.Settings({ followSymbolicLinks: false });
+
+const entries = fsScandir.scandirSync('path', settings);
+```
+
+## Entry
+
+* `name` — The name of the entry (`unknown.txt`).
+* `path` — The path of the entry relative to call directory (`root/unknown.txt`).
+* `dirent` — An instance of [`fs.Dirent`](./src/types/index.ts) class. On Node.js below 10.10 will be emulated by [`DirentFromStats`](./src/utils/fs.ts) class.
+* `stats` (optional) — An instance of `fs.Stats` class.
+
+For example, the `scandir` call for `tools` directory with one directory inside:
+
+```ts
+{
+	dirent: Dirent { name: 'typedoc', /* … */ },
+	name: 'typedoc',
+	path: 'tools/typedoc'
+}
+```
+
+## Options
+
+### stats
+
+* Type: `boolean`
+* Default: `false`
+
+Adds an instance of `fs.Stats` class to the [`Entry`](#entry).
+
+> :book: Always use `fs.readdir` without the `withFileTypes` option. ??TODO??
+
+### followSymbolicLinks
+
+* Type: `boolean`
+* Default: `false`
+
+Follow symbolic links or not. Call `fs.stat` on symbolic link if `true`.
+
+### `throwErrorOnBrokenSymbolicLink`
+
+* Type: `boolean`
+* Default: `true`
+
+Throw an error when symbolic link is broken if `true` or safely use `lstat` call if `false`.
+
+### `pathSegmentSeparator`
+
+* Type: `string`
+* Default: `path.sep`
+
+By default, this package uses the correct path separator for your OS (`\` on Windows, `/` on Unix-like systems). But you can set this option to any separator character(s) that you want to use instead.
+
+### `fs`
+
+* Type: [`FileSystemAdapter`](./src/adapters/fs.ts)
+* Default: A default FS methods
+
+By default, the built-in Node.js module (`fs`) is used to work with the file system. You can replace any method with your own.
+
+```ts
+interface FileSystemAdapter {
+	lstat?: typeof fs.lstat;
+	stat?: typeof fs.stat;
+	lstatSync?: typeof fs.lstatSync;
+	statSync?: typeof fs.statSync;
+	readdir?: typeof fs.readdir;
+	readdirSync?: typeof fs.readdirSync;
+}
+
+const settings = new fsScandir.Settings({
+	fs: { lstat: fakeLstat }
+});
+```
+
+## `old` and `modern` mode
+
+This package has two modes that are used depending on the environment and parameters of use.
+
+### old
+
+* Node.js below `10.10` or when the `stats` option is enabled
+
+When working in the old mode, the directory is read first (`fs.readdir`), then the type of entries is determined (`fs.lstat` and/or `fs.stat` for symbolic links).
+
+### modern
+
+* Node.js 10.10+ and the `stats` option is disabled
+
+In the modern mode, reading the directory (`fs.readdir` with the `withFileTypes` option) is combined with obtaining information about its entries. An additional call for symbolic links (`fs.stat`) is still present.
+
+This mode makes fewer calls to the file system. It's faster.
+
+## Changelog
+
+See the [Releases section of our GitHub project](https://github.com/nodelib/nodelib/releases) for changelog for each release version.
+
+## License
+
+This software is released under the terms of the MIT license.

package/node_modules/@nodelib/fs.scandir/out/adapters/fs.d.ts

@@ -0,0 +1,20 @@
+import type * as fsStat from '@nodelib/fs.stat';
+import type { Dirent, ErrnoException } from '../types';
+export interface ReaddirAsynchronousMethod {
+    (filepath: string, options: {
+        withFileTypes: true;
+    }, callback: (error: ErrnoException | null, files: Dirent[]) => void): void;
+    (filepath: string, callback: (error: ErrnoException | null, files: string[]) => void): void;
+}
+export interface ReaddirSynchronousMethod {
+    (filepath: string, options: {
+        withFileTypes: true;
+    }): Dirent[];
+    (filepath: string): string[];
+}
+export declare type FileSystemAdapter = fsStat.FileSystemAdapter & {
+    readdir: ReaddirAsynchronousMethod;
+    readdirSync: ReaddirSynchronousMethod;
+};
+export declare const FILE_SYSTEM_ADAPTER: FileSystemAdapter;
+export declare function createFileSystemAdapter(fsMethods?: Partial<FileSystemAdapter>): FileSystemAdapter;

package/node_modules/@nodelib/fs.scandir/out/adapters/fs.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+const fs = require("fs");
+exports.FILE_SYSTEM_ADAPTER = {
+    lstat: fs.lstat,
+    stat: fs.stat,
+    lstatSync: fs.lstatSync,
+    statSync: fs.statSync,
+    readdir: fs.readdir,
+    readdirSync: fs.readdirSync
+};
+function createFileSystemAdapter(fsMethods) {
+    if (fsMethods === undefined) {
+        return exports.FILE_SYSTEM_ADAPTER;
+    }
+    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+}
+exports.createFileSystemAdapter = createFileSystemAdapter;

package/node_modules/@nodelib/fs.scandir/out/constants.d.ts

@@ -0,0 +1,4 @@
+/**
+ * IS `true` for Node.js 10.10 and greater.
+ */
+export declare const IS_SUPPORT_READDIR_WITH_FILE_TYPES: boolean;