init 3

node_modules/enhanced-resolve/lib/AliasUtils.js

@@ -0,0 +1,172 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const forEachBail = require("./forEachBail");
+const { PathType, getType } = require("./util/path");
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {import("./Resolver").ResolveCallback} ResolveCallback */
+/** @typedef {string | string[] | false} Alias */
+/** @typedef {{ alias: Alias, name: string, onlyModule?: boolean }} AliasOption */
+
+/** @typedef {(err?: null | Error, result?: null | ResolveRequest) => void} InnerCallback */
+/**
+ * @param {Resolver} resolver resolver
+ * @param {AliasOption[]} options options
+ * @param {ResolveStepHook} target target
+ * @param {ResolveRequest} request request
+ * @param {ResolveContext} resolveContext resolve context
+ * @param {InnerCallback} callback callback
+ * @returns {void}
+ */
+function aliasResolveHandler(
+	resolver,
+	options,
+	target,
+	request,
+	resolveContext,
+	callback,
+) {
+	const innerRequest = request.request || request.path;
+	if (!innerRequest) return callback();
+
+	/**
+	 * @param {string} maybeAbsolutePath path
+	 * @returns {null | string} absolute path with slash ending
+	 */
+	const getAbsolutePathWithSlashEnding = (maybeAbsolutePath) => {
+		const type = getType(maybeAbsolutePath);
+		if (type === PathType.AbsolutePosix || type === PathType.AbsoluteWin) {
+			return resolver.join(maybeAbsolutePath, "_").slice(0, -1);
+		}
+		return null;
+	};
+	/**
+	 * @param {string} path path
+	 * @param {string} maybeSubPath sub path
+	 * @returns {boolean} true, if path is sub path
+	 */
+	const isSubPath = (path, maybeSubPath) => {
+		const absolutePath = getAbsolutePathWithSlashEnding(maybeSubPath);
+		if (!absolutePath) return false;
+		return path.startsWith(absolutePath);
+	};
+
+	forEachBail(
+		options,
+		(item, callback) => {
+			/** @type {boolean} */
+			let shouldStop = false;
+
+			const matchRequest =
+				innerRequest === item.name ||
+				(!item.onlyModule &&
+					(request.request
+						? innerRequest.startsWith(`${item.name}/`)
+						: isSubPath(innerRequest, item.name)));
+
+			const splitName = item.name.split("*");
+			const matchWildcard = !item.onlyModule && splitName.length === 2;
+
+			if (matchRequest || matchWildcard) {
+				/**
+				 * @param {Alias} alias alias
+				 * @param {(err?: null | Error, result?: null | ResolveRequest) => void} callback callback
+				 * @returns {void}
+				 */
+				const resolveWithAlias = (alias, callback) => {
+					if (alias === false) {
+						/** @type {ResolveRequest} */
+						const ignoreObj = {
+							...request,
+							path: false,
+						};
+						if (typeof resolveContext.yield === "function") {
+							resolveContext.yield(ignoreObj);
+							return callback(null, null);
+						}
+						return callback(null, ignoreObj);
+					}
+
+					let newRequestStr;
+
+					const [prefix, suffix] = splitName;
+					if (
+						matchWildcard &&
+						innerRequest.startsWith(prefix) &&
+						innerRequest.endsWith(suffix)
+					) {
+						const match = innerRequest.slice(
+							prefix.length,
+							innerRequest.length - suffix.length,
+						);
+						newRequestStr = alias.toString().replace("*", match);
+					}
+
+					if (
+						matchRequest &&
+						innerRequest !== alias &&
+						!innerRequest.startsWith(`${alias}/`)
+					) {
+						/** @type {string} */
+						const remainingRequest = innerRequest.slice(item.name.length);
+						newRequestStr = alias + remainingRequest;
+					}
+
+					if (newRequestStr !== undefined) {
+						shouldStop = true;
+						/** @type {ResolveRequest} */
+						const obj = {
+							...request,
+							request: newRequestStr,
+							fullySpecified: false,
+						};
+						return resolver.doResolve(
+							target,
+							obj,
+							`aliased with mapping '${item.name}': '${alias}' to '${newRequestStr}'`,
+							resolveContext,
+							(err, result) => {
+								if (err) return callback(err);
+								if (result) return callback(null, result);
+								return callback();
+							},
+						);
+					}
+					return callback();
+				};
+
+				/**
+				 * @param {(null | Error)=} err error
+				 * @param {(null | ResolveRequest)=} result result
+				 * @returns {void}
+				 */
+				const stoppingCallback = (err, result) => {
+					if (err) return callback(err);
+
+					if (result) return callback(null, result);
+					// Don't allow other aliasing or raw request
+					if (shouldStop) return callback(null, null);
+					return callback();
+				};
+
+				if (Array.isArray(item.alias)) {
+					return forEachBail(item.alias, resolveWithAlias, stoppingCallback);
+				}
+				return resolveWithAlias(item.alias, stoppingCallback);
+			}
+
+			return callback();
+		},
+		callback,
+	);
+}
+
+module.exports.aliasResolveHandler = aliasResolveHandler;

