@depup/webpack 5.111.1-depup.2 → 5.112.0-depup.0

package/lib/InitFragment.js

@@ -5,207 +5,6 @@
 
 "use strict";
 
-const { ConcatSource } = require("webpack-sources");
-const makeSerializable = require("./util/makeSerializable");
-
-/** @import { Source } from "webpack-sources" */
-/** @import { GenerateContext } from "./Generator" */
-/**
- * @import {
- * 	ObjectDeserializerContext,
- * 	ObjectSerializerContext
- * } from "./serialization/ObjectMiddleware"
- */
-
-/** @typedef {string} InitFragmentKey */
-
-/**
- * Defines the maybe mergeable init fragment type used by this module.
- * @template GenerateContext
- * @typedef {object} MaybeMergeableInitFragment
- * @property {InitFragmentKey=} key
- * @property {number} stage
- * @property {number} position
- * @property {(context: GenerateContext) => string | Source | undefined} getContent
- * @property {(context: GenerateContext) => string | Source | undefined} getEndContent
- * @property {(fragments: MaybeMergeableInitFragment<GenerateContext>) => MaybeMergeableInitFragment<GenerateContext>=} merge
- * @property {(fragments: MaybeMergeableInitFragment<GenerateContext>[]) => MaybeMergeableInitFragment<GenerateContext>[]=} mergeAll
- */
-
-/**
- * Represents InitFragment.
- * @template GenerateContext
- * @implements {MaybeMergeableInitFragment<GenerateContext>}
- */
-class InitFragment {
-	/**
-	 * Creates an instance of InitFragment.
-	 * @param {string | Source | undefined} content the source code that will be included as initialization code
-	 * @param {number} stage category of initialization code (contribute to order)
-	 * @param {number} position position in the category (contribute to order)
-	 * @param {InitFragmentKey=} key unique key to avoid emitting the same initialization code twice
-	 * @param {string | Source=} endContent the source code that will be included at the end of the module
-	 */
-	constructor(content, stage, position, key, endContent) {
-		/** @type {string | Source | undefined} */
-		this.content = content;
-		/** @type {number} */
-		this.stage = stage;
-		/** @type {number} */
-		this.position = position;
-		/** @type {string | undefined} */
-		this.key = key;
-		/** @type {string | Source | undefined} */
-		this.endContent = endContent;
-	}
-
-	/**
-	 * Returns the source code that will be included as initialization code.
-	 * @param {GenerateContext} context context
-	 * @returns {string | Source | undefined} the source code that will be included as initialization code
-	 */
-	getContent(context) {
-		return this.content;
-	}
-
-	/**
-	 * Returns the source code that will be included at the end of the module.
-	 * @param {GenerateContext} context context
-	 * @returns {string | Source | undefined} the source code that will be included at the end of the module
-	 */
-	getEndContent(context) {
-		return this.endContent;
-	}
-
-	/**
-	 * Adds the provided source to the init fragment.
-	 * @template Context
-	 * @param {Source} source sources
-	 * @param {MaybeMergeableInitFragment<Context>[]} initFragments init fragments
-	 * @param {Context} context context
-	 * @returns {Source} source
-	 */
-	static addToSource(source, initFragments, context) {
-		if (initFragments.length > 0) {
-			// Sort fragment indices by (stage, position), falling back to the
-			// original index — one flat number array instead of N [fragment, index]
-			// tuples for a stable-by-index order.
-			const sortedIndices = initFragments.map((_, index) => index);
-			sortedIndices.sort((a, b) => {
-				const fragmentA = initFragments[a];
-				const fragmentB = initFragments[b];
-				const stageCmp = fragmentA.stage - fragmentB.stage;
-				if (stageCmp !== 0) return stageCmp;
-				const positionCmp = fragmentA.position - fragmentB.position;
-				if (positionCmp !== 0) return positionCmp;
-				return a - b;
-			});
-
-			// Deduplicate fragments. If a fragment has no key, it is always included.
-			// Keyless fragments get a unique numeric key; number keys never collide
-			// with the string `InitFragmentKey`s used for keyed fragments.
-			/** @type {Map<InitFragmentKey | number, MaybeMergeableInitFragment<Context> | MaybeMergeableInitFragment<Context>[]>} */
-			const keyedFragments = new Map();
-			let keylessKey = 0;
-			for (const index of sortedIndices) {
-				const fragment = initFragments[index];
-				if (typeof fragment.mergeAll === "function") {
-					if (!fragment.key) {
-						throw new Error(
-							`InitFragment with mergeAll function must have a valid key: ${fragment.constructor.name}`
-						);
-					}
-					const oldValue = keyedFragments.get(fragment.key);
-					if (oldValue === undefined) {
-						keyedFragments.set(fragment.key, fragment);
-					} else if (Array.isArray(oldValue)) {
-						oldValue.push(fragment);
-					} else {
-						keyedFragments.set(fragment.key, [oldValue, fragment]);
-					}
-					continue;
-				} else if (typeof fragment.merge === "function") {
-					const key = /** @type {InitFragmentKey} */ (fragment.key);
-					const oldValue =
-						/** @type {MaybeMergeableInitFragment<Context>} */
-						(keyedFragments.get(key));
-					if (oldValue !== undefined) {
-						keyedFragments.set(key, fragment.merge(oldValue));
-						continue;
-					}
-				}
-				keyedFragments.set(fragment.key || keylessKey++, fragment);
-			}
-
-			const concatSource = new ConcatSource();
-			/** @type {(string | Source)[]} */
-			const endContents = [];
-			for (let fragment of keyedFragments.values()) {
-				if (Array.isArray(fragment)) {
-					fragment =
-						/** @type {[MaybeMergeableInitFragment<Context> & { mergeAll: (fragments: MaybeMergeableInitFragment<Context>[]) => MaybeMergeableInitFragment<Context>[] }, ...MaybeMergeableInitFragment<Context>[]]} */
-						(fragment)[0].mergeAll(fragment);
-				}
-				const content =
-					/** @type {MaybeMergeableInitFragment<Context>} */
-					(fragment).getContent(context);
-				if (content) {
-					concatSource.add(content);
-				}
-				const endContent =
-					/** @type {MaybeMergeableInitFragment<Context>} */
-					(fragment).getEndContent(context);
-				if (endContent) {
-					endContents.push(endContent);
-				}
-			}
-
-			concatSource.add(source);
-			for (const content of endContents.reverse()) {
-				concatSource.add(content);
-			}
-			return concatSource;
-		}
-		return source;
-	}
-
-	/**
-	 * Serializes this instance into the provided serializer context.
-	 * @param {ObjectSerializerContext} context context
-	 */
-	serialize(context) {
-		const { write } = context;
-
-		write(this.content);
-		write(this.stage);
-		write(this.position);
-		write(this.key);
-		write(this.endContent);
-	}
-
-	/**
-	 * Restores this instance from the provided deserializer context.
-	 * @param {ObjectDeserializerContext} context context
-	 */
-	deserialize(context) {
-		const { read } = context;
-
-		this.content = read();
-		this.stage = read();
-		this.position = read();
-		this.key = read();
-		this.endContent = read();
-	}
-}
-
-makeSerializable(InitFragment, "webpack/lib/InitFragment");
-
-InitFragment.STAGE_CONSTANTS = 10;
-InitFragment.STAGE_ASYNC_BOUNDARY = 20;
-InitFragment.STAGE_HARMONY_EXPORTS = 30;
-InitFragment.STAGE_HARMONY_IMPORTS = 40;
-InitFragment.STAGE_PROVIDES = 50;
-InitFragment.STAGE_ASYNC_DEPENDENCIES = 60;
-InitFragment.STAGE_ASYNC_HARMONY_IMPORTS = 70;
-
-module.exports = InitFragment;
+// TODO in the next major release: remove
+// Some old plugins use `require("webpack/lib/InitFragment")`, in the next major release developer should migrate to `compiler.webpack.InitFragment`
+module.exports = require("./template/InitFragment");

