webpack 5.59.0 → 5.94.0

package/lib/ChunkGroup.js

@@ -22,12 +22,13 @@ const {
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 
 /** @typedef {{id: number}} HasId */
-/** @typedef {{module: Module, loc: DependencyLocation, request: string}} OriginRecord */
+/** @typedef {{module: Module | null, loc: DependencyLocation, request: string}} OriginRecord */
 
 /**
- * @typedef {Object} RawChunkGroupOptions
+ * @typedef {object} RawChunkGroupOptions
  * @property {number=} preloadOrder
  * @property {number=} prefetchOrder
+ * @property {("low" | "high" | "auto")=} fetchPriority
  */
 
 /** @typedef {RawChunkGroupOptions & { name?: string }} ChunkGroupOptions */
@@ -69,7 +70,7 @@ const sortOrigin = (a, b) => {
 class ChunkGroup {
 	/**
 	 * Creates an instance of ChunkGroup.
-	 * @param {string|ChunkGroupOptions=} options chunk group options passed to chunkGroup
+	 * @param {string | ChunkGroupOptions=} options chunk group options passed to chunkGroup
 	 */
 	constructor(options) {
 		if (typeof options === "string") {
@@ -79,7 +80,7 @@ class ChunkGroup {
 		}
 		/** @type {number} */
 		this.groupDebugId = debugId++;
-		this.options = options;
+		this.options = /** @type {ChunkGroupOptions} */ (options);
 		/** @type {SortableSet<ChunkGroup>} */
 		this._children = new SortableSet(undefined, sortById);
 		/** @type {SortableSet<ChunkGroup>} */
@@ -92,12 +93,18 @@ class ChunkGroup {
 		/** @type {OriginRecord[]} */
 		this.origins = [];
 		/** Indices in top-down order */
-		/** @private @type {Map<Module, number>} */
+		/**
+		 * @private
+		 * @type {Map<Module, number>}
+		 */
 		this._modulePreOrderIndices = new Map();
 		/** Indices in bottom-up order */
-		/** @private @type {Map<Module, number>} */
+		/**
+		 * @private
+		 * @type {Map<Module, number>}
+		 */
 		this._modulePostOrderIndices = new Map();
-		/** @type {number} */
+		/** @type {number | undefined} */
 		this.index = undefined;
 	}
 
@@ -107,12 +114,18 @@ class ChunkGroup {
 	 * @returns {void}
 	 */
 	addOptions(options) {
-		for (const key of Object.keys(options)) {
+		for (const _key of Object.keys(options)) {
+			const key = /** @type {keyof ChunkGroupOptions} */ (_key);
 			if (this.options[key] === undefined) {
-				this.options[key] = options[key];
+				/** @type {TODO} */
+				(this.options)[key] = options[key];
 			} else if (this.options[key] !== options[key]) {
 				if (key.endsWith("Order")) {
-					this.options[key] = Math.max(this.options[key], options[key]);
+					/** @type {TODO} */
+					(this.options)[key] = Math.max(
+						/** @type {number} */ (this.options[key]),
+						/** @type {number} */ (options[key])
+					);
 				} else {
 					throw new Error(
 						`ChunkGroup.addOptions: No option merge strategy for ${key}`
@@ -124,7 +137,7 @@ class ChunkGroup {
 
 	/**
 	 * returns the name of current ChunkGroup
-	 * @returns {string|undefined} returns the ChunkGroup name
+	 * @returns {string | undefined} returns the ChunkGroup name
 	 */
 	get name() {
 		return this.options.name;
@@ -132,7 +145,7 @@ class ChunkGroup {
 
 	/**
 	 * sets a new name for current ChunkGroup
-	 * @param {string} value the new name for ChunkGroup
+	 * @param {string | undefined} value the new name for ChunkGroup
 	 * @returns {void}
 	 */
 	set name(value) {
@@ -212,7 +225,7 @@ class ChunkGroup {
 	/**
 	 * @param {Chunk} oldChunk chunk to be replaced
 	 * @param {Chunk} newChunk New chunk that will be replaced with
-	 * @returns {boolean} returns true if the replacement was successful
+	 * @returns {boolean | undefined} returns true if the replacement was successful
 	 */
 	replaceChunk(oldChunk, newChunk) {
 		const oldIdx = this.chunks.indexOf(oldChunk);
@@ -353,7 +366,7 @@ class ChunkGroup {
 	}
 
 	/**
-	 * @returns {Array} an array containing the blocks
+	 * @returns {Array<AsyncDependenciesBlock>} an array containing the blocks
 	 */
 	getBlocks() {
 		return this._blocks.getFromCache(getArray);
@@ -363,6 +376,10 @@ class ChunkGroup {
 		return this._blocks.size;
 	}
 
+	/**
+	 * @param {AsyncDependenciesBlock} block block
+	 * @returns {boolean} true, if block exists
+	 */
 	hasBlock(block) {
 		return this._blocks.has(block);
 	}
@@ -387,7 +404,7 @@ class ChunkGroup {
 	}
 
 	/**
-	 * @param {Module} module origin module
+	 * @param {Module | null} module origin module
 	 * @param {DependencyLocation} loc location of the reference in the origin module
 	 * @param {string} request request name of the reference
 	 * @returns {void}
@@ -461,7 +478,6 @@ class ChunkGroup {
 	/**
 	 * Sorting predicate which allows current ChunkGroup to be compared against another.
 	 * Sorting values are based off of number of chunks in ChunkGroup.
-	 *
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {ChunkGroup} otherGroup the chunkGroup to compare this against
 	 * @returns {-1|0|1} sort position for comparison
@@ -486,13 +502,17 @@ class ChunkGroup {
 		for (const childGroup of this._children) {
 			for (const key of Object.keys(childGroup.options)) {
 				if (key.endsWith("Order")) {
-					const name = key.substr(0, key.length - "Order".length);
+					const name = key.slice(0, key.length - "Order".length);
 					let list = lists.get(name);
 					if (list === undefined) {
 						lists.set(name, (list = []));
 					}
 					list.push({
-						order: childGroup.options[key],
+						order:
+							/** @type {number} */
+							(
+								childGroup.options[/** @type {keyof ChunkGroupOptions} */ (key)]
+							),
 						group: childGroup
 					});
 				}
@@ -524,7 +544,7 @@ class ChunkGroup {
 	/**
 	 * Gets the top-down index of a module in this ChunkGroup
 	 * @param {Module} module the module
-	 * @returns {number} index
+	 * @returns {number | undefined} index
 	 */
 	getModulePreOrderIndex(module) {
 		return this._modulePreOrderIndices.get(module);
@@ -543,7 +563,7 @@ class ChunkGroup {
 	/**
 	 * Gets the bottom-up index of a module in this ChunkGroup
 	 * @param {Module} module the module
-	 * @returns {number} index
+	 * @returns {number | undefined} index
 	 */
 	getModulePostOrderIndex(module) {
 		return this._modulePostOrderIndices.get(module);

package/lib/ChunkTemplate.js

@@ -8,8 +8,21 @@
 const util = require("util");
 const memoize = require("./util/memoize");
 
+/** @typedef {import("tapable").Tap} Tap */
 /** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("./Compilation").Hash} Hash */
+/** @typedef {import("./Compilation").RenderManifestEntry} RenderManifestEntry */
+/** @typedef {import("./Compilation").RenderManifestOptions} RenderManifestOptions */
+/** @typedef {import("./Compilation").Source} Source */
+/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/**
+ * @template T
+ * @typedef {import("tapable").IfSet<T>} IfSet
+ */
 
 const getJavascriptModulesPlugin = memoize(() =>
 	require("./javascript/JavascriptModulesPlugin")
@@ -26,6 +39,11 @@ class ChunkTemplate {
 		this.hooks = Object.freeze({
 			renderManifest: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(RenderManifestEntry[], RenderManifestOptions): RenderManifestEntry[]} fn function
+					 */
 					(options, fn) => {
 						compilation.hooks.renderManifest.tap(
 							options,
@@ -41,6 +59,11 @@ class ChunkTemplate {
 			},
 			modules: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Source, ModuleTemplate, RenderContext): Source} fn function
+					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
 							.getCompilationHooks(compilation)
@@ -58,6 +81,11 @@ class ChunkTemplate {
 			},
 			render: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Source, ModuleTemplate, RenderContext): Source} fn function
+					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
 							.getCompilationHooks(compilation)
@@ -75,6 +103,11 @@ class ChunkTemplate {
 			},
 			renderWithEntry: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Source, Chunk): Source} fn function
+					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
 							.getCompilationHooks(compilation)
@@ -96,6 +129,11 @@ class ChunkTemplate {
 			},
 			hash: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Hash): void} fn function
+					 */
 					(options, fn) => {
 						compilation.hooks.fullHash.tap(options, fn);
 					},
@@ -105,6 +143,11 @@ class ChunkTemplate {
 			},
 			hashForChunk: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Hash, Chunk, ChunkHashContext): void} fn function
+					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
 							.getCompilationHooks(compilation)

package/lib/CleanPlugin.js

@@ -7,7 +7,7 @@
 
 const asyncLib = require("neo-async");
 const { SyncBailHook } = require("tapable");
-const Compilation = require("../lib/Compilation");
+const Compilation = require("./Compilation");
 const createSchemaValidation = require("./util/create-schema-validation");
 const { join } = require("./util/fs");
 const processAsyncTree = require("./util/processAsyncTree");
@@ -15,16 +15,25 @@ const processAsyncTree = require("./util/processAsyncTree");
 /** @typedef {import("../declarations/WebpackOptions").CleanOptions} CleanOptions */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {import("./util/fs").IStats} IStats */
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
+/** @typedef {import("./util/fs").StatsCallback} StatsCallback */
 
 /** @typedef {(function(string):boolean)|RegExp} IgnoreItem */
+/** @typedef {Map<string, number>} Assets */
 /** @typedef {function(IgnoreItem): void} AddToIgnoreCallback */
 
 /**
- * @typedef {Object} CleanPluginCompilationHooks
+ * @typedef {object} CleanPluginCompilationHooks
  * @property {SyncBailHook<[string], boolean>} keep when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
  */
 
+/**
+ * @callback KeepFn
+ * @param {string} path path
+ * @returns {boolean} true, if the path should be kept
+ */
+
 const validate = createSchemaValidation(
 	undefined,
 	() => {
@@ -39,18 +48,32 @@ const validate = createSchemaValidation(
 		baseDataPath: "options"
 	}
 );
+const _10sec = 10 * 1000;
+
+/**
+ * marge assets map 2 into map 1
+ * @param {Assets} as1 assets
+ * @param {Assets} as2 assets
+ * @returns {void}
+ */
+const mergeAssets = (as1, as2) => {
+	for (const [key, value1] of as2) {
+		const value2 = as1.get(key);
+		if (!value2 || value1 > value2) as1.set(key, value1);
+	}
+};
 
 /**
  * @param {OutputFileSystem} fs filesystem
  * @param {string} outputPath output path
- * @param {Set<string>} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
- * @param {function(Error=, Set<string>=): void} callback returns the filenames of the assets that shouldn't be there
+ * @param {Map<string, number>} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
+ * @param {function((Error | null)=, Set<string>=): void} callback returns the filenames of the assets that shouldn't be there
  * @returns {void}
  */
 const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
 	const directories = new Set();
 	// get directories of assets
-	for (const asset of currentAssets) {
+	for (const [asset] of currentAssets) {
 		directories.add(asset.replace(/(^|\/)[^/]*$/, ""));
 	}
 	// and all parent directories
@@ -62,7 +85,8 @@ const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
 		directories,
 		10,
 		(directory, callback) => {
-			fs.readdir(join(fs, outputPath, directory), (err, entries) => {
+			/** @type {NonNullable<OutputFileSystem["readdir"]>} */
+			(fs.readdir)(join(fs, outputPath, directory), (err, entries) => {
 				if (err) {
 					if (err.code === "ENOENT") return callback();
 					if (err.code === "ENOTDIR") {
@@ -71,8 +95,8 @@ const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
 					}
 					return callback(err);
 				}
-				for (const entry of entries) {
-					const file = /** @type {string} */ (entry);
+				for (const entry of /** @type {string[]} */ (entries)) {
+					const file = entry;
 					const filename = directory ? `${directory}/${file}` : file;
 					if (!directories.has(filename) && !currentAssets.has(filename)) {
 						diff.add(filename);
@@ -90,18 +114,35 @@ const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
 };
 
 /**
- * @param {Set<string>} currentAssets assets list
- * @param {Set<string>} oldAssets old assets list
+ * @param {Assets} currentAssets assets list
+ * @param {Assets} oldAssets old assets list
  * @returns {Set<string>} diff
  */
 const getDiffToOldAssets = (currentAssets, oldAssets) => {
 	const diff = new Set();
-	for (const asset of oldAssets) {
+	const now = Date.now();
+	for (const [asset, ts] of oldAssets) {
+		if (ts >= now) continue;
 		if (!currentAssets.has(asset)) diff.add(asset);
 	}
 	return diff;
 };
 
+/**
+ * @param {OutputFileSystem} fs filesystem
+ * @param {string} filename path to file
+ * @param {StatsCallback} callback callback for provided filename
+ * @returns {void}
+ */
+const doStat = (fs, filename, callback) => {
+	if ("lstat" in fs) {
+		/** @type {NonNullable<OutputFileSystem["lstat"]>} */
+		(fs.lstat)(filename, callback);
+	} else {
+		fs.stat(filename, callback);
+	}
+};
+
 /**
  * @param {OutputFileSystem} fs filesystem
  * @param {string} outputPath output path
@@ -109,10 +150,13 @@ const getDiffToOldAssets = (currentAssets, oldAssets) => {
  * @param {Logger} logger logger
  * @param {Set<string>} diff filenames of the assets that shouldn't be there
  * @param {function(string): boolean} isKept check if the entry is ignored
- * @param {function(Error=): void} callback callback
+ * @param {function(Error=, Assets=): void} callback callback
  * @returns {void}
  */
 const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
+	/**
+	 * @param {string} msg message
+	 */
 	const log = msg => {
 		if (dry) {
 			logger.info(msg);
@@ -122,15 +166,21 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 	};
 	/** @typedef {{ type: "check" | "unlink" | "rmdir", filename: string, parent: { remaining: number, job: Job } | undefined }} Job */
 	/** @type {Job[]} */
-	const jobs = Array.from(diff, filename => ({
+	const jobs = Array.from(diff.keys(), filename => ({
 		type: "check",
 		filename,
 		parent: undefined
 	}));
+	/** @type {Assets} */
+	const keptAssets = new Map();
 	processAsyncTree(
 		jobs,
 		10,
 		({ type, filename, parent }, push, callback) => {
+			/**
+			 * @param {Error & { code?: string }} err error
+			 * @returns {void}
+			 */
 			const handleError = err => {
 				if (err.code === "ENOENT") {
 					log(`${filename} was removed during cleaning by something else`);
@@ -146,13 +196,14 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 			switch (type) {
 				case "check":
 					if (isKept(filename)) {
+						keptAssets.set(filename, 0);
 						// do not decrement parent entry as we don't want to delete the parent
 						log(`${filename} will be kept`);
 						return process.nextTick(callback);
 					}
-					fs.stat(path, (err, stats) => {
+					doStat(fs, path, (err, stats) => {
 						if (err) return handleError(err);
-						if (!stats.isDirectory()) {
+						if (!(/** @type {IStats} */ (stats).isDirectory())) {
 							push({
 								type: "unlink",
 								filename,
@@ -160,7 +211,9 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 							});
 							return callback();
 						}
-						fs.readdir(path, (err, entries) => {
+
+						/** @type {NonNullable<OutputFileSystem["readdir"]>} */
+						(fs.readdir)(path, (err, _entries) => {
 							if (err) return handleError(err);
 							/** @type {Job} */
 							const deleteJob = {
@@ -168,6 +221,7 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 								filename,
 								parent
 							};
+							const entries = /** @type {string[]} */ (_entries);
 							if (entries.length === 0) {
 								push(deleteJob);
 							} else {
@@ -232,7 +286,10 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 					break;
 			}
 		},
-		callback
+		err => {
+			if (err) return callback(err);
+			callback(undefined, keptAssets);
+		}
 	);
 };
 
@@ -275,18 +332,20 @@ class CleanPlugin {
 	apply(compiler) {
 		const { dry, keep } = this.options;
 
+		/** @type {KeepFn} */
 		const keepFn =
 			typeof keep === "function"
 				? keep
 				: typeof keep === "string"
-				? path => path.startsWith(keep)
-				: typeof keep === "object" && keep.test
-				? path => keep.test(path)
-				: () => false;
+					? path => path.startsWith(keep)
+					: typeof keep === "object" && keep.test
+						? path => keep.test(path)
+						: () => false;
 
 		// We assume that no external modification happens while the compiler is active
 		// So we can store the old assets and only diff to them to avoid fs access on
 		// incremental builds
+		/** @type {undefined|Assets} */
 		let oldAssets;
 
 		compiler.hooks.emit.tapAsync(
@@ -297,7 +356,7 @@ class CleanPlugin {
 			(compilation, callback) => {
 				const hooks = CleanPlugin.getCompilationHooks(compilation);
 				const logger = compilation.getLogger("webpack.CleanPlugin");
-				const fs = compiler.outputFileSystem;
+				const fs = /** @type {OutputFileSystem} */ (compiler.outputFileSystem);
 
 				if (!fs.readdir) {
 					return callback(
@@ -307,7 +366,9 @@ class CleanPlugin {
 					);
 				}
 
-				const currentAssets = new Set();
+				/** @type {Assets} */
+				const currentAssets = new Map();
+				const now = Date.now();
 				for (const asset of Object.keys(compilation.assets)) {
 					if (/^[A-Za-z]:\\|^\/|^\\\\/.test(asset)) continue;
 					let normalizedAsset;
@@ -320,30 +381,54 @@ class CleanPlugin {
 						);
 					} while (newNormalizedAsset !== normalizedAsset);
 					if (normalizedAsset.startsWith("../")) continue;
-					currentAssets.add(normalizedAsset);
+					const assetInfo = compilation.assetsInfo.get(asset);
+					if (assetInfo && assetInfo.hotModuleReplacement) {
+						currentAssets.set(normalizedAsset, now + _10sec);
+					} else {
+						currentAssets.set(normalizedAsset, 0);
+					}
 				}
 
 				const outputPath = compilation.getPath(compiler.outputPath, {});
 
+				/**
+				 * @param {string} path path
+				 * @returns {boolean} true, if needs to be kept
+				 */
 				const isKept = path => {
 					const result = hooks.keep.call(path);
 					if (result !== undefined) return result;
 					return keepFn(path);
 				};
 
+				/**
+				 * @param {(Error | null)=} err err
+				 * @param {Set<string>=} diff diff
+				 */
 				const diffCallback = (err, diff) => {
 					if (err) {
 						oldAssets = undefined;
-						return callback(err);
+						callback(err);
+						return;
 					}
-					applyDiff(fs, outputPath, dry, logger, diff, isKept, err => {
-						if (err) {
-							oldAssets = undefined;
-						} else {
-							oldAssets = currentAssets;
+					applyDiff(
+						fs,
+						outputPath,
+						dry,
+						logger,
+						/** @type {Set<string>} */ (diff),
+						isKept,
+						(err, keptAssets) => {
+							if (err) {
+								oldAssets = undefined;
+							} else {
+								if (oldAssets) mergeAssets(currentAssets, oldAssets);
+								oldAssets = currentAssets;
+								if (keptAssets) mergeAssets(oldAssets, keptAssets);
+							}
+							callback(err);
 						}
-						callback(err);
-					});
+					);
 				};
 
 				if (oldAssets) {

package/lib/CodeGenerationResults.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { provide } = require("./util/MapHelpers");
+const { getOrInsert } = require("./util/MapHelpers");
 const { first } = require("./util/SetHelpers");
 const createHash = require("./util/createHash");
 const { runtimeToString, RuntimeSpecMap } = require("./util/runtime");
@@ -42,7 +42,9 @@ class CodeGenerationResults {
 			);
 		}
 		if (runtime === undefined) {
-			if (entry.size > 1) {
+			if (
+				/** @type {RuntimeSpecMap<CodeGenerationResult>} */ (entry).size > 1
+			) {
 				const results = new Set(entry.values());
 				if (results.size !== 1) {
 					throw new Error(
@@ -53,9 +55,9 @@ class CodeGenerationResults {
 Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
 					);
 				}
-				return first(results);
+				return /** @type {CodeGenerationResult} */ (first(results));
 			}
-			return entry.values().next().value;
+			return /** @type {CodeGenerationResult} */ (entry.values().next().value);
 		}
 		const result = entry.get(runtime);
 		if (result === undefined) {
@@ -86,9 +88,8 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		} else if (entry.size > 1) {
 			const results = new Set(entry.values());
 			return results.size === 1;
-		} else {
-			return entry.size === 1;
 		}
+		return entry.size === 1;
 	}
 
 	/**
@@ -147,7 +148,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	 * @returns {void}
 	 */
 	add(module, runtime, result) {
-		const map = provide(this.map, module, () => new RuntimeSpecMap());
+		const map = getOrInsert(this.map, module, () => new RuntimeSpecMap());
 		map.set(runtime, result);
 	}
 }

package/lib/CommentCompilationWarning.js

@@ -12,7 +12,6 @@ const makeSerializable = require("./util/makeSerializable");
 
 class CommentCompilationWarning extends WebpackError {
 	/**
-	 *
 	 * @param {string} message warning message
 	 * @param {DependencyLocation} loc affected lines of code
 	 */