webpack 5.94.0 → 5.96.0

package/lib/util/LazySet.js

@@ -138,6 +138,9 @@ class LazySet {
 		return this._set.delete(value);
 	}
 
+	/**
+	 * @returns {IterableIterator<[T, T]>} entries
+	 */
 	entries() {
 		this._deopt = true;
 		if (this._needMerge) this._merge();
@@ -165,18 +168,27 @@ class LazySet {
 		return this._set.has(item);
 	}
 
+	/**
+	 * @returns {IterableIterator<T>} keys
+	 */
 	keys() {
 		this._deopt = true;
 		if (this._needMerge) this._merge();
 		return this._set.keys();
 	}
 
+	/**
+	 * @returns {IterableIterator<T>} values
+	 */
 	values() {
 		this._deopt = true;
 		if (this._needMerge) this._merge();
 		return this._set.values();
 	}
 
+	/**
+	 * @returns {IterableIterator<T>} iterable iterator
+	 */
 	[Symbol.iterator]() {
 		this._deopt = true;
 		if (this._needMerge) this._merge();

package/lib/util/SetHelpers.js

@@ -65,7 +65,7 @@ const find = (set, fn) => {
 
 /**
  * @template T
- * @param {Set<T>} set a set
+ * @param {Set<T> | ReadonlySet<T>} set a set
  * @returns {T | undefined} first item
  */
 const first = set => {

package/lib/util/cleverMerge.js

@@ -82,11 +82,13 @@ const cachedSetProperty = (obj, property, value) => {
 	return /** @type {T} */ (result);
 };
 
+/** @typedef {Map<string, any>} ByValues */
+
 /**
  * @typedef {object} ObjectParsedPropertyEntry
  * @property {any | undefined} base base value
  * @property {string | undefined} byProperty the name of the selector property
- * @property {Map<string, any>} byValues value depending on selector property, merged with base
+ * @property {ByValues} byValues value depending on selector property, merged with base
  */
 
 /**
@@ -111,12 +113,17 @@ const cachedParseObject = obj => {
 };
 
 /**
- * @param {object} obj the object
+ * @template {object} T
+ * @param {T} obj the object
  * @returns {ParsedObject} parsed object
  */
 const parseObject = obj => {
 	const info = new Map();
 	let dynamicInfo;
+	/**
+	 * @param {string} p path
+	 * @returns {Partial<ObjectParsedPropertyEntry>} object parsed property entry
+	 */
 	const getInfo = p => {
 		const entry = info.get(p);
 		if (entry !== undefined) return entry;
@@ -130,26 +137,33 @@ const parseObject = obj => {
 	};
 	for (const key of Object.keys(obj)) {
 		if (key.startsWith("by")) {
-			const byProperty = key;
-			const byObj = obj[byProperty];
+			const byProperty = /** @type {keyof T} */ (key);
+			const byObj = /** @type {object} */ (obj[byProperty]);
 			if (typeof byObj === "object") {
 				for (const byValue of Object.keys(byObj)) {
-					const obj = byObj[byValue];
+					const obj = byObj[/** @type {keyof (keyof T)} */ (byValue)];
 					for (const key of Object.keys(obj)) {
 						const entry = getInfo(key);
 						if (entry.byProperty === undefined) {
-							entry.byProperty = byProperty;
+							entry.byProperty = /** @type {string} */ (byProperty);
 							entry.byValues = new Map();
 						} else if (entry.byProperty !== byProperty) {
 							throw new Error(
-								`${byProperty} and ${entry.byProperty} for a single property is not supported`
+								`${/** @type {string} */ (byProperty)} and ${entry.byProperty} for a single property is not supported`
 							);
 						}
-						entry.byValues.set(byValue, obj[key]);
+						/** @type {ByValues} */
+						(entry.byValues).set(
+							byValue,
+							obj[/** @type {keyof (keyof T)} */ (key)]
+						);
 						if (byValue === "default") {
 							for (const otherByValue of Object.keys(byObj)) {
-								if (!entry.byValues.has(otherByValue))
-									entry.byValues.set(otherByValue, undefined);
+								if (
+									!(/** @type {ByValues} */ (entry.byValues).has(otherByValue))
+								)
+									/** @type {ByValues} */
+									(entry.byValues).set(otherByValue, undefined);
 							}
 						}
 					}
@@ -167,11 +181,11 @@ const parseObject = obj => {
 				}
 			} else {
 				const entry = getInfo(key);
-				entry.base = obj[key];
+				entry.base = obj[/** @type {keyof T} */ (key)];
 			}
 		} else {
 			const entry = getInfo(key);
-			entry.base = obj[key];
+			entry.base = obj[/** @type {keyof T} */ (key)];
 		}
 	}
 	return {
@@ -181,12 +195,13 @@ const parseObject = obj => {
 };
 
 /**
+ * @template {object} T
  * @param {Map<string, ObjectParsedPropertyEntry>} info static properties (key is property name)
  * @param {{ byProperty: string, fn: Function } | undefined} dynamicInfo dynamic part
- * @returns {object} the object
+ * @returns {T} the object
  */
 const serializeObject = (info, dynamicInfo) => {
-	const obj = {};
+	const obj = /** @type {T} */ ({});
 	// Setup byProperty structure
 	for (const entry of info.values()) {
 		if (entry.byProperty !== undefined) {
@@ -198,7 +213,7 @@ const serializeObject = (info, dynamicInfo) => {
 	}
 	for (const [key, entry] of info) {
 		if (entry.base !== undefined) {
-			obj[key] = entry.base;
+			obj[/** @type {keyof T} */ (key)] = entry.base;
 		}
 		// Fill byProperty structure
 		if (entry.byProperty !== undefined) {
@@ -475,7 +490,7 @@ const mergeSingleValue = (a, b, internalCaching) => {
 				case VALUE_TYPE_UNDEFINED:
 					return b;
 				case VALUE_TYPE_DELETE:
-					return b.filter(item => item !== "...");
+					return /** @type {any[]} */ (b).filter(item => item !== "...");
 				case VALUE_TYPE_ARRAY_EXTEND: {
 					const newArray = [];
 					for (const item of b) {
@@ -490,7 +505,9 @@ const mergeSingleValue = (a, b, internalCaching) => {
 					return newArray;
 				}
 				case VALUE_TYPE_OBJECT:
-					return b.map(item => (item === "..." ? a : item));
+					return /** @type {any[]} */ (b).map(item =>
+						item === "..." ? a : item
+					);
 				default:
 					throw new Error("Not implemented");
 			}
@@ -522,15 +539,22 @@ const removeOperations = (obj, keysToKeepOriginalValue = []) => {
 			case VALUE_TYPE_DELETE:
 				break;
 			case VALUE_TYPE_OBJECT:
-				newObj[key] = removeOperations(
-					/** @type {TODO} */ (value),
-					keysToKeepOriginalValue
-				);
+				newObj[/** @type {keyof T} */ (key)] =
+					/** @type {T[keyof T]} */
+					(
+						removeOperations(
+							/** @type {TODO} */ (value),
+							keysToKeepOriginalValue
+						)
+					);
 				break;
 			case VALUE_TYPE_ARRAY_EXTEND:
-				newObj[key] =
-					/** @type {any[]} */
-					(value).filter(i => i !== "...");
+				newObj[/** @type {keyof T} */ (key)] =
+					/** @type {T[keyof T]} */
+					(
+						/** @type {any[]} */
+						(value).filter(i => i !== "...")
+					);
 				break;
 			default:
 				newObj[/** @type {keyof T} */ (key)] = value;

package/lib/util/concatenate.js

@@ -0,0 +1,227 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Template = require("../Template");
+
+/** @typedef {import("eslint-scope").Scope} Scope */
+/** @typedef {import("eslint-scope").Reference} Reference */
+/** @typedef {import("eslint-scope").Variable} Variable */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../javascript/JavascriptParser").Program} Program */
+/** @typedef {Set<string>} UsedNames */
+
+const DEFAULT_EXPORT = "__WEBPACK_DEFAULT_EXPORT__";
+const NAMESPACE_OBJECT_EXPORT = "__WEBPACK_NAMESPACE_OBJECT__";
+
+/**
+ * @param {Variable} variable variable
+ * @returns {Reference[]} references
+ */
+const getAllReferences = variable => {
+	let set = variable.references;
+	// Look for inner scope variables too (like in class Foo { t() { Foo } })
+	const identifiers = new Set(variable.identifiers);
+	for (const scope of variable.scope.childScopes) {
+		for (const innerVar of scope.variables) {
+			if (innerVar.identifiers.some(id => identifiers.has(id))) {
+				set = set.concat(innerVar.references);
+				break;
+			}
+		}
+	}
+	return set;
+};
+
+/**
+ * @param {Node | Node[]} ast ast
+ * @param {Node} node node
+ * @returns {undefined | Node[]} result
+ */
+const getPathInAst = (ast, node) => {
+	if (ast === node) {
+		return [];
+	}
+
+	const nr = /** @type {Range} */ (node.range);
+
+	/**
+	 * @param {Node} n node
+	 * @returns {Node[] | undefined} result
+	 */
+	const enterNode = n => {
+		if (!n) return;
+		const r = n.range;
+		if (r && r[0] <= nr[0] && r[1] >= nr[1]) {
+			const path = getPathInAst(n, node);
+			if (path) {
+				path.push(n);
+				return path;
+			}
+		}
+	};
+
+	if (Array.isArray(ast)) {
+		for (let i = 0; i < ast.length; i++) {
+			const enterResult = enterNode(ast[i]);
+			if (enterResult !== undefined) return enterResult;
+		}
+	} else if (ast && typeof ast === "object") {
+		const keys =
+			/** @type {Array<keyof Node>} */
+			(Object.keys(ast));
+		for (let i = 0; i < keys.length; i++) {
+			// We are making the faster check in `enterNode` using `n.range`
+			const value =
+				ast[
+					/** @type {Exclude<keyof Node, "range" | "loc" | "leadingComments" | "trailingComments">} */
+					(keys[i])
+				];
+			if (Array.isArray(value)) {
+				const pathResult = getPathInAst(value, node);
+				if (pathResult !== undefined) return pathResult;
+			} else if (value && typeof value === "object") {
+				const enterResult = enterNode(value);
+				if (enterResult !== undefined) return enterResult;
+			}
+		}
+	}
+};
+
+/**
+ * @param {string} oldName old name
+ * @param {UsedNames} usedNamed1 used named 1
+ * @param {UsedNames} usedNamed2 used named 2
+ * @param {string} extraInfo extra info
+ * @returns {string} found new name
+ */
+function findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
+	let name = oldName;
+
+	if (name === DEFAULT_EXPORT) {
+		name = "";
+	}
+	if (name === NAMESPACE_OBJECT_EXPORT) {
+		name = "namespaceObject";
+	}
+
+	// Remove uncool stuff
+	extraInfo = extraInfo.replace(
+		/\.+\/|(\/index)?\.([a-zA-Z0-9]{1,4})($|\s|\?)|\s*\+\s*\d+\s*modules/g,
+		""
+	);
+
+	const splittedInfo = extraInfo.split("/");
+	while (splittedInfo.length) {
+		name = splittedInfo.pop() + (name ? `_${name}` : "");
+		const nameIdent = Template.toIdentifier(name);
+		if (
+			!usedNamed1.has(nameIdent) &&
+			(!usedNamed2 || !usedNamed2.has(nameIdent))
+		)
+			return nameIdent;
+	}
+
+	let i = 0;
+	let nameWithNumber = Template.toIdentifier(`${name}_${i}`);
+	while (
+		usedNamed1.has(nameWithNumber) ||
+		// eslint-disable-next-line no-unmodified-loop-condition
+		(usedNamed2 && usedNamed2.has(nameWithNumber))
+	) {
+		i++;
+		nameWithNumber = Template.toIdentifier(`${name}_${i}`);
+	}
+	return nameWithNumber;
+}
+
+/**
+ * @param {Scope | null} s scope
+ * @param {UsedNames} nameSet name set
+ * @param {TODO} scopeSet1 scope set 1
+ * @param {TODO} scopeSet2 scope set 2
+ */
+const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
+	let scope = s;
+	while (scope) {
+		if (scopeSet1.has(scope)) break;
+		if (scopeSet2.has(scope)) break;
+		scopeSet1.add(scope);
+		for (const variable of scope.variables) {
+			nameSet.add(variable.name);
+		}
+		scope = scope.upper;
+	}
+};
+
+const RESERVED_NAMES = new Set(
+	[
+		// internal names (should always be renamed)
+		DEFAULT_EXPORT,
+		NAMESPACE_OBJECT_EXPORT,
+
+		// keywords
+		"abstract,arguments,async,await,boolean,break,byte,case,catch,char,class,const,continue",
+		"debugger,default,delete,do,double,else,enum,eval,export,extends,false,final,finally,float",
+		"for,function,goto,if,implements,import,in,instanceof,int,interface,let,long,native,new,null",
+		"package,private,protected,public,return,short,static,super,switch,synchronized,this,throw",
+		"throws,transient,true,try,typeof,var,void,volatile,while,with,yield",
+
+		// commonjs/amd
+		"module,__dirname,__filename,exports,require,define",
+
+		// js globals
+		"Array,Date,eval,function,hasOwnProperty,Infinity,isFinite,isNaN,isPrototypeOf,length,Math",
+		"NaN,name,Number,Object,prototype,String,Symbol,toString,undefined,valueOf",
+
+		// browser globals
+		"alert,all,anchor,anchors,area,assign,blur,button,checkbox,clearInterval,clearTimeout",
+		"clientInformation,close,closed,confirm,constructor,crypto,decodeURI,decodeURIComponent",
+		"defaultStatus,document,element,elements,embed,embeds,encodeURI,encodeURIComponent,escape",
+		"event,fileUpload,focus,form,forms,frame,innerHeight,innerWidth,layer,layers,link,location",
+		"mimeTypes,navigate,navigator,frames,frameRate,hidden,history,image,images,offscreenBuffering",
+		"open,opener,option,outerHeight,outerWidth,packages,pageXOffset,pageYOffset,parent,parseFloat",
+		"parseInt,password,pkcs11,plugin,prompt,propertyIsEnum,radio,reset,screenX,screenY,scroll",
+		"secure,select,self,setInterval,setTimeout,status,submit,taint,text,textarea,top,unescape",
+		"untaint,window",
+
+		// window events
+		"onblur,onclick,onerror,onfocus,onkeydown,onkeypress,onkeyup,onmouseover,onload,onmouseup,onmousedown,onsubmit"
+	]
+		.join(",")
+		.split(",")
+);
+
+/**
+ * @param {Map<string, { usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }>} usedNamesInScopeInfo used names in scope info
+ * @param {string} module module identifier
+ * @param {string} id export id
+ * @returns {{ usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }} info
+ */
+const getUsedNamesInScopeInfo = (usedNamesInScopeInfo, module, id) => {
+	const key = `${module}-${id}`;
+	let info = usedNamesInScopeInfo.get(key);
+	if (info === undefined) {
+		info = {
+			usedNames: new Set(),
+			alreadyCheckedScopes: new Set()
+		};
+		usedNamesInScopeInfo.set(key, info);
+	}
+	return info;
+};
+
+module.exports = {
+	getUsedNamesInScopeInfo,
+	findNewName,
+	getAllReferences,
+	getPathInAst,
+	NAMESPACE_OBJECT_EXPORT,
+	DEFAULT_EXPORT,
+	RESERVED_NAMES,
+	addScopeSymbols
+};

package/lib/util/create-schema-validation.js

@@ -7,20 +7,33 @@
 
 const memoize = require("./memoize");
 
+/** @typedef {import("schema-utils/declarations/validate").ValidationErrorConfiguration} ValidationErrorConfiguration */
+/** @typedef {import("./fs").JsonObject} JsonObject */
+
 const getValidate = memoize(() => require("schema-utils").validate);
 
+/**
+ * @template {object | object[]} T
+ * @param {(function(T): boolean) | undefined} check check
+ * @param {() => JsonObject} getSchema get schema fn
+ * @param {ValidationErrorConfiguration} options options
+ * @returns {function(T=): void} validate
+ */
 const createSchemaValidation = (check, getSchema, options) => {
 	getSchema = memoize(getSchema);
 	return value => {
-		if (check && !check(value)) {
-			getValidate()(getSchema(), value, options);
-			if (check) {
-				require("util").deprecate(
-					() => {},
-					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
-					"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
-				)();
-			}
+		if (check && !check(/** @type {T} */ (value))) {
+			getValidate()(
+				getSchema(),
+				/** @type {object | object[]} */
+				(value),
+				options
+			);
+			require("util").deprecate(
+				() => {},
+				"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
+				"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
+			)();
 		}
 	};
 };

package/lib/util/deprecation.js

@@ -179,9 +179,21 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 	set[Symbol.isConcatSpreadable] = true;
 };
 
+/**
+ * @template T
+ * @param {string} name name
+ * @returns {{ new <T = any>(values?: readonly T[] | null): SetDeprecatedArray<T> }} SetDeprecatedArray
+ */
 module.exports.createArrayToSetDeprecationSet = name => {
 	let initialized = false;
+
+	/**
+	 * @template T
+	 */
 	class SetDeprecatedArray extends Set {
+		/**
+		 * @param {readonly T[] | null=} items items
+		 */
 		constructor(items) {
 			super(items);
 			if (!initialized) {
@@ -197,40 +209,77 @@ module.exports.createArrayToSetDeprecationSet = name => {
 };
 
 /**
- * @param {object} obj object
+ * @template {object} T
+ * @param {T} obj object
  * @param {string} name property name
  * @param {string} code deprecation code
  * @param {string} note additional note
- * @returns {Proxy<object>} frozen object with deprecation when modifying
+ * @returns {Proxy<T>} frozen object with deprecation when modifying
  */
 module.exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
 	const message = `${name} will be frozen in future, all modifications are deprecated.${
 		note && `\n${note}`
 	}`;
-	return new Proxy(obj, {
-		set: util.deprecate(
-			(target, property, value, receiver) =>
-				Reflect.set(target, property, value, receiver),
-			message,
-			code
-		),
-		defineProperty: util.deprecate(
-			(target, property, descriptor) =>
-				Reflect.defineProperty(target, property, descriptor),
-			message,
-			code
-		),
-		deleteProperty: util.deprecate(
-			(target, property) => Reflect.deleteProperty(target, property),
-			message,
-			code
-		),
-		setPrototypeOf: util.deprecate(
-			(target, proto) => Reflect.setPrototypeOf(target, proto),
-			message,
-			code
-		)
-	});
+	return /** @type {Proxy<T>} */ (
+		new Proxy(/** @type {object} */ (obj), {
+			set: util.deprecate(
+				/**
+				 * @param {T} target target
+				 * @param {string | symbol} property property
+				 * @param {any} value value
+				 * @param {any} receiver receiver
+				 * @returns {boolean} result
+				 */
+				(target, property, value, receiver) =>
+					Reflect.set(
+						/** @type {object} */ (target),
+						property,
+						value,
+						receiver
+					),
+				message,
+				code
+			),
+			defineProperty: util.deprecate(
+				/**
+				 * @param {T} target target
+				 * @param {string | symbol} property property
+				 * @param {PropertyDescriptor} descriptor descriptor
+				 * @returns {boolean} result
+				 */
+				(target, property, descriptor) =>
+					Reflect.defineProperty(
+						/** @type {object} */ (target),
+						property,
+						descriptor
+					),
+				message,
+				code
+			),
+			deleteProperty: util.deprecate(
+				/**
+				 * @param {T} target target
+				 * @param {string | symbol} property property
+				 * @returns {boolean} result
+				 */
+				(target, property) =>
+					Reflect.deleteProperty(/** @type {object} */ (target), property),
+				message,
+				code
+			),
+			setPrototypeOf: util.deprecate(
+				/**
+				 * @param {T} target target
+				 * @param {object | null} proto proto
+				 * @returns {boolean} result
+				 */
+				(target, proto) =>
+					Reflect.setPrototypeOf(/** @type {object} */ (target), proto),
+				message,
+				code
+			)
+		})
+	);
 };
 
 /**
@@ -263,7 +312,16 @@ const deprecateAllProperties = (obj, message, code) => {
 				enumerable: descriptor.enumerable,
 				get: util.deprecate(() => value, message, code),
 				set: descriptor.writable
-					? util.deprecate(v => (value = v), message, code)
+					? util.deprecate(
+							/**
+							 * @template T
+							 * @param {T} v value
+							 * @returns {T} result
+							 */
+							v => (value = v),
+							message,
+							code
+						)
 					: undefined
 			});
 		}
@@ -273,7 +331,7 @@ const deprecateAllProperties = (obj, message, code) => {
 module.exports.deprecateAllProperties = deprecateAllProperties;
 
 /**
- * @template T
+ * @template {object} T
  * @param {T} fakeHook fake hook implementation
  * @param {string=} message deprecation message (not deprecated when unset)
  * @param {string=} code deprecation code (not deprecated when unset)

package/lib/util/fs.js

@@ -84,8 +84,8 @@ const path = require("path");
 
 /**
  * @typedef {object} WatcherInfo
- * @property {Set<string>} changes get current aggregated changes that have not yet send to callback
- * @property {Set<string>} removals get current aggregated removals that have not yet send to callback
+ * @property {Set<string> | null} changes get current aggregated changes that have not yet send to callback
+ * @property {Set<string> | null} removals get current aggregated removals that have not yet send to callback
  * @property {TimeInfoEntries} fileTimeInfoEntries get info about files
  * @property {TimeInfoEntries} contextTimeInfoEntries get info about directories
  */
@@ -98,8 +98,8 @@ const path = require("path");
  * @typedef {object} Watcher
  * @property {function(): void} close closes the watcher and all underlying file watchers
  * @property {function(): void} pause closes the watcher, but keeps underlying file watchers alive until the next watch call
- * @property {function(): Changes=} getAggregatedChanges get current aggregated changes that have not yet send to callback
- * @property {function(): Removals=} getAggregatedRemovals get current aggregated removals that have not yet send to callback
+ * @property {(function(): Changes | null)=} getAggregatedChanges get current aggregated changes that have not yet send to callback
+ * @property {(function(): Removals | null)=} getAggregatedRemovals get current aggregated removals that have not yet send to callback
  * @property {function(): TimeInfoEntries} getFileTimeInfoEntries get info about files
  * @property {function(): TimeInfoEntries} getContextTimeInfoEntries get info about directories
  * @property {function(): WatcherInfo=} getInfo get info about timestamps and changes
@@ -372,7 +372,7 @@ const path = require("path");
  * @typedef {object} StreamOptions
  * @property {(string | undefined)=} flags
  * @property {(BufferEncoding | undefined)} encoding
- * @property {(number | any | undefined)=} fd
+ * @property {(number | EXPECTED_ANY | undefined)=} fd
  * @property {(number | undefined)=} mode
  * @property {(boolean | undefined)=} autoClose
  * @property {(boolean | undefined)=} emitClose
@@ -382,12 +382,12 @@ const path = require("path");
 
 /**
  * @typedef {object} FSImplementation
- * @property {((...args: any[]) => any)=} open
- * @property {((...args: any[]) => any)=} close
+ * @property {((...args: EXPECTED_ANY[]) => EXPECTED_ANY)=} open
+ * @property {((...args: EXPECTED_ANY[]) => EXPECTED_ANY)=} close
  */
 
 /**
- * @typedef {FSImplementation & { write: (...args: any[]) => any; close?: (...args: any[]) => any }} CreateWriteStreamFSImplementation
+ * @typedef {FSImplementation & { write: (...args: EXPECTED_ANY[]) => EXPECTED_ANY; close?: (...args: EXPECTED_ANY[]) => EXPECTED_ANY }} CreateWriteStreamFSImplementation
  */
 
 /**
@@ -625,8 +625,8 @@ const lstatReadlinkAbsolute = (fs, p, callback) => {
 				// we retry 2 times to catch this case before throwing the error
 				return doStat();
 			}
-			if (err || !target) return doStat();
-			const value = target.toString();
+			if (err) return callback(err);
+			const value = /** @type {string} */ (target).toString();
 			callback(null, join(fs, dirname(fs, p), value));
 		});
 	};