package/lib/LibraryTemplatePlugin.js

@@ -5,49 +5,6 @@
 
 "use strict";
 
-const EnableLibraryPlugin = require("./library/EnableLibraryPlugin");
-
-/**
- * @import {
- * 	AuxiliaryComment,
- * 	LibraryExport,
- * 	LibraryName,
- * 	LibraryType,
- * 	UmdNamedDefine
- * } from "../declarations/WebpackOptions"
- */
-/** @import Compiler from "./Compiler" */
-
-// TODO webpack 6 remove
-class LibraryTemplatePlugin {
-	/**
-	 * Creates an instance of LibraryTemplatePlugin.
-	 * @param {LibraryName} name name of library
-	 * @param {LibraryType} target type of library
-	 * @param {UmdNamedDefine} umdNamedDefine setting this to true will name the UMD module
-	 * @param {AuxiliaryComment} auxiliaryComment comment in the UMD wrapper
-	 * @param {LibraryExport} exportProperty which export should be exposed as library
-	 */
-	constructor(name, target, umdNamedDefine, auxiliaryComment, exportProperty) {
-		this.library = {
-			type: target || "var",
-			name,
-			umdNamedDefine,
-			auxiliaryComment,
-			export: exportProperty
-		};
-	}
-
-	/**
-	 * Applies the plugin by registering its hooks on the compiler.
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { output } = compiler.options;
-		output.library = this.library;
-		new EnableLibraryPlugin(this.library.type).apply(compiler);
-	}
-}
-
-module.exports = LibraryTemplatePlugin;
+// TODO in the next major release: remove
+// Some old plugins use `require("webpack/lib/LibraryTemplatePlugin")`, in the next major release developer should migrate to `compiler.webpack.LibraryTemplatePlugin`
+module.exports = require("./library/LibraryTemplatePlugin");

package/lib/ModuleFilenameHelpers.js

@@ -5,403 +5,6 @@
 
 "use strict";
 
-const NormalModule = require("./NormalModule");
-const { DEFAULTS } = require("./config/defaults");
-const createHash = require("./util/createHash");
-const memoize = require("./util/memoize");
-
-/** @import { HashFunction } from "../declarations/WebpackOptions" */
-/** @import ChunkGraph from "./ChunkGraph" */
-/** @import Module from "./Module" */
-/** @import RequestShortener from "./RequestShortener" */
-
-/** @typedef {(str: string) => boolean} MatcherFn */
-/** @typedef {string | RegExp | MatcherFn | (string | RegExp | MatcherFn)[]} Matcher */
-/** @typedef {{ test?: Matcher, include?: Matcher, exclude?: Matcher }} MatchObject */
-
-const ModuleFilenameHelpers = module.exports;
-
-ModuleFilenameHelpers.DEFAULT_MODULE_FILENAME_TEMPLATE =
-	"webpack://[namespace]/[resourcePath]";
-ModuleFilenameHelpers.DEFAULT_FALLBACK_MODULE_FILENAME_TEMPLATE =
-	"webpack://[namespace]/[resourcePath]?[hash]";
-
-// TODO webpack 6: consider removing these
-ModuleFilenameHelpers.ALL_LOADERS_RESOURCE = "[all-loaders][resource]";
-ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE =
-	/\[all-?loaders\]\[resource\]/gi;
-ModuleFilenameHelpers.LOADERS_RESOURCE = "[loaders][resource]";
-ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE = /\[loaders\]\[resource\]/gi;
-ModuleFilenameHelpers.RESOURCE = "[resource]";
-ModuleFilenameHelpers.REGEXP_RESOURCE = /\[resource\]/gi;
-ModuleFilenameHelpers.ABSOLUTE_RESOURCE_PATH = "[absolute-resource-path]";
-// cSpell:words olute
-ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH =
-	/\[abs(olute)?-?resource-?path\]/gi;
-ModuleFilenameHelpers.RESOURCE_PATH = "[resource-path]";
-ModuleFilenameHelpers.REGEXP_RESOURCE_PATH = /\[resource-?path\]/gi;
-ModuleFilenameHelpers.ALL_LOADERS = "[all-loaders]";
-ModuleFilenameHelpers.REGEXP_ALL_LOADERS = /\[all-?loaders\]/gi;
-ModuleFilenameHelpers.LOADERS = "[loaders]";
-ModuleFilenameHelpers.REGEXP_LOADERS = /\[loaders\]/gi;
-ModuleFilenameHelpers.QUERY = "[query]";
-ModuleFilenameHelpers.REGEXP_QUERY = /\[query\]/gi;
-ModuleFilenameHelpers.ID = "[id]";
-ModuleFilenameHelpers.REGEXP_ID = /\[id\]/gi;
-ModuleFilenameHelpers.HASH = "[hash]";
-ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi;
-ModuleFilenameHelpers.NAMESPACE = "[namespace]";
-ModuleFilenameHelpers.REGEXP_NAMESPACE = /\[namespace\]/gi;
-
-/** @typedef {() => string} ReturnStringCallback */
-
-/**
- * Returns a function that returns the part of the string after the token
- * @param {ReturnStringCallback} strFn the function to get the string
- * @param {string} token the token to search for
- * @returns {ReturnStringCallback} a function that returns the part of the string after the token
- */
-const getAfter = (strFn, token) => () => {
-	const str = strFn();
-	const idx = str.indexOf(token);
-	return idx < 0 ? "" : str.slice(idx);
-};
-
-/**
- * Returns a function that returns the part of the string before the token
- * @param {ReturnStringCallback} strFn the function to get the string
- * @param {string} token the token to search for
- * @returns {ReturnStringCallback} a function that returns the part of the string before the token
- */
-const getBefore = (strFn, token) => () => {
-	const str = strFn();
-	const idx = str.lastIndexOf(token);
-	return idx < 0 ? "" : str.slice(0, idx);
-};
-
-/**
- * Returns a function that returns a hash of the string
- * @param {ReturnStringCallback} strFn the function to get the string
- * @param {HashFunction=} hashFunction the hash function to use
- * @returns {ReturnStringCallback} a function that returns the hash of the string
- */
-const getHash =
-	(strFn, hashFunction = DEFAULTS.HASH_FUNCTION) =>
-	() => {
-		const hash = createHash(hashFunction);
-		hash.update(strFn());
-		const digest = hash.digest("hex");
-		return digest.slice(0, 4);
-	};
-
-/**
- * Returns the lazy access object.
- * @template T
- * Returns a lazy object. The object is lazy in the sense that the properties are
- * only evaluated when they are accessed. This is only obtained by setting a function as the value for each key.
- * @param {Record<string, () => T>} obj the object to convert to a lazy access object
- * @returns {Record<string, T>} the lazy access object
- */
-const lazyObject = (obj) => {
-	const newObj = /** @type {Record<string, T>} */ ({});
-	for (const key of Object.keys(obj)) {
-		const fn = obj[key];
-		Object.defineProperty(newObj, key, {
-			get: () => fn(),
-			set: (v) => {
-				Object.defineProperty(newObj, key, {
-					value: v,
-					enumerable: true,
-					writable: true
-				});
-			},
-			enumerable: true,
-			configurable: true
-		});
-	}
-	return newObj;
-};
-
-const SQUARE_BRACKET_TAG_REGEXP = /\[\\*([\w-]+)\\*\]/g;
-/**
- * Defines the module filename template context type used by this module.
- * @typedef {object} ModuleFilenameTemplateContext
- * @property {string} identifier the identifier of the module
- * @property {string} shortIdentifier the shortened identifier of the module
- * @property {string} resource the resource of the module request
- * @property {string} resourcePath the resource path of the module request
- * @property {string} absoluteResourcePath the absolute resource path of the module request
- * @property {string} loaders the loaders of the module request
- * @property {string} allLoaders the all loaders of the module request
- * @property {string} query the query of the module identifier
- * @property {string} moduleId the module id of the module
- * @property {string} hash the hash of the module identifier
- * @property {string} namespace the module namespace
- */
-/** @typedef {((context: ModuleFilenameTemplateContext) => string)} ModuleFilenameTemplateFunction */
-/** @typedef {string | ModuleFilenameTemplateFunction} ModuleFilenameTemplate */
-
-/**
- * Returns the filename.
- * @param {Module | string} module the module
- * @param {{ namespace?: string, moduleFilenameTemplate?: ModuleFilenameTemplate }} options options
- * @param {{ requestShortener: RequestShortener, chunkGraph: ChunkGraph, hashFunction?: HashFunction }} contextInfo context info
- * @returns {string} the filename
- */
-ModuleFilenameHelpers.createFilename = (
-	// eslint-disable-next-line default-param-last
-	module = "",
-	options,
-	{ requestShortener, chunkGraph, hashFunction = DEFAULTS.HASH_FUNCTION }
-) => {
-	const opts = {
-		namespace: "",
-		moduleFilenameTemplate: "",
-		...(typeof options === "object"
-			? options
-			: {
-					moduleFilenameTemplate: options
-				})
-	};
-
-	/** @type {ReturnStringCallback} */
-	let absoluteResourcePath;
-	/** @type {ReturnStringCallback} */
-	let hash;
-	/** @type {ReturnStringCallback} */
-	let identifier;
-	/** @type {ReturnStringCallback} */
-	let moduleId;
-	/** @type {ReturnStringCallback} */
-	let shortIdentifier;
-	/** @type {ReturnStringCallback} */
-	let resourceIdentifier;
-	if (typeof module === "string") {
-		shortIdentifier =
-			/** @type {ReturnStringCallback} */
-			(memoize(() => requestShortener.shorten(module)));
-		identifier = shortIdentifier;
-		resourceIdentifier = shortIdentifier;
-		moduleId = () => "";
-		absoluteResourcePath = () =>
-			/** @type {string} */ (module.split("!").pop());
-		hash = getHash(identifier, hashFunction);
-	} else {
-		shortIdentifier = memoize(() =>
-			module.readableIdentifier(requestShortener)
-		);
-		// `[resource]` and `[loaders]` must stay request paths: a subclass's
-		// readable identifier may carry display-only decorations (e.g. CssModule's
-		// `css ` prefix)
-		resourceIdentifier = memoize(() =>
-			module instanceof NormalModule
-				? /** @type {string} */ (requestShortener.shorten(module.userRequest))
-				: module.readableIdentifier(requestShortener)
-		);
-		identifier =
-			/** @type {ReturnStringCallback} */
-			(memoize(() => requestShortener.shorten(module.identifier())));
-		moduleId =
-			/** @type {ReturnStringCallback} */
-			(() => chunkGraph.getModuleId(module));
-		absoluteResourcePath = () =>
-			module instanceof NormalModule
-				? module.resource
-				: /** @type {string} */ (module.identifier().split("!").pop());
-		hash = getHash(identifier, hashFunction);
-	}
-	const resource =
-		/** @type {ReturnStringCallback} */
-		(memoize(() => resourceIdentifier().split("!").pop()));
-
-	const loaders = getBefore(resourceIdentifier, "!");
-	const allLoaders = getBefore(identifier, "!");
-	const query = getAfter(resource, "?");
-	const resourcePath = () => {
-		const q = query().length;
-		return q === 0 ? resource() : resource().slice(0, -q);
-	};
-	if (typeof opts.moduleFilenameTemplate === "function") {
-		return opts.moduleFilenameTemplate(
-			/** @type {ModuleFilenameTemplateContext} */
-			(
-				lazyObject({
-					identifier,
-					shortIdentifier,
-					resource,
-					resourcePath: memoize(resourcePath),
-					absoluteResourcePath: memoize(absoluteResourcePath),
-					loaders: memoize(loaders),
-					allLoaders: memoize(allLoaders),
-					query: memoize(query),
-					moduleId: memoize(moduleId),
-					hash: memoize(hash),
-					namespace: () => opts.namespace
-				})
-			)
-		);
-	}
-
-	// TODO webpack 6: consider removing alternatives without dashes
-	/** @type {Map<string, () => string>} */
-	const replacements = new Map([
-		["identifier", identifier],
-		["short-identifier", shortIdentifier],
-		["resource", resource],
-		["resource-path", resourcePath],
-		// cSpell:words resourcepath
-		["resourcepath", resourcePath],
-		["absolute-resource-path", absoluteResourcePath],
-		["abs-resource-path", absoluteResourcePath],
-		// cSpell:words absoluteresource
-		["absoluteresource-path", absoluteResourcePath],
-		// cSpell:words absresource
-		["absresource-path", absoluteResourcePath],
-		// cSpell:words resourcepath
-		["absolute-resourcepath", absoluteResourcePath],
-		// cSpell:words resourcepath
-		["abs-resourcepath", absoluteResourcePath],
-		// cSpell:words absoluteresourcepath
-		["absoluteresourcepath", absoluteResourcePath],
-		// cSpell:words absresourcepath
-		["absresourcepath", absoluteResourcePath],
-		["all-loaders", allLoaders],
-		// cSpell:words allloaders
-		["allloaders", allLoaders],
-		["loaders", loaders],
-		["query", query],
-		["id", moduleId],
-		["hash", hash],
-		["namespace", () => opts.namespace]
-	]);
-
-	// TODO webpack 6: consider removing weird double placeholders
-	return /** @type {string} */ (opts.moduleFilenameTemplate)
-		.replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE, "[identifier]")
-		.replace(
-			ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE,
-			"[short-identifier]"
-		)
-		.replace(SQUARE_BRACKET_TAG_REGEXP, (match, content) => {
-			if (content.length + 2 === match.length) {
-				const replacement = replacements.get(content.toLowerCase());
-				if (replacement !== undefined) {
-					return replacement();
-				}
-			} else if (match.startsWith("[\\") && match.endsWith("\\]")) {
-				return `[${match.slice(2, -2)}]`;
-			}
-			return match;
-		});
-};
-
-/**
- * Replaces duplicate items in an array with new values generated by a callback function.
- * The callback function is called with the duplicate item, the index of the duplicate item, and the number of times the item has been replaced.
- * The callback function should return the new value for the duplicate item.
- * @template T
- * @param {T[]} array the array with duplicates to be replaced
- * @param {(duplicateItem: T, duplicateItemIndex: number, numberOfTimesReplaced: number) => T} fn callback function to generate new values for the duplicate items
- * @param {(firstElement: T, nextElement: T) => -1 | 0 | 1=} comparator optional comparator function to sort the duplicate items
- * @returns {T[]} the array with duplicates replaced
- * @example
- * ```js
- * const array = ["a", "b", "c", "a", "b", "a"];
- * const result = ModuleFilenameHelpers.replaceDuplicates(array, (item, index, count) => `${item}-${count}`);
- * // result: ["a-1", "b-1", "c", "a-2", "b-2", "a-3"]
- * ```
- */
-ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => {
-	const countMap = Object.create(null);
-	const posMap = Object.create(null);
-
-	for (const [idx, item] of array.entries()) {
-		countMap[item] = countMap[item] || [];
-		countMap[item].push(idx);
-		posMap[item] = 0;
-	}
-	if (comparator) {
-		for (const item of Object.keys(countMap)) {
-			countMap[item].sort(comparator);
-		}
-	}
-	return array.map((item, i) => {
-		if (countMap[item].length > 1) {
-			if (comparator && countMap[item][0] === i) return item;
-			return fn(item, i, posMap[item]++);
-		}
-		return item;
-	});
-};
-
-/**
- * Tests if a string matches a RegExp or an array of RegExp.
- * @param {string} str string to test
- * @param {Matcher} test value which will be used to match against the string
- * @returns {boolean} true, when the RegExp matches
- * @example
- * ```js
- * ModuleFilenameHelpers.matchPart("foo.js", "foo"); // true
- * ModuleFilenameHelpers.matchPart("foo.js", "foo.js"); // true
- * ModuleFilenameHelpers.matchPart("foo.js", "foo."); // true
- * ModuleFilenameHelpers.matchPart("foo.js", "foo*"); // false
- * ModuleFilenameHelpers.matchPart("foo.js", "foo.*"); // false
- * ModuleFilenameHelpers.matchPart("foo.js", /^foo/); // true
- * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, "bar"]); // true
- * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, "bar"]); // true
- * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, /^bar/]); // true
- * ModuleFilenameHelpers.matchPart("foo.js", [/^baz/, /^bar/]); // false
- * ```
- */
-const matchPart = (str, test) => {
-	if (!test) return true;
-	if (test instanceof RegExp) {
-		return test.test(str);
-	} else if (typeof test === "string") {
-		return str.startsWith(test);
-	} else if (typeof test === "function") {
-		return test(str);
-	}
-
-	return test.some((test) => matchPart(str, test));
-};
-
-ModuleFilenameHelpers.matchPart = matchPart;
-
-/**
- * Tests if a string matches a match object. The match object can have the following properties:
- * - `test`: a RegExp or an array of RegExp
- * - `include`: a RegExp or an array of RegExp
- * - `exclude`: a RegExp or an array of RegExp
- *
- * The `test` property is tested first, then `include` and then `exclude`.
- * @param {MatchObject} obj a match object to test against the string
- * @param {string} str string to test against the matching object
- * @returns {boolean} true, when the object matches
- * @example
- * ```js
- * ModuleFilenameHelpers.matchObject({ test: "foo.js" }, "foo.js"); // true
- * ModuleFilenameHelpers.matchObject({ test: /^foo/ }, "foo.js"); // true
- * ModuleFilenameHelpers.matchObject({ test: [/^foo/, "bar"] }, "foo.js"); // true
- * ModuleFilenameHelpers.matchObject({ test: [/^foo/, "bar"] }, "baz.js"); // false
- * ModuleFilenameHelpers.matchObject({ include: "foo.js" }, "foo.js"); // true
- * ModuleFilenameHelpers.matchObject({ include: "foo.js" }, "bar.js"); // false
- * ModuleFilenameHelpers.matchObject({ include: /^foo/ }, "foo.js"); // true
- * ModuleFilenameHelpers.matchObject({ include: [/^foo/, "bar"] }, "foo.js"); // true
- * ModuleFilenameHelpers.matchObject({ include: [/^foo/, "bar"] }, "baz.js"); // false
- * ModuleFilenameHelpers.matchObject({ exclude: "foo.js" }, "foo.js"); // false
- * ModuleFilenameHelpers.matchObject({ exclude: [/^foo/, "bar"] }, "foo.js"); // false
- * ```
- */
-ModuleFilenameHelpers.matchObject = (obj, str) => {
-	if (obj.test && !ModuleFilenameHelpers.matchPart(str, obj.test)) {
-		return false;
-	}
-	if (obj.include && !ModuleFilenameHelpers.matchPart(str, obj.include)) {
-		return false;
-	}
-	if (obj.exclude && ModuleFilenameHelpers.matchPart(str, obj.exclude)) {
-		return false;
-	}
-	return true;
-};
+// TODO in the next major release: remove
+// Some old plugins use `require("webpack/lib/ModuleFilenameHelpers")`, in the next major release developer should migrate to `compiler.webpack.ModuleFilenameHelpers`
+module.exports = require("./devtool/ModuleFilenameHelpers");

package/lib/ModuleNotFoundError.js

@@ -5,6 +5,6 @@
 
 "use strict";
 
-// TODO remove in webpack 6
-// Some old plugins use `require("webpack/lib/ModuleNotFoundError")`, in webpack@6 developer should migrate to `compiler.webpack.ModuleNotFoundError`
+// TODO in the next major release: remove
+// Some old plugins use `require("webpack/lib/ModuleNotFoundError")`, in the next major release developer should migrate to `compiler.webpack.ModuleNotFoundError`
 module.exports = require("./errors/ModuleNotFoundError");