ULTRA [ www.resource.optimyar.com ]

Linux uranus.pws-dns.net 5.14.0-427.42.1.el9_4.x86_64 #1 SMP PREEMPT_DYNAMIC Fri Nov 1 14:58:02 EDT 2024 x86_64

LiteSpeed

31.214.174.197 | Your IP: 216.73.216.161

Cant read [ /etc/named.conf ]

[ drwxrwxr-x ]

/ home / freeclou / app.optimyar.com / backend / node_modules / webpack / lib / optimize /

Home Upload Mass Deface Mass Delete Back Connect Notify

LimitChunkCountPlugin.js

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

const validateOptions = require("schema-utils");
const schema = require("../../schemas/plugins/optimize/LimitChunkCountPlugin.json");
const LazyBucketSortedSet = require("../util/LazyBucketSortedSet");

/** @typedef {import("../../declarations/plugins/optimize/LimitChunkCountPlugin").LimitChunkCountPluginOptions} LimitChunkCountPluginOptions */
/** @typedef {import("../Chunk")} Chunk */
/** @typedef {import("../Compiler")} Compiler */

/**
 * @typedef {Object} ChunkCombination
 * @property {boolean} deleted this is set to true when combination was removed
 * @property {number} sizeDiff
 * @property {number} integratedSize
 * @property {Chunk} a
 * @property {Chunk} b
 * @property {number} aIdx
 * @property {number} bIdx
 * @property {number} aSize
 * @property {number} bSize
 */

const addToSetMap = (map, key, value) => {
	const set = map.get(key);
	if (set === undefined) {
		map.set(key, new Set([value]));
	} else {
		set.add(value);
	}
};

