docs: async function getUnionEntryPoints(entries, {cache} = {}) {
  	const
  		packs = Object.create(null),
  		weights = Object.create(null);
  
  	await $C(entries).parallel().forEach(async (el) => {
  		const
  			key = path.basename(el.path, '.js'),
  			deps = packs[key] = await getEntryRuntimeDependencies(path.dirname(el.path), el.source, {cache});
  
  		const walk = (block) => {
  			const
  				name = block.name || block;
  
  			if (name in weights) {
  				const
  					w = weights[name];
  
  				w.i++;
  				if (w.isParent) {
  					w.isParent = deps.parents.has(name);
  				}
  
  			} else {
  				weights[name] = {
  					i: 0,
  					name,
  					isParent: deps.parents.has(name)
  				};
  			}
  		};
  
  		$C(deps.runtime).forEach(walk);
  		$C(deps.libs).forEach(walk);
  	});
  
  	// Find common modules (weight > 1)
  
  	const commonPacks = $C(weights).to([]).reduce((arr, el, key) => {
  		if (el.i > 1) {
  			const pos = $C(entries).length() - el.i - 1;
  			arr[pos] = (arr[pos] || new Map()).set(key, el);
  		}
  
  		return arr;
  	});
  
  	// Remove empty modules
  	$C(commonPacks).remove((el) => !el);
  
  	const getTopParents = (entry, set = new Set(), first = true) => {
  		const
  			obj = entries[entry];
  
  		if (!obj) {
  			set.add(entry);
  			return set;
  		}
  
  		const
  			{parents} = obj;
  
  		if (parents.size) {
  			$C(parents).forEach((entry) => getTopParents(entry, set, false));
  
  		} else if (!first) {
  			set.add(entry);
  		}
  
  		return set;
  	};
  
  	const dependencies = await $C(packs)
  		.parallel()
  		.to({})
  		.reduce(async (map, deps, name) => {
  			const
  				depSet = new Set();
  
  			$C(deps.runtime).forEach((el, block) => {
  				const
  					pos = $C(commonPacks).one.search((map) => map.has(block));
  
  				if (pos !== null) {
  					depSet.add(pos);
  					deps.runtime.delete(block);
  				}
  			});
  
  			const depList = [...depSet].sort((a, b) => a - b).map((i) => getCommonName(i));
  			map[name] = new Set([...getTopParents(name), ...depList]);
  			return map;
  		});
  
  	const entry = $C(commonPacks).to({}).reduce((map, deps, i) => {
  		map[getCommonName(i)] = deps;
  		return map;
  	});
  
  	$C(packs).forEach((deps, name) => {
  		entry[name] = $C(deps.runtime).to(new Map()).reduce((map, block, name) => map.set(name, {
  			name,
  			isParent: deps.parents.has(name)
  		}));
  	});
  
  	return {dependencies, entry};
  }