feat: refactoring project

node_modules/webpack/lib/util/semver.js

@@ -6,33 +6,45 @@
 "use strict";
 
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {(string|number|undefined|[])[]} SemVerRange */
+/** @typedef {string | number | undefined} SemVerRangeItem */
+/** @typedef {(SemVerRangeItem | SemVerRangeItem[])[]} SemVerRange */
 
 /**
  * @param {string} str version string
- * @returns {(string|number|undefined|[])[]} parsed version
+ * @returns {SemVerRange} parsed version
  */
 const parseVersion = str => {
+	/**
+	 * @param {str} str str
+	 * @returns {(string | number)[]} result
+	 */
 	var splitAndConvert = function (str) {
 		return str.split(".").map(function (item) {
 			// eslint-disable-next-line eqeqeq
-			return +item == item ? +item : item;
+			return +item == /** @type {EXPECTED_ANY} */ (item) ? +item : item;
 		});
 	};
-	var match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
-	/** @type {(string|number|undefined|[])[]} */
+
+	var match =
+		/** @type {RegExpExecArray} */
+		(/^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str));
+
+	/** @type {(string | number | undefined | [])[]} */
 	var ver = match[1] ? splitAndConvert(match[1]) : [];
+
 	if (match[2]) {
 		ver.length++;
 		ver.push.apply(ver, splitAndConvert(match[2]));
 	}
+
 	if (match[3]) {
 		ver.push([]);
 		ver.push.apply(ver, splitAndConvert(match[3]));
 	}
+
 	return ver;
 };
-exports.parseVersion = parseVersion;
+module.exports.parseVersion = parseVersion;
 
 /* eslint-disable eqeqeq */
 /**
@@ -82,23 +94,35 @@ const versionLt = (a, b) => {
 	}
 };
 /* eslint-enable eqeqeq */
-exports.versionLt = versionLt;
+module.exports.versionLt = versionLt;
 
 /**
  * @param {string} str range string
  * @returns {SemVerRange} parsed range
  */
