webpack 5.76.1 → 5.88.2

package/lib/ConstPlugin.js

@@ -5,19 +5,36 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("./ModuleTypeConstants");
 const CachedConstDependency = require("./dependencies/CachedConstDependency");
 const ConstDependency = require("./dependencies/ConstDependency");
 const { evaluateToString } = require("./javascript/JavascriptParserHelpers");
 const { parseResource } = require("./util/identifier");
 
-/** @typedef {import("estree").Expression} ExpressionNode */
-/** @typedef {import("estree").Super} SuperNode */
+/** @typedef {import("estree").AssignmentProperty} AssignmentProperty */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").Pattern} Pattern */
+/** @typedef {import("estree").SourceLocation} SourceLocation */
+/** @typedef {import("estree").Statement} Statement */
+/** @typedef {import("estree").Super} Super */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./javascript/JavascriptParser").Range} Range */
 
+/**
+ * @param {Set<string>} declarations set of declarations
+ * @param {Identifier | Pattern} pattern pattern to collect declarations from
+ */
 const collectDeclaration = (declarations, pattern) => {
 	const stack = [pattern];
 	while (stack.length > 0) {
-		const node = stack.pop();
+		const node = /** @type {Pattern} */ (stack.pop());
 		switch (node.type) {
 			case "Identifier":
 				declarations.add(node.name);
@@ -34,7 +51,7 @@ const collectDeclaration = (declarations, pattern) => {
 				break;
 			case "ObjectPattern":
 				for (const property of node.properties) {
-					stack.push(property.value);
+					stack.push(/** @type {AssignmentProperty} */ (property).value);
 				}
 				break;
 			case "RestElement":
@@ -44,8 +61,14 @@ const collectDeclaration = (declarations, pattern) => {
 	}
 };
 
+/**
+ * @param {Statement} branch branch to get hoisted declarations from
+ * @param {boolean} includeFunctionDeclarations whether to include function declarations
+ * @returns {Array<string>} hoisted declarations
+ */
 const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
 	const declarations = new Set();
+	/** @type {Array<TODO | null | undefined>} */
 	const stack = [branch];
 	while (stack.length > 0) {
 		const node = stack.pop();
@@ -93,7 +116,7 @@ const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
 				break;
 			case "FunctionDeclaration":
 				if (includeFunctionDeclarations) {
-					collectDeclaration(declarations, node.id);
+					collectDeclaration(declarations, /** @type {Identifier} */ (node.id));
 				}
 				break;
 			case "VariableDeclaration":
@@ -108,6 +131,8 @@ const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
 	return Array.from(declarations);
 };
 
+const PLUGIN_NAME = "ConstPlugin";
+
 class ConstPlugin {
 	/**
 	 * Apply the plugin
@@ -117,7 +142,7 @@ class ConstPlugin {
 	apply(compiler) {
 		const cachedParseResource = parseResource.bindCache(compiler.root);
 		compiler.hooks.compilation.tap(
-			"ConstPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyTemplates.set(
 					ConstDependency,
@@ -129,15 +154,21 @@ class ConstPlugin {
 					new CachedConstDependency.Template()
 				);
 
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 */
 				const handler = parser => {
-					parser.hooks.statementIf.tap("ConstPlugin", statement => {
+					parser.hooks.statementIf.tap(PLUGIN_NAME, statement => {
 						if (parser.scope.isAsmJs) return;
 						const param = parser.evaluateExpression(statement.test);
 						const bool = param.asBool();
 						if (typeof bool === "boolean") {
 							if (!param.couldHaveSideEffects()) {
-								const dep = new ConstDependency(`${bool}`, param.range);
-								dep.loc = statement.loc;
+								const dep = new ConstDependency(
+									`${bool}`,
+									/** @type {Range} */ (param.range)
+								);
+								dep.loc = /** @type {SourceLocation} */ (statement.loc);
 								parser.state.module.addPresentationalDependency(dep);
 							} else {
 								parser.walkExpression(statement.test);
@@ -193,24 +224,27 @@ class ConstPlugin {
 								}
 								const dep = new ConstDependency(
 									replacement,
-									branchToRemove.range
+									/** @type {Range} */ (branchToRemove.range)
 								);
-								dep.loc = branchToRemove.loc;
+								dep.loc = /** @type {SourceLocation} */ (branchToRemove.loc);
 								parser.state.module.addPresentationalDependency(dep);
 							}
 							return bool;
 						}
 					});
 					parser.hooks.expressionConditionalOperator.tap(
-						"ConstPlugin",
+						PLUGIN_NAME,
 						expression => {
 							if (parser.scope.isAsmJs) return;
 							const param = parser.evaluateExpression(expression.test);
 							const bool = param.asBool();
 							if (typeof bool === "boolean") {
 								if (!param.couldHaveSideEffects()) {
-									const dep = new ConstDependency(` ${bool}`, param.range);
-									dep.loc = expression.loc;
+									const dep = new ConstDependency(
+										` ${bool}`,
+										/** @type {Range} */ (param.range)
+									);
+									dep.loc = /** @type {SourceLocation} */ (expression.loc);
 									parser.state.module.addPresentationalDependency(dep);
 								} else {
 									parser.walkExpression(expression.test);
@@ -229,15 +263,18 @@ class ConstPlugin {
 								const branchToRemove = bool
 									? expression.alternate
 									: expression.consequent;
-								const dep = new ConstDependency("0", branchToRemove.range);
-								dep.loc = branchToRemove.loc;
+								const dep = new ConstDependency(
+									"0",
+									/** @type {Range} */ (branchToRemove.range)
+								);
+								dep.loc = /** @type {SourceLocation} */ (branchToRemove.loc);
 								parser.state.module.addPresentationalDependency(dep);
 								return bool;
 							}
 						}
 					);
 					parser.hooks.expressionLogicalOperator.tap(
-						"ConstPlugin",
+						PLUGIN_NAME,
 						expression => {
 							if (parser.scope.isAsmJs) return;
 							if (
@@ -306,8 +343,11 @@ class ConstPlugin {
 										//
 										//   returnfalse&&'foo'
 										//
-										const dep = new ConstDependency(` ${bool}`, param.range);
-										dep.loc = expression.loc;
+										const dep = new ConstDependency(
+											` ${bool}`,
+											/** @type {Range} */ (param.range)
+										);
+										dep.loc = /** @type {SourceLocation} */ (expression.loc);
 										parser.state.module.addPresentationalDependency(dep);
 									} else {
 										parser.walkExpression(expression.left);
@@ -315,9 +355,9 @@ class ConstPlugin {
 									if (!keepRight) {
 										const dep = new ConstDependency(
 											"0",
-											expression.right.range
+											/** @type {Range} */ (expression.right.range)
 										);
-										dep.loc = expression.loc;
+										dep.loc = /** @type {SourceLocation} */ (expression.loc);
 										parser.state.module.addPresentationalDependency(dep);
 									}
 									return keepRight;
@@ -356,15 +396,18 @@ class ConstPlugin {
 										//
 										//   returnnull??'foo'
 										//
-										const dep = new ConstDependency(" null", param.range);
-										dep.loc = expression.loc;
+										const dep = new ConstDependency(
+											" null",
+											/** @type {Range} */ (param.range)
+										);
+										dep.loc = /** @type {SourceLocation} */ (expression.loc);
 										parser.state.module.addPresentationalDependency(dep);
 									} else {
 										const dep = new ConstDependency(
 											"0",
-											expression.right.range
+											/** @type {Range} */ (expression.right.range)
 										);
-										dep.loc = expression.loc;
+										dep.loc = /** @type {SourceLocation} */ (expression.loc);
 										parser.state.module.addPresentationalDependency(dep);
 										parser.walkExpression(expression.left);
 									}
@@ -374,10 +417,10 @@ class ConstPlugin {
 							}
 						}
 					);
-					parser.hooks.optionalChaining.tap("ConstPlugin", expr => {
-						/** @type {ExpressionNode[]} */
+					parser.hooks.optionalChaining.tap(PLUGIN_NAME, expr => {
+						/** @type {Expression[]} */
 						const optionalExpressionsStack = [];
-						/** @type {ExpressionNode|SuperNode} */
+						/** @type {Expression | Super} */
 						let next = expr.expression;
 
 						while (
@@ -388,7 +431,7 @@ class ConstPlugin {
 								if (next.optional) {
 									// SuperNode can not be optional
 									optionalExpressionsStack.push(
-										/** @type {ExpressionNode} */ (next.object)
+										/** @type {Expression} */ (next.object)
 									);
 								}
 								next = next.object;
@@ -396,7 +439,7 @@ class ConstPlugin {
 								if (next.optional) {
 									// SuperNode can not be optional
 									optionalExpressionsStack.push(
-										/** @type {ExpressionNode} */ (next.callee)
+										/** @type {Expression} */ (next.callee)
 									);
 								}
 								next = next.callee;
@@ -405,7 +448,9 @@ class ConstPlugin {
 
 						while (optionalExpressionsStack.length) {
 							const expression = optionalExpressionsStack.pop();
-							const evaluated = parser.evaluateExpression(expression);
+							const evaluated = parser.evaluateExpression(
+								/** @type {Expression} */ (expression)
+							);
 
 							if (evaluated.asNullish()) {
 								// ------------------------------------------
@@ -420,8 +465,11 @@ class ConstPlugin {
 								//
 								// ------------------------------------------
 								//
-								const dep = new ConstDependency(" undefined", expr.range);
-								dep.loc = expr.loc;
+								const dep = new ConstDependency(
+									" undefined",
+									/** @type {Range} */ (expr.range)
+								);
+								dep.loc = /** @type {SourceLocation} */ (expr.loc);
 								parser.state.module.addPresentationalDependency(dep);
 								return true;
 							}
@@ -429,7 +477,7 @@ class ConstPlugin {
 					});
 					parser.hooks.evaluateIdentifier
 						.for("__resourceQuery")
-						.tap("ConstPlugin", expr => {
+						.tap(PLUGIN_NAME, expr => {
 							if (parser.scope.isAsmJs) return;
 							if (!parser.state.module) return;
 							return evaluateToString(
@@ -438,24 +486,24 @@ class ConstPlugin {
 						});
 					parser.hooks.expression
 						.for("__resourceQuery")
-						.tap("ConstPlugin", expr => {
+						.tap(PLUGIN_NAME, expr => {
 							if (parser.scope.isAsmJs) return;
 							if (!parser.state.module) return;
 							const dep = new CachedConstDependency(
 								JSON.stringify(
 									cachedParseResource(parser.state.module.resource).query
 								),
-								expr.range,
+								/** @type {Range} */ (expr.range),
 								"__resourceQuery"
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {SourceLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
 
 					parser.hooks.evaluateIdentifier
 						.for("__resourceFragment")
-						.tap("ConstPlugin", expr => {
+						.tap(PLUGIN_NAME, expr => {
 							if (parser.scope.isAsmJs) return;
 							if (!parser.state.module) return;
 							return evaluateToString(
@@ -464,31 +512,31 @@ class ConstPlugin {
 						});
 					parser.hooks.expression
 						.for("__resourceFragment")
-						.tap("ConstPlugin", expr => {
+						.tap(PLUGIN_NAME, expr => {
 							if (parser.scope.isAsmJs) return;
 							if (!parser.state.module) return;
 							const dep = new CachedConstDependency(
 								JSON.stringify(
 									cachedParseResource(parser.state.module.resource).fragment
 								),
-								expr.range,
+								/** @type {Range} */ (expr.range),
 								"__resourceFragment"
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {SourceLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ConstPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("ConstPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ConstPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}

package/lib/ContextModule.js

@@ -9,6 +9,7 @@ const { OriginalSource, RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("./AsyncDependenciesBlock");
 const { makeWebpackError } = require("./HookWebpackError");
 const Module = require("./Module");
+const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
 const WebpackError = require("./WebpackError");
@@ -42,6 +43,8 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./dependencies/ContextElementDependency")} ContextElementDependency */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @template T @typedef {import("./util/LazySet")<T>} LazySet<T> */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
@@ -60,7 +63,8 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {RawChunkGroupOptions=} groupOptions
  * @property {string=} typePrefix
  * @property {string=} category
- * @property {string[][]=} referencedExports exports referenced from modules (won't be mangled)
+ * @property {(string[][] | null)=} referencedExports exports referenced from modules (won't be mangled)
+ * @property {string=} layer
  */
 
 /**
@@ -104,8 +108,9 @@ class ContextModule extends Module {
 			const resourceQuery = (options && options.resourceQuery) || parsed.query;
 			const resourceFragment =
 				(options && options.resourceFragment) || parsed.fragment;
+			const layer = options && options.layer;
 
-			super("javascript/dynamic", resource);
+			super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, resource, layer);
 			/** @type {ContextModuleOptions} */
 			this.options = {
 				...options,
@@ -114,7 +119,7 @@ class ContextModule extends Module {
 				resourceFragment
 			};
 		} else {
-			super("javascript/dynamic");
+			super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, undefined, options.layer);
 			/** @type {ContextModuleOptions} */
 			this.options = {
 				...options,
@@ -226,6 +231,9 @@ class ContextModule extends Module {
 		} else if (this.options.namespaceObject) {
 			identifier += "|namespace object";
 		}
+		if (this.layer) {
+			identifier += `|layer: ${this.layer}`;
+		}
 
 		return identifier;
 	}
@@ -637,7 +645,7 @@ class ContextModule extends Module {
 
 	getReturn(type, asyncModule) {
 		if (type === 9) {
-			return "__webpack_require__(id)";
+			return `${RuntimeGlobals.require}(id)`;
 		}
 		return `${RuntimeGlobals.createFakeNamespaceObject}(id, ${type}${
 			asyncModule ? " | 16" : ""
@@ -796,7 +804,7 @@ module.exports = webpackAsyncContext;`;
 				? `${arrow ? "id =>" : "function(id)"} {
 		${this.getReturnModuleObjectSource(fakeMap)}
 	}`
-				: "__webpack_require__";
+				: RuntimeGlobals.require;
 		return `var map = ${JSON.stringify(map, null, "\t")};
 ${this.getFakeMapInitStatement(fakeMap)}
 
@@ -847,7 +855,7 @@ module.exports = webpackAsyncContext;`;
 				? `${arrow ? "id =>" : "function(id)"} {
 		${this.getReturnModuleObjectSource(fakeMap, true)};
 	}`
-				: "__webpack_require__";
+				: RuntimeGlobals.require;
 
 		return `var map = ${JSON.stringify(map, null, "\t")};
 ${this.getFakeMapInitStatement(fakeMap)}
@@ -1150,6 +1158,9 @@ module.exports = webpackEmptyAsyncContext;`;
 		return size;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this._identifier);
@@ -1157,6 +1168,9 @@ module.exports = webpackEmptyAsyncContext;`;
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this._identifier = read();

package/lib/ContextModuleFactory.js

@@ -80,7 +80,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {
@@ -95,6 +95,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 			{
 				context: context,
 				dependencies: dependencies,
+				layer: data.contextInfo.issuerLayer,
 				resolveOptions,
 				fileDependencies,
 				missingDependencies,

package/lib/ContextReplacementPlugin.js

@@ -8,7 +8,15 @@
 const ContextElementDependency = require("./dependencies/ContextElementDependency");
 const { join } = require("./util/fs");
 
+/** @typedef {import("./Compiler")} Compiler */
+
 class ContextReplacementPlugin {
+	/**
+	 * @param {RegExp} resourceRegExp A regular expression that determines which files will be selected
+	 * @param {TODO=} newContentResource A new resource to replace the match
+	 * @param {TODO=} newContentRecursive If true, all subdirectories are searched for matches
+	 * @param {TODO=} newContentRegExp A regular expression that determines which files will be selected
+	 */
 	constructor(
 		resourceRegExp,
 		newContentResource,
@@ -49,6 +57,11 @@ class ContextReplacementPlugin {
 		}
 	}
 
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		const resourceRegExp = this.resourceRegExp;
 		const newContentCallback = this.newContentCallback;

package/lib/CssModule.js

@@ -0,0 +1,169 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Krasnoyarov @alexander-akait
+*/
+
+"use strict";
+
+const NormalModule = require("./NormalModule");
+const makeSerializable = require("./util/makeSerializable");
+
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./NormalModule").NormalModuleCreateData} NormalModuleCreateData */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/** @typedef {string|undefined} CssLayer */
+/** @typedef {string|undefined} Supports */
+/** @typedef {string|undefined} Media */
+/** @typedef {[CssLayer?, Supports?, Media?]} InheritanceItem */
+/** @typedef {Array<InheritanceItem>} Inheritance */
+
+/** @typedef {NormalModuleCreateData & { cssLayer: CssLayer|null, supports: Supports|null, media: Media|null, inheritance: Inheritance|null }} CSSModuleCreateData */
+
+class CssModule extends NormalModule {
+	/**
+	 * @param {CSSModuleCreateData} options options object
+	 */
+	constructor(options) {
+		super(options);
+
+		// Avoid override `layer` for `Module` class, because it is a feature to run module in specific layer
+		this.cssLayer = options.cssLayer;
+		this.supports = options.supports;
+		this.media = options.media;
+		this.inheritance = options.inheritance;
+	}
+
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		let identifier = super.identifier();
+
+		if (this.cssLayer) {
+			identifier += `|${this.cssLayer}`;
+		}
+
+		if (this.supports) {
+			identifier += `|${this.supports}`;
+		}
+
+		if (this.media) {
+			identifier += `|${this.media}`;
+		}
+
+		if (this.inheritance) {
+			const inheritance = this.inheritance.map(
+				(item, index) =>
+					`inheritance_${index}|${item[0] || ""}|${item[1] || ""}|${
+						item[2] || ""
+					}`
+			);
+
+			identifier += `|${inheritance.join("|")}`;
+		}
+
+		return identifier;
+	}
+
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		const readableIdentifier = super.readableIdentifier(requestShortener);
+
+		let identifier = `css ${readableIdentifier}`;
+
+		if (this.cssLayer) {
+			identifier += ` (layer: ${this.cssLayer})`;
+		}
+
+		if (this.supports) {
+			identifier += ` (supports: ${this.supports})`;
+		}
+
+		if (this.media) {
+			identifier += ` (media: ${this.media})`;
+		}
+
+		return identifier;
+	}
+
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		const m = /** @type {CssModule} */ (module);
+		this.cssLayer = m.cssLayer;
+		this.supports = m.supports;
+		this.media = m.media;
+		this.inheritance = m.inheritance;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.cssLayer);
+		write(this.supports);
+		write(this.media);
+		write(this.inheritance);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {CssModule} the deserialized object
+	 */
+	static deserialize(context) {
+		const obj = new CssModule({
+			// will be deserialized by Module
+			layer: null,
+			type: "",
+			// will be filled by updateCacheModule
+			resource: "",
+			context: "",
+			request: null,
+			userRequest: null,
+			rawRequest: null,
+			loaders: null,
+			matchResource: null,
+			parser: null,
+			parserOptions: null,
+			generator: null,
+			generatorOptions: null,
+			resolveOptions: null,
+			cssLayer: null,
+			supports: null,
+			media: null,
+			inheritance: null
+		});
+		obj.deserialize(context);
+		return obj;
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.cssLayer = read();
+		this.supports = read();
+		this.media = read();
+		this.inheritance = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(CssModule, "webpack/lib/CssModule");
+
+module.exports = CssModule;