mathjs 10.4.1 → 10.4.2

package/examples/node_modules/webpack/lib/cache/ResolverCachePlugin.js

@@ -0,0 +1,354 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const LazySet = require("../util/LazySet");
+const makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
+/** @typedef {import("../CacheFacade").ItemCacheFacade} ItemCacheFacade */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../FileSystemInfo")} FileSystemInfo */
+/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
+
+class CacheEntry {
+	constructor(result, snapshot) {
+		this.result = result;
+		this.snapshot = snapshot;
+	}
+
+	serialize({ write }) {
+		write(this.result);
+		write(this.snapshot);
+	}
+
+	deserialize({ read }) {
+		this.result = read();
+		this.snapshot = read();
+	}
+}
+
+makeSerializable(CacheEntry, "webpack/lib/cache/ResolverCachePlugin");
+
+/**
+ * @template T
+ * @param {Set<T> | LazySet<T>} set set to add items to
+ * @param {Set<T> | LazySet<T>} otherSet set to add items from
+ * @returns {void}
+ */
+const addAllToSet = (set, otherSet) => {
+	if (set instanceof LazySet) {
+		set.addAll(otherSet);
+	} else {
+		for (const item of otherSet) {
+			set.add(item);
+		}
+	}
+};
+
+/**
+ * @param {Object} object an object
+ * @param {boolean} excludeContext if true, context is not included in string
+ * @returns {string} stringified version
+ */
+const objectToString = (object, excludeContext) => {
+	let str = "";
+	for (const key in object) {
+		if (excludeContext && key === "context") continue;
+		const value = object[key];
+		if (typeof value === "object" && value !== null) {
+			str += `|${key}=[${objectToString(value, false)}|]`;
+		} else {
+			str += `|${key}=|${value}`;
+		}
+	}
+	return str;
+};
+
+class ResolverCachePlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const cache = compiler.getCache("ResolverCachePlugin");
+		/** @type {FileSystemInfo} */
+		let fileSystemInfo;
+		let snapshotOptions;
+		let realResolves = 0;
+		let cachedResolves = 0;
+		let cacheInvalidResolves = 0;
+		let concurrentResolves = 0;
+		compiler.hooks.thisCompilation.tap("ResolverCachePlugin", compilation => {
+			snapshotOptions = compilation.options.snapshot.resolve;
+			fileSystemInfo = compilation.fileSystemInfo;
+			compilation.hooks.finishModules.tap("ResolverCachePlugin", () => {
+				if (realResolves + cachedResolves > 0) {
+					const logger = compilation.getLogger("webpack.ResolverCachePlugin");
+					logger.log(
+						`${Math.round(
+							(100 * realResolves) / (realResolves + cachedResolves)
+						)}% really resolved (${realResolves} real resolves with ${cacheInvalidResolves} cached but invalid, ${cachedResolves} cached valid, ${concurrentResolves} concurrent)`
+					);
+					realResolves = 0;
+					cachedResolves = 0;
+					cacheInvalidResolves = 0;
+					concurrentResolves = 0;
+				}
+			});
+		});
+		/**
+		 * @param {ItemCacheFacade} itemCache cache
+		 * @param {Resolver} resolver the resolver
+		 * @param {Object} resolveContext context for resolving meta info
+		 * @param {Object} request the request info object
+		 * @param {function((Error | null)=, Object=): void} callback callback function
+		 * @returns {void}
+		 */
+		const doRealResolve = (
+			itemCache,
+			resolver,
+			resolveContext,
+			request,
+			callback
+		) => {
+			realResolves++;
+			const newRequest = {
+				_ResolverCachePluginCacheMiss: true,
+				...request
+			};
+			const newResolveContext = {
+				...resolveContext,
+				stack: new Set(),
+				missingDependencies: new LazySet(),
+				fileDependencies: new LazySet(),
+				contextDependencies: new LazySet()
+			};
+			let yieldResult;
+			let withYield = false;
+			if (typeof newResolveContext.yield === "function") {
+				yieldResult = [];
+				withYield = true;
+				newResolveContext.yield = obj => yieldResult.push(obj);
+			}
+			const propagate = key => {
+				if (resolveContext[key]) {
+					addAllToSet(resolveContext[key], newResolveContext[key]);
+				}
+			};
+			const resolveTime = Date.now();
+			resolver.doResolve(
+				resolver.hooks.resolve,
+				newRequest,
+				"Cache miss",
+				newResolveContext,
+				(err, result) => {
+					propagate("fileDependencies");
+					propagate("contextDependencies");
+					propagate("missingDependencies");
+					if (err) return callback(err);
+					const fileDependencies = newResolveContext.fileDependencies;
+					const contextDependencies = newResolveContext.contextDependencies;
+					const missingDependencies = newResolveContext.missingDependencies;
+					fileSystemInfo.createSnapshot(
+						resolveTime,
+						fileDependencies,
+						contextDependencies,
+						missingDependencies,
+						snapshotOptions,
+						(err, snapshot) => {
+							if (err) return callback(err);
+							const resolveResult = withYield ? yieldResult : result;
+							// since we intercept resolve hook
+							// we still can get result in callback
+							if (withYield && result) yieldResult.push(result);
+							if (!snapshot) {
+								if (resolveResult) return callback(null, resolveResult);
+								return callback();
+							}
+							itemCache.store(
+								new CacheEntry(resolveResult, snapshot),
+								storeErr => {
+									if (storeErr) return callback(storeErr);
+									if (resolveResult) return callback(null, resolveResult);
+									callback();
+								}
+							);
+						}
+					);
+				}
+			);
+		};
+		compiler.resolverFactory.hooks.resolver.intercept({
+			factory(type, hook) {
+				/** @type {Map<string, (function(Error=, Object=): void)[]>} */
+				const activeRequests = new Map();
+				/** @type {Map<string, [function(Error=, Object=): void, function(Error=, Object=): void][]>} */
+				const activeRequestsWithYield = new Map();
+				hook.tap(
+					"ResolverCachePlugin",
+					/**
+					 * @param {Resolver} resolver the resolver
+					 * @param {Object} options resolve options
+					 * @param {Object} userOptions resolve options passed by the user
+					 * @returns {void}
+					 */
+					(resolver, options, userOptions) => {
+						if (options.cache !== true) return;
+						const optionsIdent = objectToString(userOptions, false);
+						const cacheWithContext =
+							options.cacheWithContext !== undefined
+								? options.cacheWithContext
+								: false;
+						resolver.hooks.resolve.tapAsync(
+							{
+								name: "ResolverCachePlugin",
+								stage: -100
+							},
+							(request, resolveContext, callback) => {
+								if (request._ResolverCachePluginCacheMiss || !fileSystemInfo) {
+									return callback();
+								}
+								const withYield = typeof resolveContext.yield === "function";
+								const identifier = `${type}${
+									withYield ? "|yield" : "|default"
+								}${optionsIdent}${objectToString(request, !cacheWithContext)}`;
+
+								if (withYield) {
+									const activeRequest = activeRequestsWithYield.get(identifier);
+									if (activeRequest) {
+										activeRequest[0].push(callback);
+										activeRequest[1].push(resolveContext.yield);
+										return;
+									}
+								} else {
+									const activeRequest = activeRequests.get(identifier);
+									if (activeRequest) {
+										activeRequest.push(callback);
+										return;
+									}
+								}
+								const itemCache = cache.getItemCache(identifier, null);
+								let callbacks, yields;
+								const done = withYield
+									? (err, result) => {
+											if (callbacks === undefined) {
+												if (err) {
+													callback(err);
+												} else {
+													if (result)
+														for (const r of result) resolveContext.yield(r);
+													callback(null, null);
+												}
+												yields = undefined;
+												callbacks = false;
+											} else {
+												if (err) {
+													for (const cb of callbacks) cb(err);
+												} else {
+													for (let i = 0; i < callbacks.length; i++) {
+														const cb = callbacks[i];
+														const yield_ = yields[i];
+														if (result) for (const r of result) yield_(r);
+														cb(null, null);
+													}
+												}
+												activeRequestsWithYield.delete(identifier);
+												yields = undefined;
+												callbacks = false;
+											}
+									  }
+									: (err, result) => {
+											if (callbacks === undefined) {
+												callback(err, result);
+												callbacks = false;
+											} else {
+												for (const callback of callbacks) {
+													callback(err, result);
+												}
+												activeRequests.delete(identifier);
+												callbacks = false;
+											}
+									  };
+								/**
+								 * @param {Error=} err error if any
+								 * @param {CacheEntry=} cacheEntry cache entry
+								 * @returns {void}
+								 */
+								const processCacheResult = (err, cacheEntry) => {
+									if (err) return done(err);
+
+									if (cacheEntry) {
+										const { snapshot, result } = cacheEntry;
+										fileSystemInfo.checkSnapshotValid(
+											snapshot,
+											(err, valid) => {
+												if (err || !valid) {
+													cacheInvalidResolves++;
+													return doRealResolve(
+														itemCache,
+														resolver,
+														resolveContext,
+														request,
+														done
+													);
+												}
+												cachedResolves++;
+												if (resolveContext.missingDependencies) {
+													addAllToSet(
+														resolveContext.missingDependencies,
+														snapshot.getMissingIterable()
+													);
+												}
+												if (resolveContext.fileDependencies) {
+													addAllToSet(
+														resolveContext.fileDependencies,
+														snapshot.getFileIterable()
+													);
+												}
+												if (resolveContext.contextDependencies) {
+													addAllToSet(
+														resolveContext.contextDependencies,
+														snapshot.getContextIterable()
+													);
+												}
+												done(null, result);
+											}
+										);
+									} else {
+										doRealResolve(
+											itemCache,
+											resolver,
+											resolveContext,
+											request,
+											done
+										);
+									}
+								};
+								itemCache.get(processCacheResult);
+								if (withYield && callbacks === undefined) {
+									callbacks = [callback];
+									yields = [resolveContext.yield];
+									activeRequestsWithYield.set(
+										identifier,
+										/** @type {[any, any]} */ ([callbacks, yields])
+									);
+								} else if (callbacks === undefined) {
+									callbacks = [callback];
+									activeRequests.set(identifier, callbacks);
+								}
+							}
+						);
+					}
+				);
+				return hook;
+			}
+		});
+	}
+}
+
+module.exports = ResolverCachePlugin;

