webpack 5.97.1 → 5.104.1

package/lib/dependencies/ImportParserPlugin.js

@@ -8,21 +8,162 @@
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const CommentCompilationWarning = require("../CommentCompilationWarning");
 const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
-const { getImportAttributes } = require("../javascript/JavascriptParser");
+const {
+	VariableInfo,
+	getImportAttributes
+} = require("../javascript/JavascriptParser");
+const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
 const ContextDependencyHelpers = require("./ContextDependencyHelpers");
 const ImportContextDependency = require("./ImportContextDependency");
 const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
+const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 const ImportWeakDependency = require("./ImportWeakDependency");
 
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../ContextModule").ContextMode} ContextMode */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").ImportExpression} ImportExpression */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../javascript/JavascriptParser").JavascriptParserState} JavascriptParserState */
+/** @typedef {import("../javascript/JavascriptParser").Members} Members */
+/** @typedef {import("../javascript/JavascriptParser").MembersOptionals} MembersOptionals */
+/** @typedef {import("../javascript/JavascriptParser").ArrowFunctionExpression} ArrowFunctionExpression */
+/** @typedef {import("../javascript/JavascriptParser").FunctionExpression} FunctionExpression */
+/** @typedef {import("../javascript/JavascriptParser").Identifier} Identifier */
+/** @typedef {import("../javascript/JavascriptParser").ObjectPattern} ObjectPattern */
+/** @typedef {import("../javascript/JavascriptParser").CallExpression} CallExpression */
+
+/** @typedef {{ references: RawReferencedExports, expression: ImportExpression }} ImportSettings */
+/** @typedef {WeakMap<ImportExpression, RawReferencedExports>} State */
+
+/** @type {WeakMap<JavascriptParserState, State>} */
+const parserStateMap = new WeakMap();
+const dynamicImportTag = Symbol("import()");
+
+/**
+ * @param {JavascriptParser} parser javascript parser
+ * @returns {State} import parser plugin state
+ */
+function getState(parser) {
+	if (!parserStateMap.has(parser.state)) {
+		parserStateMap.set(parser.state, new WeakMap());
+	}
+	return /** @type {State} */ (parserStateMap.get(parser.state));
+}
+
+/**
+ * @param {JavascriptParser} parser javascript parser
+ * @param {ImportExpression} importCall import expression
+ * @param {string} variableName variable name
+ */
+function tagDynamicImportReferenced(parser, importCall, variableName) {
+	const state = getState(parser);
+	/** @type {RawReferencedExports} */
+	const references = state.get(importCall) || [];
+	state.set(importCall, references);
+	parser.tagVariable(
+		variableName,
+		dynamicImportTag,
+		/** @type {ImportSettings} */ ({
+			references,
+			expression: importCall
+		})
+	);
+}
+
+/**
+ * @param {CallExpression} importThen import().then() call
+ * @returns {Identifier | ObjectPattern | undefined} the dynamic imported namespace obj
+ */
+function getFulfilledCallbackNamespaceObj(importThen) {
+	const fulfilledCallback = importThen.arguments[0];
+	if (
+		fulfilledCallback &&
+		(fulfilledCallback.type === "ArrowFunctionExpression" ||
+			fulfilledCallback.type === "FunctionExpression") &&
+		fulfilledCallback.params[0] &&
+		(fulfilledCallback.params[0].type === "Identifier" ||
+			fulfilledCallback.params[0].type === "ObjectPattern")
+	) {
+		return fulfilledCallback.params[0];
+	}
+}
+
+/**
+ * @param {JavascriptParser} parser javascript parser
+ * @param {ImportExpression} importCall import expression
+ * @param {ArrowFunctionExpression | FunctionExpression} fulfilledCallback the fulfilled callback
+ * @param {Identifier | ObjectPattern} namespaceObjArg the argument of namespace object=
+ */
+function walkImportThenFulfilledCallback(
+	parser,
+	importCall,
+	fulfilledCallback,
+	namespaceObjArg
+) {
+	const arrow = fulfilledCallback.type === "ArrowFunctionExpression";
+	const wasTopLevel = parser.scope.topLevelScope;
+	parser.scope.topLevelScope = arrow ? (wasTopLevel ? "arrow" : false) : false;
+	const scopeParams = [...fulfilledCallback.params];
+
+	// Add function name in scope for recursive calls
+	if (!arrow && fulfilledCallback.id) {
+		scopeParams.push(fulfilledCallback.id);
+	}
+
+	parser.inFunctionScope(!arrow, scopeParams, () => {
+		if (namespaceObjArg.type === "Identifier") {
+			tagDynamicImportReferenced(parser, importCall, namespaceObjArg.name);
+		} else {
+			parser.enterDestructuringAssignment(namespaceObjArg, importCall);
+			const referencedPropertiesInDestructuring =
+				parser.destructuringAssignmentPropertiesFor(importCall);
+			if (referencedPropertiesInDestructuring) {
+				const state = getState(parser);
+				const references = /** @type {RawReferencedExports} */ (
+					state.get(importCall)
+				);
+				/** @type {RawReferencedExports} */
+				const refsInDestructuring = [];
+				traverseDestructuringAssignmentProperties(
+					referencedPropertiesInDestructuring,
+					(stack) => refsInDestructuring.push(stack.map((p) => p.id))
+				);
+				for (const ids of refsInDestructuring) {
+					references.push(ids);
+				}
+			}
+		}
+		for (const param of fulfilledCallback.params) {
+			parser.walkPattern(param);
+		}
+		if (fulfilledCallback.body.type === "BlockStatement") {
+			parser.detectMode(fulfilledCallback.body.body);
+			const prev = parser.prevStatement;
+			parser.preWalkStatement(fulfilledCallback.body);
+			parser.prevStatement = prev;
+			parser.walkStatement(fulfilledCallback.body);
+		} else {
+			parser.walkExpression(fulfilledCallback.body);
+		}
+	});
+	parser.scope.topLevelScope = wasTopLevel;
+}
+
+/**
+ * @template T
+ * @param {Iterable<T>} enumerable enumerable
+ * @returns {T[][]} array of array
+ */
+const exportsFromEnumerable = (enumerable) =>
+	Array.from(enumerable, (e) => [e]);
+
+const PLUGIN_NAME = "ImportParserPlugin";
 
 class ImportParserPlugin {
 	/**
@@ -38,20 +179,94 @@ class ImportParserPlugin {
 	 */
 	apply(parser) {
 		/**
-		 * @template T
-		 * @param {Iterable<T>} enumerable enumerable
-		 * @returns {T[][]} array of array
+		 * @param {Members} members members
+		 * @param {MembersOptionals} membersOptionals members Optionals
+		 * @returns {string[]} a non optional part
 		 */
-		const exportsFromEnumerable = enumerable =>
-			Array.from(enumerable, e => [e]);
-		parser.hooks.importCall.tap("ImportParserPlugin", expr => {
+		function getNonOptionalPart(members, membersOptionals) {
+			let i = 0;
+			while (i < members.length && membersOptionals[i] === false) i++;
+			return i !== members.length ? members.slice(0, i) : members;
+		}
+
+		parser.hooks.collectDestructuringAssignmentProperties.tap(
+			PLUGIN_NAME,
+			(expr) => {
+				if (expr.type === "ImportExpression") return true;
+				const nameInfo = parser.getNameForExpression(expr);
+				if (
+					nameInfo &&
+					nameInfo.rootInfo instanceof VariableInfo &&
+					nameInfo.rootInfo.name &&
+					parser.getTagData(nameInfo.rootInfo.name, dynamicImportTag)
+				) {
+					return true;
+				}
+			}
+		);
+		parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl) => {
+			if (
+				decl.init &&
+				decl.init.type === "AwaitExpression" &&
+				decl.init.argument.type === "ImportExpression" &&
+				decl.id.type === "Identifier"
+			) {
+				parser.defineVariable(decl.id.name);
+				tagDynamicImportReferenced(parser, decl.init.argument, decl.id.name);
+			}
+		});
+		parser.hooks.expression.for(dynamicImportTag).tap(PLUGIN_NAME, (expr) => {
+			const settings = /** @type {ImportSettings} */ (parser.currentTagData);
+			const referencedPropertiesInDestructuring =
+				parser.destructuringAssignmentPropertiesFor(expr);
+			if (referencedPropertiesInDestructuring) {
+				/** @type {RawReferencedExports} */
+				const refsInDestructuring = [];
+				traverseDestructuringAssignmentProperties(
+					referencedPropertiesInDestructuring,
+					(stack) => refsInDestructuring.push(stack.map((p) => p.id))
+				);
+				for (const ids of refsInDestructuring) {
+					settings.references.push(ids);
+				}
+			} else {
+				settings.references.push([]);
+			}
+			return true;
+		});
+		parser.hooks.expressionMemberChain
+			.for(dynamicImportTag)
+			.tap(PLUGIN_NAME, (_expression, members, membersOptionals) => {
+				const settings = /** @type {ImportSettings} */ (parser.currentTagData);
+				const ids = getNonOptionalPart(members, membersOptionals);
+				settings.references.push(ids);
+				return true;
+			});
+		parser.hooks.callMemberChain
+			.for(dynamicImportTag)
+			.tap(PLUGIN_NAME, (expression, members, membersOptionals) => {
+				const { arguments: args } = expression;
+				const settings = /** @type {ImportSettings} */ (parser.currentTagData);
+				let ids = getNonOptionalPart(members, membersOptionals);
+				const directImport = members.length === 0;
+				if (
+					!directImport &&
+					(this.options.strictThisContextOnImports || ids.length > 1)
+				) {
+					ids = ids.slice(0, -1);
+				}
+				settings.references.push(ids);
+				if (args) parser.walkExpressions(args);
+				return true;
+			});
+		parser.hooks.importCall.tap(PLUGIN_NAME, (expr, importThen) => {
 			const param = parser.evaluateExpression(expr.source);
 
 			let chunkName = null;
 			let mode = /** @type {ContextMode} */ (this.options.dynamicImportMode);
 			let include = null;
 			let exclude = null;
-			/** @type {string[][] | null} */
+			/** @type {RawReferencedExports | null} */
 			let exports = null;
 			/** @type {RawChunkGroupOptions} */
 			const groupOptions = {};
@@ -61,20 +276,26 @@ class ImportParserPlugin {
 				dynamicImportPrefetch,
 				dynamicImportFetchPriority
 			} = this.options;
-			if (dynamicImportPreload !== undefined && dynamicImportPreload !== false)
+			if (
+				dynamicImportPreload !== undefined &&
+				dynamicImportPreload !== false
+			) {
 				groupOptions.preloadOrder =
 					dynamicImportPreload === true ? 0 : dynamicImportPreload;
+			}
 			if (
 				dynamicImportPrefetch !== undefined &&
 				dynamicImportPrefetch !== false
-			)
+			) {
 				groupOptions.prefetchOrder =
 					dynamicImportPrefetch === true ? 0 : dynamicImportPrefetch;
+			}
 			if (
 				dynamicImportFetchPriority !== undefined &&
 				dynamicImportFetchPriority !== false
-			)
+			) {
 				groupOptions.fetchPriority = dynamicImportFetchPriority;
+			}
 
 			const { options: importOptions, errors: commentErrors } =
 				parser.parseCommentOptions(/** @type {Range} */ (expr.range));
@@ -91,6 +312,12 @@ class ImportParserPlugin {
 				}
 			}
 
+			const phase = createGetImportPhase(this.options.deferImport)(
+				parser,
+				expr,
+				() => importOptions
+			);
+
 			if (importOptions) {
 				if (importOptions.webpackIgnore !== undefined) {
 					if (typeof importOptions.webpackIgnore !== "boolean") {
@@ -209,8 +436,8 @@ class ImportParserPlugin {
 						!(
 							typeof importOptions.webpackExports === "string" ||
 							(Array.isArray(importOptions.webpackExports) &&
-								/** @type {string[]} */ (importOptions.webpackExports).every(
-									item => typeof item === "string"
+								importOptions.webpackExports.every(
+									(item) => typeof item === "string"
 								))
 						)
 					) {
@@ -245,18 +472,42 @@ class ImportParserPlugin {
 
 			const referencedPropertiesInDestructuring =
 				parser.destructuringAssignmentPropertiesFor(expr);
-			if (referencedPropertiesInDestructuring) {
+			const state = getState(parser);
+			const referencedPropertiesInMember = state.get(expr);
+			const fulfilledNamespaceObj =
+				importThen && getFulfilledCallbackNamespaceObj(importThen);
+			if (
+				referencedPropertiesInDestructuring ||
+				referencedPropertiesInMember ||
+				fulfilledNamespaceObj
+			) {
 				if (exports) {
 					parser.state.module.addWarning(
 						new UnsupportedFeatureWarning(
-							"`webpackExports` could not be used with destructuring assignment.",
+							"You don't need `webpackExports` if the usage of dynamic import is statically analyse-able. You can safely remove the `webpackExports` magic comment.",
 							/** @type {DependencyLocation} */ (expr.loc)
 						)
 					);
 				}
-				exports = exportsFromEnumerable(
-					[...referencedPropertiesInDestructuring].map(({ id }) => id)
-				);
+
+				if (referencedPropertiesInDestructuring) {
+					/** @type {RawReferencedExports} */
+					const refsInDestructuring = [];
+					traverseDestructuringAssignmentProperties(
+						referencedPropertiesInDestructuring,
+						(stack) => refsInDestructuring.push(stack.map((p) => p.id))
+					);
+
+					exports = refsInDestructuring;
+				} else if (referencedPropertiesInMember) {
+					exports = referencedPropertiesInMember;
+				} else {
+					/** @type {RawReferencedExports} */
+					const references = [];
+					state.set(expr, references);
+
+					exports = references;
+				}
 			}
 
 			if (param.isString()) {
@@ -267,6 +518,7 @@ class ImportParserPlugin {
 						/** @type {string} */ (param.string),
 						/** @type {Range} */ (expr.range),
 						exports,
+						phase,
 						attributes
 					);
 					parser.state.current.addDependency(dep);
@@ -275,6 +527,7 @@ class ImportParserPlugin {
 						/** @type {string} */ (param.string),
 						/** @type {Range} */ (expr.range),
 						exports,
+						phase,
 						attributes
 					);
 					parser.state.current.addDependency(dep);
@@ -291,6 +544,7 @@ class ImportParserPlugin {
 						/** @type {string} */ (param.string),
 						/** @type {Range} */ (expr.range),
 						exports,
+						phase,
 						attributes
 					);
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
@@ -298,39 +552,63 @@ class ImportParserPlugin {
 					depBlock.addDependency(dep);
 					parser.state.current.addBlock(depBlock);
 				}
-				return true;
+			} else {
+				if (mode === "weak") {
+					mode = "async-weak";
+				}
+
+				if (ImportPhaseUtils.isDefer(phase)) {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							"import.defer() is not yet supported for ContextModule (the import path is a dynamic expression).",
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
+					);
+				}
+
+				const dep = ContextDependencyHelpers.create(
+					ImportContextDependency,
+					/** @type {Range} */ (expr.range),
+					param,
+					expr,
+					this.options,
+					{
+						chunkName,
+						groupOptions,
+						include,
+						exclude,
+						mode,
+						namespaceObject:
+							/** @type {BuildMeta} */
+							(parser.state.module.buildMeta).strictHarmonyModule
+								? "strict"
+								: true,
+						typePrefix: "import()",
+						category: "esm",
+						referencedExports: exports,
+						attributes: getImportAttributes(expr)
+					},
+					parser
+				);
+				if (!dep) return;
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.optional = Boolean(parser.scope.inTry);
+				parser.state.current.addDependency(dep);
 			}
-			if (mode === "weak") {
-				mode = "async-weak";
+
+			if (fulfilledNamespaceObj) {
+				walkImportThenFulfilledCallback(
+					parser,
+					expr,
+					/** @type {ArrowFunctionExpression | FunctionExpression} */
+					(importThen.arguments[0]),
+					fulfilledNamespaceObj
+				);
+				parser.walkExpressions(importThen.arguments.slice(1));
+			} else if (importThen) {
+				parser.walkExpressions(importThen.arguments);
 			}
-			const dep = ContextDependencyHelpers.create(
-				ImportContextDependency,
-				/** @type {Range} */ (expr.range),
-				param,
-				expr,
-				this.options,
-				{
-					chunkName,
-					groupOptions,
-					include,
-					exclude,
-					mode,
-					namespaceObject: /** @type {BuildMeta} */ (
-						parser.state.module.buildMeta
-					).strictHarmonyModule
-						? "strict"
-						: true,
-					typePrefix: "import()",
-					category: "esm",
-					referencedExports: exports,
-					attributes: getImportAttributes(expr)
-				},
-				parser
-			);
-			if (!dep) return;
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-			dep.optional = Boolean(parser.scope.inTry);
-			parser.state.current.addDependency(dep);
+
 			return true;
 		});
 	}

package/lib/dependencies/ImportPhase.js

@@ -0,0 +1,121 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+const memoize = require("../util/memoize");
+
+const getCommentCompilationWarning = memoize(() =>
+	require("../CommentCompilationWarning")
+);
+
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").ExportAllDeclaration} ExportAllDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").ExportNamedDeclaration} ExportNamedDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").ImportDeclaration} ImportDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").ImportExpression} ImportExpression */
+
+/** @typedef {typeof ImportPhase.Evaluation | typeof ImportPhase.Defer | typeof ImportPhase.Source}  ImportPhaseType */
+
+const ImportPhase = Object.freeze({
+	Evaluation: 0b00,
+	Defer: 0b01,
+	Source: 0b10
+});
+
+/**
+ * @typedef {object} ImportPhaseUtils
+ * @property {(phase: ImportPhaseType) => boolean} isDefer true if phase is defer
+ * @property {(phase: ImportPhaseType) => boolean} isSource true if phase is source
+ */
+
+/** @type {ImportPhaseUtils} */
+const ImportPhaseUtils = {
+	isDefer(phase) {
+		return phase === ImportPhase.Defer;
+	},
+	isSource(phase) {
+		return phase === ImportPhase.Source;
+	}
+};
+
+/**
+ * @typedef {() => Record<string, EXPECTED_ANY> | null} GetCommentOptions
+ */
+
+/**
+ * @callback GetImportPhase
+ * @param {JavascriptParser} parser parser
+ * @param {ExportNamedDeclaration | ExportAllDeclaration | ImportDeclaration | ImportExpression} node node
+ * @param {GetCommentOptions=} getCommentOptions optional function that returns the comment options object.
+ * @returns {ImportPhaseType} import phase
+ */
+
+/**
+ * @param {boolean=} enableImportPhase enable import phase detection
+ * @returns {GetImportPhase} evaluates the import phase for ast node
+ */
+function createGetImportPhase(enableImportPhase) {
+	return (parser, node, getCommentOptions) => {
+		if (!enableImportPhase) return ImportPhase.Evaluation;
+
+		// We now only support `defer import`
+		const phaseBySyntax =
+			"phase" in node && node.phase === "defer"
+				? ImportPhase.Defer
+				: ImportPhase.Evaluation;
+
+		if (!node.range) {
+			return phaseBySyntax;
+		}
+
+		getCommentOptions =
+			getCommentOptions ||
+			(() => {
+				if (!node.range) return null;
+				const { options, errors } = parser.parseCommentOptions(node.range);
+				if (errors) {
+					for (const e of errors) {
+						const { comment } = e;
+						if (!comment.loc) continue;
+
+						const CommentCompilationWarning = getCommentCompilationWarning();
+						parser.state.module.addWarning(
+							new CommentCompilationWarning(
+								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+								comment.loc
+							)
+						);
+					}
+				}
+				return options;
+			});
+
+		const options = getCommentOptions();
+
+		if (!options || !options.webpackDefer) return phaseBySyntax;
+
+		const { webpackDefer } = options;
+		if (typeof webpackDefer === "boolean") {
+			return webpackDefer ? ImportPhase.Defer : phaseBySyntax;
+		} else if (node.loc) {
+			const CommentCompilationWarning = getCommentCompilationWarning();
+			parser.state.module.addWarning(
+				new CommentCompilationWarning(
+					"webpackDefer magic comment expected a boolean value.",
+					node.loc
+				)
+			);
+		}
+
+		return phaseBySyntax;
+	};
+}
+
+module.exports = {
+	ImportPhase,
+	ImportPhaseUtils,
+	createGetImportPhase
+};

package/lib/dependencies/ImportPlugin.js

@@ -74,8 +74,9 @@ class ImportPlugin {
 				 * @returns {void}
 				 */
 				const handler = (parser, parserOptions) => {
-					if (parserOptions.import !== undefined && !parserOptions.import)
+					if (parserOptions.import !== undefined && !parserOptions.import) {
 						return;
+					}
 
 					new ImportParserPlugin(parserOptions).apply(parser);
 				};
@@ -93,4 +94,5 @@ class ImportPlugin {
 		);
 	}
 }
+
 module.exports = ImportPlugin;

package/lib/dependencies/ImportWeakDependency.js

@@ -10,23 +10,24 @@ const ImportDependency = require("./ImportDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {ImportDependency.RawReferencedExports} RawReferencedExports */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 class ImportWeakDependency extends ImportDependency {
 	/**
 	 * @param {string} request the request
 	 * @param {Range} range expression range
-	 * @param {(string[][] | null)=} referencedExports list of referenced exports
+	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
+	 * @param {ImportPhaseType} phase import phase
 	 * @param {ImportAttributes=} attributes import attributes
 	 */
-	constructor(request, range, referencedExports, attributes) {
-		super(request, range, referencedExports, attributes);
+	constructor(request, range, referencedExports, phase, attributes) {
+		super(request, range, referencedExports, phase, attributes);
 		this.weak = true;
 	}
 
@@ -62,6 +63,7 @@ ImportWeakDependency.Template = class ImportDependencyTemplate extends (
 			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
 			message: "import() weak",
 			weak: true,
+			dependency: dep,
 			runtimeRequirements
 		});