@depup/webpack 5.105.4-depup.37

package/lib/url/URLParserPlugin.js

@@ -0,0 +1,266 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+const { pathToFileURL } = require("url");
+const CommentCompilationWarning = require("../CommentCompilationWarning");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+const ConstDependency = require("../dependencies/ConstDependency");
+const ContextDependencyHelpers = require("../dependencies/ContextDependencyHelpers");
+const URLContextDependency = require("../dependencies/URLContextDependency");
+const URLDependency = require("../dependencies/URLDependency");
+const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
+const { approve } = require("../javascript/JavascriptParserHelpers");
+const InnerGraph = require("../optimize/InnerGraph");
+
+/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("estree").NewExpression} NewExpressionNode */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+const PLUGIN_NAME = "URLParserPlugin";
+
+/**
+ * @param {NormalModule} module module
+ * @returns {URL} file url
+ */
+const getUrl = (module) => pathToFileURL(module.resource);
+
+/**
+ * @param {JavascriptParser} parser parser parser
+ * @param {MemberExpression} arg arg
+ * @returns {boolean} true when it is `meta.url`, otherwise false
+ */
+const isMetaUrl = (parser, arg) => {
+	const chain = parser.extractMemberExpressionChain(arg);
+
+	if (
+		chain.members.length !== 1 ||
+		chain.object.type !== "MetaProperty" ||
+		chain.object.meta.name !== "import" ||
+		chain.object.property.name !== "meta" ||
+		chain.members[0] !== "url"
+	) {
+		return false;
+	}
+
+	return true;
+};
+
+/** @type {WeakMap<NewExpressionNode, BasicEvaluatedExpression | undefined>} */
+const getEvaluatedExprCache = new WeakMap();
+
+/**
+ * @param {NewExpressionNode} expr expression
+ * @param {JavascriptParser} parser parser parser
+ * @returns {BasicEvaluatedExpression | undefined} basic evaluated expression
+ */
+const getEvaluatedExpr = (expr, parser) => {
+	let result = getEvaluatedExprCache.get(expr);
+	if (result !== undefined) return result;
+
+	/**
+	 * @returns {BasicEvaluatedExpression | undefined} basic evaluated expression
+	 */
+	const evaluate = () => {
+		if (expr.arguments.length !== 2) return;
+
+		const [arg1, arg2] = expr.arguments;
+
+		if (arg2.type !== "MemberExpression" || arg1.type === "SpreadElement") {
+			return;
+		}
+		if (!isMetaUrl(parser, arg2)) return;
+
+		return parser.evaluateExpression(arg1);
+	};
+
+	result = evaluate();
+	getEvaluatedExprCache.set(expr, result);
+
+	return result;
+};
+
+class URLParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options options
+	 */
+	constructor(options) {
+		/** @type {JavascriptParserOptions} */
+		this.options = options;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		const relative = this.options.url === "relative";
+
+		parser.hooks.canRename.for("URL").tap(PLUGIN_NAME, approve);
+		parser.hooks.evaluateNewExpression.for("URL").tap(PLUGIN_NAME, (expr) => {
+			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			const request = evaluatedExpr && evaluatedExpr.asString();
+
+			if (!request) return;
+			const url = new URL(request, getUrl(parser.state.module));
+
+			return new BasicEvaluatedExpression()
+				.setString(url.toString())
+				.setRange(/** @type {Range} */ (expr.range));
+		});
+		parser.hooks.new.for("URL").tap(PLUGIN_NAME, (_expr) => {
+			const expr = /** @type {NewExpressionNode} */ (_expr);
+			const { options: importOptions, errors: commentErrors } =
+				parser.parseCommentOptions(/** @type {Range} */ (expr.range));
+
+			if (commentErrors) {
+				for (const e of commentErrors) {
+					const { comment } = e;
+					parser.state.module.addWarning(
+						new CommentCompilationWarning(
+							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+							/** @type {DependencyLocation} */ (comment.loc)
+						)
+					);
+				}
+			}
+
+			if (importOptions && importOptions.webpackIgnore !== undefined) {
+				if (typeof importOptions.webpackIgnore !== "boolean") {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
+					);
+					return;
+				} else if (importOptions.webpackIgnore) {
+					if (expr.arguments.length !== 2) return;
+
+					const [, arg2] = expr.arguments;
+
+					if (arg2.type !== "MemberExpression" || !isMetaUrl(parser, arg2)) {
+						return;
+					}
+
+					const dep = new ConstDependency(
+						RuntimeGlobals.baseURI,
+						/** @type {Range} */ (arg2.range),
+						[RuntimeGlobals.baseURI]
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addPresentationalDependency(dep);
+
+					return true;
+				}
+			}
+
+			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			if (!evaluatedExpr) return;
+
+			/** @type {string | undefined} */
+			let request;
+
+			// static URL
+			if ((request = evaluatedExpr.asString())) {
+				const [arg1, arg2] = expr.arguments;
+				const dep = new URLDependency(
+					request,
+					[
+						/** @type {Range} */ (arg1.range)[0],
+						/** @type {Range} */ (arg2.range)[1]
+					],
+					/** @type {Range} */ (expr.range),
+					relative
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.current.addDependency(dep);
+				InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
+				return true;
+			}
+
+			if (this.options.dynamicUrl === false) return;
+
+			// context URL
+			/** @type {undefined | RegExp} */
+			let include;
+			/** @type {undefined | RegExp} */
+			let exclude;
+
+			if (importOptions) {
+				if (importOptions.webpackInclude !== undefined) {
+					if (
+						!importOptions.webpackInclude ||
+						!(importOptions.webpackInclude instanceof RegExp)
+					) {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					} else {
+						include = importOptions.webpackInclude;
+					}
+				}
+				if (importOptions.webpackExclude !== undefined) {
+					if (
+						!importOptions.webpackExclude ||
+						!(importOptions.webpackExclude instanceof RegExp)
+					) {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					} else {
+						exclude = importOptions.webpackExclude;
+					}
+				}
+			}
+			const dep = ContextDependencyHelpers.create(
+				URLContextDependency,
+				/** @type {Range} */ (expr.range),
+				evaluatedExpr,
+				expr,
+				this.options,
+				{
+					include,
+					exclude,
+					mode: "sync",
+					typePrefix: "new URL with import.meta.url",
+					category: "url"
+				},
+				parser
+			);
+			if (!dep) return;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.current.addDependency(dep);
+			return true;
+		});
+		parser.hooks.isPure.for("NewExpression").tap(PLUGIN_NAME, (_expr) => {
+			const expr = /** @type {NewExpressionNode} */ (_expr);
+			const { callee } = expr;
+			if (callee.type !== "Identifier") return;
+			const calleeInfo = parser.getFreeInfoFromVariable(callee.name);
+			if (!calleeInfo || calleeInfo.name !== "URL") return;
+
+			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			const request = evaluatedExpr && evaluatedExpr.asString();
+
+			if (request) return true;
+		});
+	}
+}
+
+module.exports = URLParserPlugin;

