removed autoprefix hover as it will have a high chance of making hover stopped working

5 files changed, 0 insertions, 657 deletions

diff --git a/node_modules/webpack/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js b/node_modules/webpack/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js
deleted file mode 100644
index 65175872..00000000
--- a/node_modules/webpack/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
-const Template = require("../Template");
-
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
-
-/**
- * @typedef {Object} AsyncWasmLoadingRuntimeModuleOptions
- * @property {function(string): string} generateLoadBinaryCode
- * @property {boolean} supportsStreaming
- */
-
-class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {AsyncWasmLoadingRuntimeModuleOptions} options options
-	 */
-	constructor({ generateLoadBinaryCode, supportsStreaming }) {
-		super("wasm loading", RuntimeModule.STAGE_NORMAL);
-		this.generateLoadBinaryCode = generateLoadBinaryCode;
-		this.supportsStreaming = supportsStreaming;
-	}
-
-	/**
-	 * @returns {string | null} runtime code
-	 */
-	generate() {
-		const compilation = /** @type {Compilation} */ (this.compilation);
-		const chunk = /** @type {Chunk} */ (this.chunk);
-		const { outputOptions, runtimeTemplate } = compilation;
-		const fn = RuntimeGlobals.instantiateWasm;
-		const wasmModuleSrcPath = compilation.getPath(
-			JSON.stringify(outputOptions.webassemblyModuleFilename),
-			{
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: length =>
-					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
-				module: {
-					id: '" + wasmModuleId + "',
-					hash: `" + wasmModuleHash + "`,
-					hashWithLength(length) {
-						return `" + wasmModuleHash.slice(0, ${length}) + "`;
-					}
-				},
-				runtime: chunk.runtime
-			}
-		);
-		return `${fn} = ${runtimeTemplate.basicFunction(
-			"exports, wasmModuleId, wasmModuleHash, importsObj",
-			[
-				`var req = ${this.generateLoadBinaryCode(wasmModuleSrcPath)};`,
-				this.supportsStreaming
-					? Template.asString([
-							"if (typeof WebAssembly.instantiateStreaming === 'function') {",
-							Template.indent([
-								"return WebAssembly.instantiateStreaming(req, importsObj)",
-								Template.indent([
-									`.then(${runtimeTemplate.returningFunction(
-										"Object.assign(exports, res.instance.exports)",
-										"res"
-									)});`
-								])
-							]),
-							"}"
-					  ])
-					: "// no support for streaming compilation",
-				"return req",
-				Template.indent([
-					`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,
-					`.then(${runtimeTemplate.returningFunction(
-						"WebAssembly.instantiate(bytes, importsObj)",
-						"bytes"
-					)})`,
-					`.then(${runtimeTemplate.returningFunction(
-						"Object.assign(exports, res.instance.exports)",
-						"res"
-					)});`
-				])
-			]
-		)};`;
-	}
-}
-
-module.exports = AsyncWasmLoadingRuntimeModule;
diff --git a/node_modules/webpack/lib/wasm-async/AsyncWebAssemblyGenerator.js b/node_modules/webpack/lib/wasm-async/AsyncWebAssemblyGenerator.js
deleted file mode 100644
index 7a43f263..00000000
--- a/node_modules/webpack/lib/wasm-async/AsyncWebAssemblyGenerator.js
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const Generator = require("../Generator");
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../NormalModule")} NormalModule */
-
-const TYPES = new Set(["webassembly"]);
-
-/**
- * @typedef {Object} AsyncWebAssemblyGeneratorOptions
- * @property {boolean} [mangleImports] mangle imports
- */
-
-class AsyncWebAssemblyGenerator extends Generator {
-	/**
-	 * @param {AsyncWebAssemblyGeneratorOptions} options options
-	 */
-	constructor(options) {
-		super();
-		this.options = options;
-	}
-
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		return TYPES;
-	}
-
-	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
-	 */
-	getSize(module, type) {
-		const originalSource = module.originalSource();
-		if (!originalSource) {
-			return 0;
-		}
-		return originalSource.size();
-	}
-
-	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
-	 */
-	generate(module, generateContext) {
-		return /** @type {Source} */ (module.originalSource());
-	}
-}
-
-module.exports = AsyncWebAssemblyGenerator;
diff --git a/node_modules/webpack/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js b/node_modules/webpack/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js
deleted file mode 100644
index baa71333..00000000
--- a/node_modules/webpack/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const { RawSource } = require("webpack-sources");
-const Generator = require("../Generator");
-const InitFragment = require("../InitFragment");
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
-const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-
-const TYPES = new Set(["webassembly"]);
-
-/**
- * @typedef {{ request: string, importVar: string }} ImportObjRequestItem
- */
-
-class AsyncWebAssemblyJavascriptGenerator extends Generator {
-	/**
-	 * @param {OutputOptions["webassemblyModuleFilename"]} filenameTemplate template for the WebAssembly module filename
-	 */
-	constructor(filenameTemplate) {
-		super();
-		this.filenameTemplate = filenameTemplate;
-	}
-
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		return TYPES;
-	}
-
-	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
-	 */
-	getSize(module, type) {
-		return 40 + module.dependencies.length * 10;
-	}
-
-	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
-	 */
-	generate(module, generateContext) {
-		const {
-			runtimeTemplate,
-			chunkGraph,
-			moduleGraph,
-			runtimeRequirements,
-			runtime
-		} = generateContext;
-		runtimeRequirements.add(RuntimeGlobals.module);
-		runtimeRequirements.add(RuntimeGlobals.moduleId);
-		runtimeRequirements.add(RuntimeGlobals.exports);
-		runtimeRequirements.add(RuntimeGlobals.instantiateWasm);
-		/** @type {InitFragment<InitFragment<string>>[]} */
-		const initFragments = [];
-		/** @type {Map<Module, ImportObjRequestItem>} */
-		const depModules = new Map();
-		/** @type {Map<string, WebAssemblyImportDependency[]>} */
-		const wasmDepsByRequest = new Map();
-		for (const dep of module.dependencies) {
-			if (dep instanceof WebAssemblyImportDependency) {
-				const module = moduleGraph.getModule(dep);
-				if (!depModules.has(module)) {
-					depModules.set(module, {
-						request: dep.request,
-						importVar: `WEBPACK_IMPORTED_MODULE_${depModules.size}`
-					});
-				}
-				let list = wasmDepsByRequest.get(dep.request);
-				if (list === undefined) {
-					list = [];
-					wasmDepsByRequest.set(dep.request, list);
-				}
-				list.push(dep);
-			}
-		}
-
-		/** @type {Array<string>} */
-		const promises = [];
-
-		const importStatements = Array.from(
-			depModules,
-			([importedModule, { request, importVar }]) => {
-				if (moduleGraph.isAsync(importedModule)) {
-					promises.push(importVar);
-				}
-				return runtimeTemplate.importStatement({
-					update: false,
-					module: importedModule,
-					chunkGraph,
-					request,
-					originModule: module,
-					importVar,
-					runtimeRequirements
-				});
-			}
-		);
-		const importsCode = importStatements.map(([x]) => x).join("");
-		const importsCompatCode = importStatements.map(([_, x]) => x).join("");
-
-		const importObjRequestItems = Array.from(
-			wasmDepsByRequest,
-			([request, deps]) => {
-				const exportItems = deps.map(dep => {
-					const importedModule = moduleGraph.getModule(dep);
-					const importVar =
-						/** @type {ImportObjRequestItem} */
-						(depModules.get(importedModule)).importVar;
-					return `${JSON.stringify(
-						dep.name
-					)}: ${runtimeTemplate.exportFromImport({
-						moduleGraph,
-						module: importedModule,
-						request,
-						exportName: dep.name,
-						originModule: module,
-						asiSafe: true,
-						isCall: false,
-						callContext: false,
-						defaultInterop: true,
-						importVar,
-						initFragments,
-						runtime,
-						runtimeRequirements
-					})}`;
-				});
-				return Template.asString([
-					`${JSON.stringify(request)}: {`,
-					Template.indent(exportItems.join(",\n")),
-					"}"
-				]);
-			}
-		);
-
-		const importsObj =
-			importObjRequestItems.length > 0
-				? Template.asString([
-						"{",
-						Template.indent(importObjRequestItems.join(",\n")),
-						"}"
-				  ])
-				: undefined;
-
-		const instantiateCall =
-			`${RuntimeGlobals.instantiateWasm}(${module.exportsArgument}, ${
-				module.moduleArgument
-			}.id, ${JSON.stringify(
-				chunkGraph.getRenderedModuleHash(module, runtime)
-			)}` + (importsObj ? `, ${importsObj})` : `)`);
-
-		if (promises.length > 0)
-			runtimeRequirements.add(RuntimeGlobals.asyncModule);
-
-		const source = new RawSource(
-			promises.length > 0
-				? Template.asString([
-						`var __webpack_instantiate__ = ${runtimeTemplate.basicFunction(
-							`[${promises.join(", ")}]`,
-							`${importsCompatCode}return ${instantiateCall};`
-						)}`,
-						`${RuntimeGlobals.asyncModule}(${
-							module.moduleArgument
-						}, async ${runtimeTemplate.basicFunction(
-							"__webpack_handle_async_dependencies__, __webpack_async_result__",
-							[
-								"try {",
-								importsCode,
-								`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${promises.join(
-									", "
-								)}]);`,
-								`var [${promises.join(
-									", "
-								)}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__;`,
-								`${importsCompatCode}await ${instantiateCall};`,
-								"__webpack_async_result__();",
-								"} catch(e) { __webpack_async_result__(e); }"
-							]
-						)}, 1);`
-				  ])
-				: `${importsCode}${importsCompatCode}module.exports = ${instantiateCall};`
-		);
-
-		return InitFragment.addToSource(source, initFragments, generateContext);
-	}
-}
-
-module.exports = AsyncWebAssemblyJavascriptGenerator;
diff --git a/node_modules/webpack/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js b/node_modules/webpack/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js
deleted file mode 100644
index cd93468e..00000000
--- a/node_modules/webpack/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const { SyncWaterfallHook } = require("tapable");
-const Compilation = require("../Compilation");
-const Generator = require("../Generator");
-const { tryRunOrWebpackError } = require("../HookWebpackError");
-const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
-const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
-const { compareModulesByIdentifier } = require("../util/comparators");
-const memoize = require("../util/memoize");
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../Template").RenderManifestEntry} RenderManifestEntry */
-/** @typedef {import("../Template").RenderManifestOptions} RenderManifestOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
-
-const getAsyncWebAssemblyGenerator = memoize(() =>
-	require("./AsyncWebAssemblyGenerator")
-);
-const getAsyncWebAssemblyJavascriptGenerator = memoize(() =>
-	require("./AsyncWebAssemblyJavascriptGenerator")
-);
-const getAsyncWebAssemblyParser = memoize(() =>
-	require("./AsyncWebAssemblyParser")
-);
-
-/**
- * @typedef {Object} WebAssemblyRenderContext
- * @property {Chunk} chunk the chunk
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {CodeGenerationResults} codeGenerationResults results of code generation
- */
-
-/**
- * @typedef {Object} CompilationHooks
- * @property {SyncWaterfallHook<[Source, Module, WebAssemblyRenderContext]>} renderModuleContent
- */
-
-/**
- * @typedef {Object} AsyncWebAssemblyModulesPluginOptions
- * @property {boolean} [mangleImports] mangle imports
- */
-
-/** @type {WeakMap<Compilation, CompilationHooks>} */
-const compilationHooksMap = new WeakMap();
-
-const PLUGIN_NAME = "AsyncWebAssemblyModulesPlugin";
-
-class AsyncWebAssemblyModulesPlugin {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CompilationHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				renderModuleContent: new SyncWaterfallHook([
-					"source",
-					"module",
-					"renderContext"
-				])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
-	/**
-	 * @param {AsyncWebAssemblyModulesPluginOptions} options options
-	 */
-	constructor(options) {
-		this.options = options;
-	}
-
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			PLUGIN_NAME,
-			(compilation, { normalModuleFactory }) => {
-				const hooks =
-					AsyncWebAssemblyModulesPlugin.getCompilationHooks(compilation);
-				compilation.dependencyFactories.set(
-					WebAssemblyImportDependency,
-					normalModuleFactory
-				);
-
-				normalModuleFactory.hooks.createParser
-					.for(WEBASSEMBLY_MODULE_TYPE_ASYNC)
-					.tap(PLUGIN_NAME, () => {
-						const AsyncWebAssemblyParser = getAsyncWebAssemblyParser();
-
-						return new AsyncWebAssemblyParser();
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for(WEBASSEMBLY_MODULE_TYPE_ASYNC)
-					.tap(PLUGIN_NAME, () => {
-						const AsyncWebAssemblyJavascriptGenerator =
-							getAsyncWebAssemblyJavascriptGenerator();
-						const AsyncWebAssemblyGenerator = getAsyncWebAssemblyGenerator();
-
-						return Generator.byType({
-							javascript: new AsyncWebAssemblyJavascriptGenerator(
-								compilation.outputOptions.webassemblyModuleFilename
-							),
-							webassembly: new AsyncWebAssemblyGenerator(this.options)
-						});
-					});
-
-				compilation.hooks.renderManifest.tap(
-					"WebAssemblyModulesPlugin",
-					(result, options) => {
-						const { moduleGraph, chunkGraph, runtimeTemplate } = compilation;
-						const {
-							chunk,
-							outputOptions,
-							dependencyTemplates,
-							codeGenerationResults
-						} = options;
-
-						for (const module of chunkGraph.getOrderedChunkModulesIterable(
-							chunk,
-							compareModulesByIdentifier
-						)) {
-							if (module.type === WEBASSEMBLY_MODULE_TYPE_ASYNC) {
-								const filenameTemplate =
-									/** @type {NonNullable<OutputOptions["webassemblyModuleFilename"]>} */
-									(outputOptions.webassemblyModuleFilename);
-
-								result.push({
-									render: () =>
-										this.renderModule(
-											module,
-											{
-												chunk,
-												dependencyTemplates,
-												runtimeTemplate,
-												moduleGraph,
-												chunkGraph,
-												codeGenerationResults
-											},
-											hooks
-										),
-									filenameTemplate,
-									pathOptions: {
-										module,
-										runtime: chunk.runtime,
-										chunkGraph
-									},
-									auxiliary: true,
-									identifier: `webassemblyAsyncModule${chunkGraph.getModuleId(
-										module
-									)}`,
-									hash: chunkGraph.getModuleHash(module, chunk.runtime)
-								});
-							}
-						}
-
-						return result;
-					}
-				);
-			}
-		);
-	}
-
-	/**
-	 * @param {Module} module the rendered module
-	 * @param {WebAssemblyRenderContext} renderContext options object
-	 * @param {CompilationHooks} hooks hooks
-	 * @returns {Source} the newly generated source from rendering
-	 */
-	renderModule(module, renderContext, hooks) {
-		const { codeGenerationResults, chunk } = renderContext;
-		try {
-			const moduleSource = codeGenerationResults.getSource(
-				module,
-				chunk.runtime,
-				"webassembly"
-			);
-			return tryRunOrWebpackError(
-				() =>
-					hooks.renderModuleContent.call(moduleSource, module, renderContext),
-				"AsyncWebAssemblyModulesPlugin.getCompilationHooks().renderModuleContent"
-			);
-		} catch (e) {
-			/** @type {WebpackError} */ (e).module = module;
-			throw e;
-		}
-	}
-}
-
-module.exports = AsyncWebAssemblyModulesPlugin;
diff --git a/node_modules/webpack/lib/wasm-async/AsyncWebAssemblyParser.js b/node_modules/webpack/lib/wasm-async/AsyncWebAssemblyParser.js
deleted file mode 100644
index 4a9632cb..00000000
--- a/node_modules/webpack/lib/wasm-async/AsyncWebAssemblyParser.js
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const t = require("@webassemblyjs/ast");
-const { decode } = require("@webassemblyjs/wasm-parser");
-const Parser = require("../Parser");
-const StaticExportsDependency = require("../dependencies/StaticExportsDependency");
-const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
-
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
-
-const decoderOpts = {
-	ignoreCodeSection: true,
-	ignoreDataSection: true,
-
-	// this will avoid having to lookup with identifiers in the ModuleContext
-	ignoreCustomNameSection: true
-};
-
-class WebAssemblyParser extends Parser {
-	/**
-	 * @param {{}=} options parser options
-	 */
-	constructor(options) {
-		super();
-		this.hooks = Object.freeze({});
-		this.options = options;
-	}
-
-	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
-	 */
-	parse(source, state) {
-		if (!Buffer.isBuffer(source)) {
-			throw new Error("WebAssemblyParser input must be a Buffer");
-		}
-
-		// flag it as async module
-		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
-		buildInfo.strict = true;
-		const BuildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
-		BuildMeta.exportsType = "namespace";
-		BuildMeta.async = true;
-
-		// parse it
-		const program = decode(source, decoderOpts);
-		const module = program.body[0];
-		/** @type {Array<string>} */
-		const exports = [];
-		t.traverse(module, {
-			ModuleExport({ node }) {
-				exports.push(node.name);
-			},
-
-			ModuleImport({ node }) {
-				const dep = new WebAssemblyImportDependency(
-					node.module,
-					node.name,
-					node.descr,
-					false
-				);
-
-				state.module.addDependency(dep);
-			}
-		});
-
-		state.module.addDependency(new StaticExportsDependency(exports, false));
-
-		return state;
-	}
-}
-
-module.exports = WebAssemblyParser;