webpack 5.110.3 → 5.111.0

package/lib/errors/UnusedModulesWarning.js

@@ -0,0 +1,38 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} UnusedModuleDetails
+ * @property {string} name the module, by request
+ * @property {number} size the bytes it adds to the bundle
+ * @property {string} statement the statement that kept it, as `type at location`
+ */
+
+class UnusedModulesWarning extends WebpackError {
+	/**
+	 * Creates an instance of UnusedModulesWarning.
+	 * @param {UnusedModuleDetails[]} modules the modules nothing uses
+	 * @param {number} total how many such modules there are
+	 * @param {number} size the bytes they add between them
+	 */
+	constructor(modules, total, size) {
+		const list = modules
+			.map((it) => `\n  ${it.name} (${it.size} bytes) — ${it.statement}`)
+			.join("");
+
+		super(
+			`unused modules: ${total} ${total === 1 ? "module is" : "modules are"} bundled although nothing uses what they export, costing ${size} bytes:${list}\nEach is kept only by the statement named above, which runs for its effect rather than for anything the importer reads. Move that effect to where it is wanted, or drop the import — 'sideEffects' in the package's package.json says so for a whole package at once.\nFor more info visit https://webpack.js.org/guides/tree-shaking/#mark-the-file-as-side-effect-free`
+		);
+
+		/** @type {string} */
+		this.name = "UnusedModulesWarning";
+	}
+}
+
+module.exports = UnusedModulesWarning;

package/lib/esm/ExportWebpackRequireRuntimeModule.js

@@ -22,6 +22,15 @@ class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -19,7 +19,10 @@ const {
 	getChunkFilenameTemplate,
 	getCompilationHooks
 } = require("../javascript/JavascriptModulesPlugin");
-const { entryModuleIdExpression } = require("../javascript/StartupHelpers");
+const {
+	entryModuleIdExpression,
+	renderAwaitedEntries
+} = require("../javascript/StartupHelpers");
 const { getUndoPath } = require("../util/identifier");
 
 /** @import { Source } from "webpack-sources" */
@@ -186,7 +189,8 @@ class ModuleChunkFormatPlugin {
 				}
 			);
 			hooks.renderChunk.tap(PLUGIN_NAME, (modules, renderContext) => {
-				const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+				const { chunk, chunkGraph, moduleGraph, runtimeTemplate } =
+					renderContext;
 				const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null;
 				const source = new ConcatSource();
 				const cst = runtimeTemplate.renderConst();
@@ -239,6 +243,17 @@ class ModuleChunkFormatPlugin {
 						);
 					}
 
+					const entryOptions = chunk.getEntryOptions();
+					const library =
+						entryOptions && entryOptions.library !== undefined
+							? entryOptions.library
+							: runtimeTemplate.outputOptions.library;
+					// A module library awaits the entry itself, in `ModuleLibraryPlugin`.
+					const canAwaitEntry =
+						runtimeTemplate.supportsTopLevelAwait() &&
+						!(library !== undefined && library.type === "module");
+					/** @type {string[]} */
+					const awaitedEntries = [];
 					/** @type {Set<Chunk>} */
 					const loadedChunks = new Set();
 					let ownInstalled = false;
@@ -296,13 +311,23 @@ class ModuleChunkFormatPlugin {
 							startupSource.add(inlinedEntrySource);
 							startupSource.add("\n");
 						} else {
+							// An async entry nobody awaits settles after the bundle did,
+							// which orphans its rejection.
+							const awaitEntry = canAwaitEntry && moduleGraph.isAsync(module);
+							const target = final
+								? RuntimeGlobals.exports
+								: `${RuntimeGlobals.exports}_${i}`;
 							startupSource.add(
 								`${
-									final ? `var ${RuntimeGlobals.exports} = ` : ""
+									final || awaitEntry ? `var ${target} = ` : ""
 								}__webpack_exec__(${JSON.stringify(moduleId)});\n`
 							);
+							if (awaitEntry) awaitedEntries.push(target);
 						}
 					}
