webpack 5.97.1 → 5.104.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,9 +97,9 @@ 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 sumSize = (nodes) => {
 	const sum = Object.create(null);
 	for (const node of nodes) {
 		addSizeTo(sum, node.size);
@@ -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) => {
@@ -135,12 +137,15 @@ const isTooSmall = (size, minSize) => {
 	return false;
 };
 
+/** @typedef {Set<string>} Types */
+
 /**
- * @param {Record<string, number>} size size
- * @param {Record<string, number>} minSize minimum size
- * @returns {Set<string>} set of types that are too small
+ * @param {Sizes} size size
+ * @param {Sizes} minSize minimum size
+ * @returns {Types} set of types that are too small
  */
 const getTooSmallTypes = (size, minSize) => {
+	/** @typedef {Types} */
 	const types = new Set();
 	for (const key of Object.keys(size)) {
 		const s = size[key];
@@ -152,22 +157,22 @@ const getTooSmallTypes = (size, minSize) => {
 };
 
 /**
- * @template T
- * @param {TODO} size size
- * @param {Set<string>} types types
+ * @template {object} T
+ * @param {T} size size
+ * @param {Types} types types
  * @returns {number} number of matching size types
  */
 const getNumberOfMatchingSizeTypes = (size, types) => {
 	let i = 0;
 	for (const key of Object.keys(size)) {
-		if (size[key] !== 0 && types.has(key)) i++;
+		if (size[/** @type {keyof T} */ (key)] !== 0 && types.has(key)) i++;
 	}
 	return i;
 };
 
 /**
- * @param {Record<string, number>} size size
- * @param {Set<string>} types types
+ * @param {Sizes} size size
+ * @param {Types} types types
  * @returns {number} selective size sum
  */
 const selectiveSizeSum = (size, types) => {
@@ -185,7 +190,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 +199,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;
@@ -212,7 +219,7 @@ class Group {
 	}
 
 	/**
-	 * @param {function(Node<T>): boolean} filter filter function
+	 * @param {(node: Node<T>) => boolean} filter filter function
 	 * @returns {Node<T>[] | undefined} removed nodes
 	 */
 	popNodes(filter) {
@@ -228,7 +235,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 +254,11 @@ class Group {
 /**
  * @template T
  * @param {Iterable<Node<T>>} nodes nodes
- * @returns {number[]} similarities
+ * @returns {Similarities} similarities
  */
-const getSimilarities = nodes => {
+const getSimilarities = (nodes) => {
 	// calculate similarities between lexically adjacent nodes
-	/** @type {number[]} */
+	/** @type {Similarities} */
 	const similarities = [];
 	let last;
 	for (const node of nodes) {
@@ -268,17 +275,17 @@ 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 {function(T): Record<string, number>} getSize function to get size of an item
- * @property {function(T): string} getKey function to get the key 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
  */
 
 /**
@@ -292,7 +299,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 
 	const nodes = Array.from(
 		items,
-		item => new Node(item, getKey(item), getSize(item))
+		(item) => new Node(item, getKey(item), getSize(item))
 	);
 
 	/** @type {Node<T>[]} */
@@ -320,7 +327,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) => {
@@ -329,12 +336,12 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				// We hit an edge case where the working set is already smaller than minSize
 				// We merge problematic nodes with the smallest result node to keep minSize intact
 				const problemNodes = group.popNodes(
-					n => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0
+					(n) => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0
 				);
 				if (problemNodes === undefined) return false;
 				// Only merge it with result nodes that have the problematic size type
 				const possibleResultGroups = result.filter(
-					n => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0
+					(n) => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0
 				);
 				if (possibleResultGroups.length > 0) {
 					const bestGroup = possibleResultGroups.reduce((min, group) => {
@@ -343,13 +350,15 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 							group,
 							problemTypes
 						);
-						if (minMatches !== groupMatches)
+						if (minMatches !== groupMatches) {
 							return minMatches < groupMatches ? group : min;
+						}
 						if (
 							selectiveSizeSum(min.size, problemTypes) >
 							selectiveSizeSum(group.size, problemTypes)
-						)
+						) {
 							return group;
+						}
 						return min;
 					});
 					for (const node of problemNodes) bestGroup.nodes.push(node);
@@ -453,9 +462,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) &&
@@ -482,22 +491,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]);
 				}
@@ -529,11 +538,11 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 
 	// return the results
 	return result.map(
-		group =>
+		(group) =>
 			/** @type {GroupedItems<T>} */
 			({
 				key: group.key,
-				items: group.nodes.map(node => node.item),
+				items: group.nodes.map((node) => node.item),
 				size: group.size
 			})
 	);

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/extractUrlAndGlobal.js

@@ -14,5 +14,5 @@ module.exports = function extractUrlAndGlobal(urlAndGlobal) {
 	if (index <= 0 || index === urlAndGlobal.length - 1) {
 		throw new Error(`Invalid request "${urlAndGlobal}"`);
 	}
-	return [urlAndGlobal.substring(index + 1), urlAndGlobal.substring(0, index)];
+	return [urlAndGlobal.slice(index + 1), urlAndGlobal.slice(0, index)];
 };