Method apply

lib/javascript/JavascriptModulesPlugin.js:434–750

* Applies the plugin by registering its hooks on the compiler. * @param {Compiler} compiler the compiler instance * @returns {void}

(compiler)

	 * @returns {void}
	 */
	apply(compiler) {
		compiler.hooks.compilation.tap(
			PLUGIN_NAME,
			(compilation, { normalModuleFactory }) => {
				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);

				for (const type of [
					JAVASCRIPT_MODULE_TYPE_AUTO,
					JAVASCRIPT_MODULE_TYPE_DYNAMIC,
					JAVASCRIPT_MODULE_TYPE_ESM
				]) {
					normalModuleFactory.hooks.createModuleClass
						.for(type)
						.tap(
							PLUGIN_NAME,
							(createData, _resolveData) => new JavascriptModule(createData)
						);
					normalModuleFactory.hooks.createParser
						.for(type)
						.tap(PLUGIN_NAME, (options) => {
							switch (type) {
								case JAVASCRIPT_MODULE_TYPE_AUTO: {
									return new JavascriptParser(class="st">"auto", {
										parse: options.parse,
										typescript: options.typescript
									});
								}
								case JAVASCRIPT_MODULE_TYPE_DYNAMIC: {
									return new JavascriptParser(class="st">"script", {
										parse: options.parse,
										typescript: options.typescript
									});
								}
								case JAVASCRIPT_MODULE_TYPE_ESM: {
									return new JavascriptParser(class="st">"module", {
										parse: options.parse,
										typescript: options.typescript
									});
								}
							}
						});
					normalModuleFactory.hooks.createGenerator
						.for(type)
						.tap(PLUGIN_NAME, () => new JavascriptGenerator());

					NormalModule.getCompilationHooks(compilation).processResult.tap(
						PLUGIN_NAME,
						(result, module) => {
							if (module.type === type) {
								const [source, ...rest] = result;

								return [removeBOM(source), ...rest];
							}

							return result;
						}
					);
				}