webpack 5.104.1 → 5.105.4

package/lib/serialization/BinaryMiddleware.js

@@ -313,6 +313,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 					/** @type {number[]} */
 					const lengths = [];
 					for (const item of serializedData) {
+						/** @type {undefined | number} */
 						let last;
 						if (typeof item === "function") {
 							lengths.push(0);
@@ -490,8 +491,10 @@ class BinaryMiddleware extends SerializerMiddleware {
 				}
 				case "boolean": {
 					let lastByte = thing === true ? 1 : 0;
+					/** @type {number[]} */
 					const bytes = [];
 					let count = 1;
+					/** @type {undefined | number} */
 					let n;
 					for (n = 1; n < 0xffffffff && i + n < data.length; n++) {
 						const item = data[i + n];
@@ -541,6 +544,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 				}
 				case "object": {
 					if (thing === null) {
+						/** @type {number} */
 						let n;
 						for (n = 1; n < 0x100000104 && i + n < data.length; n++) {
 							const item = data[i + n];

package/lib/serialization/FileMiddleware.js

@@ -21,7 +21,7 @@ const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
 const SerializerMiddleware = require("./SerializerMiddleware");
 
-/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/Hash").HashFunction} HashFunction */
 /** @typedef {import("../util/fs").IStats} IStats */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 /** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
@@ -49,7 +49,7 @@ const WRITE_LIMIT_CHUNK = 511 * 1024 * 1024;
 
 /**
  * @param {Buffer[]} buffers buffers
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @returns {string} hash
  */
 const hashForName = (buffers, hashFunction) => {
@@ -101,7 +101,7 @@ const readUInt64LE = Buffer.prototype.readBigUInt64LE
  * @param {(BufferSerializableType | LazyFunction)[]} data data to be serialized
  * @param {string | boolean} name file base name
  * @param {(name: string | false, buffers: Buffer[], size: number) => Promise<void>} writeFile writes a file
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction=} hashFunction hash function to use
  * @returns {Promise<SerializeResult>} resulting file pointer and promise
  */
 const serialize = async (
@@ -336,6 +336,7 @@ const deserialize = async (middleware, name, readFile) => {
 		throw new Error("Invalid file version");
 	}
 	const sectionCount = readUInt32LE();
+	/** @type {number[]} */
 	const lengths = [];
 	let lastLengthPositive = false;
 	for (let i = 0; i < sectionCount; i++) {
@@ -433,11 +434,13 @@ const deserialize = async (middleware, name, readFile) => {
 class FileMiddleware extends SerializerMiddleware {
 	/**
 	 * @param {IntermediateFileSystem} fs filesystem
-	 * @param {string | Hash} hashFunction hash function to use
+	 * @param {HashFunction} hashFunction hash function to use
 	 */
 	constructor(fs, hashFunction = DEFAULTS.HASH_FUNCTION) {
 		super();
+		/** @type {IntermediateFileSystem} */
 		this.fs = fs;
+		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
 	}
 
@@ -454,6 +457,7 @@ class FileMiddleware extends SerializerMiddleware {
 
 				// It's important that we don't touch existing files during serialization
 				// because serialize may read existing files (when deserializing)
+				/** @type {Set<string>} */
 				const allWrittenFiles = new Set();
 				/**
 				 * @param {string | false} name name
@@ -472,6 +476,7 @@ class FileMiddleware extends SerializerMiddleware {
 						 */
 						(resolve, reject) => {
 							let stream = this.fs.createWriteStream(`${file}_`);
+							/** @type {undefined | import("zlib").Gzip | import("zlib").BrotliCompress} */
 							let compression;
 							if (file.endsWith(".gz")) {
 								compression = createGzip({

package/lib/serialization/ObjectMiddleware.js

@@ -18,7 +18,7 @@ const SerializerMiddleware = require("./SerializerMiddleware");
 const SetObjectSerializer = require("./SetObjectSerializer");
 
 /** @typedef {import("../logging/Logger").Logger} Logger */
-/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/Hash").HashFunction} HashFunction */
 /** @typedef {import("./SerializerMiddleware").LazyOptions} LazyOptions */
 /** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
@@ -111,7 +111,7 @@ const setMapSize = (map, size) => {
 
 /**
  * @param {Buffer} buffer buffer
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @returns {string} hash
  */
 const toHash = (buffer, hashFunction) => {
@@ -207,17 +207,21 @@ const loaders = new Map();
 /** @typedef {PrimitiveSerializableType[]} SerializedType */
 /** @typedef {{ logger: Logger }} Context */
 
+/** @typedef {(context: ObjectSerializerContext | ObjectDeserializerContext) => void} ExtendContext */
+
 /**
  * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class ObjectMiddleware extends SerializerMiddleware {
 	/**
-	 * @param {(context: ObjectSerializerContext | ObjectDeserializerContext) => void} extendContext context extensions
-	 * @param {string | Hash} hashFunction hash function to use
+	 * @param {ExtendContext} extendContext context extensions
+	 * @param {HashFunction} hashFunction hash function to use
 	 */
 	constructor(extendContext, hashFunction = DEFAULTS.HASH_FUNCTION) {
 		super();
+		/** @type {ExtendContext} */
 		this.extendContext = extendContext;
+		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
 	}
 
@@ -276,11 +280,12 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	/**
-	 * @param {Constructor} object for serialization
+	 * @param {EXPECTED_ANY} object for serialization
 	 * @returns {SerializerConfigWithSerializer} Serializer config
 	 */
 	static getSerializerFor(object) {
 		const proto = Object.getPrototypeOf(object);
+		/** @type {null | Constructor} */
 		let c;
 		if (proto === null) {
 			// Object created with Object.create(null)
@@ -295,7 +300,11 @@ class ObjectMiddleware extends SerializerMiddleware {
 		}
 		const config = serializers.get(c);
 
-		if (!config) throw new Error(`No serializer registered for ${c.name}`);
+		if (!config) {
+			throw new Error(
+				`No serializer registered for ${/** @type {Constructor} */ (c).name}`
+			);
+		}
 		if (config === NOT_SERIALIZABLE) throw NOT_SERIALIZABLE;
 
 		return /** @type {SerializerConfigWithSerializer} */ (config);
@@ -345,6 +354,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		const addReferenceable = (item) => {
 			referenceable.set(item, currentPos++);
 		};
+		/** @type {Map<number, Buffer | [Buffer, Buffer] | Map<string, Buffer>>} */
 		let bufferDedupeMap = new Map();
 		/**
 		 * @param {Buffer} buf buffer
@@ -366,6 +376,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 					return buf;
 				}
 				const hash = toHash(entry, this._hashFunction);
+				/** @type {Map<string, Buffer>} */
 				const newMap = new Map();
 				newMap.set(hash, entry);
 				bufferDedupeMap.set(len, newMap);
@@ -384,8 +395,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 					entry.push(buf);
 					return buf;
 				}
+				/** @type {Map<string, Buffer>} */
 				const newMap = new Map();
 				const hash = toHash(buf, this._hashFunction);
+				/** @type {undefined | Buffer} */
 				let found;
 				for (const item of entry) {
 					const itemHash = toHash(item, this._hashFunction);
@@ -408,7 +421,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 			return buf;
 		};
 		let currentPosTypeLookup = 0;
+		/** @type {Map<ComplexSerializableType, number>} */
 		let objectTypeLookup = new Map();
+		/** @type {Set<ComplexSerializableType>} */
 		const cycleStack = new Set();
 		/**
 		 * @param {ComplexSerializableType} item item to stack
@@ -441,12 +456,18 @@ class ObjectMiddleware extends SerializerMiddleware {
 							if (item.constructor === Object) {
 								return `Object { ${Object.keys(item).join(", ")} }`;
 							}
-							if (item.constructor === Map) return `Map { ${item.size} items }`;
+							if (item.constructor === Map) {
+								return `Map { ${/** @type {Map<EXPECTED_ANY, EXPECTED_ANY>} */ (item).size} items }`;
+							}
 							if (item.constructor === Array) {
-								return `Array { ${item.length} items }`;
+								return `Array { ${/** @type {EXPECTED_ANY[]} */ (item).length} items }`;
+							}
+							if (item.constructor === Set) {
+								return `Set { ${/** @type {Set<EXPECTED_ANY>} */ (item).size} items }`;
+							}
+							if (item.constructor === RegExp) {
+								return /** @type {RegExp} */ (item).toString();
 							}
-							if (item.constructor === Set) return `Set { ${item.size} items }`;
-							if (item.constructor === RegExp) return item.toString();
 							return `${item.constructor.name}`;
 						}
 						return `Object [null prototype] { ${Object.keys(item).join(
@@ -464,7 +485,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 				})
 				.join(" -> ");
 		};
-		/** @type {WeakSet<Error>} */
+		/** @type {undefined | WeakSet<Error>} */
 		let hasDebugInfoAttached;
 		/** @type {ObjectSerializerContext} */
 		let ctx = {
@@ -723,6 +744,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 					);
 				} else {
 					const request = nextItem;
+					/** @type {undefined | ObjectSerializer} */
 					let serializer;
 
 					if (typeof request === "number") {
@@ -788,6 +810,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 						// As this is only for error handling, we omit creating a Map for
 						// faster access to this information, as this would affect performance
 						// in the good case
+						/** @type {undefined | [Constructor | null, SerializerConfig]} */
 						let serializerEntry;
 						for (const entry of serializers) {
 							if (entry[1].serializer === serializer) {

package/lib/serialization/PlainObjectSerializer.js

@@ -20,7 +20,9 @@ const cache = new WeakMap();
  */
 class ObjectStructure {
 	constructor() {
+		/** @type {undefined | keyof T[]} */
 		this.keys = undefined;
+		/** @type {undefined | Map<keyof T, ObjectStructure<T>>} */
 		this.children = undefined;
 	}
 

package/lib/sharing/ConsumeSharedModule.js

@@ -8,7 +8,10 @@
 const { RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
-const { CONSUME_SHARED_TYPES } = require("../ModuleSourceTypeConstants");
+const {
+	CONSUME_SHARED_TYPES,
+	JAVASCRIPT_TYPES
+} = require("../ModuleSourceTypeConstants");
 const {
 	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE
 } = require("../ModuleTypeConstants");
@@ -17,6 +20,9 @@ const makeSerializable = require("../util/makeSerializable");
 const { rangeToString, stringifyHoley } = require("../util/semver");
 const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependency");
 
+/** @type {WeakMap<ModuleGraph, WeakMap<ConsumeSharedModule, Module | null>>} */
+const fallbackModuleCache = new WeakMap();
+
 /** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
@@ -27,7 +33,10 @@ const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependen
 /** @typedef {import("../Module").LibIdent} LibIdent */
 /** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").Sources} Sources */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../Module").ExportsType} ExportsType */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -35,6 +44,7 @@ const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependen
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/semver").SemVerRange} SemVerRange */
+/** @typedef {import("../Module").BasicSourceTypes} BasicSourceTypes */
 
 /**
  * @typedef {object} ConsumeOptions
@@ -153,6 +163,70 @@ class ConsumeSharedModule extends Module {
 		return CONSUME_SHARED_TYPES;
 	}
 
+	/**
+	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
+	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
+	 * added or changed over time by generators and do not need to be handled or detected here.
+	 *
+	 * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init"
+	 * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
+	 * @returns {BasicSourceTypes} types available (do not mutate)
+	 */
+	getSourceBasicTypes() {
+		return JAVASCRIPT_TYPES;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {Module | null} fallback module
+	 */
+	_getFallbackModule(moduleGraph) {
+		let moduleCache = fallbackModuleCache.get(moduleGraph);
+		if (!moduleCache) {
+			moduleCache = new WeakMap();
+			fallbackModuleCache.set(moduleGraph, moduleCache);
+		}
+		const cached = moduleCache.get(this);
+		if (cached !== undefined) {
+			return cached;
+		}
+
+		/** @type {undefined | null | Module} */
+		let fallbackModule = null;
+
+		if (this.options.import) {
+			if (this.options.eager) {
+				const dep = this.dependencies[0];
+				if (dep) {
+					fallbackModule = moduleGraph.getModule(dep);
+				}
+			} else {
+				const block = this.blocks[0];
+				if (block && block.dependencies.length > 0) {
+					fallbackModule = moduleGraph.getModule(block.dependencies[0]);
+				}
+			}
+		}
+
+		moduleCache.set(this, fallbackModule);
+		return fallbackModule;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {boolean | undefined} strict the importing module is strict
+	 * @returns {ExportsType} export type
+	 * "namespace": Exports is already a namespace object. namespace = exports.
+	 * "dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }.
+	 * "default-only": Provide a namespace object with only default export. namespace = { default: exports }
+	 * "default-with-named": Provide a namespace object with named and default export. namespace = { ...exports, default: exports }
+	 */
+	getExportsType(moduleGraph, strict) {
+		const fallbackModule = this._getFallbackModule(moduleGraph);
+		if (!fallbackModule) return "dynamic";
+		return fallbackModule.getExportsType(moduleGraph, strict);
+	}
+
 	/**
 	 * @param {string=} type the source type for which the size should be estimated
 	 * @returns {number} the estimated size of the module (must be non-zero)
@@ -186,6 +260,7 @@ class ConsumeSharedModule extends Module {
 			singleton,
 			eager
 		} = this.options;
+		/** @type {undefined | string} */
 		let fallbackCode;
 		if (request) {
 			if (eager) {
@@ -219,6 +294,7 @@ class ConsumeSharedModule extends Module {
 			args.push(fallbackCode);
 		}
 
+		/** @type {string} */
 		let fn;
 
 		if (requiredVersion) {
@@ -232,6 +308,7 @@ class ConsumeSharedModule extends Module {
 		}
 
 		const code = runtimeTemplate.returningFunction(`${fn}(${args.join(", ")})`);
+		/** @type {Sources} */
 		const sources = new Map();
 		sources.set("consume-shared", new RawSource(code));
 		return {

package/lib/sharing/ConsumeSharedPlugin.js

@@ -26,6 +26,7 @@ const {
 /** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
 /** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Compilation").FileSystemDependencies} FileSystemDependencies */
 /** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
 /** @typedef {import("../util/semver").SemVerRange} SemVerRange */
 /** @typedef {import("./ConsumeSharedModule").ConsumeOptions} ConsumeOptions */
@@ -159,7 +160,7 @@ class ConsumeSharedPlugin {
 					};
 					const directFallback =
 						config.import &&
-						/^(\.\.?(\/|$)|\/|[A-Za-z]:|\\\\)/.test(config.import);
+						/^(?:\.\.?(?:\/|$)|\/|[A-Z]:|\\\\)/i.test(config.import);
 					return Promise.all([
 						new Promise(
 							/**
@@ -170,7 +171,7 @@ class ConsumeSharedPlugin {
 									resolve();
 									return;
 								}
-								/** @typedef {ResolveContext} */
+								/** @type {ResolveContext & { fileDependencies: FileSystemDependencies, contextDependencies: FileSystemDependencies, missingDependencies: FileSystemDependencies }} */
 								const resolveContext = {
 									fileDependencies: new LazySet(),
 									contextDependencies: new LazySet(),
@@ -215,13 +216,13 @@ class ConsumeSharedPlugin {
 								}
 								let packageName = config.packageName;
 								if (packageName === undefined) {
-									if (/^(\/|[A-Za-z]:|\\\\)/.test(request)) {
+									if (/^(?:\/|[A-Z]:|\\\\)/i.test(request)) {
 										// For relative or absolute requests we don't automatically use a packageName.
 										// If wished one can specify one with the packageName option.
 										resolve();
 										return;
 									}
-									const match = /^((?:@[^\\/]+[\\/])?[^\\/]+)/.exec(request);
+									const match = /^(?:@[^\\/]+[\\/])?[^\\/]+/.exec(request);
 									if (!match) {
 										requiredVersionWarning(
 											"Unable to extract the package name from request."

package/lib/sharing/ProvideSharedModule.js

@@ -22,7 +22,9 @@ const ProvideForSharedDependency = require("./ProvideForSharedDependency");
 /** @typedef {import("../Module").LibIdent} LibIdent */
 /** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").Sources} Sources */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -147,7 +149,9 @@ class ProvideSharedModule extends Module {
 						runtimeRequirements
 					})
 		}${this._eager ? ", 1" : ""});`;
+		/** @type {Sources} */
 		const sources = new Map();
+		/** @type {CodeGenerationResultData} */
 		const data = new Map();
 		data.set("share-init", [
 			{

package/lib/sharing/ProvideSharedPlugin.js

@@ -45,29 +45,28 @@ class ProvideSharedPlugin {
 	constructor(options) {
 		validate(options);
 
-		this._provides = /** @type {[string, ProvideOptions][]} */ (
-			parseOptions(
-				options.provides,
-				(item) => {
-					if (Array.isArray(item)) {
-						throw new Error("Unexpected array of provides");
-					}
-					/** @type {ProvideOptions} */
-					const result = {
-						shareKey: item,
-						version: undefined,
-						shareScope: options.shareScope || "default",
-						eager: false
-					};
-					return result;
-				},
-				(item) => ({
-					shareKey: item.shareKey,
-					version: item.version,
-					shareScope: item.shareScope || options.shareScope || "default",
-					eager: Boolean(item.eager)
-				})
-			)
+		/** @type {[string, ProvideOptions][]} */
+		this._provides = parseOptions(
+			options.provides,
+			(item) => {
+				if (Array.isArray(item)) {
+					throw new Error("Unexpected array of provides");
+				}
+				/** @type {ProvideOptions} */
+				const result = {
+					shareKey: item,
+					version: undefined,
+					shareScope: options.shareScope || "default",
+					eager: false
+				};
+				return result;
+			},
+			(item) => ({
+				shareKey: /** @type {string} */ (item.shareKey),
+				version: item.version,
+				shareScope: item.shareScope || options.shareScope || "default",
+				eager: Boolean(item.eager)
+			})
 		);
 		this._provides.sort(([a], [b]) => {
 			if (a < b) return -1;
@@ -95,13 +94,13 @@ class ProvideSharedPlugin {
 				/** @type {Map<string, ProvideOptions>} */
 				const prefixMatchProvides = new Map();
 				for (const [request, config] of this._provides) {
-					if (/^(\/|[A-Za-z]:\\|\\\\|\.\.?(\/|$))/.test(request)) {
+					if (/^(?:\/|[A-Z]:\\|\\\\|\.\.?(?:\/|$))/i.test(request)) {
 						// relative request
 						resolvedProvideMap.set(request, {
 							config,
 							version: config.version
 						});
-					} else if (/^(\/|[A-Za-z]:\\|\\\\)/.test(request)) {
+					} else if (/^(?:\/|[A-Z]:\\|\\\\)/i.test(request)) {
 						// absolute path
 						resolvedProvideMap.set(request, {
 							config,

package/lib/sharing/resolveMatchedConfigs.js

@@ -54,7 +54,7 @@ module.exports.resolveMatchedConfigs = (compilation, configs) => {
 	return Promise.all(
 		// eslint-disable-next-line array-callback-return
 		configs.map(([request, config]) => {
-			if (/^\.\.?(\/|$)/.test(request)) {
+			if (/^\.\.?(?:\/|$)/.test(request)) {
 				// relative request
 				return new Promise((resolve) => {
 					resolver.resolve(
@@ -77,7 +77,7 @@ module.exports.resolveMatchedConfigs = (compilation, configs) => {
 						}
 					);
 				});
-			} else if (/^(\/|[A-Za-z]:\\|\\\\)/.test(request)) {
+			} else if (/^(?:\/|[a-z]:\\|\\\\)/i.test(request)) {
 				// absolute path
 				resolved.set(request, config);
 			} else if (request.endsWith("/")) {

package/lib/sharing/utils.js

@@ -15,30 +15,30 @@ const { dirname, join, readJson } = require("../util/fs");
 const RE_URL_GITHUB_EXTREME_SHORT = /^[^/@:.\s][^/@:\s]*\/[^@:\s]*[^/@:\s]#\S+/;
 
 // Short url with specific protocol. eg: github:foo/bar
-const RE_GIT_URL_SHORT = /^(github|gitlab|bitbucket|gist):\/?[^/.]+\/?/i;
+const RE_GIT_URL_SHORT = /^(?:github|gitlab|bitbucket|gist):\/?[^/.]+\/?/i;
 
 // Currently supported protocols
 const RE_PROTOCOL =
-	/^((git\+)?(ssh|https?|file)|git|github|gitlab|bitbucket|gist):$/i;
+	/^(?:(?:git\+)?(?:ssh|https?|file)|git|github|gitlab|bitbucket|gist):$/i;
 
 // Has custom protocol
-const RE_CUSTOM_PROTOCOL = /^((git\+)?(ssh|https?|file)|git):\/\//i;
+const RE_CUSTOM_PROTOCOL = /^(?:(?:git\+)?(?:ssh|https?|file)|git):\/\//i;
 
 // Valid hash format for npm / yarn ...
 const RE_URL_HASH_VERSION = /#(?:semver:)?(.+)/;
 
 // Simple hostname validate
-const RE_HOSTNAME = /^(?:[^/.]+(\.[^/]+)+|localhost)$/;
+const RE_HOSTNAME = /^(?:[^/.]+(?:\.[^/]+)+|localhost)$/;
 
 // For hostname with colon. eg: ssh://user@github.com:foo/bar
 const RE_HOSTNAME_WITH_COLON =
 	/([^/@#:.]+(?:\.[^/@#:.]+)+|localhost):([^#/0-9]+)/;
 
 // Reg for url without protocol
-const RE_NO_PROTOCOL = /^([^/@#:.]+(?:\.[^/@#:.]+)+)/;
+const RE_NO_PROTOCOL = /^[^/@#:.]+(?:\.[^/@#:.]+)+/;
 
 // RegExp for version string
-const VERSION_PATTERN_REGEXP = /^([\d^=v<>~]|[*xX]$)/;
+const VERSION_PATTERN_REGEXP = /^(?:[\d^=v<>~]|[*xX]$)/;
 
 // Specific protocol for short url without normal hostname
 const PROTOCOLS_FOR_SHORT = [
@@ -248,7 +248,9 @@ function getGitUrlVersion(gitUrl) {
 
 	gitUrl = correctUrl(gitUrl);
 
+	/** @type {undefined | URL} */
 	let parsed;
+
 	try {
 		parsed = new URL(gitUrl);
 		// eslint-disable-next-line no-empty