Offers a async require.resolve function. It's highly configurable. 

evilebottnawi

sokra

jhnns

thelarkinn

enhanced-resolve

	MIT License http://www.opensource.org/licenses/mit-license.php

const versions = require("process").versions;

const { getType, PathType } = require("./util/path");

const SyncAsyncFileSystemDecorator = require("./SyncAsyncFileSystemDecorator");

const AliasFieldPlugin = require("./AliasFieldPlugin");

const AliasPlugin = require("./AliasPlugin");

const AppendPlugin = require("./AppendPlugin");

const ConditionalPlugin = require("./ConditionalPlugin");

const DescriptionFilePlugin = require("./DescriptionFilePlugin");

const DirectoryExistsPlugin = require("./DirectoryExistsPlugin");

const ExportsFieldPlugin = require("./ExportsFieldPlugin");

const ExtensionAliasPlugin = require("./ExtensionAliasPlugin");

const FileExistsPlugin = require("./FileExistsPlugin");

const ImportsFieldPlugin = require("./ImportsFieldPlugin");

const JoinRequestPartPlugin = require("./JoinRequestPartPlugin");

const JoinRequestPlugin = require("./JoinRequestPlugin");

const MainFieldPlugin = require("./MainFieldPlugin");

const ModulesInHierarchicalDirectoriesPlugin = require("./ModulesInHierarchicalDirectoriesPlugin");

const ModulesInRootPlugin = require("./ModulesInRootPlugin");

const NextPlugin = require("./NextPlugin");

const ParsePlugin = require("./ParsePlugin");

const PnpPlugin = require("./PnpPlugin");

const RestrictionsPlugin = require("./RestrictionsPlugin");

const ResultPlugin = require("./ResultPlugin");

const RootsPlugin = require("./RootsPlugin");

const SelfReferencePlugin = require("./SelfReferencePlugin");

const SymlinkPlugin = require("./SymlinkPlugin");

const TryNextPlugin = require("./TryNextPlugin");

const UnsafeCachePlugin = require("./UnsafeCachePlugin");

const UseFilePlugin = require("./UseFilePlugin");

/** @typedef {import("./AliasPlugin").AliasOption} AliasOptionEntry */

/** @typedef {import("./ExtensionAliasPlugin").ExtensionAliasOption} ExtensionAliasOption */

/** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */

/** @typedef {import("./Resolver").EnsuredHooks} EnsuredHooks */

/** @typedef {import("./Resolver").FileSystem} FileSystem */

/** @typedef {import("./Resolver").KnownHooks} KnownHooks */

/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */

/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */

/** @typedef {string|string[]|false} AliasOptionNewRequest */

/** @typedef {{[k: string]: AliasOptionNewRequest}} AliasOptions */

/** @typedef {{[k: string]: string|string[] }} ExtensionAliasOptions */

/** @typedef {{apply: function(Resolver): void} | function(this: Resolver, Resolver): void} Plugin */

/** @typedef {false | 0 | "" | null | undefined} Falsy */

