webpack 5.102.1 → 5.103.0

package/lib/runtime/MakeDeferredNamespaceObjectRuntime.js

@@ -8,8 +8,12 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+/** @typedef {import("../Module").ExportsType} ExportsType */
+/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
+
 /**
- * @param {import("../Module").ExportsType} exportsType exports type
+ * @param {ExportsType} exportsType exports type
  * @returns {string} mode
  */
 function getMakeDeferredNamespaceModeFromExportsType(exportsType) {
@@ -19,61 +23,81 @@ function getMakeDeferredNamespaceModeFromExportsType(exportsType) {
 	if (exportsType === "dynamic") return `/* ${exportsType} */ 3`;
 	return "";
 }
+
 /**
- * @param {import("../ModuleTemplate").RuntimeTemplate} _runtimeTemplate runtimeTemplate
- * @param {import("../Module").ExportsType} exportsType exportsType
  * @param {string} moduleId moduleId
- * @param {(import("../ChunkGraph").ModuleId | null)[]} asyncDepsIds asyncDepsIds
- * @returns {string} function
+ * @param {ExportsType} exportsType exportsType
+ * @param {(ModuleId | null)[]} asyncDepsIds asyncDepsIds
+ * @param {RuntimeRequirements} runtimeRequirements runtime requirements
+ * @returns {string} call make optimized deferred namespace object
  */
 function getOptimizedDeferredModule(
-	_runtimeTemplate,
-	exportsType,
 	moduleId,
-	asyncDepsIds
+	exportsType,
+	asyncDepsIds,
+	runtimeRequirements
 ) {
-	const isAsync = asyncDepsIds && asyncDepsIds.length;
-	const init = `${RuntimeGlobals.require}(${moduleId})${
-		isAsync ? `[${RuntimeGlobals.asyncModuleExportSymbol}]` : ""
-	}`;
-	const props = [
-		`/* ${exportsType} */ get a() {`,
-		// if exportsType is "namespace" we can generate the most optimized code,
-		// on the second access, we can avoid trigger the getter.
-		// we can also do this if exportsType is "dynamic" and there is a "__esModule" property on it.
-		exportsType === "namespace" || exportsType === "dynamic"
-			? Template.indent([
-					`var exports = ${init};`,
-					`${
-						exportsType === "dynamic" ? "if (exports.__esModule) " : ""
-					}Object.defineProperty(this, "a", { value: exports });`,
-					"return exports;"
-				])
-			: Template.indent([`return ${init};`]),
-		isAsync ? "}," : "}",
-		isAsync
-			? `[${
-					RuntimeGlobals.makeDeferredNamespaceObjectSymbol
-				}]: ${JSON.stringify(asyncDepsIds.filter((x) => x !== null))}`
+	runtimeRequirements.add(RuntimeGlobals.makeOptimizedDeferredNamespaceObject);
+	const mode = getMakeDeferredNamespaceModeFromExportsType(exportsType);
+	return `${RuntimeGlobals.makeOptimizedDeferredNamespaceObject}(${moduleId}, ${mode}${
+		asyncDepsIds.length > 0
+			? `, ${JSON.stringify(asyncDepsIds.filter((x) => x !== null))}`
 			: ""
-	];
-	return Template.asString(["{", Template.indent(props), "}"]);
+	})`;
 }
 
-const strictModuleCache = [
-	"if (cachedModule && cachedModule.error === undefined) {",
-	Template.indent([
-		"var exports = cachedModule.exports;",
-		"if (mode == 0) return exports;",
-		`if (mode == 1) return ${RuntimeGlobals.createFakeNamespaceObject}(exports);`,
-		`if (mode == 2) return ${RuntimeGlobals.createFakeNamespaceObject}(exports, 2);`,
-		`if (mode == 3) return ${RuntimeGlobals.createFakeNamespaceObject}(exports, 6);` // 2 | 4
-	]),
-	"}"
-];
-const nonStrictModuleCache = [
-	"// optimization not applied when output.strictModuleErrorHandling is off"
-];
+class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {boolean} hasAsyncRuntime if async module is used.
+	 */
+	constructor(hasAsyncRuntime) {
+		super("make optimized deferred namespace object");
+		this.hasAsyncRuntime = hasAsyncRuntime;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		if (!this.compilation) return null;
+		const fn = RuntimeGlobals.makeOptimizedDeferredNamespaceObject;
+		const hasAsync = this.hasAsyncRuntime;
+		return Template.asString([
+			// Note: must be a function (not arrow), because this is used in body!
+			`${fn} = function(moduleId, mode${hasAsync ? ", asyncDeps" : ""}) {`,
+			Template.indent([
+				"// mode: 0 => namespace (esm)",
+				"// mode: 1 => default-only (esm strict cjs)",
+				"// mode: 2 => default-with-named (esm-cjs compat)",
+				"// mode: 3 => dynamic (if exports has __esModule, then esm, otherwise default-with-named)",
+				"var r = this;",
+				hasAsync ? "var isAsync = asyncDeps && asyncDeps.length;" : "",
+				"var obj = {",
+				Template.indent([
+					"get a() {",
+					Template.indent([
+						"var exports = r(moduleId);",
+						hasAsync
+							? `if(isAsync) exports = exports[${RuntimeGlobals.asyncModuleExportSymbol}];`
+							: "",
+						// if exportsType is "namespace" we can generate the most optimized code,
+						// on the second access, we can avoid trigger the getter.
+						// we can also do this if exportsType is "dynamic" and there is a "__esModule" property on it.
+						'if(mode == 0 || (mode == 3 && exports.__esModule)) Object.defineProperty(this, "a", { value: exports });',
+						"return exports;"
+					]),
+					"}"
+				]),
+				"};",
+				hasAsync
+					? `if(isAsync) obj[${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol}] = asyncDeps;`
+					: "",
+				"return obj;"
+			]),
+			"};"
+		]);
+	}
+}
 
 class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 	/**
@@ -92,8 +116,6 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 		const { runtimeTemplate } = this.compilation;
 		const fn = RuntimeGlobals.makeDeferredNamespaceObject;
 		const hasAsync = this.hasAsyncRuntime;
-		const strictError =
-			this.compilation.options.output.strictModuleErrorHandling;
 		const init = runtimeTemplate.supportsOptionalChaining()
 			? "init?.();"
 			: "if (init) init();";
@@ -104,7 +126,18 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 			"// mode: 3 => dynamic (if exports has __esModule, then esm, otherwise default-with-named)",
 			"",
 			"var cachedModule = __webpack_module_cache__[moduleId];",
-			...(strictError ? strictModuleCache : nonStrictModuleCache),
+			"if (cachedModule && cachedModule.error === undefined) {",
+			Template.indent([
+				"var exports = cachedModule.exports;",
+				hasAsync
+					? `if (${RuntimeGlobals.asyncModuleExportSymbol} in exports) exports = exports[${RuntimeGlobals.asyncModuleExportSymbol}];`
+					: "",
+				"if (mode == 0) return exports;",
+				`if (mode == 1) return ${RuntimeGlobals.createFakeNamespaceObject}(exports);`,
+				`if (mode == 2) return ${RuntimeGlobals.createFakeNamespaceObject}(exports, 2);`,
+				`if (mode == 3) return ${RuntimeGlobals.createFakeNamespaceObject}(exports, 6);` // 2 | 4
+			]),
+			"}",
 			"",
 			`var init = ${runtimeTemplate.basicFunction("", [
 				`ns = ${RuntimeGlobals.require}(moduleId);`,
@@ -137,9 +170,7 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				"}"
 			])};`,
 			"",
-			`var ns = ${
-				strictError ? "" : "cachedModule && cachedModule.exports || "
-			}__webpack_module_deferred_exports__[moduleId] || (__webpack_module_deferred_exports__[moduleId] = { __proto__: null });`,
+			"var ns = __webpack_module_deferred_exports__[moduleId] || (__webpack_module_deferred_exports__[moduleId] = { __proto__: null });",
 			"var handler = {",
 			Template.indent([
 				"__proto__: null,",
@@ -161,7 +192,7 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 							'case "__esModule":',
 							"case Symbol.toStringTag:",
 							hasAsync
-								? `case ${RuntimeGlobals.makeDeferredNamespaceObjectSymbol}:`
+								? `case ${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol}:`
 								: "",
 							Template.indent("return true;"),
 							'case "then":',
@@ -208,7 +239,10 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 	}
 }
 
-module.exports = MakeDeferredNamespaceObjectRuntimeModule;
+module.exports.MakeDeferredNamespaceObjectRuntimeModule =
+	MakeDeferredNamespaceObjectRuntimeModule;
+module.exports.MakeOptimizedDeferredNamespaceObjectRuntimeModule =
+	MakeOptimizedDeferredNamespaceObjectRuntimeModule;
 module.exports.getMakeDeferredNamespaceModeFromExportsType =
 	getMakeDeferredNamespaceModeFromExportsType;
 module.exports.getOptimizedDeferredModule = getOptimizedDeferredModule;

package/lib/util/comparators.js

@@ -19,6 +19,7 @@ const { compareRuntime } = require("./runtime");
 /** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../dependencies/ModuleDependency")} ModuleDependency */
 
 /**
  * @typedef {object} DependencySourceOrder
@@ -524,9 +525,9 @@ const sortWithSourceOrder = (dependencies, dependencySourceOrderMap) => {
 			);
 			return main;
 		}
-		return /** @type { HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */ (
-			dep
-		).sourceOrder;
+		return /** @type {number} */ (
+			/** @type {ModuleDependency} */ (dep).sourceOrder
+		);
 	};
 
 	/**

package/lib/util/internalSerializables.js

@@ -73,10 +73,10 @@ module.exports = {
 		require("../dependencies/CriticalDependencyWarning"),
 	"dependencies/CssImportDependency": () =>
 		require("../dependencies/CssImportDependency"),
-	"dependencies/CssLocalIdentifierDependency": () =>
-		require("../dependencies/CssLocalIdentifierDependency"),
-	"dependencies/CssSelfLocalIdentifierDependency": () =>
-		require("../dependencies/CssSelfLocalIdentifierDependency"),
+	"dependencies/CssIcssLocalIdentifierDependency": () =>
+		require("../dependencies/CssIcssLocalIdentifierDependency"),
+	"dependencies/CssIcssSelfLocalIdentifierDependency": () =>
+		require("../dependencies/CssIcssSelfLocalIdentifierDependency"),
 	"dependencies/CssIcssImportDependency": () =>
 		require("../dependencies/CssIcssImportDependency"),
 	"dependencies/CssIcssExportDependency": () =>

package/lib/util/jsonParseEvenBetterErrors.js

@@ -0,0 +1,10 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+//#region runtime code: json-parse-even-better-errors, parseJsonError
+module.exports = "test";
+//#endregion

package/lib/wasm/EnableWasmLoadingPlugin.js

@@ -77,7 +77,6 @@ class EnableWasmLoadingPlugin {
 			switch (type) {
 				case "fetch": {
 					if (compiler.options.experiments.syncWebAssembly) {
-						// TODO webpack 6 remove FetchCompileWasmPlugin
 						const FetchCompileWasmPlugin = require("../web/FetchCompileWasmPlugin");
 
 						new FetchCompileWasmPlugin({
@@ -95,7 +94,6 @@ class EnableWasmLoadingPlugin {
 				}
 				case "async-node": {
 					if (compiler.options.experiments.syncWebAssembly) {
-						// TODO webpack 6 remove ReadFileCompileWasmPlugin
 						const ReadFileCompileWasmPlugin = require("../node/ReadFileCompileWasmPlugin");
 
 						new ReadFileCompileWasmPlugin({
@@ -119,9 +117,17 @@ class EnableWasmLoadingPlugin {
 					break;
 				}
 				case "universal": {
-					const UniversalCompileAsyncWasmPlugin = require("../wasm-async/UniversalCompileAsyncWasmPlugin");
+					if (compiler.options.experiments.syncWebAssembly) {
+						throw new Error(
+							"Universal wasm loading type is only supported by asynchronous web assembly."
+						);
+					}
 
-					new UniversalCompileAsyncWasmPlugin().apply(compiler);
+					if (compiler.options.experiments.asyncWebAssembly) {
+						const UniversalCompileAsyncWasmPlugin = require("../wasm-async/UniversalCompileAsyncWasmPlugin");
+
+						new UniversalCompileAsyncWasmPlugin().apply(compiler);
+					}
 					break;
 				}
 				default:

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -20,7 +20,7 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 /** @typedef {import("../NormalModule")} NormalModule */
 
 /**
- * @typedef {{ request: string, importVar: string }} ImportObjRequestItem
+ * @typedef {{ request: string, importVar: string, dependency: WebAssemblyImportDependency }} ImportObjRequestItem
  */
 
 class AsyncWebAssemblyJavascriptGenerator extends Generator {
@@ -70,7 +70,8 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 				if (!depModules.has(module)) {
 					depModules.set(module, {
 						request: dep.request,
-						importVar: `WEBPACK_IMPORTED_MODULE_${depModules.size}`
+						importVar: `WEBPACK_IMPORTED_MODULE_${depModules.size}`,
+						dependency: dep
 					});
 				}
 				let list = wasmDepsByRequest.get(dep.request);
@@ -87,7 +88,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 
 		const importStatements = Array.from(
 			depModules,
-			([importedModule, { request, importVar }]) => {
+			([importedModule, { request, importVar, dependency }]) => {
 				if (moduleGraph.isAsync(importedModule)) {
 					promises.push(importVar);
 				}
@@ -99,7 +100,8 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 					request,
 					originModule: module,
 					importVar,
-					runtimeRequirements
+					runtimeRequirements,
+					dependency
 				});
 			}
 		);
