FM / util

/var/www/flurhymez/node_modules/webpack/lib/util/

/var/www/flurhymez/node_modules/webpack/lib/util

Name	Size	Mode	Actions
hash/	-	0755	rm
ArrayHelpers.js	280	0644	edit dl rm
ArrayQueue.js	2198	0644	edit dl rm
AsyncQueue.js	9631	0644	edit dl rm
binarySearchBounds.js	1907	0644	edit dl rm
cleverMerge.js	16534	0644	edit dl rm
comparators.js	12446	0644	edit dl rm
compileBooleanMatcher.js	5822	0644	edit dl rm
create-schema-validation.js	477	0644	edit dl rm
createHash.js	4819	0644	edit dl rm
deprecation.js	6454	0644	edit dl rm
deterministicGrouping.js	13764	0644	edit dl rm
extractUrlAndGlobal.js	416	0644	edit dl rm
findGraphRoots.js	6111	0644	edit dl rm
fs.js	10776	0644	edit dl rm
Hash.js	925	0644	edit dl rm
identifier.js	10335	0644	edit dl rm
internalSerializables.js	9973	0644	edit dl rm
IterableHelpers.js	962	0644	edit dl rm
LazyBucketSortedSet.js	5732	0644	edit dl rm
LazySet.js	4569	0644	edit dl rm
makeSerializable.js	640	0644	edit dl rm
MapHelpers.js	472	0644	edit dl rm
memoize.js	604	0644	edit dl rm
numberHash.js	1060	0644	edit dl rm
objectToMap.js	346	0644	edit dl rm
ParallelismFactorCalculator.js	1528	0644	edit dl rm
processAsyncTree.js	1483	0644	edit dl rm
propertyAccess.js	1190	0644	edit dl rm
Queue.js	1048	0644	edit dl rm
registerExternalSerializer.js	7913	0644	edit dl rm
runtime.js	14605	0644	edit dl rm
Semaphore.js	1008	0644	edit dl rm
semver.js	15546	0644	edit dl rm
serialization.js	4018	0644	edit dl rm
SetHelpers.js	2316	0644	edit dl rm
smartGrouping.js	5271	0644	edit dl rm
SortableSet.js	3635	0644	edit dl rm
source.js	1759	0644	edit dl rm
StackedCacheMap.js	2284	0644	edit dl rm
StackedMap.js	3453	0644	edit dl rm
StringXor.js	1120	0644	edit dl rm
TupleQueue.js	1317	0644	edit dl rm
TupleSet.js	2909	0644	edit dl rm
URLAbsoluteSpecifier.js	2553	0644	edit dl rm
WeakTupleMap.js	3443	0644	edit dl rm

Edit: /var/www/flurhymez/node_modules/webpack/lib/util/LazySet.js (4569B)

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/

"use strict";

const makeSerializable = require("./makeSerializable.js");

/**
 * @template T
 * @param {Set<T>} targetSet set where items should be added
 * @param {Set<Iterable<T>>} toMerge iterables to be merged
 * @returns {void}
 */
const merge = (targetSet, toMerge) => {
	for (const set of toMerge) {
		for (const item of set) {
			targetSet.add(item);
		}
	}
};

/**
 * @template T
 * @param {Set<Iterable<T>>} targetSet set where iterables should be added
 * @param {Array<LazySet<T>>} toDeepMerge lazy sets to be flattened
 * @returns {void}
 */
const flatten = (targetSet, toDeepMerge) => {
	for (const set of toDeepMerge) {
		if (set._set.size > 0) targetSet.add(set._set);
		if (set._needMerge) {
			for (const mergedSet of set._toMerge) {
				targetSet.add(mergedSet);
			}
			flatten(targetSet, set._toDeepMerge);
		}
	}
};

