webpack 5.90.3 → 5.92.0

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 */
 
@@ -128,9 +136,43 @@ const escapeCss = (str, omitOptionalUnderscore) => {
 		: escaped;
 };
 
+/**
+ * @param {string} str string
+ * @returns {string} encoded string
+ */
+const LZWEncode = str => {
+	/** @type {Map<string, string>} */
+	const map = new Map();
+	let encoded = "";
+	let phrase = str[0];
+	let code = 256;
+	let maxCode = "\uffff".charCodeAt(0);
+	for (let i = 1; i < str.length; i++) {
+		const c = str[i];
+		if (map.has(phrase + c)) {
+			phrase += c;
+		} else {
+			encoded += phrase.length > 1 ? map.get(phrase) : phrase;
+			map.set(phrase + c, String.fromCharCode(code));
+			phrase = c;
+			if (++code > maxCode) {
+				code = 256;
+				map.clear();
+			}
+		}
+	}
+	encoded += phrase.length > 1 ? map.get(phrase) : phrase;
+	return encoded;
+};
+
 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
@@ -190,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
@@ -213,8 +255,16 @@ class CssModulesPlugin {
 							validateGeneratorOptions[type](generatorOptions);
 
 							return generatorOptions.exportsOnly
-								? new CssExportsGenerator()
-								: new CssGenerator();
+								? new CssExportsGenerator(
+										generatorOptions.exportsConvention,
+										generatorOptions.localIdentName,
+										generatorOptions.esModule
+									)
+								: new CssGenerator(
+										generatorOptions.exportsConvention,
+										generatorOptions.localIdentName,
+										generatorOptions.esModule
+									);
 						});
 					normalModuleFactory.hooks.createModuleClass
 						.for(type)
@@ -318,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: () =>
@@ -326,18 +393,13 @@ class CssModulesPlugin {
 									chunkGraph,
 									codeGenerationResults,
 									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
 						});
@@ -355,7 +417,7 @@ class CssModulesPlugin {
 						options && options.chunkLoading !== undefined
 							? options.chunkLoading
 							: globalChunkLoading;
-					return chunkLoading === "jsonp";
+					return chunkLoading === "jsonp" || chunkLoading === "import";
 				};
 				const onceForChunkSet = new WeakSet();
 				/**
@@ -468,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
@@ -535,8 +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
@@ -545,6 +740,8 @@ class CssModulesPlugin {
 	 */
 	renderChunk({
 		uniqueName,
+		cssHeadDataCompression,
+		undoPath,
 		chunk,
 		chunkGraph,
 		codeGenerationResults,
@@ -555,93 +752,27 @@ 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]) => {
-									const shortcutValue = `${
-										uniqueName ? uniqueName + "-" : ""
-									}${moduleId}-${n}`;
-									return v === shortcutValue
-										? `${escapeCss(n)}/`
-										: v === "--" + shortcutValue
-											? `${escapeCss(n)}%`
-											: `${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()}`;
 				throw e;
 			}
 		}
