text: /*
  	MIT License http://www.opensource.org/licenses/mit-license.php
  	Author Tobias Koppers @sokra
  */
  
  "use strict";
  
  const OptionsApply = require("./OptionsApply");
  
  const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
  const JsonModulesPlugin = require("./json/JsonModulesPlugin");
  
  const LoaderTargetPlugin = require("./LoaderTargetPlugin");
  
  const EntryOptionPlugin = require("./EntryOptionPlugin");
  const RecordIdsPlugin = require("./RecordIdsPlugin");
  
  const RuntimePlugin = require("./RuntimePlugin");
  
  const APIPlugin = require("./APIPlugin");
  const CompatibilityPlugin = require("./CompatibilityPlugin");
  const ConstPlugin = require("./ConstPlugin");
  const ExportsInfoApiPlugin = require("./ExportsInfoApiPlugin");
  
  const TemplatedPathPlugin = require("./TemplatedPathPlugin");
  const UseStrictPlugin = require("./UseStrictPlugin");
  const WarnCaseSensitiveModulesPlugin = require("./WarnCaseSensitiveModulesPlugin");
  
  const ResolverCachePlugin = require("./cache/ResolverCachePlugin");
  
  const CommonJsPlugin = require("./dependencies/CommonJsPlugin");
  const HarmonyModulesPlugin = require("./dependencies/HarmonyModulesPlugin");
  const ImportPlugin = require("./dependencies/ImportPlugin");
  const LoaderPlugin = require("./dependencies/LoaderPlugin");
  const RequireContextPlugin = require("./dependencies/RequireContextPlugin");
  const RequireEnsurePlugin = require("./dependencies/RequireEnsurePlugin");
  const RequireIncludePlugin = require("./dependencies/RequireIncludePlugin");
  const SystemPlugin = require("./dependencies/SystemPlugin");
  
  const InferAsyncModulesPlugin = require("./async-modules/InferAsyncModulesPlugin");
  
  const FlagUsingEvalPlugin = require("./FlagUsingEvalPlugin");
  const DefaultStatsFactoryPlugin = require("./stats/DefaultStatsFactoryPlugin");
  const DefaultStatsPresetPlugin = require("./stats/DefaultStatsPresetPlugin");
  const DefaultStatsPrinterPlugin = require("./stats/DefaultStatsPrinterPlugin");
  
  const { cachedCleverMerge } = require("./util/cleverMerge");
  
  /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
  /** @typedef {import("./Compiler")} Compiler */
  
  class WebpackOptionsApply extends OptionsApply {
  	constructor() {
  		super();
  	}
  
  	/**
  	 * @param {WebpackOptions} options options object
  	 * @param {Compiler} compiler compiler object
  	 * @returns {WebpackOptions} options object
  	 */
  	process(options, compiler) {
  		compiler.outputPath = options.output.path;
  		compiler.recordsInputPath = options.recordsInputPath || null;
  		compiler.recordsOutputPath = options.recordsOutputPath || null;
  		compiler.name = options.name;
  		if (typeof options.target === "string") {
  			switch (options.target) {
  				case "web": {
  					const JsonpTemplatePlugin = require("./web/JsonpTemplatePlugin");
  					const FetchCompileWasmPlugin = require("./web/FetchCompileWasmPlugin");
  					const FetchCompileAsyncWasmPlugin = require("./web/FetchCompileAsyncWasmPlugin");
  					const NodeSourcePlugin = require("./node/NodeSourcePlugin");
  					const ChunkPrefetchPreloadPlugin = require("./prefetch/ChunkPrefetchPreloadPlugin");
  					new JsonpTemplatePlugin().apply(compiler);
  					new FetchCompileWasmPlugin({
  						mangleImports: options.optimization.mangleWasmImports
  					}).apply(compiler);
  					new FetchCompileAsyncWasmPlugin().apply(compiler);
  					new NodeSourcePlugin(options.node).apply(compiler);
  					new LoaderTargetPlugin(options.target).apply(compiler);
  					new ChunkPrefetchPreloadPlugin().apply(compiler);
  					break;
  				}
  				case "webworker": {
  					const WebWorkerTemplatePlugin = require("./webworker/WebWorkerTemplatePlugin");
  					const FetchCompileWasmPlugin = require("./web/FetchCompileWasmPlugin");
  					const FetchCompileAsyncWasmPlugin = require("./web/FetchCompileAsyncWasmPlugin");
  					const NodeSourcePlugin = require("./node/NodeSourcePlugin");
  					const StartupChunkDependenciesPlugin = require("./runtime/StartupChunkDependenciesPlugin");
  					new WebWorkerTemplatePlugin().apply(compiler);
  					new FetchCompileWasmPlugin({
  						mangleImports: options.optimization.mangleWasmImports
  					}).apply(compiler);
  					new FetchCompileAsyncWasmPlugin().apply(compiler);
  					new NodeSourcePlugin(options.node).apply(compiler);
  					new LoaderTargetPlugin(options.target).apply(compiler);
  					new StartupChunkDependenciesPlugin({
  						asyncChunkLoading: true
  					}).apply(compiler);
  					break;
  				}
  				case "node":
  				case "async-node": {
  					const NodeTemplatePlugin = require("./node/NodeTemplatePlugin");
  					const ReadFileCompileWasmPlugin = require("./node/ReadFileCompileWasmPlugin");
  					const ReadFileCompileAsyncWasmPlugin = require("./node/ReadFileCompileAsyncWasmPlugin");
  					const NodeTargetPlugin = require("./node/NodeTargetPlugin");
  					const StartupChunkDependenciesPlugin = require("./runtime/StartupChunkDependenciesPlugin");
  					new NodeTemplatePlugin({
  						asyncChunkLoading: options.target === "async-node"
  					}).apply(compiler);
  					new ReadFileCompileWasmPlugin({
  						mangleImports: options.optimization.mangleWasmImports
  					}).apply(compiler);
  					new ReadFileCompileAsyncWasmPlugin().apply(compiler);
  					new NodeTargetPlugin().apply(compiler);
  					new LoaderTargetPlugin("node").apply(compiler);
  					new StartupChunkDependenciesPlugin({
  						asyncChunkLoading: options.target === "async-node"
  					}).apply(compiler);
  					break;
  				}
  				case "node-webkit": {
  					const JsonpTemplatePlugin = require("./web/JsonpTemplatePlugin");
  					const NodeTargetPlugin = require("./node/NodeTargetPlugin");
  					const ExternalsPlugin = require("./ExternalsPlugin");
  					const StartupChunkDependenciesPlugin = require("./runtime/StartupChunkDependenciesPlugin");
  					const ChunkPrefetchPreloadPlugin = require("./prefetch/ChunkPrefetchPreloadPlugin");
  					new JsonpTemplatePlugin().apply(compiler);
  					new NodeTargetPlugin().apply(compiler);
  					new ExternalsPlugin("commonjs", "nw.gui").apply(compiler);
  					new LoaderTargetPlugin(options.target).apply(compiler);
  					new StartupChunkDependenciesPlugin({
  						asyncChunkLoading: true
  					}).apply(compiler);
  					new ChunkPrefetchPreloadPlugin().apply(compiler);
  					break;
  				}
  				case "electron-main": {
  					const NodeTemplatePlugin = require("./node/NodeTemplatePlugin");
  					const NodeTargetPlugin = require("./node/NodeTargetPlugin");
  					const ExternalsPlugin = require("./ExternalsPlugin");
  					const StartupChunkDependenciesPlugin = require("./runtime/StartupChunkDependenciesPlugin");
  					new NodeTemplatePlugin({
  						asyncChunkLoading: true
  					}).apply(compiler);
  					new NodeTargetPlugin().apply(compiler);
  					new ExternalsPlugin("commonjs", [
  						"app",
  						"auto-updater",
  						"browser-window",
  						"clipboard",
  						"content-tracing",
  						"crash-reporter",
  						"dialog",
  						"electron",
  						"global-shortcut",
  						"ipc",
  						"ipc-main",
  						"menu",
  						"menu-item",
  						"native-image",
  						"original-fs",
  						"power-monitor",
  						"power-save-blocker",
  						"protocol",
  						"screen",
  						"session",
  						"shell",
  						"tray",
  						"web-contents"
  					]).apply(compiler);
  					new LoaderTargetPlugin(options.target).apply(compiler);
  					new StartupChunkDependenciesPlugin({
  						asyncChunkLoading: true
  					}).apply(compiler);
  					break;
  				}
  				case "electron-renderer":
  				case "electron-preload": {
  					const FetchCompileWasmPlugin = require("./web/FetchCompileWasmPlugin");
  					const FetchCompileAsyncWasmPlugin = require("./web/FetchCompileAsyncWasmPlugin");
  					const NodeTargetPlugin = require("./node/NodeTargetPlugin");
  					const ExternalsPlugin = require("./ExternalsPlugin");
  					const ChunkPrefetchPreloadPlugin = require("./prefetch/ChunkPrefetchPreloadPlugin");
  					if (options.target === "electron-renderer") {
  						const JsonpTemplatePlugin = require("./web/JsonpTemplatePlugin");
  						new JsonpTemplatePlugin().apply(compiler);
  					} else if (options.target === "electron-preload") {
  						const NodeTemplatePlugin = require("./node/NodeTemplatePlugin");
  						new NodeTemplatePlugin({
  							asyncChunkLoading: true
  						}).apply(compiler);
  					}
  					new FetchCompileWasmPlugin({
  						mangleImports: options.optimization.mangleWasmImports
  					}).apply(compiler);
  					new FetchCompileAsyncWasmPlugin().apply(compiler);
  					new NodeTargetPlugin().apply(compiler);
  					new ExternalsPlugin("commonjs", [
  						"clipboard",
  						"crash-reporter",
  						"desktop-capturer",
  						"electron",
  						"ipc",
  						"ipc-renderer",
  						"native-image",
  						"original-fs",
  						"remote",
  						"screen",
  						"shell",
  						"web-frame"
  					]).apply(compiler);
  					new LoaderTargetPlugin(options.target).apply(compiler);
  					new ChunkPrefetchPreloadPlugin().apply(compiler);
  					break;
  				}
  				default:
  					throw new Error("Unsupported target '" + options.target + "'.");
  			}
  		} else {
  			options.target(compiler);
  		}
  
  		if (options.output.enabledLibraryTypes.length > 0) {
  			for (const type of options.output.enabledLibraryTypes) {
  				const EnableLibraryPlugin = require("./library/EnableLibraryPlugin");
  				new EnableLibraryPlugin(type).apply(compiler);
  			}
  		}
  		if (options.externals) {
  			const ExternalsPlugin = require("./ExternalsPlugin");
  			new ExternalsPlugin(options.externalsType, options.externals).apply(
  				compiler
  			);
  		}
  
  		if (options.output.pathinfo) {
  			const ModuleInfoHeaderPlugin = require("./ModuleInfoHeaderPlugin");
  			new ModuleInfoHeaderPlugin().apply(compiler);
  		}
  
  		if (options.devtool) {
  			if (options.devtool.includes("source-map")) {
  				const hidden = options.devtool.includes("hidden");
  				const inline = options.devtool.includes("inline");
  				const evalWrapped = options.devtool.includes("eval");
  				const cheap = options.devtool.includes("cheap");
  				const moduleMaps = options.devtool.includes("module");
  				const noSources = options.devtool.includes("nosources");
  				const Plugin = evalWrapped
  					? require("./EvalSourceMapDevToolPlugin")
  					: require("./SourceMapDevToolPlugin");
  				new Plugin({
  					filename: inline ? null : options.output.sourceMapFilename,
  					moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
  					fallbackModuleFilenameTemplate:
  						options.output.devtoolFallbackModuleFilenameTemplate,
  					append: hidden ? false : undefined,
  					module: moduleMaps ? true : cheap ? false : true,
  					columns: cheap ? false : true,
  					noSources: noSources,
  					namespace: options.output.devtoolNamespace
  				}).apply(compiler);
  			} else if (options.devtool.includes("eval")) {
  				const EvalDevToolModulePlugin = require("./EvalDevToolModulePlugin");
  				new EvalDevToolModulePlugin({
  					moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
  					namespace: options.output.devtoolNamespace
  				}).apply(compiler);
  			}
  		}
  
  		new JavascriptModulesPlugin().apply(compiler);
  		new JsonModulesPlugin().apply(compiler);
  
  		if (!options.experiments.outputModule) {
  			if (options.output.module) {
  				throw new Error(
  					"'output.module: true' is only allowed when 'experiments.outputModule' is enabled"
  				);
  			}
  			if (options.output.enabledLibraryTypes.includes("module")) {
  				throw new Error(
  					"library type \"module\" is only allowed when 'experiments.outputModule' is enabled"
  				);
  			}
  			if (options.externalsType === "module") {
  				throw new Error(
  					"'externalsType: \"module\"' is only allowed when 'experiments.outputModule' is enabled"
  				);
  			}
  		}
  
  		if (options.experiments.asset) {
  			const AssetModulesPlugin = require("./asset/AssetModulesPlugin");
  			new AssetModulesPlugin().apply(compiler);
  		}
  
  		if (options.experiments.syncWebAssembly) {
  			const WebAssemblyModulesPlugin = require("./wasm/WebAssemblyModulesPlugin");
  			new WebAssemblyModulesPlugin({
  				mangleImports: options.optimization.mangleWasmImports
  			}).apply(compiler);
  		}
  
  		if (options.experiments.asyncWebAssembly) {
  			const AsyncWebAssemblyModulesPlugin = require("./wasm-async/AsyncWebAssemblyModulesPlugin");
  			new AsyncWebAssemblyModulesPlugin({
  				mangleImports: options.optimization.mangleWasmImports
  			}).apply(compiler);
  		}
  
  		new EntryOptionPlugin().apply(compiler);
  		compiler.hooks.entryOption.call(options.context, options.entry);
  
  		new RuntimePlugin().apply(compiler);
  
  		new InferAsyncModulesPlugin({
  			errorOnImport: options.experiments.importAsync
  				? false
  				: options.experiments.importAwait
  				? "await"
  				: true
  		}).apply(compiler);
  
  		new CompatibilityPlugin().apply(compiler);
  		new HarmonyModulesPlugin({
  			module: options.module,
  			topLevelAwait: options.experiments.topLevelAwait,
  			importAwait: options.experiments.importAwait
  		}).apply(compiler);
  		if (options.amd !== false) {
  			const AMDPlugin = require("./dependencies/AMDPlugin");
  			const RequireJsStuffPlugin = require("./RequireJsStuffPlugin");
  			new AMDPlugin(options.module, options.amd || {}).apply(compiler);
  			new RequireJsStuffPlugin().apply(compiler);
  		}
  		new CommonJsPlugin(options.module).apply(compiler);
  		new LoaderPlugin().apply(compiler);
  		if (options.node !== false) {
  			const NodeStuffPlugin = require("./NodeStuffPlugin");
  			new NodeStuffPlugin(options.node).apply(compiler);
  		}
  		new APIPlugin().apply(compiler);
  		new ExportsInfoApiPlugin().apply(compiler);
  		new ConstPlugin().apply(compiler);
  		new UseStrictPlugin().apply(compiler);
  		new RequireIncludePlugin().apply(compiler);
  		new RequireEnsurePlugin().apply(compiler);
  		new RequireContextPlugin(
  			options.resolve.modules,
  			options.resolve.extensions,
  			options.resolve.mainFiles
  		).apply(compiler);
  		new ImportPlugin(options.module).apply(compiler);
  		new SystemPlugin(options.module).apply(compiler);
  
  		new DefaultStatsFactoryPlugin().apply(compiler);
  		new DefaultStatsPresetPlugin().apply(compiler);
  		new DefaultStatsPrinterPlugin().apply(compiler);
  
  		new FlagUsingEvalPlugin().apply(compiler);
  
  		if (typeof options.mode !== "string") {
  			const WarnNoModeSetPlugin = require("./WarnNoModeSetPlugin");
  			new WarnNoModeSetPlugin().apply(compiler);
  		}
  
  		const EnsureChunkConditionsPlugin = require("./optimize/EnsureChunkConditionsPlugin");
  		new EnsureChunkConditionsPlugin().apply(compiler);
  		if (options.optimization.removeAvailableModules) {
  			const RemoveParentModulesPlugin = require("./optimize/RemoveParentModulesPlugin");
  			new RemoveParentModulesPlugin().apply(compiler);
  		}
  		if (options.optimization.removeEmptyChunks) {
  			const RemoveEmptyChunksPlugin = require("./optimize/RemoveEmptyChunksPlugin");
  			new RemoveEmptyChunksPlugin().apply(compiler);
  		}
  		if (options.optimization.mergeDuplicateChunks) {
  			const MergeDuplicateChunksPlugin = require("./optimize/MergeDuplicateChunksPlugin");
  			new MergeDuplicateChunksPlugin().apply(compiler);
  		}
  		if (options.optimization.flagIncludedChunks) {
  			const FlagIncludedChunksPlugin = require("./optimize/FlagIncludedChunksPlugin");
  			new FlagIncludedChunksPlugin().apply(compiler);
  		}
  		if (options.optimization.sideEffects) {
  			const SideEffectsFlagPlugin = require("./optimize/SideEffectsFlagPlugin");
  			new SideEffectsFlagPlugin().apply(compiler);
  		}
  		if (options.optimization.providedExports) {
  			const FlagDependencyExportsPlugin = require("./FlagDependencyExportsPlugin");
  			new FlagDependencyExportsPlugin().apply(compiler);
  		}
  		if (options.optimization.usedExports) {
  			const FlagDependencyUsagePlugin = require("./FlagDependencyUsagePlugin");
  			new FlagDependencyUsagePlugin().apply(compiler);
  		}
  		if (options.optimization.innerGraph) {
  			const InnerGraphPlugin = require("./optimize/InnerGraphPlugin");
  			new InnerGraphPlugin().apply(compiler);
  		}
  		if (options.optimization.mangleExports) {
  			const MangleExportsPlugin = require("./optimize/MangleExportsPlugin");
  			new MangleExportsPlugin().apply(compiler);
  		}
  		if (options.optimization.concatenateModules) {
  			const ModuleConcatenationPlugin = require("./optimize/ModuleConcatenationPlugin");
  			new ModuleConcatenationPlugin().apply(compiler);
  		}
  		if (options.optimization.splitChunks) {
  			const SplitChunksPlugin = require("./optimize/SplitChunksPlugin");
  			new SplitChunksPlugin(options.optimization.splitChunks).apply(compiler);
  		}
  		if (options.optimization.runtimeChunk) {
  			const RuntimeChunkPlugin = require("./optimize/RuntimeChunkPlugin");
  			new RuntimeChunkPlugin(options.optimization.runtimeChunk).apply(compiler);
  		}
  		if (options.optimization.noEmitOnErrors) {
  			const NoEmitOnErrorsPlugin = require("./NoEmitOnErrorsPlugin");
  			new NoEmitOnErrorsPlugin().apply(compiler);
  		}
  		if (options.optimization.checkWasmTypes) {
  			const WasmFinalizeExportsPlugin = require("./wasm/WasmFinalizeExportsPlugin");
  			new WasmFinalizeExportsPlugin().apply(compiler);
  		}
  		const moduleIds = options.optimization.moduleIds;
  		if (moduleIds) {
  			switch (moduleIds) {
  				case "natural": {
  					const NaturalModuleIdsPlugin = require("./ids/NaturalModuleIdsPlugin");
  					new NaturalModuleIdsPlugin().apply(compiler);
  					break;
  				}
  				case "named": {
  					const NamedModuleIdsPlugin = require("./ids/NamedModuleIdsPlugin");
  					new NamedModuleIdsPlugin().apply(compiler);
  					break;
  				}
  				case "hashed": {
  					const WarnDeprecatedOptionPlugin = require("./WarnDeprecatedOptionPlugin");
  					const HashedModuleIdsPlugin = require("./ids/HashedModuleIdsPlugin");
  					new WarnDeprecatedOptionPlugin(
  						"optimization.moduleIds",
  						"hashed",
  						"deterministic"
  					).apply(compiler);
  					new HashedModuleIdsPlugin().apply(compiler);
  					break;
  				}
  				case "deterministic": {
  					const DeterministicModuleIdsPlugin = require("./ids/DeterministicModuleIdsPlugin");
  					new DeterministicModuleIdsPlugin().apply(compiler);
  					break;
  				}
  				case "size": {
  					const OccurrenceModuleIdsPlugin = require("./ids/OccurrenceModuleIdsPlugin");
  					new OccurrenceModuleIdsPlugin({
  						prioritiseInitial: true
  					}).apply(compiler);
  					break;
  				}
  				default:
  					throw new Error(
  						`webpack bug: moduleIds: ${moduleIds} is not implemented`
  					);
  			}
  		}
  		const chunkIds = options.optimization.chunkIds;
  		if (chunkIds) {
  			switch (chunkIds) {
  				case "natural": {
  					const NaturalChunkIdsPlugin = require("./ids/NaturalChunkIdsPlugin");
  					new NaturalChunkIdsPlugin().apply(compiler);
  					break;
  				}
  				case "named": {
  					const NamedChunkIdsPlugin = require("./ids/NamedChunkIdsPlugin");
  					new NamedChunkIdsPlugin().apply(compiler);
  					break;
  				}
  				case "deterministic": {
  					const DeterministicChunkIdsPlugin = require("./ids/DeterministicChunkIdsPlugin");
  					new DeterministicChunkIdsPlugin().apply(compiler);
  					break;
  				}
  				case "size": {
  					const OccurrenceChunkIdsPlugin = require("./ids/OccurrenceChunkIdsPlugin");
  					new OccurrenceChunkIdsPlugin({
  						prioritiseInitial: true
  					}).apply(compiler);
  					break;
  				}
  				case "total-size": {
  					const OccurrenceChunkIdsPlugin = require("./ids/OccurrenceChunkIdsPlugin");
  					new OccurrenceChunkIdsPlugin({
  						prioritiseInitial: false
  					}).apply(compiler);
  					break;
  				}
  				default:
  					throw new Error(
  						`webpack bug: chunkIds: ${chunkIds} is not implemented`
  					);
  			}
  		}
  		if (options.optimization.nodeEnv) {
  			const DefinePlugin = require("./DefinePlugin");
  			new DefinePlugin({
  				"process.env.NODE_ENV": JSON.stringify(options.optimization.nodeEnv)
  			}).apply(compiler);
  		}
  		if (options.optimization.minimize) {
  			for (const minimizer of options.optimization.minimizer) {
  				if (typeof minimizer === "function") {
  					minimizer.call(compiler, compiler);
  				} else {
  					minimizer.apply(compiler);
  				}
  			}
  		}
  
  		if (options.performance) {
  			const SizeLimitsPlugin = require("./performance/SizeLimitsPlugin");
  			new SizeLimitsPlugin(options.performance).apply(compiler);
  		}
  
  		new TemplatedPathPlugin().apply(compiler);
  
  		new RecordIdsPlugin({
  			portableIds: options.optimization.portableRecords
  		}).apply(compiler);
  
  		new WarnCaseSensitiveModulesPlugin().apply(compiler);
  
  		if (options.cache && typeof options.cache === "object") {
  			const cacheOptions = options.cache;
  			const AddManagedPathsPlugin = require("./cache/AddManagedPathsPlugin");
  			new AddManagedPathsPlugin(
  				cacheOptions.managedPaths,
  				cacheOptions.immutablePaths
  			).apply(compiler);
  			switch (cacheOptions.type) {
  				case "memory": {
  					const MemoryCachePlugin = require("./cache/MemoryCachePlugin");
  					new MemoryCachePlugin().apply(compiler);
  					break;
  				}
  				case "filesystem": {
  					const AddBuildDependenciesPlugin = require("./cache/AddBuildDependenciesPlugin");
  					for (const key in cacheOptions.buildDependencies) {
  						const list = cacheOptions.buildDependencies[key];
  						new AddBuildDependenciesPlugin(list).apply(compiler);
  					}
  					const MemoryCachePlugin = require("./cache/MemoryCachePlugin");
  					new MemoryCachePlugin().apply(compiler);
  					switch (cacheOptions.store) {
  						case "pack": {
  							const IdleFileCachePlugin = require("./cache/IdleFileCachePlugin");
  							const PackFileCacheStrategy = require("./cache/PackFileCacheStrategy");
  							new IdleFileCachePlugin(
  								new PackFileCacheStrategy({
  									fs: compiler.intermediateFileSystem,
  									context: options.context,
  									cacheLocation: cacheOptions.cacheLocation,
  									version: cacheOptions.version,
  									logger: compiler.getInfrastructureLogger(
  										"webpack.cache.PackFileCacheStrategy"
  									),
  									managedPaths: cacheOptions.managedPaths,
  									immutablePaths: cacheOptions.immutablePaths
  								}),
  								cacheOptions.idleTimeout,
  								cacheOptions.idleTimeoutForInitialStore
  							).apply(compiler);
  							break;
  						}
  						default:
  							throw new Error("Unhandled value for cache.store");
  					}
  					break;
  				}
  				default:
  					// @ts-ignore never is expected here
  					throw new Error(`Unknown cache type ${options.cache.type}`);
  			}
  		}
  		new ResolverCachePlugin().apply(compiler);
  
  		compiler.hooks.afterPlugins.call(compiler);
  		if (!compiler.inputFileSystem) {
  			throw new Error("No input filesystem provided");
  		}
  		compiler.resolverFactory.hooks.resolveOptions
  			.for("normal")
  			.tap("WebpackOptionsApply", resolveOptions => {
  				return {
  					fileSystem: compiler.inputFileSystem,
  					...cachedCleverMerge(options.resolve, resolveOptions)
  				};
  			});
  		compiler.resolverFactory.hooks.resolveOptions
  			.for("context")
  			.tap("WebpackOptionsApply", resolveOptions => {
  				return {
  					fileSystem: compiler.inputFileSystem,
  					resolveToContext: true,
  					...cachedCleverMerge(options.resolve, resolveOptions)
  				};
  			});
  		compiler.resolverFactory.hooks.resolveOptions
  			.for("loader")
  			.tap("WebpackOptionsApply", resolveOptions => {
  				return {
  					fileSystem: compiler.inputFileSystem,
  					...cachedCleverMerge(options.resolveLoader, resolveOptions)
  				};
  			});
  		compiler.hooks.afterResolvers.call(compiler);
  		return options;
  	}
  }
  
  module.exports = WebpackOptionsApply;
  