added hover prefixer

1 files changed, 249 insertions, 0 deletions

diff --git a/node_modules/webpack/lib/stats/StatsPrinter.js b/node_modules/webpack/lib/stats/StatsPrinter.js
new file mode 100644
index 00000000..228b81db
--- /dev/null
+++ b/node_modules/webpack/lib/stats/StatsPrinter.js
@@ -0,0 +1,249 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { HookMap, SyncWaterfallHook, SyncBailHook } = require("tapable");
+
+/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
+/** @typedef {import("tapable").Hook} Hook */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModule} StatsModule */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
+
+/**
+ * @typedef {Object} PrintedElement
+ * @property {string} element
+ * @property {string} content
+ */
+
+/**
+ * @typedef {Object} KnownStatsPrinterContext
+ * @property {string=} type
+ * @property {StatsCompilation=} compilation
+ * @property {StatsChunkGroup=} chunkGroup
+ * @property {StatsAsset=} asset
+ * @property {StatsModule=} module
+ * @property {StatsChunk=} chunk
+ * @property {StatsModuleReason=} moduleReason
+ * @property {(str: string) => string=} bold
+ * @property {(str: string) => string=} yellow
+ * @property {(str: string) => string=} red
+ * @property {(str: string) => string=} green
+ * @property {(str: string) => string=} magenta
+ * @property {(str: string) => string=} cyan
+ * @property {(file: string, oversize?: boolean) => string=} formatFilename
+ * @property {(id: string) => string=} formatModuleId
+ * @property {(id: string, direction?: "parent"|"child"|"sibling") => string=} formatChunkId
+ * @property {(size: number) => string=} formatSize
+ * @property {(dateTime: number) => string=} formatDateTime
+ * @property {(flag: string) => string=} formatFlag
+ * @property {(time: number, boldQuantity?: boolean) => string=} formatTime
+ * @property {string=} chunkGroupKind
+ */
+
+/** @typedef {KnownStatsPrinterContext & Record<string, any>} StatsPrinterContext */
+
+class StatsPrinter {
+	constructor() {
+		this.hooks = Object.freeze({
+			/** @type {HookMap<SyncBailHook<[string[], StatsPrinterContext], true>>} */
+			sortElements: new HookMap(
+				() => new SyncBailHook(["elements", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[PrintedElement[], StatsPrinterContext], string>>} */
+			printElements: new HookMap(
+				() => new SyncBailHook(["printedElements", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[any[], StatsPrinterContext], true>>} */
+			sortItems: new HookMap(() => new SyncBailHook(["items", "context"])),
+			/** @type {HookMap<SyncBailHook<[any, StatsPrinterContext], string>>} */
+			getItemName: new HookMap(() => new SyncBailHook(["item", "context"])),
+			/** @type {HookMap<SyncBailHook<[string[], StatsPrinterContext], string>>} */
+			printItems: new HookMap(
+				() => new SyncBailHook(["printedItems", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[{}, StatsPrinterContext], string>>} */
+			print: new HookMap(() => new SyncBailHook(["object", "context"])),
+			/** @type {HookMap<SyncWaterfallHook<[string, StatsPrinterContext]>>} */
+			result: new HookMap(() => new SyncWaterfallHook(["result", "context"]))
+		});
+		/** @type {Map<HookMap<Hook>, Map<string, Hook[]>>} */
+		this._levelHookCache = new Map();
+		this._inPrint = false;
+	}
+
+	/**
+	 * get all level hooks
+	 * @private
+	 * @template {Hook} T
+	 * @param {HookMap<T>} hookMap HookMap
+	 * @param {string} type type
+	 * @returns {T[]} hooks
+	 */
+	_getAllLevelHooks(hookMap, type) {
+		let cache = /** @type {Map<string, T[]>} */ (
+			this._levelHookCache.get(hookMap)
+		);
+		if (cache === undefined) {
+			cache = new Map();
+			this._levelHookCache.set(hookMap, cache);
+		}
+		const cacheEntry = cache.get(type);
+		if (cacheEntry !== undefined) {
+			return cacheEntry;
+		}
+		/** @type {T[]} */
+		const hooks = [];
+		const typeParts = type.split(".");
+		for (let i = 0; i < typeParts.length; i++) {
+			const hook = hookMap.get(typeParts.slice(i).join("."));
+			if (hook) {
+				hooks.push(hook);
+			}
+		}
+		cache.set(type, hooks);
+		return hooks;
+	}
+
+	/**
+	 * Run `fn` for each level
+	 * @private
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap HookMap
+	 * @param {string} type type
+	 * @param {(hook: SyncBailHook<T, R>) => R} fn function
+	 * @returns {R} result of `fn`
+	 */
+	_forEachLevel(hookMap, type, fn) {
+		for (const hook of this._getAllLevelHooks(hookMap, type)) {
+			const result = fn(hook);
+			if (result !== undefined) return result;
+		}
+	}
+
+	/**
+	 * Run `fn` for each level
+	 * @private
+	 * @template T
+	 * @param {HookMap<SyncWaterfallHook<T>>} hookMap HookMap
+	 * @param {string} type type
+	 * @param {AsArray<T>[0]} data data
+	 * @param {(hook: SyncWaterfallHook<T>, data: AsArray<T>[0]) => AsArray<T>[0]} fn function
+	 * @returns {AsArray<T>[0]} result of `fn`
+	 */
+	_forEachLevelWaterfall(hookMap, type, data, fn) {
+		for (const hook of this._getAllLevelHooks(hookMap, type)) {
+			data = fn(hook, data);
+		}
+		return data;
+	}
+
+	/**
+	 * @param {string} type The type
+	 * @param {Object} object Object to print
+	 * @param {Object=} baseContext The base context
+	 * @returns {string} printed result
+	 */
+	print(type, object, baseContext) {
+		if (this._inPrint) {
+			return this._print(type, object, baseContext);
+		} else {
+			try {
+				this._inPrint = true;
+				return this._print(type, object, baseContext);
+			} finally {
+				this._levelHookCache.clear();
+				this._inPrint = false;
+			}
+		}
+	}
+
+	/**
+	 * @private
+	 * @param {string} type type
+	 * @param {Object} object object
+	 * @param {Object=} baseContext context
+	 * @returns {string} printed result
+	 */
+	_print(type, object, baseContext) {
+		const context = {
+			...baseContext,
+			type,
+			[type]: object
+		};
+
+		let printResult = this._forEachLevel(this.hooks.print, type, hook =>
+			hook.call(object, context)
+		);
+		if (printResult === undefined) {
+			if (Array.isArray(object)) {
+				const sortedItems = object.slice();
+				this._forEachLevel(this.hooks.sortItems, type, h =>
+					h.call(sortedItems, context)
+				);
+				const printedItems = sortedItems.map((item, i) => {
+					const itemContext = {
+						...context,
+						_index: i
+					};
+					const itemName = this._forEachLevel(
+						this.hooks.getItemName,
+						`${type}[]`,
+						h => h.call(item, itemContext)
+					);
+					if (itemName) itemContext[itemName] = item;
+					return this.print(
+						itemName ? `${type}[].${itemName}` : `${type}[]`,
+						item,
+						itemContext
+					);
+				});
+				printResult = this._forEachLevel(this.hooks.printItems, type, h =>
+					h.call(printedItems, context)
+				);
+				if (printResult === undefined) {
+					const result = printedItems.filter(Boolean);
+					if (result.length > 0) printResult = result.join("\n");
+				}
+			} else if (object !== null && typeof object === "object") {
+				const elements = Object.keys(object).filter(
+					key => object[key] !== undefined
+				);
+				this._forEachLevel(this.hooks.sortElements, type, h =>
+					h.call(elements, context)
+				);
+				const printedElements = elements.map(element => {
+					const content = this.print(`${type}.${element}`, object[element], {
+						...context,
+						_parent: object,
+						_element: element,
+						[element]: object[element]
+					});
+					return { element, content };
+				});
+				printResult = this._forEachLevel(this.hooks.printElements, type, h =>
+					h.call(printedElements, context)
+				);
+				if (printResult === undefined) {
+					const result = printedElements.map(e => e.content).filter(Boolean);
+					if (result.length > 0) printResult = result.join("\n");
+				}
+			}
+		}
+
+		return this._forEachLevelWaterfall(
+			this.hooks.result,
+			type,
+			printResult,
+			(h, r) => h.call(r, context)
+		);
+	}
+}
+module.exports = StatsPrinter;