FM / lib

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

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

Name	Size	Mode	Actions
asset/	-	0755	rm
async-modules/	-	0755	rm
cache/	-	0755	rm
config/	-	0755	rm
container/	-	0755	rm
debug/	-	0755	rm
dependencies/	-	0755	rm
electron/	-	0755	rm
errors/	-	0755	rm
hmr/	-	0755	rm
ids/	-	0755	rm
javascript/	-	0755	rm
json/	-	0755	rm
library/	-	0755	rm
logging/	-	0755	rm
node/	-	0755	rm
optimize/	-	0755	rm
performance/	-	0755	rm
prefetch/	-	0755	rm
rules/	-	0755	rm
runtime/	-	0755	rm
schemes/	-	0755	rm
serialization/	-	0755	rm
sharing/	-	0755	rm
stats/	-	0755	rm
util/	-	0755	rm
wasm/	-	0755	rm
wasm-async/	-	0755	rm
wasm-sync/	-	0755	rm
web/	-	0755	rm
webworker/	-	0755	rm
AbstractMethodError.js	1133	0644	edit dl rm
APIPlugin.js	5719	0644	edit dl rm
AsyncDependenciesBlock.js	2733	0644	edit dl rm
AsyncDependencyToInitialChunkError.js	965	0644	edit dl rm
AutomaticPrefetchPlugin.js	1491	0644	edit dl rm
BannerPlugin.js	2647	0644	edit dl rm
buildChunkGraph.js	42904	0644	edit dl rm
Cache.js	3967	0644	edit dl rm
CacheFacade.js	8433	0644	edit dl rm
CaseSensitiveModulesWarning.js	2146	0644	edit dl rm
Chunk.js	20042	0644	edit dl rm
ChunkGraph.js	46071	0644	edit dl rm
ChunkGroup.js	15121	0644	edit dl rm
ChunkRenderError.js	709	0644	edit dl rm
ChunkTemplate.js	3992	0644	edit dl rm
CleanPlugin.js	9940	0644	edit dl rm
cli.js	15603	0644	edit dl rm
CodeGenerationError.js	671	0644	edit dl rm
CodeGenerationResults.js	4266	0644	edit dl rm
CommentCompilationWarning.js	781	0644	edit dl rm
CompatibilityPlugin.js	4181	0644	edit dl rm
Compilation.js	122013	0644	edit dl rm
Compiler.js	31643	0644	edit dl rm
ConcatenationScope.js	4635	0644	edit dl rm
ConcurrentCompilationError.js	493	0644	edit dl rm
ConditionalInitFragment.js	3537	0644	edit dl rm
ConstPlugin.js	14769	0644	edit dl rm
ContextExclusionPlugin.js	797	0644	edit dl rm
ContextModule.js	32171	0644	edit dl rm
ContextModuleFactory.js	11089	0644	edit dl rm
ContextReplacementPlugin.js	4711	0644	edit dl rm
DefinePlugin.js	9970	0644	edit dl rm
DelegatedModule.js	7043	0644	edit dl rm
DelegatedModuleFactoryPlugin.js	2337	0644	edit dl rm
DelegatedPlugin.js	1015	0644	edit dl rm
DependenciesBlock.js	2379	0644	edit dl rm
Dependency.js	6694	0644	edit dl rm
DependencyTemplate.js	1990	0644	edit dl rm
DependencyTemplates.js	1527	0644	edit dl rm
DllEntryPlugin.js	1277	0644	edit dl rm
DllModule.js	4313	0644	edit dl rm
DllModuleFactory.js	1008	0644	edit dl rm
DllPlugin.js	1597	0644	edit dl rm
DllReferencePlugin.js	5070	0644	edit dl rm
DynamicEntryPlugin.js	2035	0644	edit dl rm
EntryOptionPlugin.js	2747	0644	edit dl rm
EntryPlugin.js	1738	0644	edit dl rm
Entrypoint.js	3025	0644	edit dl rm
EnvironmentPlugin.js	1743	0644	edit dl rm
ErrorHelpers.js	1454	0644	edit dl rm
EvalDevToolModulePlugin.js	3235	0644	edit dl rm
EvalSourceMapDevToolPlugin.js	6239	0644	edit dl rm
ExportsInfo.js	42660	0644	edit dl rm
ExportsInfoApiPlugin.js	2072	0644	edit dl rm
ExternalModule.js	14840	0644	edit dl rm
ExternalModuleFactoryPlugin.js	7205	0644	edit dl rm
ExternalsPlugin.js	899	0644	edit dl rm
FileSystemInfo.js	81514	0644	edit dl rm
FlagAllModulesAsUsedPlugin.js	1451	0644	edit dl rm
FlagDependencyExportsPlugin.js	11603	0644	edit dl rm
FlagDependencyUsagePlugin.js	10780	0644	edit dl rm
FlagEntryExportAsUsedPlugin.js	1373	0644	edit dl rm
formatLocation.js	1781	0644	edit dl rm
Generator.js	4571	0644	edit dl rm
GraphHelpers.js	1074	0644	edit dl rm
HarmonyLinkingError.js	409	0644	edit dl rm
HookWebpackError.js	2121	0644	edit dl rm
HotModuleReplacementPlugin.js	25526	0644	edit dl rm
HotUpdateChunk.js	353	0644	edit dl rm
IgnoreErrorModuleFactory.js	1048	0644	edit dl rm
IgnorePlugin.js	2144	0644	edit dl rm
IgnoreWarningsPlugin.js	964	0644	edit dl rm
index.js	14063	0644	edit dl rm
InitFragment.js	3659	0644	edit dl rm
InvalidDependenciesModuleWarning.js	1926	0644	edit dl rm
JavascriptMetaInfoPlugin.js	1885	0644	edit dl rm
LibManifestPlugin.js	3116	0644	edit dl rm
LibraryTemplatePlugin.js	1588	0644	edit dl rm
LoaderOptionsPlugin.js	1743	0644	edit dl rm
LoaderTargetPlugin.js	747	0644	edit dl rm
MainTemplate.js	10377	0644	edit dl rm
Module.js	28536	0644	edit dl rm
ModuleBuildError.js	1678	0644	edit dl rm
ModuleDependencyError.js	1159	0644	edit dl rm
ModuleDependencyWarning.js	1274	0644	edit dl rm
ModuleError.js	1254	0644	edit dl rm
ModuleFactory.js	1363	0644	edit dl rm
ModuleFilenameHelpers.js	7430	0644	edit dl rm
ModuleGraph.js	21886	0644	edit dl rm
ModuleGraphConnection.js	5203	0644	edit dl rm
ModuleInfoHeaderPlugin.js	7182	0644	edit dl rm
ModuleNotFoundError.js	2662	0644	edit dl rm
ModuleParseError.js	3384	0644	edit dl rm
ModuleProfile.js	2440	0644	edit dl rm
ModuleRestoreError.js	1009	0644	edit dl rm
ModuleStoreError.js	1003	0644	edit dl rm
ModuleTemplate.js	4337	0644	edit dl rm
ModuleWarning.js	1332	0644	edit dl rm
MultiCompiler.js	14470	0644	edit dl rm
MultiStats.js	4222	0644	edit dl rm
MultiWatching.js	1466	0644	edit dl rm
NodeStuffPlugin.js	4016	0644	edit dl rm
NoEmitOnErrorsPlugin.js	713	0644	edit dl rm
NoModeWarning.js	715	0644	edit dl rm
NormalModule.js	34324	0644	edit dl rm
NormalModuleFactory.js	29122	0644	edit dl rm
NormalModuleReplacementPlugin.js	1883	0644	edit dl rm
NullFactory.js	628	0644	edit dl rm
OptimizationStages.js	204	0644	edit dl rm
OptionsApply.js	201	0644	edit dl rm
Parser.js	930	0644	edit dl rm
PrefetchPlugin.js	1048	0644	edit dl rm
ProgressPlugin.js	17145	0644	edit dl rm
ProvidePlugin.js	2890	0644	edit dl rm
RawModule.js	4275	0644	edit dl rm
RecordIdsPlugin.js	6775	0644	edit dl rm
RequestShortener.js	755	0644	edit dl rm
RequireJsStuffPlugin.js	1904	0644	edit dl rm
ResolverFactory.js	4938	0644	edit dl rm
RuntimeGlobals.js	7569	0644	edit dl rm
RuntimeModule.js	5520	0644	edit dl rm
RuntimePlugin.js	11842	0644	edit dl rm
RuntimeTemplate.js	27656	0644	edit dl rm
SelfModuleFactory.js	384	0644	edit dl rm
SingleEntryPlugin.js	161	0644	edit dl rm
SizeFormatHelpers.js	583	0644	edit dl rm
SourceMapDevToolModuleOptionsPlugin.js	1325	0644	edit dl rm
SourceMapDevToolPlugin.js	16631	0644	edit dl rm
Stats.js	2003	0644	edit dl rm
Template.js	12701	0644	edit dl rm
TemplatedPathPlugin.js	8036	0644	edit dl rm
UnhandledSchemeError.js	833	0644	edit dl rm
UnsupportedFeatureWarning.js	832	0644	edit dl rm
UseStrictPlugin.js	1645	0644	edit dl rm
validateSchema.js	6376	0644	edit dl rm
WarnCaseSensitiveModulesPlugin.js	1212	0644	edit dl rm
WarnDeprecatedOptionPlugin.js	1327	0644	edit dl rm
WarnNoModeSetPlugin.js	545	0644	edit dl rm
WatchIgnorePlugin.js	2816	0644	edit dl rm
Watching.js	10335	0644	edit dl rm
webpack.js	4722	0644	edit dl rm
WebpackError.js	1429	0644	edit dl rm
WebpackIsIncludedPlugin.js	2420	0644	edit dl rm
WebpackOptionsApply.js	22651	0644	edit dl rm
WebpackOptionsDefaulter.js	470	0644	edit dl rm