package/examples/node_modules/webpack/lib/cache/getLazyHashedEtag.js

@@ -0,0 +1,81 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const createHash = require("../util/createHash");
+
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {typeof import("../util/Hash")} HashConstructor */
+
+/**
+ * @typedef {Object} HashableObject
+ * @property {function(Hash): void} updateHash
+ */
+
+class LazyHashedEtag {
+	/**
+	 * @param {HashableObject} obj object with updateHash method
+	 * @param {string | HashConstructor} hashFunction the hash function to use
+	 */
+	constructor(obj, hashFunction = "md4") {
+		this._obj = obj;
+		this._hash = undefined;
+		this._hashFunction = hashFunction;
+	}
+
+	/**
+	 * @returns {string} hash of object
+	 */
+	toString() {
+		if (this._hash === undefined) {
+			const hash = createHash(this._hashFunction);
+			this._obj.updateHash(hash);
+			this._hash = /** @type {string} */ (hash.digest("base64"));
+		}
+		return this._hash;
+	}
+}
+
+/** @type {Map<string | HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+const mapStrings = new Map();
+
+/** @type {WeakMap<HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+const mapObjects = new WeakMap();
+
+/**
+ * @param {HashableObject} obj object with updateHash method
+ * @param {string | HashConstructor} hashFunction the hash function to use
+ * @returns {LazyHashedEtag} etag
+ */
+const getter = (obj, hashFunction = "md4") => {
+	let innerMap;
+	if (typeof hashFunction === "string") {
+		innerMap = mapStrings.get(hashFunction);
+		if (innerMap === undefined) {
+			const newHash = new LazyHashedEtag(obj, hashFunction);
+			innerMap = new WeakMap();
+			innerMap.set(obj, newHash);
+			mapStrings.set(hashFunction, innerMap);
+			return newHash;
+		}
+	} else {
+		innerMap = mapObjects.get(hashFunction);
+		if (innerMap === undefined) {
+			const newHash = new LazyHashedEtag(obj, hashFunction);
+			innerMap = new WeakMap();
+			innerMap.set(obj, newHash);
+			mapObjects.set(hashFunction, innerMap);
+			return newHash;
+		}
+	}
+	const hash = innerMap.get(obj);
+	if (hash !== undefined) return hash;
+	const newHash = new LazyHashedEtag(obj, hashFunction);
+	innerMap.set(obj, newHash);
+	return newHash;
+};
+
+module.exports = getter;