package/lib/util/AppendOnlyStackedSet.js

@@ -0,0 +1,78 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+/**
+ * @template T
+ */
+class AppendOnlyStackedSet {
+	/**
+	 * @param {Set<T>[]} sets an optional array of sets
+	 */
+	constructor(sets = []) {
+		/** @type {Set<T>[]} */
+		this._sets = sets;
+		/** @type {Set<T> | undefined} */
+		this._current = undefined;
+	}
+
+	/**
+	 * @param {T} el element
+	 */
+	add(el) {
+		if (!this._current) {
+			this._current = new Set();
+			this._sets.push(this._current);
+		}
+		this._current.add(el);
+	}
+
+	/**
+	 * @param {T} el element
+	 * @returns {boolean} result
+	 */
+	has(el) {
+		for (const set of this._sets) {
+			if (set.has(el)) return true;
+		}
+		return false;
+	}
+
+	clear() {
+		this._sets = [];
+		if (this._current) {
+			this._current = undefined;
+		}
+	}
+
+	/**
+	 * @returns {AppendOnlyStackedSet<T>} child
+	 */
+	createChild() {
+		return new AppendOnlyStackedSet(this._sets.length ? [...this._sets] : []);
+	}
+
+	/**
+	 * @returns {Iterator<T>} iterable iterator
+	 */
+	[Symbol.iterator]() {
+		const iterators = this._sets.map((map) => map[Symbol.iterator]());
+		let current = iterators.pop();
+		return {
+			next() {
+				if (!current) return { done: true, value: undefined };
+				let result = current.next();
+				while (result.done && iterators.length > 0) {
+					current = /** @type {SetIterator<T>} */ (iterators.pop());
+					result = current.next();
+				}
+				return result;
+			}
+		};
+	}
+}
+
+module.exports = AppendOnlyStackedSet;

