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

package/lib/devtool/ModuleFilenameHelpers.js

@@ -0,0 +1,413 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { DEFAULTS } = require("../config/defaults");
+const createHash = require("../util/createHash");
+const memoize = require("../util/memoize");
+
+const getMatchGlobCondition = memoize(
+	() => require("../util/globUtils").matchGlobCondition
+);
+
+/** @import { HashFunction } from "../../declarations/WebpackOptions" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
+/** @import Module from "../module/Module" */
+/** @import RequestShortener from "../util/RequestShortener" */
+
+/** @typedef {(str: string) => boolean} MatcherFn */
+/** @typedef {import("../util/globUtils").GlobCondition} GlobCondition */
+/** @typedef {string | RegExp | MatcherFn | GlobCondition | (string | RegExp | MatcherFn | GlobCondition)[]} 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 in the next major release: 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.is("normal")
+				? /** @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.is("normal")
+				? 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 in the next major release: 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 in the next major release: 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);
+	} else if (!Array.isArray(test)) {
+		return getMatchGlobCondition()(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;
+};

package/lib/{SourceMapDevToolModuleOptionsPlugin.js → devtool/SourceMapDevToolModuleOptionsPlugin.js}

@@ -5,14 +5,14 @@
 
 "use strict";
 
-const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
+const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
 
 /**
  * @import {
  * 	SourceMapDevToolPluginOptions
- * } from "../declarations/plugins/SourceMapDevToolPlugin"
+ * } from "./SourceMapDevToolPlugin"
  */
-/** @import Compilation from "./Compilation" */
+/** @import Compilation from "../Compilation" */
 
 const PLUGIN_NAME = "SourceMapDevToolModuleOptionsPlugin";
 