/**
 * Like Set but with an addAll method to eventually add items from another iterable.
 * Access methods make sure that all delayed operations are executed.
 * Iteration methods deopts to normal Set performance until clear is called again (because of the chance of modifications during iteration).
 * @template T
 */
class LazySet {
	/**
	 * @param {Iterable<T>=} iterable init iterable
	 */
	constructor(iterable) {
		/** @type {Set<T>} */
		this._set = new Set(iterable);
		/** @type {Set<Iterable<T>>} */
		this._toMerge = new Set();
		/** @type {Array<LazySet<T>>} */
		this._toDeepMerge = [];
		this._needMerge = false;
		this._deopt = false;
	}

_flatten() {
		flatten(this._toMerge, this._toDeepMerge);
		this._toDeepMerge.length = 0;
	}

_merge() {
		this._flatten();
		merge(this._set, this._toMerge);
		this._toMerge.clear();
		this._needMerge = false;
	}

_isEmpty() {
		return (
			this._set.size === 0 &&
			this._toMerge.size === 0 &&
			this._toDeepMerge.length === 0
		);
	}

get size() {
		if (this._needMerge) this._merge();
		return this._set.size;
	}

/**
	 * @param {T} item an item
	 * @returns {this} itself
	 */
	add(item) {
		this._set.add(item);
		return this;
	}

/**
	 * @param {Iterable<T> | LazySet<T>} iterable a immutable iterable or another immutable LazySet which will eventually be merged into the Set
	 * @returns {this} itself
	 */
	addAll(iterable) {
		if (this._deopt) {
			const _set = this._set;
			for (const item of iterable) {
				_set.add(item);
			}
		} else {
			if (iterable instanceof LazySet) {
				if (iterable._isEmpty()) return this;
				this._toDeepMerge.push(iterable);
				this._needMerge = true;
				if (this._toDeepMerge.length > 100000) {
					this._flatten();
				}
			} else {
				this._toMerge.add(iterable);
				this._needMerge = true;
			}
			if (this._toMerge.size > 100000) this._merge();
		}
		return this;
	}

clear() {
		this._set.clear();
		this._toMerge.clear();
		this._toDeepMerge.length = 0;
		this._needMerge = false;
		this._deopt = false;
	}

/**
	 * @param {T} value an item
	 * @returns {boolean} true, if the value was in the Set before
	 */
	delete(value) {
		if (this._needMerge) this._merge();
		return this._set.delete(value);
	}

entries() {
		this._deopt = true;
		if (this._needMerge) this._merge();
		return this._set.entries();
	}

/**
	 * @param {function(T, T, Set<T>): void} callbackFn function called for each entry
	 * @param {any} thisArg this argument for the callbackFn
	 * @returns {void}
	 */
	forEach(callbackFn, thisArg) {
		this._deopt = true;
		if (this._needMerge) this._merge();
		this._set.forEach(callbackFn, thisArg);
	}

/**
	 * @param {T} item an item
	 * @returns {boolean} true, when the item is in the Set
	 */
	has(item) {
		if (this._needMerge) this._merge();
		return this._set.has(item);
	}

keys() {
		this._deopt = true;
		if (this._needMerge) this._merge();
		return this._set.keys();
	}

values() {
		this._deopt = true;
		if (this._needMerge) this._merge();
		return this._set.values();
	}

[Symbol.iterator]() {
		this._deopt = true;
		if (this._needMerge) this._merge();
		return this._set[Symbol.iterator]();
	}

/* istanbul ignore next */
	get [Symbol.toStringTag]() {
		return "LazySet";
	}

serialize({ write }) {
		if (this._needMerge) this._merge();
		write(this._set.size);
		for (const item of this._set) write(item);
	}

static deserialize({ read }) {
		const count = read();
		const items = [];
		for (let i = 0; i < count; i++) {
			items.push(read());
		}
		return new LazySet(items);
	}
}

makeSerializable(LazySet, "webpack/lib/util/LazySet");

module.exports = LazySet;

cmd: