@@ -0,0 +1,5 @@
+---
+"webpack": patch
+---
+
+Scope strict-mode, async and generator block function declarations to their block.
@@ -182,6 +182,7 @@ const EMPTY_MODULE_DECLARATIONS = [];
 // object pattern, so a tap on that type is not served from the list.
 const BLOCK_DECLARATION_TYPES = new Set([
 	"VariableDeclaration",
+	"FunctionDeclaration",
 	"ClassDeclaration",
 	"ExportNamedDeclaration",
 	"ExportDefaultDeclaration"
@@ -1122,6 +1123,35 @@ const hoistedDeclarationsOf = (node, trusted) => {
 	return collectHoistedDeclarations(node.body, EMPTY_HOISTED_DECLARATIONS);
 };
 
+/**
+ * Whether a statement is one of the list's own, or the declaration of an
+ * `export` that is, rather than nested in one of them. It is found by its start
+ * offset since the list is in source order.
+ * @param {(Statement | ModuleDeclaration)[]} statements the list
+ * @param {Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration} statement the statement to find
+ * @returns {boolean} whether the list holds it directly
+ */
+const holdsStatement = (statements, statement) => {
+	const start = /** @type {Range} */ (statement.range)[0];
+	let low = 0;
+	let high = statements.length - 1;
+	while (low <= high) {
+		const middle = (low + high) >>> 1;
+		const candidate = statements[middle];
+		if (candidate === statement) return true;
+		if (/** @type {Range} */ (candidate.range)[0] < start) low = middle + 1;
+		else high = middle - 1;
+	}
+	// the last statement starting before it is the one that could hold it
+	const holder = high >= 0 ? statements[high] : undefined;
+	return (
+		holder !== undefined &&
+		(holder.type === "ExportNamedDeclaration" ||
+			holder.type === "ExportDefaultDeclaration") &&
+		holder.declaration === statement
+	);
+};
+
 /**
  * Which statements of a list declare into its block scope, scanned for an AST
  * some other parser built. The parser's own record is read instead when there
@@ -1484,6 +1514,9 @@ class JavascriptParser extends Parser {
 		this.prevStatement = undefined;
 		/** @type {boolean} */
 		this._hasParserRecord = false;
+		// the statements of the scope last hoisted into, which its block pass reads next
+		/** @type {(Statement | ModuleDeclaration)[] | undefined} */
+		this._scopeStatements = undefined;
 		// BACKWARD-COMPAT START
 
 		// WHY: the hoisting pass reaches declarations alone, so a tap that
@@ -2729,6 +2762,7 @@ class JavascriptParser extends Parser {
 	 * @param {Program | BlockStatement} node the node owning the scope
 	 */
 	_preWalkScope(node) {
+		this._scopeStatements = node.body;
 		// BACKWARD-COMPAT START
 		if (this._needsFullPreWalk || this.hooks.preStatement.taps.length !== 0) {
 			if (node.type === "Program") this.preWalkStatements(node.body);
@@ -2756,6 +2790,25 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * Whether a function declaration stays in its block rather than hoisting to
+	 * the scope last pre-walked, which only sloppy-mode Annex B lets it do.
+	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
+	 * @returns {boolean} whether its block, not the scope, binds it
+	 */
+	_isBlockScopedFunction(statement) {
+		const statements = this._scopeStatements;
+		// WHY: strictness is read here, not in the parser: `javascript/auto`
+		// reads a script as a strict module first.
+		return (
+			statements !== undefined &&
+			(this.scope.isStrict ||
+				statement.generator === true ||
+				statement.async === true) &&
+			!holdsStatement(statements, statement)
+		);
+	}
+
 	// BACKWARD-COMPAT START
 	/**
 	 * Walk every statement of a scope to declare what hoists to it. Only a tap
@@ -3041,8 +3094,18 @@ class JavascriptParser extends Parser {
 		let bail =
 			preStatement.taps.length !== 0 ? preStatement.call(statement) : undefined;
 		if (!bail) {
-			const typed = preStatementByType.get(statement.type);
-			if (typed !== undefined) bail = typed.call(statement);
+			// WHY: a block-scoped function is the block pass's; the full pre-walk
+			// still shows it to `preStatement`, but not to the typed hooks, which
+			// would declare it in the scope (`InnerGraphPlugin` tags it top-level).
+			if (
+				statement.type === "FunctionDeclaration" &&
+				this._isBlockScopedFunction(statement)
+			) {
+				bail = true;
+			} else {
+				const typed = preStatementByType.get(statement.type);
+				if (typed !== undefined) bail = typed.call(statement);
+			}
 		}
 		if (bail) {
 			this.prevStatement =
@@ -3132,6 +3195,9 @@ class JavascriptParser extends Parser {
 			case "ClassDeclaration":
 				this.blockPreWalkClassDeclaration(statement);
 				break;
+			case "FunctionDeclaration":
+				this.blockPreWalkFunctionDeclaration(statement);
+				break;
 			case "ExportNamedDeclaration":
 				this.blockPreWalkExportNamedDeclaration(statement);
 				break;
@@ -3578,6 +3644,17 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * Bind a function declaration in the block holding it, when it does not
+	 * hoist to the enclosing scope.
+	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
+	 */
+	blockPreWalkFunctionDeclaration(statement) {
+		if (statement.id && this._isBlockScopedFunction(statement)) {
+			this.defineVariable(statement.id.name);
+		}
+	}
+
 	/**
 	 * Walk function declaration.
 	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
 
@@ -7938,6 +7938,7 @@ const declaresIntoBlock = (statement) => {
 	const type = statement.type;
 	if (
 		type === "VariableDeclaration" ||
+		type === "FunctionDeclaration" ||
 		type === "ClassDeclaration" ||
 		type === "ExportNamedDeclaration" ||
 		type === "ExportDefaultDeclaration"
 
@@ -0,0 +1,48 @@
+function strictOuter() {
+	"use strict";
+	{
+		function require() {}
+	}
+	return require("./lib");
+}
+
+function strictInner() {
+	"use strict";
+	{
+		function require(request) {
+			return "local " + request;
+		}
+		return require("./lib");
+	}
+}
+
+function sloppyAsync() {
+	{
+		async function require() {}
+	}
+	return require("./lib");
+}
+
+function sloppyGenerator() {
+	{
+		function* require() {}
+	}
+	return require("./lib");
+}
+
+function sloppyAnnexB() {
+	{
+		function require() {
+			return "annex b";
+		}
+	}
+	return require("./lib");
+}
+
+module.exports = {
+	strictOuter: strictOuter(),
+	strictInner: strictInner(),
+	sloppyAsync: sloppyAsync(),
+	sloppyGenerator: sloppyGenerator(),
+	sloppyAnnexB: sloppyAnnexB()
+};
@@ -2,6 +2,7 @@ import { alias, reexported } from "./barrel";
 
 const hoisting = require("./hoisting");
 const blockDeclarations = require("./block-declarations");
+const blockFunctions = require("./block-functions");
 
 it("should hoist from every position with a custom parser", () => {
 	expect(hoisting).toEqual({
@@ -47,6 +48,16 @@ it("should bind every block position with a custom parser", () => {
 	});
 });
 
+it("should scope a strict or async block function to its block with a custom parser", () => {
+	expect(blockFunctions).toEqual({
+		strictOuter: "lib",
+		strictInner: "local ./lib",
+		sloppyAsync: "lib",
+		sloppyGenerator: "lib",
+		sloppyAnnexB: "annex b"
+	});
+});
+
 it("should read imports and re-exports with a custom parser", () => {
 	expect(alias).toBe("named");
 	expect(reexported).toBe("reexported");
 
@@ -0,0 +1 @@
+module.exports = "lib";
@@ -0,0 +1,48 @@
+function strictOuter() {
+	"use strict";
+	{
+		function require() {}
+	}
+	return require("./lib");
+}
+
+function strictInner() {
+	"use strict";
+	{
+		function require(request) {
+			return "local " + request;
+		}
+		return require("./lib");
+	}
+}
+
+function sloppyAsync() {
+	{
+		async function require() {}
+	}
+	return require("./lib");
+}
+
+function sloppyGenerator() {
+	{
+		function* require() {}
+	}
+	return require("./lib");
+}
+
+function sloppyAnnexB() {
+	{
+		function require() {
+			return "annex b";
+		}
+	}
+	return require("./lib");
+}
+
+module.exports = {
+	strictOuter: strictOuter(),
+	strictInner: strictInner(),
+	sloppyAsync: sloppyAsync(),
+	sloppyGenerator: sloppyGenerator(),
+	sloppyAnnexB: sloppyAnnexB()
+};
@@ -0,0 +1,18 @@
+import { viaImport, viaRequire } from "./module";
+
+const blockFunctions = require("./block-functions");
+
+it("should scope a strict or async block function to its block", () => {
+	expect(blockFunctions).toEqual({
+		strictOuter: "lib",
+		strictInner: "local ./lib",
+		sloppyAsync: "lib",
+		sloppyGenerator: "lib",
+		sloppyAnnexB: "annex b"
+	});
+});
+
+it("should scope a block function to its block in a module", () => {
+	expect(viaImport).toBe("lib");
+	expect(viaRequire).toBe("lib");
+});
@@ -0,0 +1 @@
+module.exports = "lib";
@@ -0,0 +1,8 @@
+import lib from "./lib";
+
+{
+	function require() {}
+}
+
+export const viaImport = lib;
+export const viaRequire = require("./lib");
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"webpack": patch
 +---
++
 +Scope strict-mode, async and generator block function declarations to their block.