class LimitChunkCountPlugin {
	/**
	 * @param {LimitChunkCountPluginOptions=} options options object
	 */
	constructor(options) {
		if (!options) options = {};

validateOptions(schema, options, "Limit Chunk Count Plugin");
		this.options = options;
	}

/**
	 * @param {Compiler} compiler the webpack compiler
	 * @returns {void}
	 */
	apply(compiler) {
		const options = this.options;
		compiler.hooks.compilation.tap("LimitChunkCountPlugin", compilation => {
			compilation.hooks.optimizeChunksAdvanced.tap(
				"LimitChunkCountPlugin",
				chunks => {
					const maxChunks = options.maxChunks;
					if (!maxChunks) return;
					if (maxChunks < 1) return;
					if (chunks.length <= maxChunks) return;

let remainingChunksToMerge = chunks.length - maxChunks;

// order chunks in a deterministic way
					const orderedChunks = chunks.slice().sort((a, b) => a.compareTo(b));

// create a lazy sorted data structure to keep all combinations
					// this is large. Size = chunks * (chunks - 1) / 2
					// It uses a multi layer bucket sort plus normal sort in the last layer
					// It's also lazy so only accessed buckets are sorted
					const combinations = new LazyBucketSortedSet(
						// Layer 1: ordered by largest size benefit
						c => c.sizeDiff,
						(a, b) => b - a,
						// Layer 2: ordered by smallest combined size
						c => c.integratedSize,
						(a, b) => a - b,
						// Layer 3: ordered by position difference in orderedChunk (-> to be deterministic)
						c => c.bIdx - c.aIdx,
						(a, b) => a - b,
						// Layer 4: ordered by position in orderedChunk (-> to be deterministic)
						(a, b) => a.bIdx - b.bIdx
					);

// we keep a mappng from chunk to all combinations
					// but this mapping is not kept up-to-date with deletions
					// so `deleted` flag need to be considered when iterating this
					/** @type {Map<Chunk, Set<ChunkCombination>>} */
					const combinationsByChunk = new Map();

orderedChunks.forEach((b, bIdx) => {
						// create combination pairs with size and integrated size
						for (let aIdx = 0; aIdx < bIdx; aIdx++) {
							const a = orderedChunks[aIdx];
							const integratedSize = a.integratedSize(b, options);

// filter pairs that do not have an integratedSize
							// meaning they can NOT be integrated!
							if (integratedSize === false) continue;

const aSize = a.size(options);
							const bSize = b.size(options);
							const c = {
								deleted: false,
								sizeDiff: aSize + bSize - integratedSize,
								integratedSize,
								a,
								b,
								aIdx,
								bIdx,
								aSize,
								bSize
							};
							combinations.add(c);
							addToSetMap(combinationsByChunk, a, c);
							addToSetMap(combinationsByChunk, b, c);
						}
						return combinations;
					});

// list of modified chunks during this run
					// combinations affected by this change are skipped to allow
					// futher optimizations
					/** @type {Set<Chunk>} */
					const modifiedChunks = new Set();

let changed = false;
					// eslint-disable-next-line no-constant-condition
					loop: while (true) {
						const combination = combinations.popFirst();
						if (combination === undefined) break;

combination.deleted = true;
						const { a, b, integratedSize } = combination;

// skip over pair when
						// one of the already merged chunks is a parent of one of the chunks
						if (modifiedChunks.size > 0) {
							const queue = new Set(a.groupsIterable);
							for (const group of b.groupsIterable) {
								queue.add(group);
							}
							for (const group of queue) {
								for (const mChunk of modifiedChunks) {
									if (mChunk !== a && mChunk !== b && mChunk.isInGroup(group)) {
										// This is a potential pair which needs recalculation
										// We can't do that now, but it merge before following pairs
										// so we leave space for it, and consider chunks as modified
										// just for the worse case
										remainingChunksToMerge--;
										if (remainingChunksToMerge <= 0) break loop;
										modifiedChunks.add(a);
										modifiedChunks.add(b);
										continue loop;
									}
								}
								for (const parent of group.parentsIterable) {
									queue.add(parent);
								}
							}
						}

// merge the chunks
						if (a.integrate(b, "limit")) {
							chunks.splice(chunks.indexOf(b), 1);

// flag chunk a as modified as further optimization are possible for all children here
							modifiedChunks.add(a);

changed = true;
							remainingChunksToMerge--;
							if (remainingChunksToMerge <= 0) break;

// Update all affected combinations
							// delete all combination with the removed chunk
							// we will use combinations with the kept chunk instead
							for (const combination of combinationsByChunk.get(b)) {
								if (combination.deleted) continue;
								combination.deleted = true;
								combinations.delete(combination);
							}

// Update combinations with the kept chunk with new sizes
							for (const combination of combinationsByChunk.get(a)) {
								if (combination.deleted) continue;
								if (combination.a === a) {
									// Update size
									const newIntegratedSize = a.integratedSize(
										combination.b,
										options
									);
									if (newIntegratedSize === false) {
										combination.deleted = true;
										combinations.delete(combination);
										continue;
									}
									const finishUpdate = combinations.startUpdate(combination);
									combination.integratedSize = newIntegratedSize;
									combination.aSize = integratedSize;
									combination.sizeDiff =
										combination.bSize + integratedSize - newIntegratedSize;
									finishUpdate();
								} else if (combination.b === a) {
									// Update size
									const newIntegratedSize = combination.a.integratedSize(
										a,
										options
									);
									if (newIntegratedSize === false) {
										combination.deleted = true;
										combinations.delete(combination);
										continue;
									}
									const finishUpdate = combinations.startUpdate(combination);
									combination.integratedSize = newIntegratedSize;
									combination.bSize = integratedSize;
									combination.sizeDiff =
										integratedSize + combination.aSize - newIntegratedSize;
									finishUpdate();
								}
							}
						}
					}
					if (changed) return true;
				}
			);
		});
	}
}
module.exports = LimitChunkCountPlugin;

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	freeclou/freeclou	drwxrwxr-x	2025-01-27 08:10:26
..	dir	-	freeclou/freeclou	drwxrwxr-x	2025-01-27 08:10:26
AggressiveMergingPlugin.js	text/plain	2.02 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
AggressiveSplittingPlugin.js	text/plain	9.13 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
ChunkModuleIdRangePlugin.js	text/plain	1.55 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
ConcatenatedModule.js	text/plain	36.82 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
EnsureChunkConditionsPlugin.js	text/plain	2.01 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
FlagIncludedChunksPlugin.js	text/plain	3.14 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
LimitChunkCountPlugin.js	text/plain	7.41 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
MergeDuplicateChunksPlugin.js	text/plain	2.43 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
MinChunkSizePlugin.js	text/plain	2.52 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
MinMaxSizeWarning.js	text/plain	819 B	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
ModuleConcatenationPlugin.js	text/plain	14.49 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
NaturalChunkOrderPlugin.js	text/plain	1.1 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
OccurrenceChunkOrderPlugin.js	text/plain	2 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
OccurrenceModuleOrderPlugin.js	text/plain	3.26 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
OccurrenceOrderPlugin.js	text/plain	3.9 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
RemoveEmptyChunksPlugin.js	text/plain	990 B	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
RemoveParentModulesPlugin.js	text/plain	3.61 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
RuntimeChunkPlugin.js	text/plain	1.04 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
SideEffectsFlagPlugin.js	text/plain	10.1 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00
SplitChunksPlugin.js	text/plain	29.99 KB	freeclou/freeclou	-rw-rw-r--	1985-10-26 08:15:00