+		const metaDataStr = metaData.join(",");
 		source.add(
 			`head{--webpack-${escapeCss(
 				(uniqueName ? uniqueName + "-" : "") + chunk.id,
 				true
-			)}:${metaData.join(",")};}`
+			)}:${cssHeadDataCompression ? LZWEncode(metaDataStr) : metaDataStr};}`
 		);
 		return source;
 	}

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

@@ -17,9 +17,15 @@ const createSchemaValidation = require("../util/create-schema-validation");
 const { dirname, mkdirpSync } = require("../util/fs");
 
 /** @typedef {import("../../declarations/plugins/debug/ProfilingPlugin").ProfilingPluginOptions} ProfilingPluginOptions */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../ContextModuleFactory")} ContextModuleFactory */
+/** @typedef {import("../ModuleFactory")} ModuleFactory */
+/** @typedef {import("../NormalModuleFactory")} NormalModuleFactory */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
+/** @typedef {TODO} Inspector */
+
 const validate = createSchemaValidation(
 	require("../../schemas/plugins/debug/ProfilingPlugin.check.js"),
 	() => require("../../schemas/plugins/debug/ProfilingPlugin.json"),
@@ -28,6 +34,8 @@ const validate = createSchemaValidation(
 		baseDataPath: "options"
 	}
 );
+
+/** @type {Inspector | undefined} */
 let inspector = undefined;
 
 try {
@@ -38,6 +46,9 @@ try {
 }
 
 class Profiler {
+	/**
+	 * @param {Inspector} inspector inspector
+	 */
 	constructor(inspector) {
 		this.session = undefined;
 		this.inspector = inspector;
@@ -126,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
@@ -140,7 +151,7 @@ class Profiler {
  */
 const createTrace = (fs, outputPath) => {
 	const trace = new Tracer();
-	const profiler = new Profiler(inspector);
+	const profiler = new Profiler(/** @type {Inspector} */ (inspector));
 	if (/\/|\\/.test(outputPath)) {
 		const dirPath = dirname(fs, outputPath);
 		mkdirpSync(fs, dirPath);
@@ -216,7 +227,8 @@ class ProfilingPlugin {
 	 */
 	apply(compiler) {
 		const tracer = createTrace(
-			compiler.intermediateFileSystem,
+			/** @type {IntermediateFileSystem} */
+			(compiler.intermediateFileSystem),
 			this.outputPath
 		);
 		tracer.profiler.startProfiling();
@@ -320,6 +332,11 @@ class ProfilingPlugin {
 	}
 }
 
+/**
+ * @param {any} instance instance
+ * @param {Trace} tracer tracer
+ * @param {string} logLabel log label
+ */
 const interceptAllHooksFor = (instance, tracer, logLabel) => {
 	if (Reflect.has(instance, "hooks")) {
 		Object.keys(instance.hooks).forEach(hookName => {
@@ -331,6 +348,10 @@ const interceptAllHooksFor = (instance, tracer, logLabel) => {
 	}
 };
 
+/**
+ * @param {NormalModuleFactory} moduleFactory normal module factory
+ * @param {Trace} tracer tracer
+ */
 const interceptAllParserHooks = (moduleFactory, tracer) => {
 	const moduleTypes = [
 		JAVASCRIPT_MODULE_TYPE_AUTO,
@@ -350,6 +371,10 @@ const interceptAllParserHooks = (moduleFactory, tracer) => {
 	});
 };
 
+/**
+ * @param {Compilation} compilation compilation
+ * @param {Trace} tracer tracer
+ */
 const interceptAllJavascriptModulesPluginHooks = (compilation, tracer) => {
 	interceptAllHooksFor(
 		{

package/lib/dependencies/AMDDefineDependencyParserPlugin.js

@@ -103,7 +103,7 @@ class AMDDefineDependencyParserPlugin {
 						/** @type {string} */ (param.string)
 					)
 				)
-					identifiers[idx] = param.string;
+					identifiers[/** @type {number} */ (idx)] = param.string;
 				const result = this.processItem(parser, expr, param, namedModule);
 				if (result === undefined) {
 					this.processContext(parser, expr, param);
@@ -113,7 +113,8 @@ class AMDDefineDependencyParserPlugin {
 		} else if (param.isConstArray()) {
 			/** @type {(string | LocalModuleDependency | AMDRequireItemDependency)[]} */
 			const deps = [];
-			param.array.forEach((request, idx) => {
+			/** @type {string[]} */
+			(param.array).forEach((request, idx) => {
 				let dep;
 				let localModule;
 				if (request === "require") {
@@ -151,7 +152,7 @@ class AMDDefineDependencyParserPlugin {
 	 * @param {CallExpression} expr call expression
 	 * @param {BasicEvaluatedExpression} param param
 	 * @param {string=} namedModule named module
-	 * @returns {boolean} result
+	 * @returns {boolean | undefined} result
 	 */
 	processItem(parser, expr, param, namedModule) {
 		if (param.isConditional()) {
@@ -193,7 +194,10 @@ class AMDDefineDependencyParserPlugin {
 				localModule.flagUsed();
 				dep = new LocalModuleDependency(localModule, param.range, false);
 			} else {
-				dep = this.newRequireItemDependency(param.string, param.range);
+				dep = this.newRequireItemDependency(
+					/** @type {string} */ (param.string),
+					param.range
+				);
 				dep.optional = !!parser.scope.inTry;
 				parser.state.current.addDependency(dep);
 				return true;
@@ -377,7 +381,7 @@ class AMDDefineDependencyParserPlugin {
 					for (const [name, varInfo] of fnRenames) {
 						parser.setVariable(name, varInfo);
 					}
-					parser.scope.inTry = inTry;
+					parser.scope.inTry = /** @type {boolean} */ (inTry);
 					if (fn.callee.object.body.type === "BlockStatement") {
 						parser.detectMode(fn.callee.object.body.body);
 						const prev = parser.prevStatement;

package/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js

@@ -21,6 +21,7 @@ const getFunctionExpression = require("./getFunctionExpression");
 
 /** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("estree").SourceLocation} SourceLocation */
 /** @typedef {import("estree").SpreadElement} SpreadElement */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
@@ -49,7 +50,9 @@ class AMDRequireDependenciesBlockParserPlugin {
 		if (fnData) {
 			parser.inScope(
 				fnData.fn.params.filter(i => {
-					return !["require", "module", "exports"].includes(i.name);
+					return !["require", "module", "exports"].includes(
+						/** @type {Identifier} */ (i).name
+					);
 				}),
 				() => {
 					if (fnData.fn.body.type === "BlockStatement") {