@depup/webpack 5.109.2-depup.0 → 5.110.3-depup.0

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -6,8 +6,7 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
-const CommentCompilationWarning = require("../errors/CommentCompilationWarning");
-const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
+
 const {
 	evaluateToIdentifier,
 	evaluateToString,
@@ -21,6 +20,7 @@ const CommonJsRequireContextDependency = require("./CommonJsRequireContextDepend
 const CommonJsRequireDependency = require("./CommonJsRequireDependency");
 const ConstDependency = require("./ConstDependency");
 const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const HarmonyImportGuard = require("./HarmonyImportGuard");
 const LocalModuleDependency = require("./LocalModuleDependency");
 const { getLocalModule } = require("./LocalModulesHelpers");
 const RequireHeaderDependency = require("./RequireHeaderDependency");
@@ -28,19 +28,30 @@ const RequireResolveContextDependency = require("./RequireResolveContextDependen
 const RequireResolveDependency = require("./RequireResolveDependency");
 const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
 
-/** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").NewExpression} NewExpression */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
-/** @typedef {import("../javascript/JavascriptParser").ImportSource} ImportSource */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../javascript/JavascriptParser").Members} Members */
-/** @typedef {import("../javascript/JavascriptParser").CalleeMembers} CalleeMembers */
-/** @typedef {import("./LocalModule")} LocalModule */
+const getUnsupportedFeatureWarning = memoize(() =>
+	require("../errors/UnsupportedFeatureWarning")
+);
+
+const getCommentCompilationWarning = memoize(() =>
+	require("../errors/CommentCompilationWarning")
+);
+
+/** @import { CallExpression, Expression, NewExpression } from "estree" */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import { RawReferencedExports } from "../Dependency" */
+/**
+ * @import JavascriptParser, {
+ * 	Range,
+ * 	Members,
+ * 	CalleeMembers
+ * } from "../javascript/JavascriptParser"
+ */
+/** @import BasicEvaluatedExpression from "../javascript/BasicEvaluatedExpression" */
+/** @import LocalModule from "./LocalModule" */
 
 /**
  * Defines the common js import settings type used by this module.
@@ -58,8 +69,6 @@ const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency
  * @property {InstanceType<typeof import("./CommonJsRequireDependency")> | null} dep dependency for the `require()` call, null until the `require()` is walked; kept so a later whole-namespace use can null its list directly
  */
 
-const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
-
 const REQUIRE_BINDING_TAG = Symbol(
 	"CommonJsImportsParserPlugin require binding"
 );
@@ -170,9 +179,10 @@ const createRequireCallHandler = (
 	 * Process require item.
 	 * @param {CallExpression | NewExpression} expr expression
 	 * @param {BasicEvaluatedExpression} param param
-	 * @returns {boolean | void} true when handled
+	 * @param {boolean=} allowEvaluationOnly when false (conditional require), keep full namespace use
+	 * @returns {CommonJsRequireDependency | undefined} created dependency when handled
 	 */
-	const processRequireItem = (expr, param) => {
+	const processRequireItem = (expr, param, allowEvaluationOnly = true) => {
 		if (param.isString()) {
 			let referencedExports = getRequireReferencedExportsFromDestructuring(
 				parser,
@@ -185,6 +195,14 @@ const createRequireCallHandler = (
 				// `const NAME = require(LITERAL)` — let later member-access walks
 				// on `NAME` populate the dependency's referenced exports.
 				referencedExports = binding.referencedExports;
+			} else if (
+				allowEvaluationOnly &&
+				referencedExports === null &&
+				!binding &&
+				parser.isStatementLevelExpression(expr)
+			) {
+				// Bare `require(...)` as a statement: result discarded → evaluation only.
+				referencedExports = [];
 			}
 			const dep = new CommonJsRequireDependency(
 				/** @type {string} */ (param.string),
@@ -197,8 +215,8 @@ const createRequireCallHandler = (
 			dep.loc = parser.getLocation(expr);
 			dep.optional = Boolean(parser.scope.inTry);
 			parser.state.current.addDependency(dep);
-			getHarmonyImportGuard().attachDependencyGuards(parser, dep);
-			return true;
+			HarmonyImportGuard.attachDependencyGuards(parser, dep);
+			return dep;
 		}
 	};
 	/**
@@ -242,7 +260,7 @@ const createRequireCallHandler = (
 				for (const e of commentErrors) {
 					const { comment } = e;
 					parser.state.module.addWarning(
-						new CommentCompilationWarning(
+						new (getCommentCompilationWarning())(
 							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
 							parser.getLocation(comment)
 						)
@@ -252,7 +270,7 @@ const createRequireCallHandler = (
 			if (requireOptions && requireOptions.webpackIgnore !== undefined) {
 				if (typeof requireOptions.webpackIgnore !== "boolean") {
 					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
+						new (getUnsupportedFeatureWarning())(
 							`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
 							parser.getLocation(expr)
 						)
@@ -273,8 +291,9 @@ const createRequireCallHandler = (
 			for (const p of /** @type {BasicEvaluatedExpression[]} */ (
 				param.options
 			)) {
-				const result = processRequireItem(expr, p);
-				if (result === undefined) {
+				// Shared valueRange across branches: never mark evaluation-only.
+				const requireDep = processRequireItem(expr, p, false);
+				if (requireDep === undefined) {
 					isExpression = true;
 				}
 			}
@@ -303,12 +322,17 @@ const createRequireCallHandler = (
 			dep.loc = parser.getLocation(expr);
 			parser.state.module.addPresentationalDependency(dep);
 		} else {
-			const result = processRequireItem(expr, param);
-			if (result === undefined) {
+			const requireDep = processRequireItem(expr, param);
+			if (requireDep === undefined) {
 				processRequireContext(expr, param);
 			} else {
+				requireDep._canConcatenate = true;
+				// concatenation replaces the whole NewExpression; the template
+				// reapplies the `new` return-value rule
+				requireDep.callNew = callNew;
 				const dep = new RequireHeaderDependency(
-					/** @type {Range} */ (expr.callee.range)
+					/** @type {Range} */ (expr.callee.range),
+					requireDep
 				);
 				dep.loc = parser.getLocation(expr);
 				parser.state.module.addPresentationalDependency(dep);
@@ -384,7 +408,7 @@ const createProcessResolveHandler = (parser, options, getContext) => {
 				for (const e of commentErrors) {
 					const { comment } = e;
 					parser.state.module.addWarning(
-						new CommentCompilationWarning(
+						new (getCommentCompilationWarning())(
 							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
 							parser.getLocation(comment)
 						)
@@ -394,7 +418,7 @@ const createProcessResolveHandler = (parser, options, getContext) => {
 			if (requireOptions && requireOptions.webpackIgnore !== undefined) {
 				if (typeof requireOptions.webpackIgnore !== "boolean") {
 					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
+						new (getUnsupportedFeatureWarning())(
 							`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
 							parser.getLocation(expr)
 						)
@@ -458,6 +482,13 @@ class CommonJsImportsParserPlugin {
 			PLUGIN_NAME,
 			(expr) => {
 				if (isRequireCallExpression(expr)) return true;
+				// `const NAME = require(…); const { a } = NAME;`
+				if (
+					expr.type === "Identifier" &&
+					parser.getTagData(expr.name, REQUIRE_BINDING_TAG)
+				) {
+					return true;
+				}
 			}
 		);
 
@@ -640,9 +671,10 @@ class CommonJsImportsParserPlugin {
 					/** @type {Range} */ (expr.range)[0]
 				);
 				dep.optional = Boolean(parser.scope.inTry);
+				dep._canConcatenate = true;
 				dep.loc = parser.getLocation(expr);
 				parser.state.current.addDependency(dep);
-				getHarmonyImportGuard().attachDependencyGuards(parser, dep);
+				HarmonyImportGuard.attachDependencyGuards(parser, dep);
 				return true;
 			}
 		};
@@ -675,13 +707,17 @@ class CommonJsImportsParserPlugin {
 					/** @type {Range[]} */ memberRanges
 				);
 				dep.call = true;
+				dep.namespaceObjectAsContext = Boolean(
+					options.strictThisContextOnImports
+				);
 				dep.asiSafe = !parser.isAsiPosition(
 					/** @type {Range} */ (expr.range)[0]
 				);
 				dep.optional = Boolean(parser.scope.inTry);
+				dep._canConcatenate = true;
 				dep.loc = parser.getLocation(expr.callee);
 				parser.state.current.addDependency(dep);
-				getHarmonyImportGuard().attachDependencyGuards(parser, dep);
+				HarmonyImportGuard.attachDependencyGuards(parser, dep);
 				parser.walkExpressions(expr.arguments);
 				return true;
 			}
@@ -736,20 +772,31 @@ class CommonJsImportsParserPlugin {
 			return true;
 		});
 
-		parser.hooks.expression.for(REQUIRE_BINDING_TAG).tap(PLUGIN_NAME, () => {
-			const binding =
-				/** @type {RequireBindingData} */
-				(parser.currentTagData);
-			if (binding) {
-				// `NAME` is read as a value (not as the object of a static member
-				// chain), so we have to assume the whole exports object is used.
-				binding.referencedExports = null;
-				if (binding.dep) {
-					binding.dep.referencedExports = null;
+		parser.hooks.expression
+			.for(REQUIRE_BINDING_TAG)
+			.tap(PLUGIN_NAME, (expr) => {
+				const binding =
+					/** @type {RequireBindingData} */
+					(parser.currentTagData);
+				if (binding) {
+					const properties = parser.destructuringAssignmentPropertiesFor(expr);
+					if (properties && binding.referencedExports) {
+						// `const { a } = NAME` — only the destructured keys are read.
+						const referencedExports = binding.referencedExports;
+						traverseDestructuringAssignmentProperties(properties, (stack) =>
+							referencedExports.push(stack.map((p) => p.id))
+						);
+					} else {
+						// `NAME` is read as a value (not as the object of a static member
+						// chain), so we have to assume the whole exports object is used.
+						binding.referencedExports = null;
+						if (binding.dep) {
+							binding.dep.referencedExports = null;
+						}
+					}
 				}
-			}
-			return true;
-		});
+				return true;
+			});
 
 		parser.hooks.expressionMemberChain
 			.for(REQUIRE_BINDING_TAG)
@@ -829,9 +876,12 @@ class CommonJsImportsParserPlugin {
 	}
 }
 
-module.exports = CommonJsImportsParserPlugin;
-module.exports.createProcessResolveHandler = createProcessResolveHandler;
-module.exports.createRequireAsExpressionHandler =
+CommonJsImportsParserPlugin.createProcessResolveHandler =
+	createProcessResolveHandler;
+CommonJsImportsParserPlugin.createRequireAsExpressionHandler =
 	createRequireAsExpressionHandler;
-module.exports.createRequireCacheDependency = createRequireCacheDependency;
-module.exports.createRequireHandler = createRequireCallHandler;
+CommonJsImportsParserPlugin.createRequireCacheDependency =
+	createRequireCacheDependency;
+CommonJsImportsParserPlugin.createRequireHandler = createRequireCallHandler;
+
+module.exports = CommonJsImportsParserPlugin;

package/lib/dependencies/CommonJsObjectExportDependency.js

@@ -0,0 +1,188 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const { propertyName } = require("../util/property");
+const NullDependency = require("./NullDependency");
+
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency, { ExportsSpec, ExportInfoName } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @typedef {"keyValue" | "shorthand" | "get" | "set" | "method" | "asyncMethod" | "generatorMethod" | "asyncGeneratorMethod"} CommonJsObjectExportKind */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, Range, Range, ExportInfoName, CommonJsObjectExportKind, boolean]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, Range, Range, ExportInfoName, CommonJsObjectExportKind, boolean]>} ObjectSerializerContext */
+
+const EMPTY_OBJECT = {};
+
+/** @type {ReadonlyMap<CommonJsObjectExportKind, string>} */
+const FUNCTION_PROPERTY_DROP_HEAD = new Map([
+	["get", "...void (function "],
+	["set", "...void (function "],
+	["method", "...void (function "],
+	["asyncMethod", "...void (async function "],
+	["generatorMethod", "...void (function* "],
+	["asyncGeneratorMethod", "...void (async function* "]
+]);
+
+class CommonJsObjectExportDependency extends NullDependency {
+	/**
+	 * @param {Range} range property range
+	 * @param {Range} keyRange key range
+	 * @param {Range} valueRange value / function range
+	 * @param {ExportInfoName} name export name
+	 * @param {CommonJsObjectExportKind} kind property kind
+	 * @param {boolean} pure value is known to be side-effect free
+	 */
+	constructor(range, keyRange, valueRange, name, kind, pure) {
+		super();
+		this.range = range;
+		this.keyRange = keyRange;
+		this.valueRange = valueRange;
+		/** @type {ExportInfoName} */
+		this.name = name;
+		/** @type {CommonJsObjectExportKind} */
+		this.kind = kind;
+		/** @type {boolean} */
+		this.pure = pure;
+	}
+
+	get type() {
+		return "cjs object exports";
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const name = this.name;
+		return {
+			exports: [
+				{
+					name,
+					// Keep __esModule stable: the template never renames it.
+					canMangle: name !== "__esModule" && !(name in EMPTY_OBJECT)
+				}
+			],
+			dependencies: undefined
+		};
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context
+			.write(this.range)
+			.write(this.keyRange)
+			.write(this.valueRange)
+			.write(this.name)
+			.write(this.kind)
+			.write(this.pure);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.range = context.read();
+		const c1 = context.rest;
+		this.keyRange = c1.read();
+		const c2 = c1.rest;
+		this.valueRange = c2.read();
+		const c3 = c2.rest;
+		this.name = c3.read();
+		const c4 = c3.rest;
+		this.kind = c4.read();
+		const c5 = c4.rest;
+		this.pure = c5.read();
+		super.deserialize(c5.rest);
+	}
+}
+
+makeSerializable(
+	CommonJsObjectExportDependency,
+	"webpack/lib/dependencies/CommonJsObjectExportDependency"
+);
+
+CommonJsObjectExportDependency.Template = class CommonJsObjectExportDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @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, { module, moduleGraph, runtime, runtimeTemplate }) {
+		const dep = /** @type {CommonJsObjectExportDependency} */ (dependency);
+		// Interop marker must stay even when unused.
+		if (dep.name === "__esModule") return;
+		const used = /** @type {string | false} */ (
+			moduleGraph.getExportsInfo(module).getUsedName(dep.name, runtime)
+		);
+		if (!used) {
+			// Object spread rewrite needs environment.spread.
+			if (!runtimeTemplate.supportsSpread()) return;
+			const range = /** @type {Range} */ (dep.range);
+			if (FUNCTION_PROPERTY_DROP_HEAD.has(dep.kind)) {
+				// Keep the function body so nested dependency replaces stay valid.
+				const valueRange = /** @type {Range} */ (dep.valueRange);
+				source.replace(
+					range[0],
+					valueRange[0] - 1,
+					/** @type {string} */ (FUNCTION_PROPERTY_DROP_HEAD.get(dep.kind))
+				);
+				source.insert(valueRange[1], ")");
+				return;
+			}
+			if (dep.kind === "shorthand") {
+				source.replace(range[0], range[1] - 1, `...void (${dep.name})`);
+				return;
+			}
+			// keyValue: keep the value's side effects in place.
+			const valueRange = /** @type {Range} */ (dep.valueRange);
+			if (dep.pure) {
+				// spreading null adds nothing; the text stays so nested replaces hold
+				source.replace(
+					range[0],
+					valueRange[0] - 1,
+					"...(/* unused pure expression */ null && ("
+				);
+				source.replace(valueRange[1], range[1] - 1, "))");
+				return;
+			}
+			source.replace(range[0], valueRange[0] - 1, "...void (");
+			source.replace(valueRange[1], range[1] - 1, ")");
+			return;
+		}
+		if (used === dep.name) return;
+		// Rename the key to the mangled export name.
+		const keyRange = /** @type {Range} */ (dep.keyRange);
+		if (dep.kind === "shorthand") {
+			source.replace(
+				keyRange[0],
+				keyRange[1] - 1,
+				`${propertyName(used)}: ${dep.name}`
+			);
+			return;
+		}
+		source.replace(keyRange[0], keyRange[1] - 1, propertyName(used));
+	}
+};
+
+CommonJsObjectExportDependency.FUNCTION_PROPERTY_DROP_HEAD =
+	FUNCTION_PROPERTY_DROP_HEAD;
+
+module.exports = CommonJsObjectExportDependency;

package/lib/dependencies/CommonJsPlugin.js

@@ -23,6 +23,7 @@ const CommonJsExportsDependency = require("./CommonJsExportsDependency");
 const CommonJsExportsParserPlugin = require("./CommonJsExportsParserPlugin");
 const CommonJsFullRequireDependency = require("./CommonJsFullRequireDependency");
 const CommonJsImportsParserPlugin = require("./CommonJsImportsParserPlugin");
+const CommonJsObjectExportDependency = require("./CommonJsObjectExportDependency");
 const CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency");
 const CommonJsRequireDependency = require("./CommonJsRequireDependency");
 const CommonJsSelfReferenceDependency = require("./CommonJsSelfReferenceDependency");
@@ -33,12 +34,15 @@ const RequireResolveDependency = require("./RequireResolveDependency");
 const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
 const RuntimeRequirementsDependency = require("./RuntimeRequirementsDependency");
 
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../javascript/JavascriptParser")} Parser */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Compilation from "../Compilation" */
+/** @import Compiler from "../Compiler" */
+/** @import { BuildInfo } from "../Module" */
+/** @import Parser from "../javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "CommonJsPlugin";
 
@@ -112,6 +116,11 @@ class CommonJsPlugin {
 					new CommonJsExportsDependency.Template()
 				);
 
+				compilation.dependencyTemplates.set(
+					CommonJsObjectExportDependency,
+					new CommonJsObjectExportDependency.Template()
+				);
+
 				compilation.dependencyFactories.set(
 					CommonJsExportRequireDependency,
 					normalModuleFactory
@@ -266,6 +275,16 @@ class HarmonyModuleDecoratorRuntimeModule extends RuntimeModule {
 		super("harmony module decorator");
 	}
 
+	/**
+	 * Returns true, if the runtime module should get it's own scope.
+	 * When false, `generate()` must emit complete statements ending with `;`
+	 * so a following runtime IIFE is not parsed as a call (ASI).
+	 * @returns {boolean} true, if the runtime module should get it's own scope
+	 */
+	shouldIsolate() {
+		return false;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
@@ -297,6 +316,16 @@ class NodeModuleDecoratorRuntimeModule extends RuntimeModule {
 		super("node module decorator");
 	}
 
+	/**
+	 * Returns true, if the runtime module should get it's own scope.
+	 * When false, `generate()` must emit complete statements ending with `;`
+	 * so a following runtime IIFE is not parsed as a call (ASI).
+	 * @returns {boolean} true, if the runtime module should get it's own scope
+	 */
+	shouldIsolate() {
+		return false;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/dependencies/CommonJsRequireContextDependency.js

@@ -10,14 +10,13 @@ const makeSerializable = require("../util/makeSerializable");
 const ContextDependency = require("./ContextDependency");
 const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
 
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import { Range } from "../javascript/JavascriptParser" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, Range | undefined, boolean | string | undefined]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, Range | undefined, boolean | string | undefined]>} ObjectSerializerContext */
-/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
-/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import { ContextDependencyOptions } from "./ContextDependency" */
+/** @import { ReferencedExports } from "../Dependency" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 class CommonJsRequireContextDependency extends ContextDependency {
 	/**