@eriche/webpack 4.47.0

package/lib/util/SortableSet.js

@@ -0,0 +1,140 @@
+"use strict";
+
+/**
+ * A subset of Set that offers sorting functionality
+ * @template T item type in set
+ * @extends {Set<T>}
+ */
+class SortableSet extends Set {
+	/**
+	 * Create a new sortable set
+	 * @param {Iterable<T>=} initialIterable The initial iterable value
+	 * @typedef {function(T, T): number} SortFunction
+	 * @param {SortFunction=} defaultSort Default sorting function
+	 */
+	constructor(initialIterable, defaultSort) {
+		super(initialIterable);
+		/** @private @type {function(T, T): number}} */
+		this._sortFn = defaultSort;
+		/** @private @type {function(T, T): number} | null} */
+		this._lastActiveSortFn = null;
+		/** @private @type {Map<Function, T[]> | undefined} */
+		this._cache = undefined;
+		/** @private @type {Map<Function, T[]|string|number> | undefined} */
+		this._cacheOrderIndependent = undefined;
+	}
+
+	/**
+	 * @param {T} value value to add to set
+	 * @returns {this} returns itself
+	 */
+	add(value) {
+		this._lastActiveSortFn = null;
+		this._invalidateCache();
+		this._invalidateOrderedCache();
+		super.add(value);
+		return this;
+	}
+
+	/**
+	 * @param {T} value value to delete
+	 * @returns {boolean} true if value existed in set, false otherwise
+	 */
+	delete(value) {
+		this._invalidateCache();
+		this._invalidateOrderedCache();
+		return super.delete(value);
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	clear() {
+		this._invalidateCache();
+		this._invalidateOrderedCache();
+		return super.clear();
+	}
+
+	/**
+	 * Sort with a comparer function
+	 * @param {SortFunction} sortFn Sorting comparer function
+	 * @returns {void}
+	 */
+	sortWith(sortFn) {
+		if (this.size <= 1 || sortFn === this._lastActiveSortFn) {
+			// already sorted - nothing to do
+			return;
+		}
+
+		const sortedArray = Array.from(this).sort(sortFn);
+		super.clear();
+		for (let i = 0; i < sortedArray.length; i += 1) {
+			super.add(sortedArray[i]);
+		}
+		this._lastActiveSortFn = sortFn;
+		this._invalidateCache();
+	}
+
+	sort() {
+		this.sortWith(this._sortFn);
+	}
+
+	/**
+	 * Get data from cache
+	 * @param {function(SortableSet<T>): T[]} fn function to calculate value
+	 * @returns {T[]} returns result of fn(this), cached until set changes
+	 */
+	getFromCache(fn) {
+		if (this._cache === undefined) {
+			this._cache = new Map();
+		} else {
+			const data = this._cache.get(fn);
+			if (data !== undefined) {
+				return data;
+			}
+		}
+		const newData = fn(this);
+		this._cache.set(fn, newData);
+		return newData;
+	}
+
+	/**
+	 * @param {function(SortableSet<T>): string|number|T[]} fn function to calculate value
+	 * @returns {any} returns result of fn(this), cached until set changes
+	 */
+	getFromUnorderedCache(fn) {
+		if (this._cacheOrderIndependent === undefined) {
+			this._cacheOrderIndependent = new Map();
+		} else {
+			const data = this._cacheOrderIndependent.get(fn);
+			if (data !== undefined) {
+				return data;
+			}
+		}
+		const newData = fn(this);
+		this._cacheOrderIndependent.set(fn, newData);
+		return newData;
+	}
+
+	/**
+	 * @private
+	 * @returns {void}
+	 */
+	_invalidateCache() {
+		if (this._cache !== undefined) {
+			this._cache.clear();
+		}
+	}
+
+	/**
+	 * @private
+	 * @returns {void}
+	 */
+	_invalidateOrderedCache() {
+		if (this._cacheOrderIndependent !== undefined) {
+			this._cacheOrderIndependent.clear();
+		}
+	}
+}
+
+module.exports = SortableSet;

package/lib/util/StackedSetMap.js

@@ -0,0 +1,142 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const util = require("util");
+
+const TOMBSTONE = {};
+const UNDEFINED_MARKER = {};
+
+class StackedSetMap {
+	constructor(parentStack) {
+		this.stack = parentStack === undefined ? [] : parentStack.slice();
+		this.map = new Map();
+		this.stack.push(this.map);
+	}
+
+	add(item) {
+		this.map.set(item, true);
+	}
+
+	set(item, value) {
+		this.map.set(item, value === undefined ? UNDEFINED_MARKER : value);
+	}
+
+	delete(item) {
+		if (this.stack.length > 1) {
+			this.map.set(item, TOMBSTONE);
+		} else {
+			this.map.delete(item);
+		}
+	}
+
+	has(item) {
+		const topValue = this.map.get(item);
+		if (topValue !== undefined) return topValue !== TOMBSTONE;
+		if (this.stack.length > 1) {
+			for (var i = this.stack.length - 2; i >= 0; i--) {
+				const value = this.stack[i].get(item);
+				if (value !== undefined) {
+					this.map.set(item, value);
+					return value !== TOMBSTONE;
+				}
+			}
+			this.map.set(item, TOMBSTONE);
+		}
+		return false;
+	}
+
+	get(item) {
+		const topValue = this.map.get(item);
+		if (topValue !== undefined) {
+			return topValue === TOMBSTONE || topValue === UNDEFINED_MARKER
+				? undefined
+				: topValue;
+		}
+		if (this.stack.length > 1) {
+			for (var i = this.stack.length - 2; i >= 0; i--) {
+				const value = this.stack[i].get(item);
+				if (value !== undefined) {
+					this.map.set(item, value);
+					return value === TOMBSTONE || value === UNDEFINED_MARKER
+						? undefined
+						: value;
+				}
+			}
+			this.map.set(item, TOMBSTONE);
+		}
+		return undefined;
+	}
+
+	_compress() {
+		if (this.stack.length === 1) return;
+		this.map = new Map();
+		for (const data of this.stack) {
+			for (const pair of data) {
+				if (pair[1] === TOMBSTONE) {
+					this.map.delete(pair[0]);
+				} else {
+					this.map.set(pair[0], pair[1]);
+				}
+			}
+		}
+		this.stack = [this.map];
+	}
+
+	asArray() {
+		this._compress();
+		return Array.from(this.map.entries(), pair => pair[0]);
+	}
+
+	asSet() {
+		return new Set(this.asArray());
+	}
+
+	asPairArray() {
+		this._compress();
+		return Array.from(this.map.entries(), pair =>
+			/** @type {[TODO, TODO]} */ (pair[1] === UNDEFINED_MARKER
+				? [pair[0], undefined]
+				: pair)
+		);
+	}
+
+	asMap() {
+		return new Map(this.asPairArray());
+	}
+
+	get size() {
+		this._compress();
+		return this.map.size;
+	}
+
+	createChild() {
+		return new StackedSetMap(this.stack);
+	}
+
+	get length() {
+		throw new Error("This is no longer an Array");
+	}
+
+	set length(value) {
+		throw new Error("This is no longer an Array");
+	}
+}
+
+// TODO remove in webpack 5
+StackedSetMap.prototype.push = util.deprecate(
+	/**
+	 * @deprecated
+	 * @this {StackedSetMap}
+	 * @param {any} item Item to add
+	 * @returns {void}
+	 */
+	function(item) {
+		this.add(item);
+	},
+	"This is no longer an Array: Use add instead."
+);
+
+module.exports = StackedSetMap;

package/lib/util/TrackingSet.js

@@ -0,0 +1,35 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+module.exports = class TrackingSet {
+	constructor(set) {
+		this.set = set;
+		this.set2 = new Set();
+		this.stack = set.stack;
+	}
+
+	add(item) {
+		this.set2.add(item);
+		return this.set.add(item);
+	}
+
+	delete(item) {
+		this.set2.delete(item);
+		return this.set.delete(item);
+	}
+
+	has(item) {
+		return this.set.has(item);
+	}
+
+	createChild() {
+		return this.set.createChild();
+	}
+
+	getAddedItems() {
+		return this.set2;
+	}
+};

package/lib/util/cachedMerge.js

@@ -0,0 +1,35 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const mergeCache = new WeakMap();
+
+/**
+ * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
+ * @example
+ * // performs Object.assign(first, second), stores the result in WeakMap and returns result
+ * cachedMerge({a: 1}, {a: 2})
+ * {a: 2}
+ *  // when same arguments passed, gets the result from WeakMap and returns it.
+ * cachedMerge({a: 1}, {a: 2})
+ * {a: 2}
+ * @param {object} first first object
+ * @param {object} second second object
+ * @returns {object} merged object of first and second object
+ */
+const cachedMerge = (first, second) => {
+	let innerCache = mergeCache.get(first);
+	if (innerCache === undefined) {
+		innerCache = new WeakMap();
+		mergeCache.set(first, innerCache);
+	}
+	const prevMerge = innerCache.get(second);
+	if (prevMerge !== undefined) return prevMerge;
+	const newMerge = Object.assign({}, first, second);
+	innerCache.set(second, newMerge);
+	return newMerge;
+};
+
+module.exports = cachedMerge;

package/lib/util/cleverMerge.js

@@ -0,0 +1,77 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const mergeCache = new WeakMap();
+
+/**
+ * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
+ * @example
+ * // performs cleverMerge(first, second), stores the result in WeakMap and returns result
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ *  // when same arguments passed, gets the result from WeakMap and returns it.
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ * @param {object} first first object
+ * @param {object} second second object
+ * @returns {object} merged object of first and second object
+ */
+const cachedCleverMerge = (first, second) => {
+	let innerCache = mergeCache.get(first);
+	if (innerCache === undefined) {
+		innerCache = new WeakMap();
+		mergeCache.set(first, innerCache);
+	}
+	const prevMerge = innerCache.get(second);
+	if (prevMerge !== undefined) return prevMerge;
+	const newMerge = cleverMerge(first, second);
+	innerCache.set(second, newMerge);
+	return newMerge;
+};
+
+/**
+ * Merges two objects. Objects are not deeply merged.
+ * TODO webpack 5: merge objects deeply clever.
+ * Arrays might reference the old value with "..."
+ * @param {object} first first object
+ * @param {object} second second object
+ * @returns {object} merged object of first and second object
+ */
+const cleverMerge = (first, second) => {
+	const newObject = Object.assign({}, first);
+	for (const key of Object.keys(second)) {
+		if (!(key in newObject)) {
+			newObject[key] = second[key];
+			continue;
+		}
+		const secondValue = second[key];
+		if (!Array.isArray(secondValue)) {
+			newObject[key] = secondValue;
+			continue;
+		}
+		const firstValue = newObject[key];
+		if (Array.isArray(firstValue)) {
+			const newArray = [];
+			for (const item of secondValue) {
+				if (item === "...") {
+					for (const item of firstValue) {
+						newArray.push(item);
+					}
+				} else {
+					newArray.push(item);
+				}
+			}
+			newObject[key] = newArray;
+		} else {
+			newObject[key] = secondValue;
+		}
+	}
+	return newObject;
+};
+
+exports.cachedCleverMerge = cachedCleverMerge;
+exports.cleverMerge = cleverMerge;

package/lib/util/createHash.js

@@ -0,0 +1,174 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const AbstractMethodError = require("../AbstractMethodError");
+
+const BULK_SIZE = 1000;
+
+class Hash {
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
+	 */
+	update(data, inputEncoding) {
+		throw new AbstractMethodError();
+	}
+
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
+	digest(encoding) {
+		throw new AbstractMethodError();
+	}
+}
+
+class BulkUpdateDecorator extends Hash {
+	/**
+	 * @param {Hash} hash hash
+	 */
+	constructor(hash) {
+		super();
+		this.hash = hash;
+		this.buffer = "";
+	}
+
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
+	 */
+	update(data, inputEncoding) {
+		if (
+			inputEncoding !== undefined ||
+			typeof data !== "string" ||
+			data.length > BULK_SIZE
+		) {
+			if (this.buffer.length > 0) {
+				this.hash.update(this.buffer);
+				this.buffer = "";
+			}
+			this.hash.update(data, inputEncoding);
+		} else {
+			this.buffer += data;
+			if (this.buffer.length > BULK_SIZE) {
+				this.hash.update(this.buffer);
+				this.buffer = "";
+			}
+		}
+		return this;
+	}
+
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
+	digest(encoding) {
+		if (this.buffer.length > 0) {
+			this.hash.update(this.buffer);
+		}
+		var digestResult = this.hash.digest(encoding);
+		return typeof digestResult === "string"
+			? digestResult
+			: digestResult.toString();
+	}
+}
+
+/**
+ * istanbul ignore next
+ */
+class DebugHash extends Hash {
+	constructor() {
+		super();
+		this.string = "";
+	}
+
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
+	 */
+	update(data, inputEncoding) {
+		if (typeof data !== "string") data = data.toString("utf-8");
+		this.string += data;
+		return this;
+	}
+
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
+	digest(encoding) {
+		return this.string.replace(/[^a-z0-9]+/gi, m =>
+			Buffer.from(m).toString("hex")
+		);
+	}
+}
+
+/** @type {typeof import("crypto") | undefined} */
+let crypto = undefined;
+/** @type {typeof import("./hash/md4") | undefined} */
+let createMd4 = undefined;
+/** @type {typeof import("./hash/BatchedHash") | undefined} */
+let BatchedHash = undefined;
+
+/** @type {number} */
+const NODE_MAJOR_VERSION = parseInt(process.versions.node, 10);
+
+/**
+ * Creates a hash by name or function
+ * @param {string | HashConstructor} algorithm the algorithm name or a constructor creating a hash
+ * @returns {Hash} the hash
+ */
+module.exports = algorithm => {
+	if (typeof algorithm === "function") {
+		return new BulkUpdateDecorator(new algorithm());
+	}
+
+	switch (algorithm) {
+		// TODO add non-cryptographic algorithm here
+		case "debug":
+			return new DebugHash();
+		case "md4":
+			if (NODE_MAJOR_VERSION >= 18) {
+				if (createMd4 === undefined) {
+					createMd4 = require("./hash/md4");
+					if (BatchedHash === undefined) {
+						BatchedHash = require("./hash/BatchedHash");
+					}
+				}
+				return new /** @type {typeof import("./hash/BatchedHash")} */ (BatchedHash)(
+					createMd4()
+				);
+			}
+		// If we are on Node.js < 18, fall through to the default case
+		// eslint-disable-next-line no-fallthrough
+
+		case "native-md4":
+			if (NODE_MAJOR_VERSION >= 18) {
+				if (crypto === undefined) crypto = require("crypto");
+				return new BulkUpdateDecorator(
+					/** @type {typeof import("crypto")} */ (crypto).createHash("md4")
+				);
+			}
+		// If we are on Node.js < 18, fall through to the default case
+		// eslint-disable-next-line no-fallthrough
+
+		default:
+			if (crypto === undefined) crypto = require("crypto");
+			return new BulkUpdateDecorator(crypto.createHash(algorithm));
+	}
+};
+
+module.exports.Hash = Hash;
+/** @typedef {typeof Hash} HashConstructor */