webpack 5.59.0 → 5.76.0

package/lib/dependencies/HarmonyAcceptImportDependency.js

@@ -7,6 +7,7 @@
 
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
+const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
@@ -28,8 +29,9 @@ makeSerializable(
 	"webpack/lib/dependencies/HarmonyAcceptImportDependency"
 );
 
-HarmonyAcceptImportDependency.Template = class HarmonyAcceptImportDependencyTemplate extends (
-	HarmonyImportDependency.Template
-) {};
+HarmonyAcceptImportDependency.Template =
+	/** @type {typeof HarmonyImportDependency.Template} */ (
+		NullDependency.Template
+	);
 
 module.exports = HarmonyAcceptImportDependency;

package/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -74,14 +74,14 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 			initFragments.push(
 				new InitFragment(
 					runtimeTemplate.supportsArrowFunction()
-						? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__) => {\n`
-						: `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__) {\n`,
+						? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {\n`
+						: `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {\n`,
 					InitFragment.STAGE_ASYNC_BOUNDARY,
 					0,
 					undefined,
-					module.buildMeta.async
-						? `\n__webpack_handle_async_dependencies__();\n}, 1);`
-						: "\n});"
+					`\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } }${
+						module.buildMeta.async ? ", 1" : ""
+					});`
 				)
 			);
 		}

package/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency.js

@@ -0,0 +1,127 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+/**
+ * Dependency for static evaluating import specifier. e.g.
+ * @example
+ * import a from "a";
+ * "x" in a;
+ * a.x !== undefined; // if x value statically analyzable
+ */
+class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDependency {
+	constructor(request, sourceOrder, ids, name, range, assertions, operator) {
+		super(request, sourceOrder, ids, name, range, false, assertions);
+		this.operator = operator;
+	}
+
+	get type() {
+		return `evaluated X ${this.operator} harmony import specifier`;
+	}
+
+	serialize(context) {
+		super.serialize(context);
+		const { write } = context;
+		write(this.operator);
+	}
+
+	deserialize(context) {
+		super.deserialize(context);
+		const { read } = context;
+		this.operator = read();
+	}
+}
+
+makeSerializable(
+	HarmonyEvaluatedImportSpecifierDependency,
+	"webpack/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency"
+);
+
+HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImportSpecifierDependencyTemplate extends (
+	HarmonyImportSpecifierDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {HarmonyEvaluatedImportSpecifierDependency} */ (
+			dependency
+		);
+		const { module, moduleGraph, runtime } = templateContext;
+		const connection = moduleGraph.getConnection(dep);
+		// Skip rendering depending when dependency is conditional
+		if (connection && !connection.isTargetActive(runtime)) return;
+
+		const exportsInfo = moduleGraph.getExportsInfo(connection.module);
+		const ids = dep.getIds(moduleGraph);
+
+		let value;
+
+		const exportsType = connection.module.getExportsType(
+			moduleGraph,
+			module.buildMeta.strictHarmonyModule
+		);
+		switch (exportsType) {
+			case "default-with-named": {
+				if (ids[0] === "default") {
+					value =
+						ids.length === 1 || exportsInfo.isExportProvided(ids.slice(1));
+				} else {
+					value = exportsInfo.isExportProvided(ids);
+				}
+				break;
+			}
+			case "namespace": {
+				if (ids[0] === "__esModule") {
+					value = ids.length === 1 || undefined;
+				} else {
+					value = exportsInfo.isExportProvided(ids);
+				}
+				break;
+			}
+			case "dynamic": {
+				if (ids[0] !== "default") {
+					value = exportsInfo.isExportProvided(ids);
+				}
+				break;
+			}
+			// default-only could lead to runtime error, when default value is primitive
+		}
+
+		if (typeof value === "boolean") {
+			source.replace(dep.range[0], dep.range[1] - 1, ` ${value}`);
+		} else {
+			const usedName = exportsInfo.getUsedName(ids, runtime);
+
+			const code = this._getCodeForIds(
+				dep,
+				source,
+				templateContext,
+				ids.slice(0, -1)
+			);
+			source.replace(
+				dep.range[0],
+				dep.range[1] - 1,
+				`${
+					usedName ? JSON.stringify(usedName[usedName.length - 1]) : '""'
+				} in ${code}`
+			);
+		}
+	}
+};
+
+module.exports = HarmonyEvaluatedImportSpecifierDependency;

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -11,6 +11,7 @@ const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDepe
 const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
 const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
 const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency");