package/lib/util/ArrayHelpers.js

@@ -0,0 +1,46 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/**
+ * Compare two arrays or strings by performing strict equality check for each value.
+ * @template T
+ * @param {ArrayLike<T>} a Array of values to be compared
+ * @param {ArrayLike<T>} b Array of values to be compared
+ * @returns {boolean} returns true if all the elements of passed arrays are strictly equal.
+ */
+module.exports.equals = (a, b) => {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) {
+		if (a[i] !== b[i]) return false;
+	}
+	return true;
+};
+
+/**
+ * Partition an array by calling a predicate function on each value.
+ * @template T
+ * @param {T[]} arr Array of values to be partitioned
+ * @param {(value: T) => boolean} fn Partition function which partitions based on truthiness of result.
+ * @returns {[T[], T[]]} returns the values of `arr` partitioned into two new arrays based on fn predicate.
+ */
+module.exports.groupBy = (
+	// eslint-disable-next-line default-param-last
+	arr = [],
+	fn
+) =>
+	arr.reduce(
+		/**
+		 * @param {[T[], T[]]} groups An accumulator storing already partitioned values returned from previous call.
+		 * @param {T} value The value of the current element
+		 * @returns {[T[], T[]]} returns an array of partitioned groups accumulator resulting from calling a predicate on the current value.
+		 */
+		(groups, value) => {
+			groups[fn(value) ? 0 : 1].push(value);
+			return groups;
+		},
+		[[], []]
+	);

package/lib/util/ArrayQueue.js

@@ -0,0 +1,104 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/**
+ * @template T
+ */
+class ArrayQueue {
+	/**
+	 * @param {Iterable<T>=} items The initial elements.
+	 */
+	constructor(items) {
+		/**
+		 * @private
+		 * @type {T[]}
+		 */
+		this._list = items ? [...items] : [];
+		/**
+		 * @private
+		 * @type {T[]}
+		 */
+		this._listReversed = [];
+	}
+
+	/**
+	 * Returns the number of elements in this queue.
+	 * @returns {number} The number of elements in this queue.
+	 */
+	get length() {
+		return this._list.length + this._listReversed.length;
+	}
+
+	/**
+	 * Empties the queue.
+	 */
+	clear() {
+		this._list.length = 0;
+		this._listReversed.length = 0;
+	}
+
+	/**
+	 * Appends the specified element to this queue.
+	 * @param {T} item The element to add.
+	 * @returns {void}
+	 */
+	enqueue(item) {
+		this._list.push(item);
+	}
+
+	/**
+	 * Retrieves and removes the head of this queue.
+	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
+	 */
+	dequeue() {
+		if (this._listReversed.length === 0) {
+			if (this._list.length === 0) return;
+			if (this._list.length === 1) return this._list.pop();
+			if (this._list.length < 16) return this._list.shift();
+			const temp = this._listReversed;
+			this._listReversed = this._list;
+			this._listReversed.reverse();
+			this._list = temp;
+		}
+		return this._listReversed.pop();
+	}
+
+	/**
+	 * Finds and removes an item
+	 * @param {T} item the item
+	 * @returns {void}
+	 */
+	delete(item) {
+		const i = this._list.indexOf(item);
+		if (i >= 0) {
+			this._list.splice(i, 1);
+		} else {
+			const i = this._listReversed.indexOf(item);
+			if (i >= 0) this._listReversed.splice(i, 1);
+		}
+	}
+
+	[Symbol.iterator]() {
+		return {
+			next: () => {
+				const item = this.dequeue();
+				if (item) {
+					return {
+						done: false,
+						value: item
+					};
+				}
+				return {
+					done: true,
+					value: undefined
+				};
+			}
+		};
+	}
+}
+
+module.exports = ArrayQueue;