node_modules/enhanced-resolve/lib/CloneBasenamePlugin.js

@@ -0,0 +1,53 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { basename } = require("./getPaths");
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+module.exports = class CloneBasenamePlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("CloneBasenamePlugin", (request, resolveContext, callback) => {
+				const requestPath = /** @type {string} */ (request.path);
+				const filename = /** @type {string} */ (basename(requestPath));
+				const filePath = resolver.join(requestPath, filename);
+				/** @type {ResolveRequest} */
+				const obj = {
+					...request,
+					path: filePath,
+					relativePath:
+						request.relativePath &&
+						resolver.join(request.relativePath, filename),
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					`using path: ${filePath}`,
+					resolveContext,
+					callback,
+				);
+			});
+	}
+};

node_modules/enhanced-resolve/lib/DirectoryExistsPlugin.js

@@ -0,0 +1,68 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+module.exports = class DirectoryExistsPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync(
+				"DirectoryExistsPlugin",
+				(request, resolveContext, callback) => {
+					const fs = resolver.fileSystem;
+					const directory = request.path;
+					if (!directory) return callback();
+					fs.stat(directory, (err, stat) => {
+						if (err || !stat) {
+							if (resolveContext.missingDependencies) {
+								resolveContext.missingDependencies.add(directory);
+							}
+							if (resolveContext.log) {
+								resolveContext.log(`${directory} doesn't exist`);
+							}
+							return callback();
+						}
+						if (!stat.isDirectory()) {
+							if (resolveContext.missingDependencies) {
+								resolveContext.missingDependencies.add(directory);
+							}
+							if (resolveContext.log) {
+								resolveContext.log(`${directory} is not a directory`);
+							}
+							return callback();
+						}
+						if (resolveContext.fileDependencies) {
+							resolveContext.fileDependencies.add(directory);
+						}
+						resolver.doResolve(
+							target,
+							request,
+							`existing directory ${directory}`,
+							resolveContext,
+							callback,
+						);
+					});
+				},
+			);
+	}
+};

node_modules/enhanced-resolve/lib/RootsPlugin.js

@@ -0,0 +1,69 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const forEachBail = require("./forEachBail");
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+class RootsPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source hook
+	 * @param {Set<string>} roots roots
+	 * @param {string | ResolveStepHook} target target hook
+	 */
+	constructor(source, roots, target) {
+		this.roots = [...roots];
+		this.source = source;
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+
+		resolver
+			.getHook(this.source)
+			.tapAsync("RootsPlugin", (request, resolveContext, callback) => {
+				const req = request.request;
+				if (!req) return callback();
+				if (!req.startsWith("/")) return callback();
+
+				forEachBail(
+					this.roots,
+					/**
+					 * @param {string} root root
+					 * @param {(err?: null | Error, result?: null | ResolveRequest) => void} callback callback
+					 * @returns {void}
+					 */
+					(root, callback) => {
+						const path = resolver.join(root, req.slice(1));
+						/** @type {ResolveRequest} */
+						const obj = {
+							...request,
+							path,
+							relativePath: request.relativePath && path,
+						};
+						resolver.doResolve(
+							target,
+							obj,
+							`root path ${root}`,
+							resolveContext,
+							callback,
+						);
+					},
+					callback,
+				);
+			});
+	}
+}
+
+module.exports = RootsPlugin;

