webpack 5.101.2 → 5.102.0

package/lib/util/extractSourceMap.js

@@ -0,0 +1,319 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+const path = require("path");
+const urlUtils = require("url");
+const { isAbsolute, join } = require("./fs");
+
+/** @typedef {import("./fs").InputFileSystem} InputFileSystem */
+
+/**
+ * @typedef {(input: string | Buffer<ArrayBufferLike>, resourcePath: string, fs: InputFileSystem) => Promise<{source: string | Buffer<ArrayBufferLike>, sourceMap: string | RawSourceMap | undefined, fileDependencies: string[]}>} SourceMapExtractorFunction
+ */
+
+/** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */
+
+/**
+ * @typedef {(resourcePath: string) => Promise<string | Buffer<ArrayBufferLike>>} ReadResource
+ */
+
+/**
+ * @typedef {object} SourceMappingURL
+ * @property {string} sourceMappingURL
+ * @property {string} replacementString
+ */
+
+// Matches only the last occurrence of sourceMappingURL
+const innerRegex = /\s*[#@]\s*sourceMappingURL\s*=\s*([^\s'"]*)\s*/;
+
+const validProtocolPattern = /^[a-z][a-z0-9+.-]*:/i;
+
+const sourceMappingURLRegex = new RegExp(
+	"(?:" +
+		"/\\*" +
+		"(?:\\s*\r?\n(?://)?)?" +
+		`(?:${innerRegex.source})` +
+		"\\s*" +
+		"\\*/" +
+		"|" +
+		`//(?:${innerRegex.source})` +
+		")" +
+		"\\s*"
+);
+
+/**
+ * Extract source mapping URL from code comments
+ * @param {string} code source code content
+ * @returns {SourceMappingURL} source mapping information
+ */
+function getSourceMappingURL(code) {
+	const lines = code.split(/^/m);
+	let match;
+
+	for (let i = lines.length - 1; i >= 0; i--) {
+		match = lines[i].match(sourceMappingURLRegex);
+		if (match) {
+			break;
+		}
+	}
+
+	const sourceMappingURL = match ? match[1] || match[2] || "" : "";
+
+	return {
+		sourceMappingURL: sourceMappingURL
+			? decodeURI(sourceMappingURL)
+			: sourceMappingURL,
+		replacementString: match ? match[0] : ""
+	};
+}
+
+/**
+ * Get absolute path for source file
+ * @param {string} context context directory
+ * @param {string} request file request
+ * @param {string} sourceRoot source root directory
+ * @returns {string} absolute path
+ */
+function getAbsolutePath(context, request, sourceRoot) {
+	if (sourceRoot) {
+		if (isAbsolute(sourceRoot)) {
+			return join(undefined, sourceRoot, request);
+		}
+
+		return join(undefined, join(undefined, context, sourceRoot), request);
+	}
+
+	return join(undefined, context, request);
+}
+
+/**
+ * Check if value is a URL
+ * @param {string} value string to check
+ * @returns {boolean} true if value is a URL
+ */
+function isURL(value) {
+	return validProtocolPattern.test(value) && !path.win32.isAbsolute(value);
+}
+
+/**
+ * Fetch from multiple possible file paths
+ * @param {ReadResource} readResource read resource function
+ * @param {string[]} possibleRequests array of possible file paths
+ * @param {string} errorsAccumulator accumulated error messages
+ * @returns {Promise<{path: string, data?: string}>} source content promise
+ */
+async function fetchPathsFromURL(
+	readResource,
+	possibleRequests,
+	errorsAccumulator = ""
+) {
+	let result;
+
+	try {
+		result = await readResource(possibleRequests[0]);
+	} catch (error) {
+		errorsAccumulator += `${/** @type {Error} */ (error).message}\n\n`;
+
+		const [, ...tailPossibleRequests] = possibleRequests;
+
+		if (tailPossibleRequests.length === 0) {
+			/** @type {Error} */ (error).message = errorsAccumulator;
+
+			throw error;
+		}
+
+		return fetchPathsFromURL(
+			readResource,
+			tailPossibleRequests,
+			errorsAccumulator
+		);
+	}
+
+	return {
+		path: possibleRequests[0],
+		data: result.toString("utf8")
+	};
+}
+
+/**
+ * Fetch source content from URL
+ * @param {ReadResource} readResource The read resource function
+ * @param {string} context context directory
+ * @param {string} url source URL
+ * @param {string=} sourceRoot source root directory
+ * @param {boolean=} skipReading whether to skip reading file content
+ * @returns {Promise<{sourceURL: string, sourceContent?: string | Buffer<ArrayBufferLike>}>} source content promise
+ */
+async function fetchFromURL(
+	readResource,
+	context,
+	url,
+	sourceRoot,
+	skipReading = false
+) {
+	// 1. It's an absolute url and it is not `windows` path like `C:\dir\file`
+	if (isURL(url)) {
+		// eslint-disable-next-line n/no-deprecated-api
+		const { protocol } = urlUtils.parse(url);
+		if (protocol === "data:") {
+			const sourceContent = skipReading ? "" : await readResource(url);
+
+			return { sourceURL: "", sourceContent };
+		}
+
+		if (protocol === "file:") {
+			const pathFromURL = urlUtils.fileURLToPath(url);
+			const sourceURL = path.normalize(pathFromURL);
+			const sourceContent = skipReading ? "" : await readResource(sourceURL);
+
+			return { sourceURL, sourceContent };
+		}
+
+		const sourceContent = skipReading ? "" : await readResource(url);
+		return { sourceURL: url, sourceContent };
+	}
+
+	// 3. Absolute path
+	if (isAbsolute(url)) {
+		let sourceURL = path.normalize(url);
+
+		let sourceContent;
+
+		if (!skipReading) {
+			const possibleRequests = [sourceURL];
+
+			if (url.startsWith("/")) {
+				possibleRequests.push(
+					getAbsolutePath(context, sourceURL.slice(1), sourceRoot || "")
+				);
+			}
+
+			const result = await fetchPathsFromURL(readResource, possibleRequests);
+
+			sourceURL = result.path;
+			sourceContent = result.data;
+		}
+
+		return { sourceURL, sourceContent };
+	}
+
+	// 4. Relative path
+	const sourceURL = getAbsolutePath(context, url, sourceRoot || "");
+	let sourceContent;
+
+	if (!skipReading) {
+		sourceContent = await readResource(sourceURL);
+	}
+
+	return { sourceURL, sourceContent };
+}
+
+/**
+ * Extract source map from code content
+ * @param {string | Buffer<ArrayBufferLike>} stringOrBuffer The input code content as string or buffer
+ * @param {string} resourcePath The path to the resource file
+ * @param {ReadResource} readResource The read resource function
+ * @returns {Promise<{source: string | Buffer<ArrayBufferLike>, sourceMap: string | RawSourceMap | undefined}>} Promise resolving to extracted source map information
+ */
+async function extractSourceMap(stringOrBuffer, resourcePath, readResource) {
+	const input =
+		typeof stringOrBuffer === "string"
+			? stringOrBuffer
+			: stringOrBuffer.toString("utf8");
+	const inputSourceMap = undefined;
+	const output = {
+		source: stringOrBuffer,
+		sourceMap: inputSourceMap
+	};
+	const { sourceMappingURL, replacementString } = getSourceMappingURL(input);
+
+	if (!sourceMappingURL) {
+		return output;
+	}
+
+	const baseContext = path.dirname(resourcePath);
+
+	const { sourceURL, sourceContent } = await fetchFromURL(
+		readResource,
+		baseContext,
+		sourceMappingURL
+	);
+
+	if (!sourceContent) {
+		return output;
+	}
+
+	/** @type {RawSourceMap} */
+	const map = JSON.parse(
+		sourceContent.toString("utf8").replace(/^\)\]\}'/, "")
+	);
+
+	const context = sourceURL ? path.dirname(sourceURL) : baseContext;
+
+	const resolvedSources = await Promise.all(
+		map.sources.map(
+			async (/** @type {string} */ source, /** @type {number} */ i) => {
+				const originalSourceContent =
+					map.sourcesContent &&
+					typeof map.sourcesContent[i] !== "undefined" &&
+					map.sourcesContent[i] !== null
+						? map.sourcesContent[i]
+						: undefined;
+				const skipReading = typeof originalSourceContent !== "undefined";
+				// We do not skipReading here, because we need absolute paths in sources.
+				// This is necessary so that for sourceMaps with the same file structure in sources, name collisions do not occur.
+				// https://github.com/webpack-contrib/source-map-loader/issues/51
+				let { sourceURL, sourceContent } = await fetchFromURL(
+					readResource,
+					context,
+					source,
+					map.sourceRoot,
+					skipReading
+				);
+
+				if (skipReading) {
+					sourceContent = originalSourceContent;
+				}
+
+				// Return original value of `source` when error happens
+				return { sourceURL, sourceContent };
+			}
+		)
+	);
+
+	/** @type {RawSourceMap} */
+	const newMap = { ...map };
+
+	newMap.sources = [];
+	newMap.sourcesContent = [];
+
+	delete newMap.sourceRoot;
+
+	for (const source of resolvedSources) {
+		const { sourceURL, sourceContent } = source;
+
+		newMap.sources.push(sourceURL || "");
+		newMap.sourcesContent.push(
+			sourceContent ? sourceContent.toString("utf8") : ""
+		);
+	}
+
+	const sourcesContentIsEmpty =
+		newMap.sourcesContent.filter(Boolean).length === 0;
+
+	if (sourcesContentIsEmpty) {
+		delete newMap.sourcesContent;
+	}
+
+	return {
+		source: input.replace(replacementString, ""),
+		sourceMap: /** @type {RawSourceMap} */ (newMap)
+	};
+}
+
+module.exports = extractSourceMap;
+module.exports.getSourceMappingURL = getSourceMappingURL;

package/lib/util/findGraphRoots.js

@@ -11,6 +11,16 @@ const DONE_MARKER = 2;
 const DONE_MAYBE_ROOT_CYCLE_MARKER = 3;
 const DONE_AND_ROOT_MARKER = 4;
 
+/**
+ * @template T
+ * @typedef {Set<Node<T>>} Nodes
+ */
+
+/**
+ * @template T
+ * @typedef {Set<Cycle<T>>} Cycles
+ */
+
 /**
  * @template T
  */
@@ -20,7 +30,7 @@ class Node {
 	 */
 	constructor(item) {
 		this.item = item;
-		/** @type {Set<Node<T>>} */
+		/** @type {Nodes<T>} */
 		this.dependencies = new Set();
 		this.marker = NO_MARKER;
 		/** @type {Cycle<T> | undefined} */
@@ -34,7 +44,7 @@ class Node {
  */
 class Cycle {
 	constructor() {
-		/** @type {Set<Node<T>>} */
+		/** @type {Nodes<T>} */
 		this.nodes = new Set();
 	}
 }
@@ -75,13 +85,13 @@ module.exports = (items, getDependencies) => {
 
 	// Set of current root modules
 	// items will be removed if a new reference to it has been found
-	/** @type {Set<Node<T>>} */
+	/** @type {Nodes<T>} */
 	const roots = new Set();
 
 	// Set of current cycles without references to it
 	// cycles will be removed if a new reference to it has been found
 	// that is not part of the cycle
-	/** @type {Set<Cycle<T>>} */
+	/** @type {Cycles<T>} */
 	const rootCycles = new Set();
 
 	// For all non-marked nodes
@@ -201,7 +211,7 @@ module.exports = (items, getDependencies) => {
 	// inside of the cycle
 	for (const cycle of rootCycles) {
 		let max = 0;
-		/** @type {Set<Node<T>>} */
+		/** @type {Nodes<T>} */
 		const cycleRoots = new Set();
 		const nodes = cycle.nodes;
 		for (const node of nodes) {

package/lib/util/fs.js

@@ -85,17 +85,17 @@ const path = require("path");
 
 /** @typedef {Map<string, FileSystemInfoEntry | "ignore">} TimeInfoEntries */
 
+/** @typedef {Set<string>} Changes */
+/** @typedef {Set<string>} Removals */
+
 /**
  * @typedef {object} WatcherInfo
- * @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 {Changes | null} changes get current aggregated changes that have not yet send to callback
+ * @property {Removals | 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
  */
 
-/** @typedef {Set<string>} Changes */
-/** @typedef {Set<string>} Removals */
-
 // TODO webpack 6 deprecate missing getInfo
 /**
  * @typedef {object} Watcher
@@ -345,16 +345,29 @@ const path = require("path");
  * @typedef {(pathLike: PathLike, callback: NoParamCallback) => void} Unlink
  */
 
+/**
+ * @typedef {FSImplementation & { read: (...args: EXPECTED_ANY[]) => EXPECTED_ANY }} CreateReadStreamFSImplementation
+ */
+
+/**
+ * @typedef {StreamOptions & { fs?: CreateReadStreamFSImplementation | null | undefined, end?: number | undefined }} ReadStreamOptions
+ */
+
+/**
+ * @typedef {(path: PathLike, options?: BufferEncoding | ReadStreamOptions) => NodeJS.ReadableStream} CreateReadStream
+ */
+
 /**
  * @typedef {object} OutputFileSystem
- * @property {WriteFile} writeFile
  * @property {Mkdir} mkdir
  * @property {Readdir=} readdir
  * @property {Rmdir=} rmdir
+ * @property {WriteFile} writeFile
  * @property {Unlink=} unlink
  * @property {Stat} stat
  * @property {LStat=} lstat
  * @property {ReadFile} readFile
+ * @property {CreateReadStream=} createReadStream
  * @property {((path1: string, path2: string) => string)=} join
  * @property {((from: string, to: string) => string)=} relative
  * @property {((dirname: string) => string)=} dirname
@@ -396,7 +409,7 @@ const path = require("path");
  */
 
 /**
- * @typedef {StreamOptions & { fs?: CreateWriteStreamFSImplementation | null | undefined }} WriteStreamOptions
+ * @typedef {StreamOptions & { fs?: CreateWriteStreamFSImplementation | null | undefined, flush?: boolean | undefined }} WriteStreamOptions
  */
 
 /**
@@ -461,7 +474,7 @@ const path = require("path");
 /** @typedef {InputFileSystem & OutputFileSystem & IntermediateFileSystemExtras} IntermediateFileSystem */
 
 /**
- * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
+ * @param {InputFileSystem | OutputFileSystem|undefined} fs a file system
  * @param {string} rootPath the root path
  * @param {string} targetPath the target path
  * @returns {string} location of targetPath relative to rootPath
@@ -649,7 +662,15 @@ const lstatReadlinkAbsolute = (fs, p, callback) => {
 	doReadLink();
 };
 
+/**
+ * @param {string} pathname a path
+ * @returns {boolean} is absolute
+ */
+const isAbsolute = (pathname) =>
+	path.posix.isAbsolute(pathname) || path.win32.isAbsolute(pathname);
+
 module.exports.dirname = dirname;
+module.exports.isAbsolute = isAbsolute;
 module.exports.join = join;
 module.exports.lstatReadlinkAbsolute = lstatReadlinkAbsolute;
 module.exports.mkdirp = mkdirp;

package/lib/util/semver.js

@@ -6,7 +6,8 @@
 "use strict";
 
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {string | number | undefined} SemVerRangeItem */
+/** @typedef {string | number} VersionValue */
+/** @typedef {VersionValue | undefined} SemVerRangeItem */
 /** @typedef {(SemVerRangeItem | SemVerRangeItem[])[]} SemVerRange */
 
 /**
@@ -16,12 +17,12 @@
 const parseVersion = (str) => {
 	/**
 	 * @param {str} str str
-	 * @returns {(string | number)[]} result
+	 * @returns {VersionValue[]} result
 	 */
 	var splitAndConvert = function (str) {
 		return str.split(".").map(function (item) {
 			// eslint-disable-next-line eqeqeq
-			return +item == /** @type {EXPECTED_ANY} */ (item) ? +item : item;
+			return +item == /** @type {string | number} */ (item) ? +item : item;
 		});
 	};
 
@@ -29,7 +30,7 @@ const parseVersion = (str) => {
 		/** @type {RegExpExecArray} */
 		(/^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str));
 
-	/** @type {(string | number | undefined | [])[]} */
+	/** @type {(VersionValue | undefined | [])[]} */
 	var ver = match[1] ? splitAndConvert(match[1]) : [];
 
 	if (match[2]) {
@@ -103,7 +104,7 @@ module.exports.versionLt = versionLt;
 module.exports.parseRange = (str) => {
 	/**
 	 * @param {string} str str
-	 * @returns {(string | number)[]} result
+	 * @returns {VersionValue[]} result
 	 */
 	const splitAndConvert = (str) => {
 		return str
@@ -429,7 +430,7 @@ const satisfy = (range, version) => {
 				/** @type {"s" | "n" | "u" | ""} */
 				(j < range.length ? (typeof range[j])[0] : "");
 
-			/** @type {number | string | undefined} */
+			/** @type {VersionValue | undefined} */
 			var versionValue;
 			/** @type {"n" | "s" | "u" | "o" | undefined} */
 			var versionType;
@@ -470,8 +471,8 @@ const satisfy = (range, version) => {
 						// Handles "cmp" cases
 						if (
 							negated
-								? versionValue > /** @type {(number | string)[]} */ (range)[j]
-								: versionValue < /** @type {(number | string)[]} */ (range)[j]
+								? versionValue > /** @type {VersionValue[]} */ (range)[j]
+								: versionValue < /** @type {VersionValue[]} */ (range)[j]
 						) {
 							return false;
 						}

package/lib/util/smartGrouping.js

@@ -13,42 +13,53 @@
  */
 
 /**
- * @template T
- * @template R
+ * @template I
+ * @template G
  * @typedef {object} GroupConfig
- * @property {(item: T) => string[] | undefined} getKeys
- * @property {(key: string, children: (R | T)[], items: T[]) => R} createGroup
- * @property {(name: string, items: T[]) => GroupOptions=} getOptions
+ * @property {(item: I) => string[] | undefined} getKeys
+ * @property {(name: string, items: I[]) => GroupOptions=} getOptions
+ * @property {(key: string, children: I[], items: I[]) => G} createGroup
  */
 
 /**
- * @template T
- * @template R
+ * @template I
+ * @template G
+ * @typedef {{ config: GroupConfig<I, G>, name: string, alreadyGrouped: boolean, items: Items<I, G> | undefined }} Group
+ */
+
+/**
+ * @template I, G
+ * @typedef {Set<Group<I, G>>} Groups
+ */
+
+/**
+ * @template I
+ * @template G
  * @typedef {object} ItemWithGroups
- * @property {T} item
- * @property {Set<Group<T, R>>} groups
+ * @property {I} item
+ * @property {Groups<I, G>} groups
  */
 
 /**
- * @template T
- * @template R
- * @typedef {{ config: GroupConfig<T, R>, name: string, alreadyGrouped: boolean, items: Set<ItemWithGroups<T, R>> | undefined }} Group
+ * @template T, G
+ * @typedef {Set<ItemWithGroups<T, G>>} Items
  */
 
 /**
- * @template T
+ * @template I
+ * @template G
  * @template R
- * @param {T[]} items the list of items
- * @param {GroupConfig<T, R>[]} groupConfigs configuration
- * @returns {(R | T)[]} grouped items
+ * @param {I[]} items the list of items
+ * @param {GroupConfig<I, G>[]} groupConfigs configuration
+ * @returns {(I | G)[]} grouped items
  */
 const smartGrouping = (items, groupConfigs) => {
-	/** @type {Set<ItemWithGroups<T, R>>} */
+	/** @type {Items<I, G>} */
 	const itemsWithGroups = new Set();
-	/** @type {Map<string, Group<T, R>>} */
+	/** @type {Map<string, Group<I, G>>} */
 	const allGroups = new Map();
 	for (const item of items) {
-		/** @type {Set<Group<T, R>>} */
+		/** @type {Groups<I, G>} */
 		const groups = new Set();
 		for (let i = 0; i < groupConfigs.length; i++) {
 			const groupConfig = groupConfigs[i];
@@ -77,9 +88,10 @@ const smartGrouping = (items, groupConfigs) => {
 			groups
 		});
 	}
+
 	/**
-	 * @param {Set<ItemWithGroups<T, R>>} itemsWithGroups input items with groups
-	 * @returns {(T | R)[]} groups items
+	 * @param {Items<I, G>} itemsWithGroups input items with groups
+	 * @returns {(I | G)[]} groups items
 	 */
 	const runGrouping = (itemsWithGroups) => {
 		const totalSize = itemsWithGroups.size;
@@ -94,7 +106,7 @@ const smartGrouping = (items, groupConfigs) => {
 				}
 			}
 		}
-		/** @type {Map<Group<T, R>, { items: Set<ItemWithGroups<T, R>>, options: GroupOptions | false | undefined, used: boolean }>} */
+		/** @type {Map<Group<I, G>, { items: Items<I, G>, options: GroupOptions | false | undefined, used: boolean }>} */
 		const groupMap = new Map();
 		for (const group of allGroups.values()) {
 			if (group.items) {
@@ -107,13 +119,15 @@ const smartGrouping = (items, groupConfigs) => {
 				});
 			}
 		}
-		/** @type {(T | R)[]} */
+		/** @type {(I | G)[]} */
 		const results = [];
 		for (;;) {
-			/** @type {Group<T, R> | undefined} */
+			/** @type {Group<I, G> | undefined} */
 			let bestGroup;
 			let bestGroupSize = -1;
+			/** @type {Items<I, G> | undefined} */
 			let bestGroupItems;
+			/** @type {GroupOptions | false | undefined} */
 			let bestGroupOptions;
 			for (const [group, state] of groupMap) {
 				const { items, used } = state;
@@ -192,8 +206,9 @@ const smartGrouping = (items, groupConfigs) => {
 			bestGroup.alreadyGrouped = true;
 			const children = groupChildren ? runGrouping(items) : allItems;
 			bestGroup.alreadyGrouped = false;
-
-			results.push(groupConfig.createGroup(key, children, allItems));
+			results.push(
+				groupConfig.createGroup(key, /** @type {I[]} */ (children), allItems)
+			);
 		}
 		for (const { item } of itemsWithGroups) {
 			results.push(item);

package/lib/util/traverseDestructuringAssignmentProperties.js

@@ -0,0 +1,45 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
+/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
+
+/**
+ * Deep first traverse the properties of a destructuring assignment.
+ * @param {DestructuringAssignmentProperties} properties destructuring assignment properties
+ * @param {((stack: DestructuringAssignmentProperty[]) => void) | undefined=} onLeftNode on left node callback
+ * @param {((stack: DestructuringAssignmentProperty[]) => void) | undefined=} enterNode enter node callback
+ * @param {((stack: DestructuringAssignmentProperty[]) => void) | undefined=} exitNode exit node callback
+ * @param {DestructuringAssignmentProperty[] | undefined=} stack stack of the walking nodes
+ */
+function traverseDestructuringAssignmentProperties(
+	properties,
+	onLeftNode,
+	enterNode,
+	exitNode,
+	stack = []
+) {
+	for (const property of properties) {
+		stack.push(property);
+		if (enterNode) enterNode(stack);
+		if (property.pattern) {
+			traverseDestructuringAssignmentProperties(
+				property.pattern,
+				onLeftNode,
+				enterNode,
+				exitNode,
+				stack
+			);
+		} else if (onLeftNode) {
+			onLeftNode(stack);
+		}
+		if (exitNode) exitNode(stack);
+		stack.pop();
+	}
+}
+
+module.exports = traverseDestructuringAssignmentProperties;