/** @typedef {{apply: function(Resolver): void} | (function(this: Resolver, Resolver): void) | Falsy} Plugin */

 * @property {(AliasOptions | AliasOptionEntry[])=} alias A list of module alias configurations or an object which maps key to value

 * @property {(AliasOptions | AliasOptionEntry[])=} fallback A list of module alias configurations or an object which maps key to value, applied only after modules option

 * @property {ExtensionAliasOptions=} extensionAlias An object which maps extension to extension aliases

 * @property {(string | string[])[]=} aliasFields A list of alias fields in description files

 * @property {(function(ResolveRequest): boolean)=} cachePredicate A function which decides whether a request should be cached or not. An object is passed with at least `path` and `request` properties.

 * @property {boolean=} cacheWithContext Whether or not the unsafeCache should include request context as part of the cache key.

 * @property {string[]=} descriptionFiles A list of description files to read from

 * @property {string[]=} conditionNames A list of exports field condition names.

 * @property {boolean=} enforceExtension Enforce that a extension from extensions must be used

 * @property {(string | string[])[]=} exportsFields A list of exports fields in description files

 * @property {(string | string[])[]=} importsFields A list of imports fields in description files

 * @property {string[]=} extensions A list of extensions which should be tried for files

 * @property {FileSystem} fileSystem The file system which should be used

 * @property {(object | boolean)=} unsafeCache Use this cache object to unsafely cache the successful requests

 * @property {boolean=} symlinks Resolve symlinks to their symlinked location

 * @property {Resolver=} resolver A prepared Resolver to which the plugins are attached

 * @property {string[] | string=} modules A list of directories to resolve modules from, can be absolute path or folder name

 * @property {(string | string[] | {name: string | string[], forceRelative: boolean})[]=} mainFields A list of main fields in description files

 * @property {string[]=} mainFiles  A list of main files in directories

 * @property {Plugin[]=} plugins A list of additional resolve plugins which should be applied

 * @property {PnpApi | null=} pnpApi A PnP API that should be used - null is "never", undefined is "auto"

 * @property {string[]=} roots A list of root paths

 * @property {boolean=} fullySpecified The request is already fully specified and no extensions or directories are resolved for it

 * @property {boolean=} resolveToContext Resolve to a context instead of a file

 * @property {(string|RegExp)[]=} restrictions A list of resolve restrictions

 * @property {boolean=} useSyncFileSystemCalls Use only the sync constraints of the file system calls

 * @property {boolean=} preferRelative Prefer to resolve module requests as relative requests before falling back to modules

 * @property {boolean=} preferAbsolute Prefer to resolve server-relative urls as absolute paths before falling back to resolve in roots

 * @property {AliasOptionEntry[]} fallback

 * @property {Set<string | string[]>} aliasFields

 * @property {ExtensionAliasOption[]} extensionAlias

 * @property {(function(ResolveRequest): boolean)} cachePredicate

 * @property {Set<string>} conditionNames A list of exports field condition names.

 * @property {Set<string | string[]>} exportsFields

 * @property {Set<string | string[]>} importsFields

 * @property {object | false} unsafeCache

 * @property {Array<string | string[]>} modules

 * @property {{name: string[], forceRelative: boolean}[]} mainFields

 * @property {Set<string|RegExp>} restrictions

 * @returns {PnpApi | null} processed option

		/** @type {NodeJS.ProcessVersions & {pnp: string}} */ versions.pnp

		return require("pnpapi"); // eslint-disable-line node/no-missing-require

 * @param {AliasOptions | AliasOptionEntry[] | undefined} alias alias

 * @returns {AliasOptionEntry[]} normalized aliases

	return typeof alias === "object" && !Array.isArray(alias) && alias !== null

				const obj = { name: key, onlyModule: false, alias: alias[key] };

		: /** @type {Array<AliasOptionEntry>} */ (alias) || [];

 * @param {function(string): boolean} filter predicate

 * @returns {Array<string | string[]>} merge result