package/examples/node_modules/webpack/lib/cache/mergeEtags.js

@@ -0,0 +1,74 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../Cache").Etag} Etag */
+
+class MergedEtag {
+	/**
+	 * @param {Etag} a first
+	 * @param {Etag} b second
+	 */
+	constructor(a, b) {
+		this.a = a;
+		this.b = b;
+	}
+
+	toString() {
+		return `${this.a.toString()}|${this.b.toString()}`;
+	}
+}
+
+const dualObjectMap = new WeakMap();
+const objectStringMap = new WeakMap();
+
+/**
+ * @param {Etag} a first
+ * @param {Etag} b second
+ * @returns {Etag} result
+ */
+const mergeEtags = (a, b) => {
+	if (typeof a === "string") {
+		if (typeof b === "string") {
+			return `${a}|${b}`;
+		} else {
+			const temp = b;
+			b = a;
+			a = temp;
+		}
+	} else {
+		if (typeof b !== "string") {
+			// both a and b are objects
+			let map = dualObjectMap.get(a);
+			if (map === undefined) {
+				dualObjectMap.set(a, (map = new WeakMap()));
+			}
+			const mergedEtag = map.get(b);
+			if (mergedEtag === undefined) {
+				const newMergedEtag = new MergedEtag(a, b);
+				map.set(b, newMergedEtag);
+				return newMergedEtag;
+			} else {
+				return mergedEtag;
+			}
+		}
+	}
+	// a is object, b is string
+	let map = objectStringMap.get(a);
+	if (map === undefined) {
+		objectStringMap.set(a, (map = new Map()));
+	}
+	const mergedEtag = map.get(b);
+	if (mergedEtag === undefined) {
+		const newMergedEtag = new MergedEtag(a, b);
+		map.set(b, newMergedEtag);
+		return newMergedEtag;
+	} else {
+		return mergedEtag;
+	}
+};
+
+module.exports = mergeEtags;