-exports.parseRange = str => {
+module.exports.parseRange = str => {
+	/**
+	 * @param {string} str str
+	 * @returns {(string | number)[]} result
+	 */
 	const splitAndConvert = str => {
 		return str
 			.split(".")
 			.map(item => (item !== "NaN" && `${+item}` === item ? +item : item));
 	};
+
 	// see https://docs.npmjs.com/misc/semver#range-grammar for grammar
+	/**
+	 * @param {string} str str
+	 * @returns {SemVerRangeItem[]}
+	 */
 	const parsePartial = str => {
-		const match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
-		/** @type {(string|number|undefined|[])[]} */
+		const match =
+			/** @type {RegExpExecArray} */
+			(/^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str));
+		/** @type {SemVerRangeItem[]} */
 		const ver = match[1] ? [0, ...splitAndConvert(match[1])] : [0];
+
 		if (match[2]) {
 			ver.length++;
 			ver.push.apply(ver, splitAndConvert(match[2]));
@@ -116,6 +140,12 @@ exports.parseRange = str => {
 
 		return ver;
 	};
+
+	/**
+	 *
+	 * @param {SemVerRangeItem[]} range range
+	 * @returns {SemVerRangeItem[]}
+	 */
 	const toFixed = range => {
 		if (range.length === 1) {
 			// Special case for "*" is "x.x.x" instead of "="
@@ -126,13 +156,24 @@ exports.parseRange = str => {
 		} else if (range.length === 3) {
 			// Special case for "1.2" is "1.2.x" instead of "=1.2"
 			return [2, ...range.slice(1)];
-		} else {
-			return [range.length, ...range.slice(1)];
 		}
+
+		return [range.length, ...range.slice(1)];
 	};
+
+	/**
+	 *
+	 * @param {SemVerRangeItem[]} range
+	 * @returns {SemVerRangeItem[]} result
+	 */
 	const negate = range => {
-		return [-range[0] - 1, ...range.slice(1)];
+		return [-(/** @type { [number]} */ (range)[0]) - 1, ...range.slice(1)];
 	};
+
+	/**
+	 * @param {string} str str
+	 * @returns {SemVerRange}
+	 */
 	const parseSimple = str => {
 		// simple       ::= primitive | partial | tilde | caret
 		// primitive    ::= ( '<' | '>' | '>=' | '<=' | '=' | '!' ) ( ' ' ) * partial
@@ -143,6 +184,7 @@ exports.parseRange = str => {
 		const remainder = parsePartial(
 			start.length ? str.slice(start.length).trim() : str.trim()
 		);
+
 		switch (start) {
 			case "^":
 				if (remainder.length > 1 && remainder[1] === 0) {
@@ -185,6 +227,13 @@ exports.parseRange = str => {
 				throw new Error("Unexpected start value");
 		}
 	};
+
+	/**
+	 *
+	 * @param {SemVerRangeItem[][]} items items
+	 * @param {number} fn fn
+	 * @returns {SemVerRange} result
+	 */
 	const combine = (items, fn) => {
 		if (items.length === 1) return items[0];
 		const arr = [];
@@ -195,38 +244,64 @@ exports.parseRange = str => {
 				arr.push(...item.slice(1));
 			}
 		}
+
 		// eslint-disable-next-line no-sparse-arrays
 		return [, ...arr, ...items.slice(1).map(() => fn)];
 	};
+
+	/**
+	 * @param {string} str str
+	 * @returns {SemVerRange}
+	 */
 	const parseRange = str => {
 		// range      ::= hyphen | simple ( ' ' ( ' ' ) * simple ) * | ''
 		// hyphen     ::= partial ( ' ' ) * ' - ' ( ' ' ) * partial
 		const items = str.split(/\s+-\s+/);
+
 		if (items.length === 1) {
-			const items = str
-				.trim()
-				.split(/(?<=[-0-9A-Za-z])\s+/g)
-				.map(parseSimple);
+			const items =
+				/** @type {SemVerRangeItem[][]} */
+				(
+					str
+						.trim()
+						.split(/(?<=[-0-9A-Za-z])\s+/g)
+						.map(parseSimple)
+				);
+
 			return combine(items, 2);
 		}
+
 		const a = parsePartial(items[0]);
 		const b = parsePartial(items[1]);
 		// >=a <=b => and( >=a, or( <b, =b ) ) => >=a, <b, =b, or, and
 		// eslint-disable-next-line no-sparse-arrays
 		return [, toFixed(b), negate(b), 1, a, 2];
 	};
+
+	/**
+	 * @param {string} str str
+	 * @returns {SemVerRange}
+	 */
 	const parseLogicalOr = str => {
 		// range-set  ::= range ( logical-or range ) *
 		// logical-or ::= ( ' ' ) * '||' ( ' ' ) *
-		const items = str.split(/\s*\|\|\s*/).map(parseRange);
+		const items =
+			/** @type {SemVerRangeItem[][]} */
+			(str.split(/\s*\|\|\s*/).map(parseRange));
+
 		return combine(items, 1);
 	};
+
 	return parseLogicalOr(str);
 };
 
 /* eslint-disable eqeqeq */
+/**
+ * @param {SemVerRange} range
+ * @returns {string}
+ */
 const rangeToString = range => {
-	var fixCount = range[0];
+	var fixCount = /** @type {number} */ (range[0]);
 	var str = "";
 	if (range.length === 1) {
 		return "*";
@@ -256,32 +331,32 @@ const rangeToString = range => {
 						(needDot > 0 ? "." : "") + ((needDot = 2), item);
 		}
 		return str;
-	} else {
-		var stack = [];
-		// eslint-disable-next-line no-redeclare
-		for (var i = 1; i < range.length; i++) {
-			// eslint-disable-next-line no-redeclare
-			var item = range[i];
-			stack.push(
-				item === 0
-					? "not(" + pop() + ")"
-					: item === 1
-						? "(" + pop() + " || " + pop() + ")"
-						: item === 2
-							? stack.pop() + " " + stack.pop()
-							: rangeToString(item)
-			);
-		}
-		return pop();
 	}
+	/** @type {string[]} */
+	var stack = [];
+	// eslint-disable-next-line no-redeclare
+	for (var i = 1; i < range.length; i++) {
+		// eslint-disable-next-line no-redeclare
+		var item = range[i];
+		stack.push(
+			item === 0
+				? "not(" + pop() + ")"
+				: item === 1
+					? "(" + pop() + " || " + pop() + ")"
+					: item === 2
+						? stack.pop() + " " + stack.pop()
+						: rangeToString(/** @type {SemVerRange} */ (item))
+		);
+	}
+	return pop();
+
 	function pop() {
-		return stack.pop().replace(/^\((.+)\)$/, "$1");
+		return /** @type {string} */ (stack.pop()).replace(/^\((.+)\)$/, "$1");
 	}
 };
-/* eslint-enable eqeqeq */
-exports.rangeToString = rangeToString;
 
-/* eslint-disable eqeqeq */
+module.exports.rangeToString = rangeToString;
+
 /**
  * @param {SemVerRange} range version range
  * @param {string} version the version
@@ -340,16 +415,22 @@ const satisfy = (range, version) => {
 			// big-cmp: when negated => return false, else => next-nequ
 			// small-cmp: when negated => next-nequ, else => return false
 
-			var rangeType = j < range.length ? (typeof range[j])[0] : "";
+			var rangeType =
+				/** @type {"s" | "n" | "u" | ""} */
+				(j < range.length ? (typeof range[j])[0] : "");
 
+			/** @type {number | string | undefined} */
 			var versionValue;
+			/** @type {"n" | "s" | "u" | "o" | undefined} */
 			var versionType;
 
 			// Handles first column in both tables (end of version or object)
 			if (
 				i >= version.length ||
 				((versionValue = version[i]),
-				(versionType = (typeof versionValue)[0]) == "o")
+				(versionType = /** @type {"n" | "s" | "u" | "o"} */ (
+					(typeof versionValue)[0]
+				)) == "o")
 			) {
 				// Handles nequal
 				if (!isEqual) return true;
@@ -377,7 +458,11 @@ const satisfy = (range, version) => {
 						}
 					} else {
 						// Handles "cmp" cases
-						if (negated ? versionValue > range[j] : versionValue < range[j]) {
+						if (
+							negated
+								? versionValue > /** @type {(number | string)[]} */ (range)[j]
+								: versionValue < /** @type {(number | string)[]} */ (range)[j]
+						) {
 							return false;
 						}
 						if (versionValue != range[j]) isEqual = false;
@@ -399,6 +484,7 @@ const satisfy = (range, version) => {
 				}
 			} else {
 				// Handles all "next-ver" cases in the second table
+				// eslint-disable-next-line no-lonely-if
 				if (rangeType != "s" && rangeType != "n") {
 					isEqual = false;
 					j--;
@@ -408,17 +494,20 @@ const satisfy = (range, version) => {
 			}
 		}
 	}
+
 	/** @type {(boolean | number)[]} */
 	var stack = [];
 	var p = stack.pop.bind(stack);
 	// eslint-disable-next-line no-redeclare
 	for (var i = 1; i < range.length; i++) {
-		var item = /** @type {SemVerRange | 0 | 1 | 2} */ (range[i]);
+		var item = /** @type {SemVerRangeItem[] | 0 | 1 | 2} */ (range[i]);
+
 		stack.push(
 			item == 1
-				? p() | p()
+				? /** @type {() => number} */ (p)() | /** @type {() => number} */ (p)()
 				: item == 2
-					? p() & p()
+					? /** @type {() => number} */ (p)() &
+						/** @type {() => number} */ (p)()
 					: item
 						? satisfy(item, version)
 						: !p()
@@ -427,9 +516,13 @@ const satisfy = (range, version) => {
 	return !!p();
 };
 /* eslint-enable eqeqeq */
-exports.satisfy = satisfy;
+module.exports.satisfy = satisfy;
 
-exports.stringifyHoley = json => {
+/**
+ * @param {SemVerRange | string | number | false | undefined} json
+ * @returns {string}
+ */
+module.exports.stringifyHoley = json => {
 	switch (typeof json) {
 		case "undefined":
 			return "";
@@ -442,15 +535,19 @@ exports.stringifyHoley = json => {
 				}
 				str += "]";
 				return str;
-			} else {
-				return JSON.stringify(json);
 			}
+
+			return JSON.stringify(json);
 		default:
 			return JSON.stringify(json);
 	}
 };
 
 //#region runtime code: parseVersion
+/**
+ * @param {RuntimeTemplate} runtimeTemplate
+ * @returns {string}
+ */
 exports.parseVersionRuntimeCode = runtimeTemplate =>
 	`var parseVersion = ${runtimeTemplate.basicFunction("str", [
 		"// see webpack/lib/util/semver.js for original code",
@@ -459,6 +556,10 @@ exports.parseVersionRuntimeCode = runtimeTemplate =>
 //#endregion
 
 //#region runtime code: versionLt
+/**
+ * @param {RuntimeTemplate} runtimeTemplate
+ * @returns {string}
+ */
 exports.versionLtRuntimeCode = runtimeTemplate =>
 	`var versionLt = ${runtimeTemplate.basicFunction("a, b", [
 		"// see webpack/lib/util/semver.js for original code",
@@ -467,6 +568,10 @@ exports.versionLtRuntimeCode = runtimeTemplate =>
 //#endregion
 
 //#region runtime code: rangeToString
+/**
+ * @param {RuntimeTemplate} runtimeTemplate
+ * @returns {string}
+ */
 exports.rangeToStringRuntimeCode = runtimeTemplate =>
 	`var rangeToString = ${runtimeTemplate.basicFunction("range", [
 		"// see webpack/lib/util/semver.js for original code",
@@ -475,6 +580,10 @@ exports.rangeToStringRuntimeCode = runtimeTemplate =>
 //#endregion
 
 //#region runtime code: satisfy
+/**
+ * @param {RuntimeTemplate} runtimeTemplate
+ * @returns {string}
+ */
 exports.satisfyRuntimeCode = runtimeTemplate =>
 	`var satisfy = ${runtimeTemplate.basicFunction("range, version", [
 		"// see webpack/lib/util/semver.js for original code",