+					for (const line of renderAwaitedEntries(awaitedEntries)) {
+						startupSource.add(`${line}\n`);
+					}
 
 					entrySource.add(
 						hooks.renderStartup.call(

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -78,7 +78,6 @@ class ModuleChunkLoadingPlugin {
 				RuntimeGlobals.ensureChunkHandlers,
 				RuntimeGlobals.baseURI,
 				RuntimeGlobals.externalInstallChunk,
-				RuntimeGlobals.analyzableChunkImport,
 				RuntimeGlobals.onChunksLoaded,
 				RuntimeGlobals.hmrDownloadUpdateHandlers,
 				RuntimeGlobals.hmrDownloadManifest
@@ -90,7 +89,6 @@ class ModuleChunkLoadingPlugin {
 			for (const requirement of [
 				RuntimeGlobals.ensureChunkHandlers,
 				RuntimeGlobals.externalInstallChunk,
-				RuntimeGlobals.analyzableChunkImport,
 				RuntimeGlobals.hmrDownloadUpdateHandlers
 			]) {
 				compilation.hooks.runtimeRequirementInTree
@@ -120,23 +118,44 @@ class ModuleChunkLoadingPlugin {
 						if (!isEnabledForChunk(chunk)) return;
 						// A baked url carries where the chunk is, so neither is read for it.
 						// Asked as the runtime module asks, so the two always agree.
-						const baked = compilation.runtimeTemplate.analyzableChunkScriptUrls(
-							chunk,
-							chunkGraph,
-							set
-						);
-						if (baked !== null && baked.complete) return;
+						if (
+							compilation.runtimeTemplate.analyzableChunkScriptUrls(
+								chunk,
+								chunkGraph,
+								set
+							) !== null
+						) {
+							return;
+						}
 						set.add(RuntimeGlobals.publicPath);
 						set.add(RuntimeGlobals.getChunkScriptFilename);
 					});
 			}
 
 			// Keyed on `ensureChunk`, not on the handler map: only the runtime chunk loader
-			// builds a URL from a chunk id, and an analyzable `import()` carries its own.
+			// builds a URL from a chunk id, and a baked specifier carries its own.
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.ensureChunk)
-				.tap(PLUGIN_NAME, (chunk, set) => {
-					if (!isEnabledForChunk(chunk)) return;
+				.tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => {
+					if (!isEnabledForChunk(chunk)) {
+						compilation.runtimeTemplate.reportChunkImportBailout(
+							chunk,
+							chunkGraph
+						);
+						return;
+					}
+
+					// Asked as the runtime module asks, so the two always agree on whether
+					// a chunk id is ever turned into a url here.
+					const { runtimeTemplate } = compilation;
+					if (
+						runtimeTemplate.analyzableChunkImports(chunk, chunkGraph, set) !==
+							null &&
+						!set.has(RuntimeGlobals.hmrDownloadUpdateHandlers) &&
+						!runtimeTemplate.chunkImportsNeedRuntimeUrl(chunk, chunkGraph)
+					) {
+						return;
+					}
 
 					if (compilation.outputOptions.publicPath !== "auto") {
 						set.add(RuntimeGlobals.publicPath);

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -17,6 +17,7 @@ const { getInitialChunkIds } = require("../javascript/StartupHelpers");
 const { renderBaseUri } = require("../runtime/baseUri");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const createHooksRegistry = require("../util/createHooksRegistry");
+const { RESOLVABLE_SPECIFIER_REGEXP } = require("../util/identifier");
 const memoize = require("../util/memoize");
 
 const getAPIPlugin = memoize(() => require("../APIPlugin"));
@@ -53,6 +54,54 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		this._runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const runtimeRequirements = this._runtimeRequirements;
+		const withHmr = runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const withHint =
+			compilation.outputOptions.environment.document ||
+			compilation.runtimeTemplate.isNeutralPlatform();
+		/** @type {[string, string][]} */
+		const handlers = [];
+		if (
+			runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers) &&
+			(runtimeRequirements.has(RuntimeGlobals.ensureChunk) || withHmr)
+		) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "j"]);
+		}
+		// The hot update flow installs this one onto the same map while it runs.
+		if (withHmr) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "moduleHmr"]);
+		}
+		if (
+			withHint &&
+			runtimeRequirements.has(RuntimeGlobals.prefetchChunkHandlers) &&
+			chunk.hasChildByOrder(chunkGraph, "prefetch", true, chunkHasJs)
+		) {
+			handlers.push([RuntimeGlobals.prefetchChunkHandlers, "j"]);
+		}
+		if (
+			withHint &&
+			runtimeRequirements.has(RuntimeGlobals.preloadChunkHandlers) &&
+			chunk.hasChildByOrder(chunkGraph, "preload", true, chunkHasJs)
+		) {
+			handlers.push([RuntimeGlobals.preloadChunkHandlers, "j"]);
+		}
+		if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+			handlers.push([RuntimeGlobals.onChunksLoaded, "j"]);
+		}
+		return handlers;
+	}
+
 	/**
 	 * Returns generated code.
 	 * @private
@@ -96,9 +145,6 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		const withExternalInstallChunk = this._runtimeRequirements.has(
 			RuntimeGlobals.externalInstallChunk
 		);
-		const withAnalyzableImport = this._runtimeRequirements.has(
-			RuntimeGlobals.analyzableChunkImport
-		);
 		const withLoading = this._runtimeRequirements.has(
 			RuntimeGlobals.ensureChunkHandlers
 		);
@@ -111,8 +157,8 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		const withHmrManifest = this._runtimeRequirements.has(
 			RuntimeGlobals.hmrDownloadManifest
 		);
-		// `.f.j` serves `ensureChunk`: an analyzable import dispatches every handler but
-		// this one. HMR's force-load knows only a chunk id, so it needs the loader too.
+		// `.f.j` serves `ensureChunk`. HMR's force-load knows only a chunk id, so it
+		// needs the loader too.
 		const withJsLoading =
 			withLoading &&
 			(this._runtimeRequirements.has(RuntimeGlobals.ensureChunk) || withHmr);
@@ -129,7 +175,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			chunk.hasChildByOrder(chunkGraph, "preload", true, chunkHasJs);
 		// Under module output each hinted chunk is a known file, so the urls are written
 		// out and read by id rather than built from the chunk id at runtime.
-		const bakedChunkUrls =
+		const chunkUrls =
 			withPrefetch || withPreload
 				? runtimeTemplate.analyzableChunkScriptUrls(
 						chunk,
@@ -138,12 +184,16 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 						this
 					)
 				: null;
-		// A hint is best-effort, so an id an incomplete map lacks is not worth a per-id
-		// fallback — only a complete map replaces the runtime name lookup.
-		const chunkUrls =
-			bakedChunkUrls !== null && bakedChunkUrls.complete
-				? bakedChunkUrls.urls
-				: null;
+		// Under module output every chunk the loader reaches is a known file, so it
+		// imports a literal specifier read by id instead of a url built from that id.
+		const chunkImports = withJsLoading
+			? runtimeTemplate.analyzableChunkImports(
+					chunk,
+					chunkGraph,
+					this._runtimeRequirements,
+					this
+				)
+			: null;
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
@@ -158,7 +208,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			publicPath === "auto"
 				? JSON.stringify(rootOutputDir)
 				: typeof publicPath === "string" &&
-					  !/^(?:\.{0,2}\/|[a-zA-Z][\w+.-]*:)/.test(publicPath) &&
+					  !RESOLVABLE_SPECIFIER_REGEXP.test(publicPath) &&
 					  !getAPIPlugin().usesRuntimePublicPathOverride(compilation)
 					? `"./" + ${RuntimeGlobals.publicPath}`
 					: RuntimeGlobals.publicPath;
@@ -179,7 +229,6 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		const withInstalledChunks =
 			withLoading ||
 			withExternalInstallChunk ||
-			withAnalyzableImport ||
 			withOnChunkLoad ||
 			withHmr ||
 			withPrefetch ||
@@ -194,6 +243,19 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			chunkUrls === null
 				? `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(${id})`
 				: `chunkUrls[${id}]()`;
+		const runtimeImport = `${importFunctionName}(${chunkImportBase} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId))`;
+		// A hot update can force-load an id this build never saw, and a chunk with a
+		// runtime of its own is never named, so only those keep the url form.
+		const withRuntimeUrl =
+			chunkImports === null ||
+			withHmr ||
+			runtimeTemplate.chunkImportsNeedRuntimeUrl(chunk, chunkGraph);
+		const chunkImport =
+			chunkImports === null
+				? runtimeImport
+				: withRuntimeUrl
+					? `(${RuntimeGlobals.hasOwnProperty}(chunkImports, chunkId) ? chunkImports[chunkId]() : ${runtimeImport})`
+					: "chunkImports[chunkId]()";
 		return Template.asString([
 			withBaseURI
 				? this._generateBaseUri(chunk, rootOutputDir)
@@ -211,6 +273,20 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 						""
 					]
 				: []),
+			...(chunkImports
+				? [
+						`${cst} chunkImports = {\n${Template.indent(
+							Array.from(
+								chunkImports,
+								([id, specifier]) =>
+									`${JSON.stringify(String(id))}: ${runtimeTemplate.returningFunction(
+										`${importFunctionName}(${specifier})`
+									)}`
+							).join(",\n")
+						)}\n};`,
+						""
+					]
+				: []),
 			withInstalledChunks
 				? Template.asString([
 						"// object to store loaded and loading chunks",
@@ -227,7 +303,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 					])
 				: "// no installed chunks",
 			"",
-			withLoading || withExternalInstallChunk || withAnalyzableImport
+			withLoading || withExternalInstallChunk
 				? `${cst} installChunk = ${runtimeTemplate.basicFunction("data", [
 						runtimeTemplate.destructureObject(
 							[
@@ -286,9 +362,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 													: `if(${hasJsMatcher("chunkId")}) {`,
 												Template.indent([
 													"// setup Promise in chunk cache",
-													`${lt} promise = ${importFunctionName}(${chunkImportBase} + ${
-														RuntimeGlobals.getChunkScriptFilename
-													}(chunkId)).then(installChunk, ${runtimeTemplate.basicFunction(
+													`${lt} promise = ${chunkImport}.then(installChunk, ${runtimeTemplate.basicFunction(
 														"e",
 														[
 															"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
@@ -428,48 +502,6 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 					])
 				: "// no external install chunk",
 			"",
-			withAnalyzableImport
-				? `${
-						RuntimeGlobals.analyzableChunkImport
-					} = ${runtimeTemplate.basicFunction("chunkId, importFn", [
-						// `ensureChunk` with its `.j` half replaced by a literal `import()` a foreign
-						// bundler can follow. The remaining handlers still run, so a chunk's css and
-						// its prefetch/preload children are not lost by taking this path.
-						`${lt} promises = [];`,
-						`${lt} installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
-						'if(installedChunkData !== 0) { // 0 means "already installed".',
-						Template.indent([
-							'// a Promise means "currently loading".',
-							"if(installedChunkData) {",
-							Template.indent(["promises.push(installedChunkData[1]);"]),
-							"} else {",
-							Template.indent([
-								`${lt} promise = importFn().then(installChunk, ${runtimeTemplate.basicFunction(
-									"e",
-									[
-										"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
-										"throw e;"
-									]
-								)});`,
-								`promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
-									"installedChunkData = installedChunks[chunkId] = [resolve]",
-									"resolve"
-								)})]);`,
-								"promises.push((installedChunkData[1] = promise));"
-							]),
-							"}"
-						]),
-						"}",
-						withLoading
-							? `Object.keys(${fn}).forEach(${runtimeTemplate.basicFunction(
-									"key",
-									[`if(key !== "j") ${fn}[key](chunkId, promises);`]
-								)});`
-							: "// no other chunk loading handlers",
-						"return Promise.all(promises);"
-					])};`
-				: "// no analyzable chunk import",
-			"",
 			withOnChunkLoad
 				? `${
 						RuntimeGlobals.onChunksLoaded

package/lib/hmr/HotModuleReplacement.runtime.js

@@ -26,14 +26,20 @@
 
 /** @typedef {(options: ApplyOptions) => ApplyResult} ApplyHandler */
 /** @typedef {(moduleId: ModuleId, applyHandlers: ApplyHandler[]) => void} InvalidateModuleHandler */