Edit: /var/www/cobraambalaj/node_modules/webpack/lib/ChunkGroup.js (15121B)

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

"use strict";

const util = require("util");
const SortableSet = require("./util/SortableSet");
const {
	compareLocations,
	compareChunks,
	compareIterables
} = require("./util/comparators");

/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
/** @typedef {import("./Chunk")} Chunk */
/** @typedef {import("./ChunkGraph")} ChunkGraph */
/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
/** @typedef {import("./Entrypoint")} Entrypoint */
/** @typedef {import("./Module")} Module */
/** @typedef {import("./ModuleGraph")} ModuleGraph */

/** @typedef {{id: number}} HasId */
/** @typedef {{module: Module, loc: DependencyLocation, request: string}} OriginRecord */

/**
 * @typedef {Object} RawChunkGroupOptions
 * @property {number=} preloadOrder
 * @property {number=} prefetchOrder
 */

/** @typedef {RawChunkGroupOptions & { name?: string }} ChunkGroupOptions */

let debugId = 5000;

/**
 * @template T
 * @param {SortableSet<T>} set set to convert to array.
 * @returns {T[]} the array format of existing set
 */
const getArray = set => Array.from(set);

/**
 * A convenience method used to sort chunks based on their id's
 * @param {ChunkGroup} a first sorting comparator
 * @param {ChunkGroup} b second sorting comparator
 * @returns {1|0|-1} a sorting index to determine order
 */