node_modules/enhanced-resolve/lib/SymlinkPlugin.js

@@ -0,0 +1,101 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const forEachBail = require("./forEachBail");
+const getPaths = require("./getPaths");
+const { PathType, getType } = require("./util/path");
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+module.exports = class SymlinkPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		const fs = resolver.fileSystem;
+		resolver
+			.getHook(this.source)
+			.tapAsync("SymlinkPlugin", (request, resolveContext, callback) => {
+				if (request.ignoreSymlinks) return callback();
+				const pathsResult = getPaths(/** @type {string} */ (request.path));
+				const pathSegments = pathsResult.segments;
+				const { paths } = pathsResult;
+
+				let containsSymlink = false;
+				let idx = -1;
+				forEachBail(
+					paths,
+					/**
+					 * @param {string} path path
+					 * @param {(err?: null | Error, result?: null | number) => void} callback callback
+					 * @returns {void}
+					 */
+					(path, callback) => {
+						idx++;
+						if (resolveContext.fileDependencies) {
+							resolveContext.fileDependencies.add(path);
+						}
+						fs.readlink(path, (err, result) => {
+							if (!err && result) {
+								pathSegments[idx] = /** @type {string} */ (result);
+								containsSymlink = true;
+								// Shortcut when absolute symlink found
+								const resultType = getType(result.toString());
+								if (
+									resultType === PathType.AbsoluteWin ||
+									resultType === PathType.AbsolutePosix
+								) {
+									return callback(null, idx);
+								}
+							}
+							callback();
+						});
+					},
+					/**
+					 * @param {null | Error=} err error
+					 * @param {null | number=} idx result
+					 * @returns {void}
+					 */
+					(err, idx) => {
+						if (!containsSymlink) return callback();
+						const resultSegments =
+							typeof idx === "number"
+								? pathSegments.slice(0, idx + 1)
+								: [...pathSegments];
+						const result = resultSegments.reduceRight((a, b) =>
+							resolver.join(a, b),
+						);
+						/** @type {ResolveRequest} */
+						const obj = {
+							...request,
+							path: result,
+						};
+						resolver.doResolve(
+							target,
+							obj,
+							`resolved symlink to ${result}`,
+							resolveContext,
+							callback,
+						);
+					},
+				);
+			});
+	}
+};

node_modules/enhanced-resolve/lib/getPaths.js

@@ -0,0 +1,45 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/**
+ * @param {string} path path
+ * @returns {{ paths: string[], segments: string[] }}} paths and segments
+ */
+module.exports = function getPaths(path) {
+	if (path === "/") return { paths: ["/"], segments: [""] };
+	const parts = path.split(/(.*?[\\/]+)/);
+	const paths = [path];
+	const segments = [parts[parts.length - 1]];
+	let part = parts[parts.length - 1];
+	path = path.slice(0, Math.max(0, path.length - part.length - 1));
+	for (let i = parts.length - 2; i > 2; i -= 2) {
+		paths.push(path);
+		part = parts[i];
+		path = path.slice(0, Math.max(0, path.length - part.length)) || "/";
+		segments.push(part.slice(0, -1));
+	}
+	[, part] = parts;
+	segments.push(part);
+	paths.push(part);
+	return {
+		paths,
+		segments,
+	};
+};
+
+/**
+ * @param {string} path path
+ * @returns {string | null} basename or null
+ */
+module.exports.basename = function basename(path) {
+	const i = path.lastIndexOf("/");
+	const j = path.lastIndexOf("\\");
+	const resolvedPath = i < 0 ? j : j < 0 ? i : i < j ? j : i;
+	if (resolvedPath < 0) return null;
+	const basename = path.slice(resolvedPath + 1);
+	return basename;
+};