@@ -132,7 +134,8 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 						importVar,
 						initFragments,
 						runtime,
-						runtimeRequirements
+						runtimeRequirements,
+						dependency: dep
 					})}`;
 				});
 				return Template.asString([

package/lib/wasm-sync/WebAssemblyJavascriptGenerator.js

@@ -71,6 +71,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 					importedModules.set(
 						moduleGraph.getModule(dep),
 						(importData = {
+							dependency: moduleDep,
 							importVar: `m${index}`,
 							index,
 							request: (moduleDep && moduleDep.userRequest) || undefined,
@@ -106,7 +107,8 @@ class WebAssemblyJavascriptGenerator extends Generator {
 										defaultInterop: true,
 										initFragments,
 										runtime,
-										runtimeRequirements
+										runtimeRequirements,
+										dependency: dep
 									})
 								);
 							}
@@ -138,7 +140,8 @@ class WebAssemblyJavascriptGenerator extends Generator {
 								defaultInterop: true,
 								initFragments,
 								runtime,
-								runtimeRequirements
+								runtimeRequirements,
+								dependency: dep
 							})};`,
 							`if(WebAssembly.Global) ${exportProp} = ` +
 								`new WebAssembly.Global({ value: ${JSON.stringify(
@@ -154,7 +157,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 		const importsCode = Template.asString(
 			Array.from(
 				importedModules,
-				([module, { importVar, request, reexports }]) => {
+				([module, { importVar, request, reexports, dependency }]) => {
 					const importStatement = runtimeTemplate.importStatement({
 						module,
 						moduleGraph,
@@ -162,7 +165,8 @@ class WebAssemblyJavascriptGenerator extends Generator {
 						request,
 						importVar,
 						originModule: module,
-						runtimeRequirements
+						runtimeRequirements,
+						dependency
 					});
 					return importStatement[0] + importStatement[1] + reexports.join("\n");
 				}

package/lib/web/FetchCompileWasmPlugin.js

@@ -17,8 +17,6 @@ const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRunt
  * @property {boolean=} mangleImports mangle imports
  */
 
-// TODO webpack 6 remove
-
 const PLUGIN_NAME = "FetchCompileWasmPlugin";
 
 class FetchCompileWasmPlugin {

package/lib/webpack.js

@@ -106,107 +106,110 @@ const createCompiler = (rawOptions, compilerIndex) => {
 };
 
 /**
- * @callback WebpackFunctionSingle
+ * @template T
+ * @param {T[] | T} options options
+ * @returns {T[]} array of options
+ */
+const asArray = (options) =>
+	Array.isArray(options) ? [...options] : [options];
+
+/**
+ * @overload
  * @param {WebpackOptions} options options object
- * @param {Callback<Stats>=} callback callback
+ * @param {Callback<Stats>} callback callback
  * @returns {Compiler | null} the compiler object
  */
-
 /**
- * @callback WebpackFunctionMulti
+ * @overload
+ * @param {WebpackOptions} options options object
+ * @returns {Compiler} the compiler object
+ */
+/**
+ * @overload
  * @param {MultiWebpackOptions} options options objects
- * @param {Callback<MultiStats>=} callback callback
+ * @param {Callback<MultiStats>} callback callback
  * @returns {MultiCompiler | null} the multi compiler object
  */
-
 /**
- * @template T
- * @param {T[] | T} options options
- * @returns {T[]} array of options
+ * @overload
+ * @param {MultiWebpackOptions} options options objects
+ * @returns {MultiCompiler} the multi compiler object
  */
-const asArray = (options) =>
-	Array.isArray(options) ? [...options] : [options];
-
 /**
- * @callback WebpackCallback
  * @param {WebpackOptions | MultiWebpackOptions} options options
  * @param {Callback<Stats> & Callback<MultiStats>=} callback callback
  * @returns {Compiler | MultiCompiler | null} Compiler or MultiCompiler
  */
-
-const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
-	/** @type {WebpackCallback} */
-	(options, callback) => {
-		const create = () => {
-			if (
-				!asArray(/** @type {WebpackOptions} */ (options)).every(
-					webpackOptionsSchemaCheck
-				)
-			) {
-				getValidateSchema()(webpackOptionsSchema, options);
-				util.deprecate(
-					() => {},
-					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
-					"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
-				)();
-			}
-			/** @type {MultiCompiler|Compiler} */
-			let compiler;
-			/** @type {boolean | undefined} */
-			let watch = false;
-			/** @type {WatchOptions | WatchOptions[]} */
-			let watchOptions;
-			if (Array.isArray(options)) {
-				/** @type {MultiCompiler} */
-				compiler = createMultiCompiler(
-					options,
-					/** @type {MultiCompilerOptions} */
-					(options)
-				);
-				watch = options.some((options) => options.watch);
-				watchOptions = options.map((options) => options.watchOptions || {});
-			} else {
-				const webpackOptions = /** @type {WebpackOptions} */ (options);
-				/** @type {Compiler} */
-				compiler = createCompiler(webpackOptions);
-				watch = webpackOptions.watch;
-				watchOptions = webpackOptions.watchOptions || {};
-			}
-			return { compiler, watch, watchOptions };
-		};
-		if (callback) {
-			try {
-				const { compiler, watch, watchOptions } = create();
-				if (watch) {
-					compiler.watch(watchOptions, callback);
-				} else {
-					compiler.run((err, stats) => {
-						compiler.close((err2) => {
-							callback(
-								err || err2,
-								/** @type {options extends WebpackOptions ? Stats : MultiStats} */
-								(stats)
-							);
-						});
-					});
-				}
-				return compiler;
-			} catch (err) {
-				process.nextTick(() => callback(/** @type {Error} */ (err)));
-				return null;
-			}
+const webpack = (options, callback) => {
+	const create = () => {
+		if (
+			!asArray(/** @type {WebpackOptions} */ (options)).every(
+				webpackOptionsSchemaCheck
+			)
+		) {
+			getValidateSchema()(webpackOptionsSchema, options);
+			util.deprecate(
+				() => {},
+				"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
+				"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
+			)();
+		}
+		/** @type {MultiCompiler|Compiler} */
+		let compiler;
+		/** @type {boolean | undefined} */
+		let watch = false;
+		/** @type {WatchOptions | WatchOptions[]} */
+		let watchOptions;
+		if (Array.isArray(options)) {
+			/** @type {MultiCompiler} */
+			compiler = createMultiCompiler(
+				options,
+				/** @type {MultiCompilerOptions} */
+				(options)
+			);
+			watch = options.some((options) => options.watch);
+			watchOptions = options.map((options) => options.watchOptions || {});
 		} else {
-			const { compiler, watch } = create();
+			const webpackOptions = /** @type {WebpackOptions} */ (options);
+			/** @type {Compiler} */
+			compiler = createCompiler(webpackOptions);
+			watch = webpackOptions.watch;
+			watchOptions = webpackOptions.watchOptions || {};
+		}
+		return { compiler, watch, watchOptions };
+	};
+	if (callback) {
+		try {
+			const { compiler, watch, watchOptions } = create();
 			if (watch) {
-				util.deprecate(
-					() => {},
-					"A 'callback' argument needs to be provided to the 'webpack(options, callback)' function when the 'watch' option is set. There is no way to handle the 'watch' option without a callback.",
-					"DEP_WEBPACK_WATCH_WITHOUT_CALLBACK"
-				)();
+				compiler.watch(watchOptions, callback);
+			} else {
+				compiler.run((err, stats) => {
+					compiler.close((err2) => {
+						callback(
+							err || err2,
+							/** @type {options extends WebpackOptions ? Stats : MultiStats} */
+							(stats)
+						);
+					});
+				});
 			}
 			return compiler;
+		} catch (err) {
+			process.nextTick(() => callback(/** @type {Error} */ (err)));
+			return null;
 		}
+	} else {
+		const { compiler, watch } = create();
+		if (watch) {
+			util.deprecate(
+				() => {},
+				"A 'callback' argument needs to be provided to the 'webpack(options, callback)' function when the 'watch' option is set. There is no way to handle the 'watch' option without a callback.",
+				"DEP_WEBPACK_WATCH_WITHOUT_CALLBACK"
+			)();
+		}
+		return compiler;
 	}
-);
+};
 
 module.exports = webpack;

package/module.d.ts

@@ -161,10 +161,15 @@ declare namespace webpack {
 	}
 }
 
+interface ImportMetaEnv {
+	[key: string]: string | boolean | undefined;
+}
+
 interface ImportMeta {
 	url: string;
 	webpack: number;
 	webpackHot: webpack.Hot;
+	env: ImportMetaEnv;
 	webpackContext: (
 		request: string,
 		options?: {