const sortById = (a, b) => {
	if (a.id < b.id) return -1;
	if (b.id < a.id) return 1;
	return 0;
};

/**
 * @param {OriginRecord} a the first comparator in sort
 * @param {OriginRecord} b the second comparator in sort
 * @returns {1|-1|0} returns sorting order as index
 */
const sortOrigin = (a, b) => {
	const aIdent = a.module ? a.module.identifier() : "";
	const bIdent = b.module ? b.module.identifier() : "";
	if (aIdent < bIdent) return -1;
	if (aIdent > bIdent) return 1;
	return compareLocations(a.loc, b.loc);
};

class ChunkGroup {
	/**
	 * Creates an instance of ChunkGroup.
	 * @param {string|ChunkGroupOptions=} options chunk group options passed to chunkGroup
	 */
	constructor(options) {
		if (typeof options === "string") {
			options = { name: options };
		} else if (!options) {
			options = { name: undefined };
		}
		/** @type {number} */
		this.groupDebugId = debugId++;
		this.options = options;
		/** @type {SortableSet<ChunkGroup>} */
		this._children = new SortableSet(undefined, sortById);
		/** @type {SortableSet<ChunkGroup>} */
		this._parents = new SortableSet(undefined, sortById);
		/** @type {SortableSet<ChunkGroup>} */
		this._asyncEntrypoints = new SortableSet(undefined, sortById);
		this._blocks = new SortableSet();
		/** @type {Chunk[]} */
		this.chunks = [];
		/** @type {OriginRecord[]} */
		this.origins = [];
		/** Indices in top-down order */
		/** @private @type {Map<Module, number>} */
		this._modulePreOrderIndices = new Map();
		/** Indices in bottom-up order */
		/** @private @type {Map<Module, number>} */
		this._modulePostOrderIndices = new Map();
		/** @type {number} */
		this.index = undefined;
	}

/**
	 * when a new chunk is added to a chunkGroup, addingOptions will occur.
	 * @param {ChunkGroupOptions} options the chunkGroup options passed to addOptions
	 * @returns {void}
	 */
	addOptions(options) {
		for (const key of Object.keys(options)) {
			if (this.options[key] === undefined) {
				this.options[key] = options[key];
			} else if (this.options[key] !== options[key]) {
				if (key.endsWith("Order")) {
					this.options[key] = Math.max(this.options[key], options[key]);
				} else {
					throw new Error(
						`ChunkGroup.addOptions: No option merge strategy for ${key}`
					);
				}
			}
		}
	}

/**
	 * returns the name of current ChunkGroup
	 * @returns {string|undefined} returns the ChunkGroup name
	 */
	get name() {
		return this.options.name;
	}

/**
	 * sets a new name for current ChunkGroup
	 * @param {string} value the new name for ChunkGroup
	 * @returns {void}
	 */
	set name(value) {
		this.options.name = value;
	}

/* istanbul ignore next */
	/**
	 * get a uniqueId for ChunkGroup, made up of its member Chunk debugId's
	 * @returns {string} a unique concatenation of chunk debugId's
	 */
	get debugId() {
		return Array.from(this.chunks, x => x.debugId).join("+");
	}

/**
	 * get a unique id for ChunkGroup, made up of its member Chunk id's
	 * @returns {string} a unique concatenation of chunk ids
	 */
	get id() {
		return Array.from(this.chunks, x => x.id).join("+");
	}

/**
	 * Performs an unshift of a specific chunk
	 * @param {Chunk} chunk chunk being unshifted
	 * @returns {boolean} returns true if attempted chunk shift is accepted
	 */
	unshiftChunk(chunk) {
		const oldIdx = this.chunks.indexOf(chunk);
		if (oldIdx > 0) {
			this.chunks.splice(oldIdx, 1);
			this.chunks.unshift(chunk);
		} else if (oldIdx < 0) {
			this.chunks.unshift(chunk);
			return true;
		}
		return false;
	}

/**
	 * inserts a chunk before another existing chunk in group
	 * @param {Chunk} chunk Chunk being inserted
	 * @param {Chunk} before Placeholder/target chunk marking new chunk insertion point
	 * @returns {boolean} return true if insertion was successful
	 */
	insertChunk(chunk, before) {
		const oldIdx = this.chunks.indexOf(chunk);
		const idx = this.chunks.indexOf(before);
		if (idx < 0) {
			throw new Error("before chunk not found");
		}
		if (oldIdx >= 0 && oldIdx > idx) {
			this.chunks.splice(oldIdx, 1);
			this.chunks.splice(idx, 0, chunk);
		} else if (oldIdx < 0) {
			this.chunks.splice(idx, 0, chunk);
			return true;
		}
		return false;
	}

/**
	 * add a chunk into ChunkGroup. Is pushed on or prepended
	 * @param {Chunk} chunk chunk being pushed into ChunkGroupS
	 * @returns {boolean} returns true if chunk addition was successful.
	 */
	pushChunk(chunk) {
		const oldIdx = this.chunks.indexOf(chunk);
		if (oldIdx >= 0) {
			return false;
		}
		this.chunks.push(chunk);
		return true;
	}

/**
	 * @param {Chunk} oldChunk chunk to be replaced
	 * @param {Chunk} newChunk New chunk that will be replaced with
	 * @returns {boolean} returns true if the replacement was successful
	 */
	replaceChunk(oldChunk, newChunk) {
		const oldIdx = this.chunks.indexOf(oldChunk);
		if (oldIdx < 0) return false;
		const newIdx = this.chunks.indexOf(newChunk);
		if (newIdx < 0) {
			this.chunks[oldIdx] = newChunk;
			return true;
		}
		if (newIdx < oldIdx) {
			this.chunks.splice(oldIdx, 1);
			return true;
		} else if (newIdx !== oldIdx) {
			this.chunks[oldIdx] = newChunk;
			this.chunks.splice(newIdx, 1);
			return true;
		}
	}

/**
	 * @param {Chunk} chunk chunk to remove
	 * @returns {boolean} returns true if chunk was removed
	 */
	removeChunk(chunk) {
		const idx = this.chunks.indexOf(chunk);
		if (idx >= 0) {
			this.chunks.splice(idx, 1);
			return true;
		}
		return false;
	}

/**
	 * @returns {boolean} true, when this chunk group will be loaded on initial page load
	 */
	isInitial() {
		return false;
	}

/**
	 * @param {ChunkGroup} group chunk group to add
	 * @returns {boolean} returns true if chunk group was added
	 */
	addChild(group) {
		const size = this._children.size;
		this._children.add(group);
		return size !== this._children.size;
	}

/**
	 * @returns {ChunkGroup[]} returns the children of this group
	 */
	getChildren() {
		return this._children.getFromCache(getArray);
	}

getNumberOfChildren() {
		return this._children.size;
	}

get childrenIterable() {
		return this._children;
	}

/**
	 * @param {ChunkGroup} group the chunk group to remove
	 * @returns {boolean} returns true if the chunk group was removed
	 */
	removeChild(group) {
		if (!this._children.has(group)) {
			return false;
		}

this._children.delete(group);
		group.removeParent(this);
		return true;
	}

/**
	 * @param {ChunkGroup} parentChunk the parent group to be added into
	 * @returns {boolean} returns true if this chunk group was added to the parent group
	 */
	addParent(parentChunk) {
		if (!this._parents.has(parentChunk)) {
			this._parents.add(parentChunk);
			return true;
		}
		return false;
	}

/**
	 * @returns {ChunkGroup[]} returns the parents of this group
	 */
	getParents() {
		return this._parents.getFromCache(getArray);
	}

getNumberOfParents() {
		return this._parents.size;
	}

/**
	 * @param {ChunkGroup} parent the parent group
	 * @returns {boolean} returns true if the parent group contains this group
	 */
	hasParent(parent) {
		return this._parents.has(parent);
	}

get parentsIterable() {
		return this._parents;
	}

/**
	 * @param {ChunkGroup} chunkGroup the parent group
	 * @returns {boolean} returns true if this group has been removed from the parent
	 */
	removeParent(chunkGroup) {
		if (this._parents.delete(chunkGroup)) {
			chunkGroup.removeChild(this);
			return true;
		}
		return false;
	}

/**
	 * @param {Entrypoint} entrypoint entrypoint to add
	 * @returns {boolean} returns true if entrypoint was added
	 */
	addAsyncEntrypoint(entrypoint) {
		const size = this._asyncEntrypoints.size;
		this._asyncEntrypoints.add(entrypoint);
		return size !== this._asyncEntrypoints.size;
	}

get asyncEntrypointsIterable() {
		return this._asyncEntrypoints;
	}

/**
	 * @returns {Array} an array containing the blocks
	 */
	getBlocks() {
		return this._blocks.getFromCache(getArray);
	}

getNumberOfBlocks() {
		return this._blocks.size;
	}

hasBlock(block) {
		return this._blocks.has(block);
	}

/**
	 * @returns {Iterable<AsyncDependenciesBlock>} blocks
	 */
	get blocksIterable() {
		return this._blocks;
	}

/**
	 * @param {AsyncDependenciesBlock} block a block
	 * @returns {boolean} false, if block was already added
	 */
	addBlock(block) {
		if (!this._blocks.has(block)) {
			this._blocks.add(block);
			return true;
		}
		return false;
	}

/**
	 * @param {Module} module origin module
	 * @param {DependencyLocation} loc location of the reference in the origin module
	 * @param {string} request request name of the reference
	 * @returns {void}
	 */
	addOrigin(module, loc, request) {
		this.origins.push({
			module,
			loc,
			request
		});
	}

/**
	 * @returns {string[]} the files contained this chunk group
	 */
	getFiles() {
		const files = new Set();

for (const chunk of this.chunks) {
			for (const file of chunk.files) {
				files.add(file);
			}
		}

return Array.from(files);
	}

/**
	 * @returns {void}
	 */
	remove() {
		// cleanup parents
		for (const parentChunkGroup of this._parents) {
			// remove this chunk from its parents
			parentChunkGroup._children.delete(this);

// cleanup "sub chunks"
			for (const chunkGroup of this._children) {
				/**
				 * remove this chunk as "intermediary" and connect
				 * it "sub chunks" and parents directly
				 */
				// add parent to each "sub chunk"
				chunkGroup.addParent(parentChunkGroup);
				// add "sub chunk" to parent
				parentChunkGroup.addChild(chunkGroup);
			}
		}

/**
		 * we need to iterate again over the children
		 * to remove this from the child's parents.
		 * This can not be done in the above loop
		 * as it is not guaranteed that `this._parents` contains anything.
		 */
		for (const chunkGroup of this._children) {
			// remove this as parent of every "sub chunk"
			chunkGroup._parents.delete(this);
		}

// remove chunks
		for (const chunk of this.chunks) {
			chunk.removeGroup(this);
		}
	}

sortItems() {
		this.origins.sort(sortOrigin);
	}

/**
	 * Sorting predicate which allows current ChunkGroup to be compared against another.
	 * Sorting values are based off of number of chunks in ChunkGroup.
	 *
	 * @param {ChunkGraph} chunkGraph the chunk graph
	 * @param {ChunkGroup} otherGroup the chunkGroup to compare this against
	 * @returns {-1|0|1} sort position for comparison
	 */
	compareTo(chunkGraph, otherGroup) {
		if (this.chunks.length > otherGroup.chunks.length) return -1;
		if (this.chunks.length < otherGroup.chunks.length) return 1;
		return compareIterables(compareChunks(chunkGraph))(
			this.chunks,
			otherGroup.chunks
		);
	}

/**
	 * @param {ModuleGraph} moduleGraph the module graph
	 * @param {ChunkGraph} chunkGraph the chunk graph
	 * @returns {Record<string, ChunkGroup[]>} mapping from children type to ordered list of ChunkGroups
	 */
	getChildrenByOrders(moduleGraph, chunkGraph) {
		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
		const lists = new Map();
		for (const childGroup of this._children) {
			for (const key of Object.keys(childGroup.options)) {
				if (key.endsWith("Order")) {
					const name = key.substr(0, key.length - "Order".length);
					let list = lists.get(name);
					if (list === undefined) {
						lists.set(name, (list = []));
					}
					list.push({
						order: childGroup.options[key],
						group: childGroup
					});
				}
			}
		}
		/** @type {Record<string, ChunkGroup[]>} */
		const result = Object.create(null);
		for (const [name, list] of lists) {
			list.sort((a, b) => {
				const cmp = b.order - a.order;
				if (cmp !== 0) return cmp;
				return a.group.compareTo(chunkGraph, b.group);
			});
			result[name] = list.map(i => i.group);
		}
		return result;
	}

/**
	 * Sets the top-down index of a module in this ChunkGroup
	 * @param {Module} module module for which the index should be set
	 * @param {number} index the index of the module
	 * @returns {void}
	 */
	setModulePreOrderIndex(module, index) {
		this._modulePreOrderIndices.set(module, index);
	}

/**
	 * Gets the top-down index of a module in this ChunkGroup
	 * @param {Module} module the module
	 * @returns {number} index
	 */
	getModulePreOrderIndex(module) {
		return this._modulePreOrderIndices.get(module);
	}

/**
	 * Sets the bottom-up index of a module in this ChunkGroup
	 * @param {Module} module module for which the index should be set
	 * @param {number} index the index of the module
	 * @returns {void}
	 */
	setModulePostOrderIndex(module, index) {
		this._modulePostOrderIndices.set(module, index);
	}

/**
	 * Gets the bottom-up index of a module in this ChunkGroup
	 * @param {Module} module the module
	 * @returns {number} index
	 */
	getModulePostOrderIndex(module) {
		return this._modulePostOrderIndices.get(module);
	}

/* istanbul ignore next */
	checkConstraints() {
		const chunk = this;
		for (const child of chunk._children) {
			if (!child._parents.has(chunk)) {
				throw new Error(
					`checkConstraints: child missing parent ${chunk.debugId} -> ${child.debugId}`
				);
			}
		}
		for (const parentChunk of chunk._parents) {
			if (!parentChunk._children.has(chunk)) {
				throw new Error(
					`checkConstraints: parent missing child ${parentChunk.debugId} <- ${chunk.debugId}`
				);
			}
		}
	}
}

ChunkGroup.prototype.getModuleIndex = util.deprecate(
	ChunkGroup.prototype.getModulePreOrderIndex,
	"ChunkGroup.getModuleIndex was renamed to getModulePreOrderIndex",
	"DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX"
);

ChunkGroup.prototype.getModuleIndex2 = util.deprecate(
	ChunkGroup.prototype.getModulePostOrderIndex,
	"ChunkGroup.getModuleIndex2 was renamed to getModulePostOrderIndex",
	"DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX_2"
);

module.exports = ChunkGroup;

cmd: