@utrecht/web-component-library-stencil 1.0.0-alpha.159 → 1.0.0-alpha.162

package/dist/collection/node_modules/@storybook/manager-webpack5/node_modules/webpack/lib/optimize/InnerGraphPlugin.js

@@ -1,368 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const PureExpressionDependency = require("../dependencies/PureExpressionDependency");
-const InnerGraph = require("./InnerGraph");
-
-/** @typedef {import("estree").ClassDeclaration} ClassDeclarationNode */
-/** @typedef {import("estree").ClassExpression} ClassExpressionNode */
-/** @typedef {import("estree").Node} Node */
-/** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("./InnerGraph").InnerGraph} InnerGraph */
-/** @typedef {import("./InnerGraph").TopLevelSymbol} TopLevelSymbol */
-
-const { topLevelSymbolTag } = InnerGraph;
-
-class InnerGraphPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"InnerGraphPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const logger = compilation.getLogger("webpack.InnerGraphPlugin");
-
-				compilation.dependencyTemplates.set(
-					PureExpressionDependency,
-					new PureExpressionDependency.Template()
-				);
-
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @param {Object} parserOptions options
-				 * @returns {void}
-				 */
-				const handler = (parser, parserOptions) => {
-					const onUsageSuper = sup => {
-						InnerGraph.onUsage(parser.state, usedByExports => {
-							switch (usedByExports) {
-								case undefined:
-								case true:
-									return;
-								default: {
-									const dep = new PureExpressionDependency(sup.range);
-									dep.loc = sup.loc;
-									dep.usedByExports = usedByExports;
-									parser.state.module.addDependency(dep);
-									break;
-								}
-							}
-						});
-					};
-
-					parser.hooks.program.tap("InnerGraphPlugin", () => {
-						InnerGraph.enable(parser.state);
-					});
-
-					parser.hooks.finish.tap("InnerGraphPlugin", () => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-
-						logger.time("infer dependency usage");
-						InnerGraph.inferDependencyUsage(parser.state);
-						logger.timeAggregate("infer dependency usage");
-					});
-
-					// During prewalking the following datastructures are filled with
-					// nodes that have a TopLevelSymbol assigned and
-					// variables are tagged with the assigned TopLevelSymbol
-
-					// We differ 3 types of nodes:
-					// 1. full statements (export default, function declaration)
-					// 2. classes (class declaration, class expression)
-					// 3. variable declarators (const x = ...)
-
-					/** @type {WeakMap<Node, TopLevelSymbol>} */
-					const statementWithTopLevelSymbol = new WeakMap();
-					/** @type {WeakMap<Node, Node>} */
-					const statementPurePart = new WeakMap();
-
-					/** @type {WeakMap<ClassExpressionNode | ClassDeclarationNode, TopLevelSymbol>} */
-					const classWithTopLevelSymbol = new WeakMap();
-
-					/** @type {WeakMap<VariableDeclaratorNode, TopLevelSymbol>} */
-					const declWithTopLevelSymbol = new WeakMap();
-					/** @type {WeakSet<VariableDeclaratorNode>} */
-					const pureDeclarators = new WeakSet();
-
-					// The following hooks are used during prewalking:
-
-					parser.hooks.preStatement.tap("InnerGraphPlugin", statement => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-
-						if (parser.scope.topLevelScope === true) {
-							if (statement.type === "FunctionDeclaration") {
-								const name = statement.id ? statement.id.name : "*default*";
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-								statementWithTopLevelSymbol.set(statement, fn);
-								return true;
-							}
-						}
-					});
-
-					parser.hooks.blockPreStatement.tap("InnerGraphPlugin", statement => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-
-						if (parser.scope.topLevelScope === true) {
-							if (statement.type === "ClassDeclaration") {
-								const name = statement.id ? statement.id.name : "*default*";
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-								classWithTopLevelSymbol.set(statement, fn);
-								return true;
-							}
-							if (statement.type === "ExportDefaultDeclaration") {
-								const name = "*default*";
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-								const decl = statement.declaration;
-								if (
-									decl.type === "ClassExpression" ||
-									decl.type === "ClassDeclaration"
-								) {
-									classWithTopLevelSymbol.set(decl, fn);
-								} else if (parser.isPure(decl, statement.range[0])) {
-									statementWithTopLevelSymbol.set(statement, fn);
-									if (
-										!decl.type.endsWith("FunctionExpression") &&
-										!decl.type.endsWith("Declaration") &&
-										decl.type !== "Literal"
-									) {
-										statementPurePart.set(statement, decl);
-									}
-								}
-							}
-						}
-					});
-
-					parser.hooks.preDeclarator.tap(
-						"InnerGraphPlugin",
-						(decl, statement) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (
-								parser.scope.topLevelScope === true &&
-								decl.init &&
-								decl.id.type === "Identifier"
-							) {
-								const name = decl.id.name;
-								if (decl.init.type === "ClassExpression") {
-									const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-									classWithTopLevelSymbol.set(decl.init, fn);
-								} else if (parser.isPure(decl.init, decl.id.range[1])) {
-									const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-									declWithTopLevelSymbol.set(decl, fn);
-									if (
-										!decl.init.type.endsWith("FunctionExpression") &&
-										decl.init.type !== "Literal"
-									) {
-										pureDeclarators.add(decl);
-									}
-									return true;
-								}
-							}
-						}
-					);
-
-					// During real walking we set the TopLevelSymbol state to the assigned
-					// TopLevelSymbol by using the fill datastructures.
-
-					// In addition to tracking TopLevelSymbols, we sometimes need to
-					// add a PureExpressionDependency. This is needed to skip execution
-					// of pure expressions, even when they are not dropped due to
-					// minimizing. Otherwise symbols used there might not exist anymore
-					// as they are removed as unused by this optimization
-
-					// When we find a reference to a TopLevelSymbol, we register a
-					// TopLevelSymbol dependency from TopLevelSymbol in state to the
-					// referenced TopLevelSymbol. This way we get a graph of all
-					// TopLevelSymbols.
-
-					// The following hooks are called during walking:
-
-					parser.hooks.statement.tap("InnerGraphPlugin", statement => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-						if (parser.scope.topLevelScope === true) {
-							InnerGraph.setTopLevelSymbol(parser.state, undefined);
-
-							const fn = statementWithTopLevelSymbol.get(statement);
-							if (fn) {
-								InnerGraph.setTopLevelSymbol(parser.state, fn);
-								const purePart = statementPurePart.get(statement);
-								if (purePart) {
-									InnerGraph.onUsage(parser.state, usedByExports => {
-										switch (usedByExports) {
-											case undefined:
-											case true:
-												return;
-											default: {
-												const dep = new PureExpressionDependency(
-													purePart.range
-												);
-												dep.loc = statement.loc;
-												dep.usedByExports = usedByExports;
-												parser.state.module.addDependency(dep);
-												break;
-											}
-										}
-									});
-								}
-							}
-						}
-					});
-
-					parser.hooks.classExtendsExpression.tap(
-						"InnerGraphPlugin",
-						(expr, statement) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (parser.scope.topLevelScope === true) {
-								const fn = classWithTopLevelSymbol.get(statement);
-								if (
-									fn &&
-									parser.isPure(
-										expr,
-										statement.id ? statement.id.range[1] : statement.range[0]
-									)
-								) {
-									InnerGraph.setTopLevelSymbol(parser.state, fn);
-									onUsageSuper(expr);
-								}
-							}
-						}
-					);
-
-					parser.hooks.classBodyElement.tap(
-						"InnerGraphPlugin",
-						(element, classDefinition) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (parser.scope.topLevelScope === true) {
-								const fn = classWithTopLevelSymbol.get(classDefinition);
-								if (fn) {
-									InnerGraph.setTopLevelSymbol(parser.state, undefined);
-								}
-							}
-						}
-					);
-
-					parser.hooks.classBodyValue.tap(
-						"InnerGraphPlugin",
-						(expression, element, classDefinition) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (parser.scope.topLevelScope === true) {
-								const fn = classWithTopLevelSymbol.get(classDefinition);
-								if (fn) {
-									if (
-										!element.static ||
-										parser.isPure(
-											expression,
-											element.key ? element.key.range[1] : element.range[0]
-										)
-									) {
-										InnerGraph.setTopLevelSymbol(parser.state, fn);
-										if (element.type !== "MethodDefinition" && element.static) {
-											InnerGraph.onUsage(parser.state, usedByExports => {
-												switch (usedByExports) {
-													case undefined:
-													case true:
-														return;
-													default: {
-														const dep = new PureExpressionDependency(
-															expression.range
-														);
-														dep.loc = expression.loc;
-														dep.usedByExports = usedByExports;
-														parser.state.module.addDependency(dep);
-														break;
-													}
-												}
-											});
-										}
-									} else {
-										InnerGraph.setTopLevelSymbol(parser.state, undefined);
-									}
-								}
-							}
-						}
-					);
-
-					parser.hooks.declarator.tap("InnerGraphPlugin", (decl, statement) => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-						const fn = declWithTopLevelSymbol.get(decl);
-
-						if (fn) {
-							InnerGraph.setTopLevelSymbol(parser.state, fn);
-							if (pureDeclarators.has(decl)) {
-								if (decl.init.type === "ClassExpression") {
-									if (decl.init.superClass) {
-										onUsageSuper(decl.init.superClass);
-									}
-								} else {
-									InnerGraph.onUsage(parser.state, usedByExports => {
-										switch (usedByExports) {
-											case undefined:
-											case true:
-												return;
-											default: {
-												const dep = new PureExpressionDependency(
-													decl.init.range
-												);
-												dep.loc = decl.loc;
-												dep.usedByExports = usedByExports;
-												parser.state.module.addDependency(dep);
-												break;
-											}
-										}
-									});
-								}
-							}
-							parser.walkExpression(decl.init);
-							InnerGraph.setTopLevelSymbol(parser.state, undefined);
-							return true;
-						}
-					});
-
-					parser.hooks.expression
-						.for(topLevelSymbolTag)
-						.tap("InnerGraphPlugin", () => {
-							const topLevelSymbol = /** @type {TopLevelSymbol} */ (
-								parser.currentTagData
-							);
-							const currentTopLevelSymbol = InnerGraph.getTopLevelSymbol(
-								parser.state
-							);
-							InnerGraph.addUsage(
-								parser.state,
-								topLevelSymbol,
-								currentTopLevelSymbol || true
-							);
-						});
-					parser.hooks.assign
-						.for(topLevelSymbolTag)
-						.tap("InnerGraphPlugin", expr => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (expr.operator === "=") return true;
-						});
-				};
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("InnerGraphPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("InnerGraphPlugin", handler);
-
-				compilation.hooks.finishModules.tap("InnerGraphPlugin", () => {
-					logger.timeAggregateEnd("infer dependency usage");
-				});
-			}
-		);
-	}
-}
-
-module.exports = InnerGraphPlugin;