-/** @typedef {(chunkIds: ModuleId[], removedChunks: ModuleId[], removedModules: ModuleId[], promises: Promise<unknown>[], applyHandlers: ApplyHandler[], updatedModulesList: ModuleId[], css: ModuleId[] | undefined, forceLoadChunks: ModuleId[] | undefined) => void} DownloadUpdateHandler */
+/**
+ * @typedef {object} CssUpdateManifest
+ * @property {ModuleId[]} r updated chunk ids that no longer have a stylesheet
+ * @property {Record<string, string>=} n the stylesheet name of each updated chunk whose name moved with its content
+ */
+
+/** @typedef {(chunkIds: ModuleId[], removedChunks: ModuleId[], removedModules: ModuleId[], promises: Promise<unknown>[], applyHandlers: ApplyHandler[], updatedModulesList: ModuleId[], css: CssUpdateManifest | undefined, forceLoadChunks: ModuleId[] | undefined) => void} DownloadUpdateHandler */
 
 /**
  * @typedef {object} HMRManifest
  * @property {ModuleId[]} c updated chunk ids
  * @property {ModuleId[]} r removed chunk ids
  * @property {ModuleId[]} m removed module ids
- * @property {ModuleId[]=} css updated css chunk ids
+ * @property {CssUpdateManifest=} css what the stylesheet loader needs to know about the update
  * @property {ModuleId[]=} f chunk ids to force-load
  */
 

