webpack 5.27.2 → 5.31.0

package/lib/config/normalization.js

@@ -121,13 +121,16 @@ const getNormalizedWebpackOptions = config => {
 			if (cache === false) return false;
 			if (cache === true) {
 				return {
-					type: "memory"
+					type: "memory",
+					maxGenerations: undefined
 				};
 			}
 			switch (cache.type) {
 				case "filesystem":
 					return {
 						type: "filesystem",
+						maxMemoryGenerations: cache.maxMemoryGenerations,
+						maxAge: cache.maxAge,
 						buildDependencies: cloneObject(cache.buildDependencies),
 						cacheDirectory: cache.cacheDirectory,
 						cacheLocation: cache.cacheLocation,
@@ -141,7 +144,8 @@ const getNormalizedWebpackOptions = config => {
 				case undefined:
 				case "memory":
 					return {
-						type: "memory"
+						type: "memory",
+						maxGenerations: cache.maxGenerations
 					};
 				default:
 					// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)

package/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -39,6 +39,7 @@ class HarmonyExportExpressionDependency extends NullDependency {
 	getExports(moduleGraph) {
 		return {
 			exports: ["default"],
+			priority: 1,
 			terminalBinding: true,
 			dependencies: undefined
 		};

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -543,6 +543,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 						export: item.ids,
 						hidden: item.hidden
 					})),
+					priority: 1,
 					dependencies: [from.module]
 				};
 			}
@@ -557,6 +558,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 								export: ["default"]
 							}
 						],
+						priority: 1,
 						dependencies: [from.module]
 					};
 				}
@@ -584,6 +586,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 							]
 						}
 					],
+					priority: 1,
 					dependencies: [from.module]
 				};
 			}
@@ -597,6 +600,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 							export: null
 						}
 					],
+					priority: 1,
 					dependencies: [from.module]
 				};
 			}
@@ -610,6 +614,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 							export: ["default"]
 						}
 					],
+					priority: 1,
 					dependencies: [from.module]
 				};
 			}

package/lib/dependencies/HarmonyExportSpecifierDependency.js

@@ -35,6 +35,7 @@ class HarmonyExportSpecifierDependency extends NullDependency {
 	getExports(moduleGraph) {
 		return {
 			exports: [this.name],
+			priority: 1,
 			terminalBinding: true,
 			dependencies: undefined
 		};

package/lib/hmr/HotModuleReplacement.runtime.js

@@ -101,6 +101,7 @@ module.exports = function () {
 	}
 
 	function createModuleHotObject(moduleId, me) {
+		var _main = currentChildModule !== moduleId;
 		var hot = {
 			// private stuff
 			_acceptedDependencies: {},
@@ -110,10 +111,10 @@ module.exports = function () {
 			_selfDeclined: false,
 			_selfInvalidated: false,
 			_disposeHandlers: [],
-			_main: currentChildModule !== moduleId,
+			_main: _main,
 			_requireSelf: function () {
 				currentParents = me.parents.slice();
-				currentChildModule = moduleId;
+				currentChildModule = _main ? undefined : moduleId;
 				__webpack_require__(moduleId);
 			},
 

package/lib/hmr/JavascriptHotModuleReplacement.runtime.js

@@ -207,7 +207,7 @@ module.exports = function () {
 			var module = $moduleCache$[outdatedModuleId];
 			if (
 				module &&
-				module.hot._selfAccepted &&
+				(module.hot._selfAccepted || module.hot._main) &&
 				// removed self-accepted modules should not be required
 				appliedUpdate[outdatedModuleId] !== warnUnexpectedRequire &&
 				// when called invalidate self-accepting is not possible

package/lib/index.js

@@ -28,7 +28,20 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./MultiStats")} MultiStats */
 /** @typedef {import("./Parser").ParserState} ParserState */
 /** @typedef {import("./Watching")} Watching */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunkOrigin} StatsChunkOrigin */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsLogging} StatsLogging */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsLoggingEntry} StatsLoggingEntry */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleIssuer} StatsModuleIssuer */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceDependency} StatsModuleTraceDependency */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceItem} StatsModuleTraceItem */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsProfile} StatsProfile */
 
 /**
  * @template {Function} T
@@ -101,6 +114,9 @@ module.exports = mergeExports(fn, {
 	get AutomaticPrefetchPlugin() {
 		return require("./AutomaticPrefetchPlugin");
 	},
+	get AsyncDependenciesBlock() {
+		return require("./AsyncDependenciesBlock");
+	},
 	get BannerPlugin() {
 		return require("./BannerPlugin");
 	},
@@ -305,6 +321,18 @@ module.exports = mergeExports(fn, {
 		}
 	},
 
+	dependencies: {
+		get ModuleDependency() {
+			return require("./dependencies/ModuleDependency");
+		},
+		get ConstDependency() {
+			return require("./dependencies/ConstDependency");
+		},
+		get NullDependency() {
+			return require("./dependencies/NullDependency");
+		}
+	},
+
 	ids: {
 		get ChunkModuleIdRangePlugin() {
 			return require("./ids/ChunkModuleIdRangePlugin");

package/lib/javascript/JavascriptParser.js

@@ -942,6 +942,10 @@ class JavascriptParser extends Parser {
 							.setRange(expr.range);
 					}
 				});
+			this.hooks.finish.tap("JavascriptParser", () => {
+				// Cleanup for GC
+				cachedExpression = cachedInfo = undefined;
+			});
 		};
 		tapEvaluateWithVariableInfo("Identifier", expr => {
 			const info = this.getVariableInfo(

package/lib/logging/createConsoleLogger.js

@@ -13,11 +13,29 @@ const { LogType } = require("./Logger");
 
 /** @typedef {function(string): boolean} FilterFunction */
 
+/**
+ * @typedef {Object} LoggerConsole
+ * @property {function(): void} clear
+ * @property {function(): void} trace
+ * @property {(...args: any[]) => void} info
+ * @property {(...args: any[]) => void} log
+ * @property {(...args: any[]) => void} warn
+ * @property {(...args: any[]) => void} error
+ * @property {(...args: any[]) => void=} debug
+ * @property {(...args: any[]) => void=} group
+ * @property {(...args: any[]) => void=} groupCollapsed
+ * @property {(...args: any[]) => void=} groupEnd
+ * @property {(...args: any[]) => void=} status
+ * @property {(...args: any[]) => void=} profile
+ * @property {(...args: any[]) => void=} profileEnd
+ * @property {(...args: any[]) => void=} logTime
+ */
+
 /**
  * @typedef {Object} LoggerOptions
  * @property {false|true|"none"|"error"|"warn"|"info"|"log"|"verbose"} level loglevel
  * @property {FilterTypes|boolean} debug filter for debug logging
- * @property {Console & { status?: Function, logTime?: Function }} console the console to log to
+ * @property {LoggerConsole} console the console to log to
  */
 
 /**

package/lib/node/NodeEnvironmentPlugin.js

@@ -11,11 +11,16 @@ const createConsoleLogger = require("../logging/createConsoleLogger");
 const NodeWatchFileSystem = require("./NodeWatchFileSystem");
 const nodeConsole = require("./nodeConsole");
 
+/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
 /** @typedef {import("../Compiler")} Compiler */
 
 class NodeEnvironmentPlugin {
+	/**
+	 * @param {Object} options options
+	 * @param {InfrastructureLogging} options.infrastructureLogging infrastructure logging options
+	 */
 	constructor(options) {
-		this.options = options || {};
+		this.options = options;
 	}
 
 	/**
@@ -24,16 +29,18 @@ class NodeEnvironmentPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.infrastructureLogger = createConsoleLogger(
-			Object.assign(
-				{
-					level: "info",
-					debug: false,
-					console: nodeConsole
-				},
-				this.options.infrastructureLogging
-			)
-		);
+		const { infrastructureLogging } = this.options;
+		compiler.infrastructureLogger = createConsoleLogger({
+			level: infrastructureLogging.level || "info",
+			debug: infrastructureLogging.debug || false,
+			console:
+				infrastructureLogging.console ||
+				nodeConsole({
+					colors: infrastructureLogging.colors,
+					appendOnly: infrastructureLogging.appendOnly,
+					stream: infrastructureLogging.stream
+				})
+		});
 		compiler.inputFileSystem = new CachedInputFileSystem(fs, 60000);
 		const inputFileSystem = compiler.inputFileSystem;
 		compiler.outputFileSystem = fs;

package/lib/node/nodeConsole.js

@@ -8,127 +8,136 @@
 const util = require("util");
 const truncateArgs = require("../logging/truncateArgs");
 
-const tty = process.stderr.isTTY && process.env.TERM !== "dumb";
+module.exports = ({ colors, appendOnly, stream }) => {
+	let currentStatusMessage = undefined;
+	let hasStatusMessage = false;
+	let currentIndent = "";
+	let currentCollapsed = 0;
 
-let currentStatusMessage = undefined;
-let hasStatusMessage = false;
-let currentIndent = "";
-let currentCollapsed = 0;
-
-const indent = (str, prefix, colorPrefix, colorSuffix) => {
-	if (str === "") return str;
-	prefix = currentIndent + prefix;
-	if (tty) {
-		return (
-			prefix +
-			colorPrefix +
-			str.replace(/\n/g, colorSuffix + "\n" + prefix + colorPrefix) +
-			colorSuffix
-		);
-	} else {
-		return prefix + str.replace(/\n/g, "\n" + prefix);
-	}
-};
+	const indent = (str, prefix, colorPrefix, colorSuffix) => {
+		if (str === "") return str;
+		prefix = currentIndent + prefix;
+		if (colors) {
+			return (
+				prefix +
+				colorPrefix +
+				str.replace(/\n/g, colorSuffix + "\n" + prefix + colorPrefix) +
+				colorSuffix
+			);
+		} else {
+			return prefix + str.replace(/\n/g, "\n" + prefix);
+		}
+	};
 
-const clearStatusMessage = () => {
-	if (hasStatusMessage) {
-		process.stderr.write("\x1b[2K\r");
-		hasStatusMessage = false;
-	}
-};
+	const clearStatusMessage = () => {
+		if (hasStatusMessage) {
+			stream.write("\x1b[2K\r");
+			hasStatusMessage = false;
+		}
+	};
 
-const writeStatusMessage = () => {
-	if (!currentStatusMessage) return;
-	const l = process.stderr.columns;
-	const args = l
-		? truncateArgs(currentStatusMessage, l - 1)
-		: currentStatusMessage;
-	const str = args.join(" ");
-	const coloredStr = `\u001b[1m${str}\u001b[39m\u001b[22m`;
-	process.stderr.write(`\x1b[2K\r${coloredStr}`);
-	hasStatusMessage = true;
-};
+	const writeStatusMessage = () => {
+		if (!currentStatusMessage) return;
+		const l = stream.columns;
+		const args = l
+			? truncateArgs(currentStatusMessage, l - 1)
+			: currentStatusMessage;
+		const str = args.join(" ");
+		const coloredStr = `\u001b[1m${str}\u001b[39m\u001b[22m`;
+		stream.write(`\x1b[2K\r${coloredStr}`);
+		hasStatusMessage = true;
+	};
 
-const writeColored = (prefix, colorPrefix, colorSuffix) => {
-	return (...args) => {
-		if (currentCollapsed > 0) return;
-		clearStatusMessage();
-		const str = indent(util.format(...args), prefix, colorPrefix, colorSuffix);
-		process.stderr.write(str + "\n");
-		writeStatusMessage();
+	const writeColored = (prefix, colorPrefix, colorSuffix) => {
+		return (...args) => {
+			if (currentCollapsed > 0) return;
+			clearStatusMessage();
+			const str = indent(
+				util.format(...args),
+				prefix,
+				colorPrefix,
+				colorSuffix
+			);
+			stream.write(str + "\n");
+			writeStatusMessage();
+		};
 	};
-};
 
-const writeGroupMessage = writeColored(
-	"<-> ",
-	"\u001b[1m\u001b[36m",
-	"\u001b[39m\u001b[22m"
-);
+	const writeGroupMessage = writeColored(
+		"<-> ",
+		"\u001b[1m\u001b[36m",
+		"\u001b[39m\u001b[22m"
+	);
 
-const writeGroupCollapsedMessage = writeColored(
-	"<+> ",
-	"\u001b[1m\u001b[36m",
-	"\u001b[39m\u001b[22m"
-);
+	const writeGroupCollapsedMessage = writeColored(
+		"<+> ",
+		"\u001b[1m\u001b[36m",
+		"\u001b[39m\u001b[22m"
+	);
 
-module.exports = {
-	log: writeColored("    ", "\u001b[1m", "\u001b[22m"),
-	debug: writeColored("    ", "", ""),
-	trace: writeColored("    ", "", ""),
-	info: writeColored("<i> ", "\u001b[1m\u001b[32m", "\u001b[39m\u001b[22m"),
-	warn: writeColored("<w> ", "\u001b[1m\u001b[33m", "\u001b[39m\u001b[22m"),
-	error: writeColored("<e> ", "\u001b[1m\u001b[31m", "\u001b[39m\u001b[22m"),
-	logTime: writeColored("<t> ", "\u001b[1m\u001b[35m", "\u001b[39m\u001b[22m"),
-	group: (...args) => {
-		writeGroupMessage(...args);
-		if (currentCollapsed > 0) {
+	return {
+		log: writeColored("    ", "\u001b[1m", "\u001b[22m"),
+		debug: writeColored("    ", "", ""),
+		trace: writeColored("    ", "", ""),
+		info: writeColored("<i> ", "\u001b[1m\u001b[32m", "\u001b[39m\u001b[22m"),
+		warn: writeColored("<w> ", "\u001b[1m\u001b[33m", "\u001b[39m\u001b[22m"),
+		error: writeColored("<e> ", "\u001b[1m\u001b[31m", "\u001b[39m\u001b[22m"),
+		logTime: writeColored(
+			"<t> ",
+			"\u001b[1m\u001b[35m",
+			"\u001b[39m\u001b[22m"
+		),
+		group: (...args) => {
+			writeGroupMessage(...args);
+			if (currentCollapsed > 0) {
+				currentCollapsed++;
+			} else {
+				currentIndent += "  ";
+			}
+		},
+		groupCollapsed: (...args) => {
+			writeGroupCollapsedMessage(...args);
 			currentCollapsed++;
-		} else {
-			currentIndent += "  ";
-		}
-	},
-	groupCollapsed: (...args) => {
-		writeGroupCollapsedMessage(...args);
-		currentCollapsed++;
-	},
-	groupEnd: () => {
-		if (currentCollapsed > 0) currentCollapsed--;
-		else if (currentIndent.length >= 2)
-			currentIndent = currentIndent.slice(0, currentIndent.length - 2);
-	},
-	// eslint-disable-next-line node/no-unsupported-features/node-builtins
-	profile: console.profile && (name => console.profile(name)),
-	// eslint-disable-next-line node/no-unsupported-features/node-builtins
-	profileEnd: console.profileEnd && (name => console.profileEnd(name)),
-	clear:
-		tty &&
+		},
+		groupEnd: () => {
+			if (currentCollapsed > 0) currentCollapsed--;
+			else if (currentIndent.length >= 2)
+				currentIndent = currentIndent.slice(0, currentIndent.length - 2);
+		},
 		// eslint-disable-next-line node/no-unsupported-features/node-builtins
-		console.clear &&
-		(() => {
-			clearStatusMessage();
+		profile: console.profile && (name => console.profile(name)),
+		// eslint-disable-next-line node/no-unsupported-features/node-builtins
+		profileEnd: console.profileEnd && (name => console.profileEnd(name)),
+		clear:
+			!appendOnly &&
 			// eslint-disable-next-line node/no-unsupported-features/node-builtins
-			console.clear();
-			writeStatusMessage();
-		}),
-	status: tty
-		? (name, ...args) => {
-				args = args.filter(Boolean);
-				if (name === undefined && args.length === 0) {
-					clearStatusMessage();
-					currentStatusMessage = undefined;
-				} else if (
-					typeof name === "string" &&
-					name.startsWith("[webpack.Progress] ")
-				) {
-					currentStatusMessage = [name.slice(19), ...args];
-					writeStatusMessage();
-				} else if (name === "[webpack.Progress]") {
-					currentStatusMessage = [...args];
-					writeStatusMessage();
-				} else {
-					currentStatusMessage = [name, ...args];
-					writeStatusMessage();
-				}
-		  }
-		: writeColored("<s> ", "", "")
+			console.clear &&
+			(() => {
+				clearStatusMessage();
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				console.clear();
+				writeStatusMessage();
+			}),
+		status: appendOnly
+			? writeColored("<s> ", "", "")
+			: (name, ...args) => {
+					args = args.filter(Boolean);
+					if (name === undefined && args.length === 0) {
+						clearStatusMessage();
+						currentStatusMessage = undefined;
+					} else if (
+						typeof name === "string" &&
+						name.startsWith("[webpack.Progress] ")
+					) {
+						currentStatusMessage = [name.slice(19), ...args];
+						writeStatusMessage();
+					} else if (name === "[webpack.Progress]") {
+						currentStatusMessage = [...args];
+						writeStatusMessage();
+					} else {
+						currentStatusMessage = [name, ...args];
+						writeStatusMessage();
+					}
+			  }
+	};
 };

package/lib/serialization/ObjectMiddleware.js

@@ -253,13 +253,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 	 */
 	serialize(data, context) {
 		/** @type {any[]} */
-		const result = [CURRENT_VERSION];
+		let result = [CURRENT_VERSION];
 		let currentPos = 0;
-		const referenceable = new Map();
+		let referenceable = new Map();
 		const addReferenceable = item => {
 			referenceable.set(item, currentPos++);
 		};
-		const bufferDedupeMap = new Map();
+		let bufferDedupeMap = new Map();
 		const dedupeBuffer = buf => {
 			const len = buf.length;
 			const entry = bufferDedupeMap.get(len);
@@ -322,7 +322,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 			}
 		};
 		let currentPosTypeLookup = 0;
-		const objectTypeLookup = new Map();
+		let objectTypeLookup = new Map();
 		const cycleStack = new Set();
 		const stackToString = item => {
 			const arr = Array.from(cycleStack);
@@ -370,7 +370,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 				.join(" -> ");
 		};
 		let hasDebugInfoAttached;
-		const ctx = {
+		let ctx = {
 			write(value, key) {
 				try {
 					process(value);
@@ -408,16 +408,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 		};
 		this.extendContext(ctx);
 		const process = item => {
-			// check if we can emit a reference
-			const ref = referenceable.get(item);
-
-			if (ref !== undefined) {
-				result.push(ESCAPE, ref - currentPos);
-
-				return;
-			}
-
 			if (Buffer.isBuffer(item)) {
+				// check if we can emit a reference
+				const ref = referenceable.get(item);
+				if (ref !== undefined) {
+					result.push(ESCAPE, ref - currentPos);
+					return;
+				}
 				const alreadyUsedBuffer = dedupeBuffer(item);
 				if (alreadyUsedBuffer !== item) {
 					const ref = referenceable.get(alreadyUsedBuffer);
@@ -431,7 +428,19 @@ class ObjectMiddleware extends SerializerMiddleware {
 				addReferenceable(item);
 
 				result.push(item);
-			} else if (typeof item === "object" && item !== null) {
+			} else if (item === ESCAPE) {
+				result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
+			} else if (
+				typeof item === "object"
+				// We don't have to check for null as ESCAPE is null and this has been checked before
+			) {
+				// check if we can emit a reference
+				const ref = referenceable.get(item);
+				if (ref !== undefined) {
+					result.push(ESCAPE, ref - currentPos);
+					return;
+				}
+
 				if (cycleStack.has(item)) {
 					throw new Error(`Circular references can't be serialized`);
 				}
@@ -464,6 +473,12 @@ class ObjectMiddleware extends SerializerMiddleware {
 			} else if (typeof item === "string") {
 				if (item.length > 1) {
 					// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
+					// check if we can emit a reference
+					const ref = referenceable.get(item);
+					if (ref !== undefined) {
+						result.push(ESCAPE, ref - currentPos);
+						return;
+					}
 					addReferenceable(item);
 				}
 
@@ -476,8 +491,6 @@ class ObjectMiddleware extends SerializerMiddleware {
 				}
 
 				result.push(item);
-			} else if (item === ESCAPE) {
-				result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
 			} else if (typeof item === "function") {
 				if (!SerializerMiddleware.isLazy(item))
 					throw new Error("Unexpected function " + item);
@@ -511,13 +524,18 @@ class ObjectMiddleware extends SerializerMiddleware {
 			for (const item of data) {
 				process(item);
 			}
+			return result;
 		} catch (e) {
 			if (e === NOT_SERIALIZABLE) return null;
 
 			throw e;
+		} finally {
+			// Get rid of these references to avoid leaking memory
+			// This happens because the optimized code v8 generates
+			// is optimized for our "ctx.write" method so it will reference
+			// it from e. g. Dependency.prototype.serialize -(IC)-> ctx.write
+			data = result = referenceable = bufferDedupeMap = objectTypeLookup = ctx = undefined;
 		}
-
-		return result;
 	}
 
 	/**
@@ -545,8 +563,8 @@ class ObjectMiddleware extends SerializerMiddleware {
 		};
 		let currentPosTypeLookup = 0;
 		let objectTypeLookup = [];
-		const result = [];
-		const ctx = {
+		let result = [];
+		let ctx = {
 			read() {
 				return decodeValue();
 			},
@@ -673,16 +691,18 @@ class ObjectMiddleware extends SerializerMiddleware {
 			}
 		};
 
-		while (currentDataPos < data.length) {
-			result.push(decodeValue());
+		try {
+			while (currentDataPos < data.length) {
+				result.push(decodeValue());
+			}
+			return result;
+		} finally {
+			// Get rid of these references to avoid leaking memory
+			// This happens because the optimized code v8 generates
+			// is optimized for our "ctx.read" method so it will reference
+			// it from e. g. Dependency.prototype.deserialize -(IC)-> ctx.read
+			result = referenceable = data = objectTypeLookup = ctx = undefined;
 		}
-
-		// Help the GC, as functions above might be cached in inline caches
-		referenceable = undefined;
-		objectTypeLookup = undefined;
-		data = undefined;
-
-		return result;
 	}
 }