package/dist/collection/node_modules/@storybook/manager-webpack5/node_modules/webpack/lib/optimize/LimitChunkCountPlugin.js

@@ -1,256 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const { STAGE_ADVANCED } = require("../OptimizationStages");
-const LazyBucketSortedSet = require("../util/LazyBucketSortedSet");
-const { compareChunks } = require("../util/comparators");
-const createSchemaValidation = require("../util/create-schema-validation");
-
-/** @typedef {import("../../declarations/plugins/optimize/LimitChunkCountPlugin").LimitChunkCountPluginOptions} LimitChunkCountPluginOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-
-const validate = createSchemaValidation(
-	require("../../schemas/plugins/optimize/LimitChunkCountPlugin.check.js"),
-	() => require("../../schemas/plugins/optimize/LimitChunkCountPlugin.json"),
-	{
-		name: "Limit Chunk Count Plugin",
-		baseDataPath: "options"
-	}
-);
-
-/**
- * @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) {
-		validate(options);
-		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.optimizeChunks.tap(
-				{
-					name: "LimitChunkCountPlugin",
-					stage: STAGE_ADVANCED
-				},
-				chunks => {
-					const chunkGraph = compilation.chunkGraph;
-					const maxChunks = options.maxChunks;
-					if (!maxChunks) return;
-					if (maxChunks < 1) return;
-					if (compilation.chunks.size <= maxChunks) return;
-
-					let remainingChunksToMerge = compilation.chunks.size - maxChunks;
-
-					// order chunks in a deterministic way
-					const compareChunksWithGraph = compareChunks(chunkGraph);
-					const orderedChunks = Array.from(chunks).sort(compareChunksWithGraph);
-
-					// 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 mapping 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];
-							// filter pairs that can not be integrated!
-							if (!chunkGraph.canChunksBeIntegrated(a, b)) continue;
-
-							const integratedSize = chunkGraph.getIntegratedChunksSize(
-								a,
-								b,
-								options
-							);
-
-							const aSize = chunkGraph.getChunkSize(a, options);
-							const bSize = chunkGraph.getChunkSize(b, 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
-					// further 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 (chunkGraph.canChunksBeIntegrated(a, b)) {
-							chunkGraph.integrateChunks(a, b);
-							compilation.chunks.delete(b);
-
-							// 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(a)) {
-								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(b)) {
-								if (combination.deleted) continue;
-								if (combination.a === b) {
-									if (!chunkGraph.canChunksBeIntegrated(a, combination.b)) {
-										combination.deleted = true;
-										combinations.delete(combination);
-										continue;
-									}
-									// Update size
-									const newIntegratedSize = chunkGraph.getIntegratedChunksSize(
-										a,
-										combination.b,
-										options
-									);
-									const finishUpdate = combinations.startUpdate(combination);
-									combination.a = a;
-									combination.integratedSize = newIntegratedSize;
-									combination.aSize = integratedSize;
-									combination.sizeDiff =
-										combination.bSize + integratedSize - newIntegratedSize;
-									finishUpdate();
-								} else if (combination.b === b) {
-									if (!chunkGraph.canChunksBeIntegrated(combination.a, a)) {
-										combination.deleted = true;
-										combinations.delete(combination);
-										continue;
-									}
-									// Update size
-									const newIntegratedSize = chunkGraph.getIntegratedChunksSize(
-										combination.a,
-										a,
-										options
-									);
-
-									const finishUpdate = combinations.startUpdate(combination);
-									combination.b = a;
-									combination.integratedSize = newIntegratedSize;
-									combination.bSize = integratedSize;
-									combination.sizeDiff =
-										integratedSize + combination.aSize - newIntegratedSize;
-									finishUpdate();
-								}
-							}
-							combinationsByChunk.set(a, combinationsByChunk.get(b));
-							combinationsByChunk.delete(b);
-						}
-					}
-					if (changed) return true;
-				}
-			);
-		});
-	}
-}
-module.exports = LimitChunkCountPlugin;