+const { ExportPresenceModes } = require("./HarmonyImportDependency");
 const {
 	harmonySpecifierTag,
 	getAssertions
@@ -21,10 +22,18 @@ const { HarmonyStarExportsList } = HarmonyExportImportedSpecifierDependency;
 
 module.exports = class HarmonyExportDependencyParserPlugin {
 	constructor(options) {
-		this.strictExportPresence = options.strictExportPresence;
+		this.exportPresenceMode =
+			options.reexportExportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.reexportExportsPresence)
+				: options.exportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.exportsPresence)
+				: options.strictExportPresence
+				? ExportPresenceModes.ERROR
+				: ExportPresenceModes.AUTO;
 	}
 
 	apply(parser) {
+		const { exportPresenceMode } = this;
 		parser.hooks.export.tap(
 			"HarmonyExportDependencyParserPlugin",
 			statement => {
@@ -128,7 +137,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 						name,
 						harmonyNamedExports,
 						null,
-						this.strictExportPresence,
+						exportPresenceMode,
 						null,
 						settings.assertions
 					);
@@ -160,7 +169,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 					name,
 					harmonyNamedExports,
 					harmonyStarExports && harmonyStarExports.slice(),
-					this.strictExportPresence,
+					exportPresenceMode,
 					harmonyStarExports
 				);
 				if (harmonyStarExports) {

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -40,6 +40,8 @@ const processExportInfo = require("./processExportInfo");
 
 /** @typedef {"missing"|"unused"|"empty-star"|"reexport-dynamic-default"|"reexport-named-default"|"reexport-namespace-object"|"reexport-fake-namespace-object"|"reexport-undefined"|"normal-reexport"|"dynamic-reexport"} ExportModeType */
 
+const { ExportPresenceModes } = HarmonyImportDependency;
+
 const idsSymbol = Symbol("HarmonyExportImportedSpecifierDependency.ids");
 
 class NormalReexportItem {
@@ -325,7 +327,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 * @param {string | null} name the export name of for this module
 	 * @param {Set<string>} activeExports other named exports in the module
 	 * @param {ReadonlyArray<HarmonyExportImportedSpecifierDependency> | Iterable<HarmonyExportImportedSpecifierDependency>} otherStarExports other star exports in the module before this import
-	 * @param {boolean} strictExportPresence when true, missing exports in the imported module lead to errors instead of warnings
+	 * @param {number} exportPresenceMode mode of checking export names
 	 * @param {HarmonyStarExportsList} allStarExports all star exports in the module
 	 * @param {Record<string, any>=} assertions import assertions
 	 */
@@ -336,7 +338,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		name,
 		activeExports,
 		otherStarExports,
-		strictExportPresence,
+		exportPresenceMode,
 		allStarExports,
 		assertions
 	) {
@@ -346,7 +348,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		this.name = name;
 		this.activeExports = activeExports;
 		this.otherStarExports = otherStarExports;
-		this.strictExportPresence = strictExportPresence;
+		this.exportPresenceMode = exportPresenceMode;
 		this.allStarExports = allStarExports;
 	}
 
@@ -735,20 +737,29 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		}
 	}
 
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {number} effective mode
+	 */
+	_getEffectiveExportPresenceLevel(moduleGraph) {
+		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
+			return this.exportPresenceMode;
+		return moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
+			? ExportPresenceModes.ERROR
+			: ExportPresenceModes.WARN;
+	}
+
 	/**
 	 * Returns warnings
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {WebpackError[]} warnings
 	 */
 	getWarnings(moduleGraph) {
-		if (
-			this.strictExportPresence ||
-			moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
-		) {
-			return null;
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.WARN) {
+			return this._getErrors(moduleGraph);
 		}
-
-		return this._getErrors(moduleGraph);
+		return null;
 	}
 
 	/**
@@ -757,13 +768,10 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 * @returns {WebpackError[]} errors
 	 */
 	getErrors(moduleGraph) {
-		if (
-			this.strictExportPresence ||
-			moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
-		) {
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.ERROR) {
 			return this._getErrors(moduleGraph);
 		}
-
 		return null;
 	}
 
@@ -856,7 +864,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		write(this.name);
 		write(this.activeExports);
 		write(this.otherStarExports);
-		write(this.strictExportPresence);
+		write(this.exportPresenceMode);
 		write(this.allStarExports);
 
 		super.serialize(context);
@@ -870,7 +878,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		this.name = read();
 		this.activeExports = read();
 		this.otherStarExports = read();
