webpack 5.91.0 → 5.92.0

package/lib/css/CssGenerator.js

@@ -15,6 +15,8 @@ const { cssExportConvention } = require("../util/conventions");
 /** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
 /** @typedef {import("../../declarations/WebpackOptions").CssGeneratorLocalIdentName} CssGeneratorLocalIdentName */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../DependencyTemplate").CssExportsData} CssExportsData */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../NormalModule")} NormalModule */
@@ -24,15 +26,18 @@ const TYPES = new Set(["css"]);
 
 class CssGenerator extends Generator {
 	/**
-	 * @param {CssGeneratorExportsConvention} convention the convention of the exports name
+	 * @param {CssGeneratorExportsConvention | undefined} convention the convention of the exports name
 	 * @param {CssGeneratorLocalIdentName | undefined} localIdentName css export local ident name
+	 * @param {boolean} esModule whether to use ES modules syntax
 	 */
-	constructor(convention, localIdentName) {
+	constructor(convention, localIdentName, esModule) {
 		super();
-		/** @type {CssGeneratorExportsConvention} */
+		/** @type {CssGeneratorExportsConvention | undefined} */
 		this.convention = convention;
 		/** @type {CssGeneratorLocalIdentName | undefined} */
 		this.localIdentName = localIdentName;
+		/** @type {boolean} */
+		this.esModule = esModule;
 	}
 
 	/**
@@ -45,12 +50,16 @@ class CssGenerator extends Generator {
 		const source = new ReplaceSource(originalSource);
 		/** @type {InitFragment[]} */
 		const initFragments = [];
-		/** @type {Map<string, string>} */
-		const cssExports = new Map();
+		/** @type {CssExportsData} */
+		const cssExportsData = {
+			esModule: this.esModule,
+			exports: new Map()
+		};
 
 		generateContext.runtimeRequirements.add(RuntimeGlobals.hasCssModules);
 
 		let chunkInitFragments;
+		/** @type {DependencyTemplateContext} */
 		const templateContext = {
 			runtimeTemplate: generateContext.runtimeTemplate,
 			dependencyTemplates: generateContext.dependencyTemplates,
@@ -62,7 +71,7 @@ class CssGenerator extends Generator {
 			concatenationScope: generateContext.concatenationScope,
 			codeGenerationResults: generateContext.codeGenerationResults,
 			initFragments,
-			cssExports,
+			cssExportsData,
 			get chunkInitFragments() {
 				if (!chunkInitFragments) {
 					const data = generateContext.getData();
@@ -97,16 +106,17 @@ class CssGenerator extends Generator {
 		if (module.presentationalDependencies !== undefined)
 			module.presentationalDependencies.forEach(handleDependency);
 
-		if (cssExports.size > 0) {
-			const newCssExports = new Map();
-			for (let [name, v] of cssExports) {
+		if (cssExportsData.exports.size > 0) {
+			const newExports = new Map();
+			for (let [name, v] of cssExportsData.exports) {
 				for (let newName of cssExportConvention(name, this.convention)) {
-					newCssExports.set(newName, v);
+					newExports.set(newName, v);
 				}
 			}
-			const data = generateContext.getData();
-			data.set("css-exports", newCssExports);
+			cssExportsData.exports = newExports;
 		}
+		const data = generateContext.getData();
+		data.set("css-exports", cssExportsData);
 
 		return InitFragment.addToSource(source, initFragments, generateContext);
 	}

package/lib/css/CssLoadingRuntimeModule.js

@@ -19,7 +19,7 @@ const { chunkHasCss } = require("./CssModulesPlugin");
 /** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
 /**
- * @typedef {Object} CssLoadingRuntimeModulePluginHooks
+ * @typedef {object} CssLoadingRuntimeModulePluginHooks
  * @property {SyncWaterfallHook<[string, Chunk]>} createStylesheet
  * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
  * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
@@ -224,7 +224,9 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 					withCompression
 						? Template.asString([
 								// LZW decode
-								`var map = {}, char = data[0], oldPhrase = char, decoded = char, code = 256, maxCode = "\uffff".charCodeAt(0), phrase;`,
+								`var map = {}, char = data[0], oldPhrase = char, decoded = char, code = 256, maxCode = ${"\uffff".charCodeAt(
+									0
+								)}, phrase;`,
 								"for (i = 1; i < data.length; i++) {",
 								Template.indent([
 									"cc = data[i].charCodeAt(0);",
@@ -246,11 +248,12 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 						`else if(cc == ${cc(
 							"/"
 						)}) { token = token.replace(/^_/, ""); token2 = token2.replace(/^_/, ""); exports[token2] = token; token = ""; token2 = ""; }`,
+						`else if(cc == ${cc("&")}) { ${
+							RuntimeGlobals.makeNamespaceObject
+						}(exports); }`,
 						`else if(!cc || cc == ${cc(
 							","
-						)}) { token = token.replace(/^_/, ""); ${
-							RuntimeGlobals.makeNamespaceObject
-						}(exports); target[token] = (${runtimeTemplate.basicFunction(
+						)}) { token = token.replace(/^_/, ""); target[token] = (${runtimeTemplate.basicFunction(
 							"exports, module",
 							`module.exports = exports;`
 						)}).bind(null, exports); ${

package/lib/css/CssModulesPlugin.js

@@ -5,7 +5,12 @@
 
 "use strict";
 
-const { ConcatSource, PrefixSource } = require("webpack-sources");
+const {
+	ConcatSource,
+	PrefixSource,
+	ReplaceSource,
+	CachedSource
+} = require("webpack-sources");
 const CssModule = require("../CssModule");
 const HotUpdateChunk = require("../HotUpdateChunk");
 const {
@@ -26,6 +31,7 @@ const StaticExportsDependency = require("../dependencies/StaticExportsDependency
 const { compareModulesByIdentifier } = require("../util/comparators");
 const createSchemaValidation = require("../util/create-schema-validation");
 const createHash = require("../util/createHash");
+const { getUndoPath } = require("../util/identifier");
 const memoize = require("../util/memoize");
 const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
 const CssExportsGenerator = require("./CssExportsGenerator");
@@ -39,6 +45,8 @@ const CssParser = require("./CssParser");
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../CssModule").Inheritance} Inheritance */
+/** @typedef {import("../DependencyTemplate").CssExportsData} CssExportsData */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../util/memoize")} Memoize */
 
@@ -160,6 +168,11 @@ const LZWEncode = str => {
 const plugin = "CssModulesPlugin";
 
 class CssModulesPlugin {
+	constructor() {
+		/** @type {WeakMap<Source, { undoPath: string, inheritance: Inheritance, source: CachedSource }>} */
+		this._moduleCache = new WeakMap();
+	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -219,12 +232,12 @@ class CssModulesPlugin {
 							const { namedExports } = parserOptions;
 
 							switch (type) {
-								case CSS_MODULE_TYPE:
+								case CSS_MODULE_TYPE_GLOBAL:
 								case CSS_MODULE_TYPE_AUTO:
 									return new CssParser({
 										namedExports
 									});
-								case CSS_MODULE_TYPE_GLOBAL:
+								case CSS_MODULE_TYPE:
 									return new CssParser({
 										allowModeSwitch: false,
 										namedExports
@@ -244,11 +257,13 @@ class CssModulesPlugin {
 							return generatorOptions.exportsOnly
 								? new CssExportsGenerator(
 										generatorOptions.exportsConvention,
-										generatorOptions.localIdentName
+										generatorOptions.localIdentName,
+										generatorOptions.esModule
 									)
 								: new CssGenerator(
 										generatorOptions.exportsConvention,
-										generatorOptions.localIdentName
+										generatorOptions.localIdentName,
+										generatorOptions.esModule
 									);
 						});
 					normalModuleFactory.hooks.createModuleClass
@@ -353,6 +368,23 @@ class CssModulesPlugin {
 
 					/** @type {CssModule[] | undefined} */
 					const modules = orderedCssModulesPerChunk.get(chunk);
+					const { path: filename, info } = compilation.getPathWithInfo(
+						CssModulesPlugin.getChunkFilenameTemplate(
+							chunk,
+							compilation.outputOptions
+						),
+						{
+							hash,
+							runtime: chunk.runtime,
+							chunk,
+							contentHashType: "css"
+						}
+					);
+					const undoPath = getUndoPath(
+						filename,
+						compilation.outputOptions.path,
+						false
+					);
 					if (modules !== undefined) {
 						result.push({
 							render: () =>
@@ -363,18 +395,11 @@ class CssModulesPlugin {
 									uniqueName: compilation.outputOptions.uniqueName,
 									cssHeadDataCompression:
 										compilation.outputOptions.cssHeadDataCompression,
+									undoPath,
 									modules
 								}),
-							filenameTemplate: CssModulesPlugin.getChunkFilenameTemplate(
-								chunk,
-								compilation.outputOptions
-							),
-							pathOptions: {
-								hash,
-								runtime: chunk.runtime,
-								chunk,
-								contentHashType: "css"
-							},
+							filename,
+							info,
 							identifier: `css${chunk.id}`,
 							hash: chunk.contentHash.css
 						});
@@ -392,7 +417,7 @@ class CssModulesPlugin {
 						options && options.chunkLoading !== undefined
 							? options.chunkLoading
 							: globalChunkLoading;
-					return chunkLoading === "jsonp";
+					return chunkLoading === "jsonp" || chunkLoading === "import";
 				};
 				const onceForChunkSet = new WeakSet();
 				/**
@@ -505,19 +530,17 @@ class CssModulesPlugin {
 			}
 			if (hasFailed) {
 				// There is a not resolve-able conflict with the selectedModule
-				if (compilation) {
-					// TODO print better warning
-					compilation.warnings.push(
-						new WebpackError(
-							`chunk ${chunk.name || chunk.id}\nConflicting order between ${
-								/** @type {Module} */
-								(hasFailed).readableIdentifier(compilation.requestShortener)
-							} and ${selectedModule.readableIdentifier(
-								compilation.requestShortener
-							)}`
-						)
-					);
-				}
+				// TODO print better warning
+				compilation.warnings.push(
+					new WebpackError(
+						`chunk ${chunk.name || chunk.id}\nConflicting order between ${
+							/** @type {Module} */
+							(hasFailed).readableIdentifier(compilation.requestShortener)
+						} and ${selectedModule.readableIdentifier(
+							compilation.requestShortener
+						)}`
+					)
+				);
 				selectedModule = /** @type {Module} */ (hasFailed);
 			}
 			// Insert the selected module into the final modules list
@@ -572,9 +595,143 @@ class CssModulesPlugin {
 	}
 
 	/**
-	 * @param {Object} options options
+	 * @param {object} options options
+	 * @param {string[]} options.metaData meta data
+	 * @param {string} options.undoPath undo path for public path auto
+	 * @param {Chunk} options.chunk chunk
+	 * @param {ChunkGraph} options.chunkGraph chunk graph
+	 * @param {CodeGenerationResults} options.codeGenerationResults code generation results
+	 * @param {CssModule} options.module css module
+	 * @returns {Source} css module source
+	 */
+	renderModule({
+		metaData,
+		undoPath,
+		chunk,
+		chunkGraph,
+		codeGenerationResults,
+		module
+	}) {
+		const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
+		const moduleSourceContent =
+			/** @type {Source} */
+			(
+				codeGenResult.sources.get("css") ||
+					codeGenResult.sources.get("css-import")
+			);
+
+		const cacheEntry = this._moduleCache.get(moduleSourceContent);
+
+		/** @type {Inheritance} */
+		let inheritance = [[module.cssLayer, module.supports, module.media]];
+		if (module.inheritance) {
+			inheritance.push(...module.inheritance);
+		}
+
+		let source;
+		if (
+			cacheEntry &&
+			cacheEntry.undoPath === undoPath &&
+			cacheEntry.inheritance.every(([layer, supports, media], i) => {
+				const item = inheritance[i];
+				if (Array.isArray(item)) {
+					return layer === item[0] && supports === item[1] && media === item[2];
+				}
+				return false;
+			})
+		) {
+			source = cacheEntry.source;
+		} else {
+			const moduleSourceCode = /** @type {string} */ (
+				moduleSourceContent.source()
+			);
+			const publicPathAutoRegex = new RegExp(
+				CssUrlDependency.PUBLIC_PATH_AUTO,
+				"g"
+			);
+			/** @type {Source} */
+			let moduleSource = new ReplaceSource(moduleSourceContent);
+			let match;
+			while ((match = publicPathAutoRegex.exec(moduleSourceCode))) {
+				/** @type {ReplaceSource} */ (moduleSource).replace(
+					match.index,
+					(match.index += match[0].length - 1),
+					undoPath
+				);
+			}
+
+			for (let i = 0; i < inheritance.length; i++) {
+				const layer = inheritance[i][0];
+				const supports = inheritance[i][1];
+				const media = inheritance[i][2];
+
+				if (media) {
+					moduleSource = new ConcatSource(
+						`@media ${media} {\n`,
+						new PrefixSource("\t", moduleSource),
+						"}\n"
+					);
+				}
+
+				if (supports) {
+					moduleSource = new ConcatSource(
+						`@supports (${supports}) {\n`,
+						new PrefixSource("\t", moduleSource),
+						"}\n"
+					);
+				}
+
+				// Layer can be anonymous
+				if (layer !== undefined && layer !== null) {
+					moduleSource = new ConcatSource(
+						`@layer${layer ? ` ${layer}` : ""} {\n`,
+						new PrefixSource("\t", moduleSource),
+						"}\n"
+					);
+				}
+			}
+
+			if (moduleSource) {
+				moduleSource = new ConcatSource(moduleSource, "\n");
+			}
+
+			source = new CachedSource(moduleSource);
+			this._moduleCache.set(moduleSourceContent, {
+				inheritance,
+				undoPath,
+				source
+			});
+		}
+		/** @type {CssExportsData | undefined} */
+		const cssExportsData =
+			codeGenResult.data && codeGenResult.data.get("css-exports");
+		const exports = cssExportsData && cssExportsData.exports;
+		const esModule = cssExportsData && cssExportsData.esModule;
+		let moduleId = chunkGraph.getModuleId(module) + "";
+
+		// When `optimization.moduleIds` is `named` the module id is a path, so we need to normalize it between platforms
+		if (typeof moduleId === "string") {
+			moduleId = moduleId.replace(/\\/g, "/");
+		}
+
+		metaData.push(
+			`${
+				exports
+					? Array.from(
+							exports,
+							([n, v]) => `${escapeCss(n)}:${escapeCss(v)}/`
+						).join("")
+					: ""
+			}${esModule ? "&" : ""}${escapeCss(moduleId)}`
+		);
+		return source;
+	}
+
+	/**
+	 * @param {object} options options
 	 * @param {string | undefined} options.uniqueName unique name
 	 * @param {boolean | undefined} options.cssHeadDataCompression compress css head data
+	 * @param {string} options.undoPath undo path for public path auto
 	 * @param {Chunk} options.chunk chunk
 	 * @param {ChunkGraph} options.chunkGraph chunk graph
 	 * @param {CodeGenerationResults} options.codeGenerationResults code generation results
@@ -584,6 +741,7 @@ class CssModulesPlugin {
 	renderChunk({
 		uniqueName,
 		cssHeadDataCompression,
+		undoPath,
 		chunk,
 		chunkGraph,
 		codeGenerationResults,
@@ -594,76 +752,15 @@ class CssModulesPlugin {
 		const metaData = [];
 		for (const module of modules) {
 			try {
-				const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
-
-				let moduleSource =
-					/** @type {Source} */
-					(
-						codeGenResult.sources.get("css") ||
-							codeGenResult.sources.get("css-import")
-					);
-
-				let inheritance = [[module.cssLayer, module.supports, module.media]];
-
-				if (module.inheritance) {
-					inheritance.push(...module.inheritance);
-				}
-
-				for (let i = 0; i < inheritance.length; i++) {
-					const layer = inheritance[i][0];
-					const supports = inheritance[i][1];
-					const media = inheritance[i][2];
-
-					if (media) {
-						moduleSource = new ConcatSource(
-							`@media ${media} {\n`,
-							new PrefixSource("\t", moduleSource),
-							"}\n"
-						);
-					}
-
-					if (supports) {
-						moduleSource = new ConcatSource(
-							`@supports (${supports}) {\n`,
-							new PrefixSource("\t", moduleSource),
-							"}\n"
-						);
-					}
-
-					// Layer can be anonymous
-					if (layer !== undefined && layer !== null) {
-						moduleSource = new ConcatSource(
-							`@layer${layer ? ` ${layer}` : ""} {\n`,
-							new PrefixSource("\t", moduleSource),
-							"}\n"
-						);
-					}
-				}
-
-				if (moduleSource) {
-					source.add(moduleSource);
-					source.add("\n");
-				}
-				/** @type {Map<string, string> | undefined} */
-				const exports =
-					codeGenResult.data && codeGenResult.data.get("css-exports");
-				let moduleId = chunkGraph.getModuleId(module) + "";
-
-				// When `optimization.moduleIds` is `named` the module id is a path, so we need to normalize it between platforms
-				if (typeof moduleId === "string") {
-					moduleId = moduleId.replace(/\\/g, "/");
-				}
-
-				metaData.push(
-					`${
-						exports
-							? Array.from(
-									exports,
-									([n, v]) => `${escapeCss(n)}:${escapeCss(v)}/`
-								).join("")
-							: ""
-					}${escapeCss(moduleId)}`
-				);
+				const moduleSource = this.renderModule({
+					metaData,
+					undoPath,
+					chunk,
+					chunkGraph,
+					codeGenerationResults,
+					module
+				});
+				source.add(moduleSource);
 			} catch (e) {
 				/** @type {Error} */
 				(e).message += `\nduring rendering of css ${module.identifier()}`;

package/lib/css/CssParser.js

@@ -600,11 +600,13 @@ class CssParser extends Parser {
 
 						return newPos;
 					}
-					const { line: sl, column: sc } = locConverter.get(pos);
-					const { line: el, column: ec } = locConverter.get(newPos);
-					const dep = new CssLocalIdentifierDependency(name, [pos, newPos]);
-					dep.setLoc(sl, sc, el, ec);
-					module.addDependency(dep);
+					if (isLocalMode()) {
+						const { line: sl, column: sc } = locConverter.get(pos);
+						const { line: el, column: ec } = locConverter.get(newPos);
+						const dep = new CssLocalIdentifierDependency(name, [pos, newPos]);
+						dep.setLoc(sl, sc, el, ec);
+						module.addDependency(dep);
+					}
 					pos = newPos;
 					return pos + 1;
 				} else if (this.allowModeSwitch && name === "@property") {
@@ -630,17 +632,19 @@ class CssParser extends Parser {
 
 						return propertyNameEnd;
 					}
-					const { line: sl, column: sc } = locConverter.get(pos);
-					const { line: el, column: ec } = locConverter.get(propertyNameEnd);
 					const name = propertyName.slice(2);
-					const dep = new CssLocalIdentifierDependency(
-						name,
-						[propertyNameStart, propertyNameEnd],
-						"--"
-					);
-					dep.setLoc(sl, sc, el, ec);
-					module.addDependency(dep);
 					declaredCssVariables.add(name);
+					if (isLocalMode()) {
+						const { line: sl, column: sc } = locConverter.get(pos);
+						const { line: el, column: ec } = locConverter.get(propertyNameEnd);
+						const dep = new CssLocalIdentifierDependency(
+							name,
+							[propertyNameStart, propertyNameEnd],
+							"--"
+						);
+						dep.setLoc(sl, sc, el, ec);
+						module.addDependency(dep);
+					}
 					pos = propertyNameEnd;
 					return pos + 1;
 				} else if (
@@ -710,7 +714,7 @@ class CssParser extends Parser {
 						}
 
 						const semicolonPos = end;
-						end = walkCssTokens.eatWhiteLine(input, end + 1);
+						end = walkCssTokens.eatWhiteLine(input, end);
 						const { line: sl, column: sc } = locConverter.get(start);
 						const { line: el, column: ec } = locConverter.get(end);
 						const lastEnd =
@@ -1030,6 +1034,11 @@ class CssParser extends Parser {
 
 		module.buildInfo.strict = true;
 		module.buildMeta.exportsType = this.namedExports ? "namespace" : "default";
+
+		if (!this.namedExports) {
+			module.buildMeta.defaultObject = "redirect";
+		}
+
 		module.addDependency(new StaticExportsDependency([], true));
 		return state;
 	}

package/lib/css/walkCssTokens.js

@@ -6,7 +6,7 @@
 "use strict";
 
 /**
- * @typedef {Object} CssTokenCallbacks
+ * @typedef {object} CssTokenCallbacks
  * @property {function(string, number): boolean=} isSelector
  * @property {function(string, number, number, number, number): number=} url
  * @property {function(string, number, number): number=} string

package/lib/debug/ProfilingPlugin.js

@@ -137,7 +137,7 @@ class Profiler {
 
 /**
  * an object that wraps Tracer and Profiler with a counter
- * @typedef {Object} Trace
+ * @typedef {object} Trace
  * @property {Tracer} trace instance of Tracer
  * @property {number} counter Counter
  * @property {Profiler} profiler instance of Profiler

package/lib/dependencies/ContextElementDependency.js

@@ -11,7 +11,7 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../javascript/JavascriptParser").Attributes} Attributes */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
@@ -24,7 +24,7 @@ class ContextElementDependency extends ModuleDependency {
 	 * @param {string} category category
 	 * @param {string[][]=} referencedExports referenced exports
 	 * @param {string=} context context
-	 * @param {Attributes=} attributes attributes
+	 * @param {ImportAttributes=} attributes import assertions
 	 */
 	constructor(
 		request,

package/lib/dependencies/CssExportDependency.js

@@ -79,9 +79,9 @@ CssExportDependency.Template = class CssExportDependencyTemplate extends (
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, { cssExports }) {
+	apply(dependency, source, { cssExportsData }) {
 		const dep = /** @type {CssExportDependency} */ (dependency);
-		cssExports.set(dep.name, dep.value);
+		cssExportsData.exports.set(dep.name, dep.value);
 	}
 };
 

package/lib/dependencies/CssLocalIdentifierDependency.js

@@ -157,7 +157,14 @@ CssLocalIdentifierDependency.Template = class CssLocalIdentifierDependencyTempla
 	apply(
 		dependency,
 		source,
-		{ module, moduleGraph, chunkGraph, runtime, runtimeTemplate, cssExports }
+		{
+			module,
+			moduleGraph,
+			chunkGraph,
+			runtime,
+			runtimeTemplate,
+			cssExportsData
+		}
 	) {
 		const dep = /** @type {CssLocalIdentifierDependency} */ (dependency);
 		const used = moduleGraph
@@ -179,7 +186,7 @@ CssLocalIdentifierDependency.Template = class CssLocalIdentifierDependencyTempla
 			dep.range[1] - 1,
 			escapeCssIdentifier(localIdent, dep.prefix)
 		);
-		if (used) cssExports.set(used, localIdent);
+		if (used) cssExportsData.exports.set(used, localIdent);
 	}
 };