function mergeFilteredToArray(array, filter) {

				result.length > 0 ? result[result.length - 1] : undefined;

  "description": "Offers a async require.resolve function. It's highly configurable.",

    "process": "./lib/util/process-browser.js"

    "tooling": "webpack/tooling#v1.14.0",

  "homepage": "http://github.com/webpack/enhanced-resolve",

    "lint": "yarn run code-lint && yarn run type-lint && yarn typings-test && yarn run special-lint && yarn run spelling",

    "fix": "yarn run code-lint-fix && yarn run special-lint-fix",

    "code-lint": "eslint --cache lib test",

    "code-lint-fix": "eslint --cache lib test --fix",

    "typings-test": "tsc -p tsconfig.types.test.json",

    "type-report": "rimraf coverage && yarn cover:types && yarn cover:report && open-cli coverage/lcov-report/index.html",

    "special-lint": "node node_modules/tooling/lockfile-lint && node node_modules/tooling/inherit-types && node node_modules/tooling/format-file-header && node node_modules/tooling/generate-types",

    "special-lint-fix": "node node_modules/tooling/inherit-types --write && node node_modules/tooling/format-file-header --write && node node_modules/tooling/generate-types --write",

    "pretty": "prettier --loglevel warn --write \"lib/**/*.{js,json}\" \"test/*.js\"",

    "test:watch": "yarn test:only -- --watch",

    "test:coverage": "yarn test:only -- --collectCoverageFrom=\"lib/**/*.js\" --coverage",

    "url": "git://github.com/webpack/enhanced-resolve.git"

 * This file was automatically generated.

import { AsyncSeriesBailHook, AsyncSeriesHook, SyncHook } from "tapable";

type AliasOptionNewRequest = string | false | string[];

	constructor(fileSystem: any, duration: number);

		(arg0: string, arg1: FileSystemCallback<FileSystemStats>): void;

			arg2: FileSystemCallback<string | Buffer>

	lstatSync?: (arg0: string, arg1?: object) => FileSystemStats;

	statSync: (arg0: string, arg1?: object) => FileSystemStats;

					arg0?: null | NodeJS.ErrnoException,

					arg1?: (string | Buffer)[] | Dirent[]

	) => (string | Buffer)[] | FileSystemDirent[];

		(arg0: string, arg1: FileSystemCallback<string | Buffer>): void;

	readFileSync: (arg0: string, arg1?: object) => string | Buffer;

		(arg0: string, arg1: FileSystemCallback<object>): void;

		(arg0: string, arg1: object, arg2: FileSystemCallback<object>): void;

	readJsonSync?: (arg0: string, arg1?: object) => object;

	| ((this: Resolver, arg1: Resolver) => void);

	resolveToUnqualified: (arg0: string, arg1: string, arg2: object) => string;

declare interface PossibleFileSystemError {

	contextDependencies?: WriteOnlySet<string>;

	fileDependencies?: WriteOnlySet<string>;

	 * dependencies that was not found on file system

	missingDependencies?: WriteOnlySet<string>;

	 * set of hooks' calls. For instance, `resolve → parsedResolve → describedResolve`,

	 * yield result, if provided plugins can return several results

	(context: object, path: string, request: string): string | false;

	(path: string, request: string): string | false;

		@@ -53,3 +53,4 @@ /*
		/** @typedef {{[k: string]: string\|string[] }} ExtensionAliasOptions */
		/** @typedef {{apply: function(Resolver): void} \| function(this: Resolver, Resolver): void} Plugin */
		/** @typedef {false \| 0 \| "" \| null \| undefined} Falsy */
		/** @typedef {{apply: function(Resolver): void} \| (function(this: Resolver, Resolver): void) \| Falsy} Plugin */

		@@ -661,3 +662,3 @@ /**
		(plugin).call(resolver, resolver);
		} else {
		} else if (plugin) {
		plugin.apply(resolver);
		@@ -664,0 +665,0 @@ }

		{
		"name": "enhanced-resolve",
		"version": "5.14.1",
		"version": "5.15.0",
		"author": "Tobias Koppers @sokra",
		@@ -56,3 +56,3 @@ "description": "Offers a async require.resolve function. It's highly configurable.",
		"pretest": "yarn lint",
		"spelling": "cspell \"*/.*\"",
		"spelling": "cspell \"**\"",
		"test:only": "jest",
		@@ -66,2 +66,3 @@ "test:watch": "yarn test:only -- --watch",
		"lint-staged": {
		"*": "cspell --no-must-find-files",
		"*.js": "eslint --cache"
		@@ -68,0 +69,0 @@ },

		@@ -284,2 +284,7 @@ /*
		type Plugin =
		\| undefined
		\| null
		\| false
		\| ""
		\| 0
		\| { apply: (arg0: Resolver) => void }
		@@ -286,0 +291,0 @@ \| ((this: Resolver, arg1: Resolver) => void);

Improved metrics