FM / util

/var/www/cobraambalaj/node_modules/webpack/lib/util/

/var/www/cobraambalaj/node_modules/webpack/lib/util

Name	Size	Mode	Actions
ArrayHelpers.js	280	0644	edit dl rm
ArrayQueue.js	2092	0644	edit dl rm
AsyncQueue.js	8272	0644	edit dl rm
binarySearchBounds.js	1907	0644	edit dl rm
cleverMerge.js	16529	0644	edit dl rm
comparators.js	12280	0644	edit dl rm
compileBooleanMatcher.js	5822	0644	edit dl rm
createHash.js	4094	0644	edit dl rm
DataURI.js	702	0644	edit dl rm
deprecation.js	6327	0644	edit dl rm
deterministicGrouping.js	11413	0644	edit dl rm
extractUrlAndGlobal.js	416	0644	edit dl rm
findGraphRoots.js	6111	0644	edit dl rm
fs.js	9505	0644	edit dl rm
Hash.js	925	0644	edit dl rm
identifier.js	9248	0644	edit dl rm
internalSerializables.js	9703	0644	edit dl rm
IterableHelpers.js	962	0644	edit dl rm
LazyBucketSortedSet.js	5732	0644	edit dl rm
LazySet.js	4434	0644	edit dl rm
makeSerializable.js	660	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	1468	0644	edit dl rm
propertyAccess.js	522	0644	edit dl rm
Queue.js	1048	0644	edit dl rm
registerExternalSerializer.js	7888	0644	edit dl rm
runtime.js	14613	0644	edit dl rm
Semaphore.js	1008	0644	edit dl rm
semver.js	15546	0644	edit dl rm
serialization.js	2502	0644	edit dl rm
SetHelpers.js	2316	0644	edit dl rm
smartGrouping.js	4598	0644	edit dl rm
SortableSet.js	3635	0644	edit dl rm
source.js	1759	0644	edit dl rm
StackedMap.js	3453	0644	edit dl rm
StackedSetMap.js	3453	0644	edit dl rm
StringXor.js	1062	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

Edit: /var/www/cobraambalaj/node_modules/webpack/lib/util/LazySet.js (4434B)

/*
	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<Iterable<T> | LazySet<T>>} toDeepMerge iterables or lazy set to be flattened
 * @returns {void}
 */
const flatten = (targetSet, toDeepMerge) => {
	for (const set of toDeepMerge) {
		if (set instanceof LazySet) {
			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);
			}
		} else {
			targetSet.add(set);
		}
	}
};

/**
 * 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<Iterable<T> | 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;
	}

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 {
			this._toDeepMerge.push(iterable);
			this._needMerge = true;
			// Avoid being too memory hungry
			if (this._toDeepMerge.length > 100000) {
				this._flatten();
				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: