webpack 5.101.3 → 5.102.1

package/lib/util/deterministicGrouping.js

@@ -70,9 +70,11 @@ const getName = (a, b, usedNames) => {
 	return a;
 };
 
+/** @typedef {Record<string, number>} Sizes */
+
 /**
- * @param {Record<string, number>} total total size
- * @param {Record<string, number>} size single size
+ * @param {Sizes} total total size
+ * @param {Sizes} size single size
  * @returns {void}
  */
 const addSizeTo = (total, size) => {
@@ -82,8 +84,8 @@ const addSizeTo = (total, size) => {
 };
 
 /**
- * @param {Record<string, number>} total total size
- * @param {Record<string, number>} size single size
+ * @param {Sizes} total total size
+ * @param {Sizes} size single size
  * @returns {void}
  */
 const subtractSizeFrom = (total, size) => {
@@ -95,7 +97,7 @@ const subtractSizeFrom = (total, size) => {
 /**
  * @template T
  * @param {Iterable<Node<T>>} nodes some nodes
- * @returns {Record<string, number>} total size
+ * @returns {Sizes} total size
  */
 const sumSize = (nodes) => {
 	const sum = Object.create(null);
@@ -106,8 +108,8 @@ const sumSize = (nodes) => {
 };
 
 /**
- * @param {Record<string, number>} size size
- * @param {Record<string, number>} maxSize minimum size
+ * @param {Sizes} size size
+ * @param {Sizes} maxSize minimum size
  * @returns {boolean} true, when size is too big
  */
 const isTooBig = (size, maxSize) => {
@@ -121,8 +123,8 @@ const isTooBig = (size, maxSize) => {
 };
 
 /**
- * @param {Record<string, number>} size size
- * @param {Record<string, number>} minSize minimum size
+ * @param {Sizes} size size
+ * @param {Sizes} minSize minimum size
  * @returns {boolean} true, when size is too small
  */
 const isTooSmall = (size, minSize) => {
@@ -136,8 +138,8 @@ const isTooSmall = (size, minSize) => {
 };
 
 /**
- * @param {Record<string, number>} size size
- * @param {Record<string, number>} minSize minimum size
+ * @param {Sizes} size size
+ * @param {Sizes} minSize minimum size
  * @returns {Set<string>} set of types that are too small
  */
 const getTooSmallTypes = (size, minSize) => {
@@ -166,7 +168,7 @@ const getNumberOfMatchingSizeTypes = (size, types) => {
 };
 
 /**
- * @param {Record<string, number>} size size
+ * @param {Sizes} size size
  * @param {Set<string>} types types
  * @returns {number} selective size sum
  */
@@ -185,7 +187,7 @@ class Node {
 	/**
 	 * @param {T} item item
 	 * @param {string} key key
-	 * @param {Record<string, number>} size size
+	 * @param {Sizes} size size
 	 */
 	constructor(item, key, size) {
 		this.item = item;
@@ -194,14 +196,16 @@ class Node {
 	}
 }
 
+/** @typedef {number[]} Similarities */
+
 /**
  * @template T
  */
 class Group {
 	/**
 	 * @param {Node<T>[]} nodes nodes
-	 * @param {number[] | null} similarities similarities between the nodes (length = nodes.length - 1)
-	 * @param {Record<string, number>=} size size of the group
+	 * @param {Similarities | null} similarities similarities between the nodes (length = nodes.length - 1)
+	 * @param {Sizes=} size size of the group
 	 */
 	constructor(nodes, similarities, size) {
 		this.nodes = nodes;
@@ -228,7 +232,7 @@ class Group {
 				if (newNodes.length > 0) {
 					newSimilarities.push(
 						lastNode === this.nodes[i - 1]
-							? /** @type {number[]} */ (this.similarities)[i - 1]
+							? /** @type {Similarities} */ (this.similarities)[i - 1]
 							: similarity(/** @type {Node<T>} */ (lastNode).key, node.key)
 					);
 				}
@@ -247,11 +251,11 @@ class Group {
 /**
  * @template T
  * @param {Iterable<Node<T>>} nodes nodes
- * @returns {number[]} similarities
+ * @returns {Similarities} similarities
  */
 const getSimilarities = (nodes) => {
 	// calculate similarities between lexically adjacent nodes
-	/** @type {number[]} */
+	/** @type {Similarities} */
 	const similarities = [];
 	let last;
 	for (const node of nodes) {
@@ -268,16 +272,16 @@ const getSimilarities = (nodes) => {
  * @typedef {object} GroupedItems<T>
  * @property {string} key
  * @property {T[]} items
- * @property {Record<string, number>} size
+ * @property {Sizes} size
  */
 
 /**
  * @template T
  * @typedef {object} Options
- * @property {Record<string, number>} maxSize maximum size of a group
- * @property {Record<string, number>} minSize minimum size of a group (preferred over maximum size)
+ * @property {Sizes} maxSize maximum size of a group
+ * @property {Sizes} minSize minimum size of a group (preferred over maximum size)
  * @property {Iterable<T>} items a list of items
- * @property {(item: T) => Record<string, number>} getSize function to get size of an item
+ * @property {(item: T) => Sizes} getSize function to get size of an item
  * @property {(item: T) => string} getKey function to get the key of an item
  */
 
@@ -320,7 +324,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 
 		/**
 		 * @param {Group<T>} group group
-		 * @param {Record<string, number>} consideredSize size of the group to consider
+		 * @param {Sizes} consideredSize size of the group to consider
 		 * @returns {boolean} true, if the group was modified
 		 */
 		const removeProblematicNodes = (group, consideredSize = group.size) => {
@@ -455,9 +459,9 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 					// rightSize ^^^^^^^^^^^^^^^
 
 					while (pos <= right + 1) {
-						const similarity = /** @type {number[]} */ (group.similarities)[
-							pos - 1
-						];
+						const similarity =
+							/** @type {Similarities} */
+							(group.similarities)[pos - 1];
 						if (
 							similarity < bestSimilarity &&
 							!isTooSmall(leftSize, minSize) &&
@@ -484,22 +488,22 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				// create two new groups for left and right area
 				// and queue them up
 				const rightNodes = [group.nodes[right + 1]];
-				/** @type {number[]} */
+				/** @type {Similarities} */
 				const rightSimilarities = [];
 				for (let i = right + 2; i < group.nodes.length; i++) {
 					rightSimilarities.push(
-						/** @type {number[]} */ (group.similarities)[i - 1]
+						/** @type {Similarities} */ (group.similarities)[i - 1]
 					);
 					rightNodes.push(group.nodes[i]);
 				}
 				queue.push(new Group(rightNodes, rightSimilarities));
 
 				const leftNodes = [group.nodes[0]];
-				/** @type {number[]} */
+				/** @type {Similarities} */
 				const leftSimilarities = [];
 				for (let i = 1; i < left; i++) {
 					leftSimilarities.push(
-						/** @type {number[]} */ (group.similarities)[i - 1]
+						/** @type {Similarities} */ (group.similarities)[i - 1]
 					);
 					leftNodes.push(group.nodes[i]);
 				}

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;