package/lib/hmr/HotModuleReplacementRuntimeModule.js

@@ -16,6 +16,15 @@ class HotModuleReplacementRuntimeModule extends RuntimeModule {
 		super("hot module replacement", RuntimeModule.STAGE_BASIC);
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/html/HtmlGenerator.js

@@ -9,6 +9,7 @@ const ConcatenationScope = require("../ConcatenationScope");
 const Generator = require("../Generator");
 const {
 	HTML_TYPE,
+	HTML_TYPES,
 	JAVASCRIPT_TYPE,
 	JAVASCRIPT_TYPES
 } = require("../ModuleSourceTypeConstants");
@@ -1047,13 +1048,16 @@ class HtmlGenerator extends Generator {
 	 * Creates an instance of HtmlGenerator.
 	 * @param {HtmlGeneratorOptions=} options generator options
 	 * @param {ModuleGraph=} moduleGraph the module graph; used to detect when an HTML module is reached as a compilation entry so `extract` can default to `true` for it
+	 * @param {((module: NormalModule) => boolean)=} isPageOnly tells whether the module's only output is its emitted page, so it exposes no JavaScript
 	 */
-	constructor(options, moduleGraph) {
+	constructor(options, moduleGraph, isPageOnly) {
 		super();
 		/** @type {HtmlGeneratorOptions} */
 		this.options = options || {};
 		/** @type {ModuleGraph | undefined} */
 		this._moduleGraph = moduleGraph;
+		/** @type {((module: NormalModule) => boolean) | undefined} */
+		this._isPageOnly = isPageOnly;
 		// Raw dependency-template render (before `[webpack/auto]` resolution),
 		// shared between the JS and HTML type passes of a single
 		// `codeGeneration()` call. Keyed by that call's `runtimeRequirements`
@@ -1134,6 +1138,9 @@ class HtmlGenerator extends Generator {
 	 */
 	getTypes(module) {
 		if (this._shouldExposeHtmlType(module)) {
+			// A page nothing else reads has no JavaScript side: that chunk would
+			// only re-export the markup already emitted as the `.html` asset.
+			if (this._isPageOnly && this._isPageOnly(module)) return HTML_TYPES;
 			return JAVASCRIPT_AND_HTML_TYPES;
 		}
 		return JAVASCRIPT_TYPES;
@@ -1143,10 +1150,9 @@ class HtmlGenerator extends Generator {
 	 * @returns {boolean} whether getTypes() depends on the module's incoming connections
 	 */
 	getTypesDependOnIncomingConnections() {
-		// A fixed extract (`true` / `false` / `"inline"`) gives a stable type set;
-		// only the unset default reads `_isEntryModule` (incoming connections).
-		const { extract } = this.options;
-		return extract !== true && extract !== false && extract !== "inline";
+		// Every page that can expose the html type reads incoming connections —
+		// for the `extract` default, and for the page-only JavaScript drop.
+		return this.options.extract !== false;
 	}
 
 	/**