-		this.strictExportPresence = read();
+		this.exportPresenceMode = read();
 		this.allStarExports = read();
 
 		super.deserialize(context);

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -145,7 +145,10 @@ class HarmonyExportInitFragment extends InitFragment {
 				? `/* unused harmony export ${first(this.unusedExports)} */\n`
 				: "";
 		const definitions = [];
-		for (const [key, value] of this.exportMap) {
+		const orderedExportMap = Array.from(this.exportMap).sort(([a], [b]) =>
+			a < b ? -1 : 1
+		);
+		for (const [key, value] of orderedExportMap) {
 			definitions.push(
 				`\n/* harmony export */   ${JSON.stringify(
 					key

package/lib/dependencies/HarmonyImportDependency.js

@@ -27,6 +27,27 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+const ExportPresenceModes = {
+	NONE: /** @type {0} */ (0),
+	WARN: /** @type {1} */ (1),
+	AUTO: /** @type {2} */ (2),
+	ERROR: /** @type {3} */ (3),
+	fromUserOption(str) {
+		switch (str) {
+			case "error":
+				return ExportPresenceModes.ERROR;
+			case "warn":
+				return ExportPresenceModes.WARN;
+			case "auto":
+				return ExportPresenceModes.AUTO;
+			case false:
+				return ExportPresenceModes.NONE;
+			default:
+				throw new Error(`Invalid export presence value ${str}`);
+		}
+	}
+};
+
 class HarmonyImportDependency extends ModuleDependency {
 	/**
 	 *
@@ -334,3 +355,5 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 		return emittedModules.get(referencedModule) || false;
 	}
 };
+
+module.exports.ExportPresenceModes = ExportPresenceModes;

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -10,7 +10,9 @@ const InnerGraph = require("../optimize/InnerGraph");
 const ConstDependency = require("./ConstDependency");
 const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
+const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
 const HarmonyExports = require("./HarmonyExports");
+const { ExportPresenceModes } = require("./HarmonyImportDependency");
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
 
@@ -19,6 +21,7 @@ const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDepend
 /** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
 /** @typedef {import("estree").ImportExpression} ImportExpression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../optimize/InnerGraph").InnerGraph} InnerGraph */
 /** @typedef {import("../optimize/InnerGraph").TopLevelSymbol} TopLevelSymbol */
@@ -60,8 +63,18 @@ function getAssertions(node) {
 }
 
 module.exports = class HarmonyImportDependencyParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options options
+	 */
 	constructor(options) {
-		this.strictExportPresence = options.strictExportPresence;
+		this.exportPresenceMode =
+			options.importExportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
+				: options.exportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.exportsPresence)
+				: options.strictExportPresence
+				? ExportPresenceModes.ERROR
+				: ExportPresenceModes.AUTO;
 		this.strictThisContextOnImports = options.strictThisContextOnImports;
 	}
 
@@ -70,6 +83,19 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 	 * @returns {void}
 	 */
 	apply(parser) {
+		const { exportPresenceMode } = this;
+
+		function getNonOptionalPart(members, membersOptionals) {
+			let i = 0;
+			while (i < members.length && membersOptionals[i] === false) i++;
+			return i !== members.length ? members.slice(0, i) : members;
+		}
+
+		function getNonOptionalMemberChain(node, count) {
+			while (count--) node = node.object;
+			return node;
+		}
+
 		parser.hooks.isPure
 			.for("Identifier")
 			.tap("HarmonyImportDependencyParserPlugin", expression => {
@@ -118,74 +144,145 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				return true;
 			}
 		);
-		parser.hooks.expression
-			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", expr => {
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const dep = new HarmonyImportSpecifierDependency(
+		parser.hooks.binaryExpression.tap(
+			"HarmonyImportDependencyParserPlugin",
+			expression => {
+				if (expression.operator !== "in") return;
+
+				const leftPartEvaluated = parser.evaluateExpression(expression.left);
+				if (leftPartEvaluated.couldHaveSideEffects()) return;
+				const leftPart = leftPartEvaluated.asString();
+				if (!leftPart) return;
+
+				const rightPart = parser.evaluateExpression(expression.right);
+				if (!rightPart.isIdentifier()) return;
+
+				const rootInfo = rightPart.rootInfo;
+				if (
+					!rootInfo ||
+					!rootInfo.tagInfo ||
+					rootInfo.tagInfo.tag !== harmonySpecifierTag
+				)
+					return;
+				const settings = rootInfo.tagInfo.data;
+				const members = rightPart.getMembers();
+				const dep = new HarmonyEvaluatedImportSpecifierDependency(
 					settings.source,
 					settings.sourceOrder,
-					settings.ids,
+					settings.ids.concat(members).concat([leftPart]),
 					settings.name,
-					expr.range,
-					this.strictExportPresence,
-					settings.assertions
+					expression.range,
+					settings.assertions,
+					"in"
 				);
-				dep.shorthand = parser.scope.inShorthand;
-				dep.directImport = true;
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
-				dep.loc = expr.loc;
+				dep.directImport = members.length === 0;
+				dep.asiSafe = !parser.isAsiPosition(expression.range[0]);
+				dep.loc = expression.loc;
 				parser.state.module.addDependency(dep);
 				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
 				return true;
-			});
-		parser.hooks.expressionMemberChain
+			}
+		);
+		parser.hooks.expression
 			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
+			.tap("HarmonyImportDependencyParserPlugin", expr => {
 				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const ids = settings.ids.concat(members);
 				const dep = new HarmonyImportSpecifierDependency(
 					settings.source,
 					settings.sourceOrder,
-					ids,
+					settings.ids,
 					settings.name,
 					expr.range,
-					this.strictExportPresence,
+					exportPresenceMode,
 					settings.assertions
 				);
+				dep.shorthand = parser.scope.inShorthand;
+				dep.directImport = true;
 				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
 				dep.loc = expr.loc;
 				parser.state.module.addDependency(dep);
 				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
 				return true;
 			});
+		parser.hooks.expressionMemberChain
+			.for(harmonySpecifierTag)
+			.tap(
+				"HarmonyImportDependencyParserPlugin",
+				(expression, members, membersOptionals) => {
+					const settings = /** @type {HarmonySettings} */ (
+						parser.currentTagData
+					);
+					const nonOptionalMembers = getNonOptionalPart(
+						members,
+						membersOptionals
+					);
+					const expr =
+						nonOptionalMembers !== members
+							? getNonOptionalMemberChain(
+									expression,
+									members.length - nonOptionalMembers.length
+							  )
+							: expression;
+					const ids = settings.ids.concat(nonOptionalMembers);
+					const dep = new HarmonyImportSpecifierDependency(
+						settings.source,
+						settings.sourceOrder,
+						ids,
+						settings.name,
+						expr.range,
+						exportPresenceMode,
+						settings.assertions
+					);
+					dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+					InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+					return true;
+				}
+			);
 		parser.hooks.callMemberChain
 			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
-				const { arguments: args, callee } = expr;
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const ids = settings.ids.concat(members);
-				const dep = new HarmonyImportSpecifierDependency(
-					settings.source,
-					settings.sourceOrder,
-					ids,
-					settings.name,
-					callee.range,
-					this.strictExportPresence,
-					settings.assertions
-				);
-				dep.directImport = members.length === 0;
-				dep.call = true;
-				dep.asiSafe = !parser.isAsiPosition(callee.range[0]);
-				// only in case when we strictly follow the spec we need a special case here
-				dep.namespaceObjectAsContext =
-					members.length > 0 && this.strictThisContextOnImports;
-				dep.loc = callee.loc;
-				parser.state.module.addDependency(dep);
-				if (args) parser.walkExpressions(args);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-				return true;
-			});
+			.tap(
+				"HarmonyImportDependencyParserPlugin",
+				(expression, members, membersOptionals) => {
+					const { arguments: args, callee } = expression;
+					const settings = /** @type {HarmonySettings} */ (
+						parser.currentTagData
+					);
+					const nonOptionalMembers = getNonOptionalPart(
+						members,
+						membersOptionals
+					);
+					const expr =
+						nonOptionalMembers !== members
+							? getNonOptionalMemberChain(
+									callee,
+									members.length - nonOptionalMembers.length
+							  )
+							: callee;
+					const ids = settings.ids.concat(nonOptionalMembers);
+					const dep = new HarmonyImportSpecifierDependency(
+						settings.source,
+						settings.sourceOrder,
+						ids,
+						settings.name,
+						expr.range,
+						exportPresenceMode,
+						settings.assertions
+					);
+					dep.directImport = members.length === 0;
+					dep.call = true;
+					dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+					// only in case when we strictly follow the spec we need a special case here
+					dep.namespaceObjectAsContext =
+						members.length > 0 && this.strictThisContextOnImports;
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+					if (args) parser.walkExpressions(args);
+					InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+					return true;
+				}
+			);
 		const { hotAcceptCallback, hotAcceptWithoutCallback } =
 			HotModuleReplacementPlugin.getParserHooks(parser);
 		hotAcceptCallback.tap(