@@ -33,6 +33,13 @@ class SourceMapDevToolModuleOptionsPlugin {
 	 */
 	apply(compilation) {
 		const options = this.options;
+		if (options.scopes) {
+			const { dependencyTemplates } = compilation;
+			dependencyTemplates.importBindingScopes = true;
+			// Code generation cached by a build without scopes carries no binding
+			// expressions, and nothing else in its key says the devtool changed.
+			dependencyTemplates.updateHash("source-map-scopes");
+		}
 		if (options.module !== false) {
 			compilation.hooks.buildModule.tap(PLUGIN_NAME, (module) => {
 				module.useSourceMap = true;

package/lib/{SourceMapDevToolPlugin.js → devtool/SourceMapDevToolPlugin.js}

@@ -5,17 +5,17 @@
 
 "use strict";
 
-const { ConcatSource, RawSource } = require("webpack-sources");
-const Compilation = require("./Compilation");
+const { ConcatSource, RawSource, util } = require("webpack-sources");
+const Compilation = require("../Compilation");
+const { dirname, relative } = require("../fs/fs");
+const ProgressPlugin = require("../logging/ProgressPlugin");
+const { getPresentKinds } = require("../template/TemplatedPathPlugin");
+const asyncLib = require("../util/async");
+const createHash = require("../util/createHash");
+const { makePathsAbsolute } = require("../util/identifier");
 const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
-const ProgressPlugin = require("./ProgressPlugin");
 const SourceMapDevToolModuleOptionsPlugin = require("./SourceMapDevToolModuleOptionsPlugin");
-const { getPresentKinds } = require("./TemplatedPathPlugin");
-const asyncLib = require("./util/async");
-const createHash = require("./util/createHash");
-const { dirname, relative } = require("./util/fs");
-const generateDebugId = require("./util/generateDebugId");
-const { makePathsAbsolute } = require("./util/identifier");
+const generateDebugId = require("./generateDebugId");
 
 /** @import { MapOptions, Source, RawSourceMap } from "webpack-sources" */
 /**
@@ -23,25 +23,122 @@ const { makePathsAbsolute } = require("./util/identifier");
  * 	DevtoolNamespace,
  * 	DevtoolModuleFilenameTemplate,
  * 	DevtoolFallbackModuleFilenameTemplate
- * } from "../declarations/WebpackOptions"
+ * } from "../../declarations/WebpackOptions"
  */
+/** @import { ItemCacheFacade } from "../cache/CacheFacade" */
+/** @import Chunk from "../graph/Chunk" */
+/** @import { Asset, AssetInfo } from "../Compilation" */
+/** @import Compiler from "../Compiler" */
+/** @import Module from "../module/Module" */
 /**
  * @import {
- * 	SourceMapDevToolPluginOptions,
- * 	Rules
- * } from "../declarations/plugins/SourceMapDevToolPlugin"
+ * 	TemplatePath as SourceMappingURLComment
+ * } from "../template/TemplatedPathPlugin"
  */
-/** @import { ItemCacheFacade } from "./CacheFacade" */
-/** @import Chunk from "./Chunk" */
-/** @import { Asset, AssetInfo } from "./Compilation" */
-/** @import Compiler from "./Compiler" */
-/** @import Module from "./Module" */
+/** @import { OutputFileSystem } from "../fs/fs" */
+
 /**
- * @import {
- * 	TemplatePath as SourceMappingURLComment
- * } from "./TemplatedPathPlugin"
+ * @inline
+ * @minLength 1
+ * @absolutePath false
+ * @typedef {string} NonEmptyRelativePath
+ */
+
+/**
+ * @inline
+ * @minLength 1
+ * @typedef {string} NonEmptyString
+ */
+
+/**
+ * A rule condition.
+ * @inline
+ * @typedef {Rule} RulesBranch1Item
+ */
+
+/**
+ * Append no SourceMap comment to the bundle, but still generate SourceMaps.
+ * @inline
+ * @typedef {(false | null)} SourceMapDevToolPluginOptionsAppendBranch1
+ */
+
+/**
+ * Custom function generating the identifier.
+ * @inline
+ * @typedef {import("./ModuleFilenameHelpers").ModuleFilenameTemplateFunction} SourceMapDevToolPluginOptionsFallbackModuleFilenameTemplateBranch2
+ */
+
+/**
+ * Disable separate SourceMap file and inline SourceMap as DataUrl.
+ * @inline
+ * @typedef {(false | null)} SourceMapDevToolPluginOptionsFilenameBranch1
+ */
+
+/**
+ * Custom function generating the identifier.
+ * @inline
+ * @typedef {import("./ModuleFilenameHelpers").ModuleFilenameTemplateFunction} SourceMapDevToolPluginOptionsModuleFilenameTemplateBranch2
+ */
+
+/**
+ * A glob pattern.
+ * @inline
+ * @minLength 1
+ * @typedef {string} RuleGlobPattern
+ */
+
+/**
+ * @minItems 1
+ * @inline
+ * @typedef {RuleGlobPattern[]} RuleGlobList
+ */
+
+/**
+ * Glob patterns matched against the file name, `!` in front of a pattern excludes it, and a relative pattern matches at any depth.
+ * @since 5.112.0
+ * @inline
+ * @typedef {object} RuleGlob
+ * @property {RuleGlobList | NonEmptyString} glob Glob patterns to match.
+ */
+
+/**
+ * Condition used to match resource (string, RegExp or Function).
+ * @typedef {RegExp | NonEmptyString | RuleGlob | import("./ModuleFilenameHelpers").MatcherFn} Rule
+ */
+
+/**
+ * One or multiple conditions used to match resource.
+ * @typedef {RulesBranch1Item[] | Rule} Rules
+ */
+
+/**
+ * Emit the 'scopes' field, which tells a debugger the generated expression each imported ESM binding reads, so it resolves under the name the source uses.
+ * @since 5.112.0
+ * @inline
+ * @typedef {boolean} SourceMapDevToolPluginOptionsScopes
+ */
+
+/**
+ * @schema plugins/SourceMapDevToolPlugin
+ * @typedef {object} SourceMapDevToolPluginOptions
+ * @property {SourceMapDevToolPluginOptionsAppendBranch1 | NonEmptyString | import("../template/TemplatedPathPlugin").TemplatePathFn=} append Appends the given value to the original asset. Usually the #sourceMappingURL comment. [url] is replaced with a URL to the source map file. false disables the appending.
+ * @property {boolean=} columns Indicates whether column mappings should be used (defaults to true).
+ * @property {boolean=} debugIds Emit debug IDs into source and SourceMap.
+ * @property {Rules=} exclude Exclude modules that match the given value from source map generation.
+ * @property {NonEmptyString | SourceMapDevToolPluginOptionsFallbackModuleFilenameTemplateBranch2=} fallbackModuleFilenameTemplate Generator string or function to create identifiers of modules for the 'sources' array in the SourceMap used only if 'moduleFilenameTemplate' would result in a conflict.
+ * @property {string=} fileContext Path prefix to which the [file] placeholder is relative to.
+ * @property {SourceMapDevToolPluginOptionsFilenameBranch1 | NonEmptyRelativePath=} filename Defines the output filename of the SourceMap (will be inlined if no value is provided).
+ * @property {Rules=} ignoreList Decide whether to ignore source files that match the specified value in the SourceMap.
+ * @property {Rules=} include Include source maps for module paths that match the given value.
+ * @property {boolean=} module Indicates whether SourceMaps from loaders should be used (defaults to true).
+ * @property {NonEmptyString | SourceMapDevToolPluginOptionsModuleFilenameTemplateBranch2=} moduleFilenameTemplate Generator string or function to create identifiers of modules for the 'sources' array in the SourceMap.
+ * @property {string=} namespace Namespace prefix to allow multiple webpack roots in the devtools.
+ * @property {boolean=} noSources Omit the 'sourceContents' array from the SourceMap.
+ * @property {string=} publicPath Provide a custom public path for the SourceMapping comment.
+ * @property {SourceMapDevToolPluginOptionsScopes=} scopes
+ * @property {string=} sourceRoot Provide a custom value for the 'sourceRoot' property in the SourceMap.
+ * @property {Rules=} test Include source maps for modules based on their extension (defaults to .js and .css).
  */
-/** @import { OutputFileSystem } from "./util/fs" */
 
 /**
  * Defines the source map task type used by this module.
@@ -210,6 +307,10 @@ const getTaskForFile = (
 
 const PLUGIN_NAME = "SourceMapDevToolPlugin";
 
+/** @typedef {SourceMapDevToolPluginOptions["filename"] | SourceMapDevToolPluginOptions["append"] | Rules | DevtoolModuleFilenameTemplate | DevtoolFallbackModuleFilenameTemplate | DevtoolNamespace} CacheKeyOption */
+/** @typedef {CacheKeyValue[]} CacheKeyValues */
+/** @typedef {string | false | null | undefined | RuleGlob | CacheKeyValues} CacheKeyValue */
+
 /**
  * Maps a configuration value (string, RegExp, function, nullish, or array of
  * such) into a JSON-serializable form. Functions and RegExps are turned into
@@ -221,8 +322,8 @@ const PLUGIN_NAME = "SourceMapDevToolPlugin";
  * we deliberately avoid any homemade `|` / `,` separators that could collide
  * with characters appearing inside user-provided values such as `publicPath`,
  * template strings, or `sourceRoot`.
- * @param {EXPECTED_ANY} value option value
- * @returns {EXPECTED_ANY} JSON-serializable representation
+ * @param {CacheKeyOption} value option value
+ * @returns {CacheKeyValue} JSON-serializable representation
  */
 const toCacheKeyValue = (value) => {
 	if (value === undefined || value === null) return value;
@@ -274,6 +375,7 @@ class SourceMapDevToolPlugin {
 			options.columns !== false,
 			Boolean(options.noSources),
 			Boolean(options.debugIds),
+			Boolean(options.scopes),
 			options.sourceRoot || "",
 			toCacheKeyValue(options.ignoreList),
 			options.publicPath || "",
@@ -289,14 +391,14 @@ class SourceMapDevToolPlugin {
 	apply(compiler) {
 		compiler.hooks.validate.tap(PLUGIN_NAME, () => {
 			compiler.validate(
-				() => require("../schemas/plugins/SourceMapDevToolPlugin.json"),
+				() => require("../../schemas/plugins/SourceMapDevToolPlugin.json"),
 				this.options,
 				{
 					name: "SourceMap DevTool Plugin",
 					baseDataPath: "options"
 				},
 				(options) =>
-					require("../schemas/plugins/SourceMapDevToolPlugin.check")(options)
+					require("../../schemas/plugins/SourceMapDevToolPlugin.check")(options)
 			);
 		});
 
@@ -722,6 +824,32 @@ class SourceMapDevToolPlugin {
 									if (debugIdValue !== undefined) {
 										outputSourceMap.debugId = debugIdValue;
 									}
+									const { codeGenerationResults } = compilation;
+									if (options.scopes && codeGenerationResults) {
+										// The spread above shares `names` with a map a
+										// `SourceMapSource` may hold, and encoding appends to it.
+										outputSourceMap.names = sourceMap.names
+											? [...sourceMap.names]
+											: [];
+										const runtime = chunk && chunk.runtime;
+										util.scopes.addScopesToSourceMap(
+											outputSourceMap,
+											(sourceIndex) => {
+												const module = modules[sourceIndex];
+												if (
+													typeof module === "string" ||
+													!codeGenerationResults.has(module, runtime)
+												) {
+													return;
+												}
+												return codeGenerationResults.getData(
+													module,
+													runtime,
+													"importBindings"
+												);
+											}
+										);
+									}
 
 									if (sourceMapFilename) {
 										// Hold the serialized map as a `Buffer`, which `RawSource`