@rspack/core 0.5.8 → 0.5.9-canary-6bcb6c4-20240326140146

package/dist/Compiler.js

@@ -36,20 +36,30 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _Compiler_instances, _Compiler_instance, _Compiler_disabledHooks, _Compiler_moduleExecutionResultsMap, _Compiler_getInstance, _Compiler_updateDisabledHooks, _Compiler_finishMake, _Compiler_buildModule, _Compiler_afterProcessAssets, _Compiler_afterResolve, _Compiler_contextModuleFactoryBeforeResolve, _Compiler_contextModuleFactoryAfterResolve, _Compiler_normalModuleFactoryCreateModule, _Compiler_normalModuleFactoryResolveForScheme, _Compiler_optimizeChunkModules, _Compiler_optimizeTree, _Compiler_optimizeModules, _Compiler_afterOptimizeModules, _Compiler_chunkAsset, _Compiler_finishModules, _Compiler_emit, _Compiler_assetEmitted, _Compiler_afterEmit, _Compiler_succeedModule, _Compiler_stillValidModule, _Compiler_runtimeModule, _Compiler_executeModule, _Compiler_decorateUpdateDisabledHooks, _Compiler_createRegisterTaps, _Compiler_createCompilation, _Compiler_resetThisCompilation, _Compiler_newCompilationParams;
+var _Compiler_instances, _Compiler_instance, _Compiler_disabledHooks, _Compiler_nonSkippableRegisters, _Compiler_registers, _Compiler_moduleExecutionResultsMap, _Compiler_getInstance, _Compiler_updateNonSkippableRegisters, _Compiler_updateDisabledHooks, _Compiler_contextModuleFactoryAfterResolve, _Compiler_normalModuleFactoryCreateModule, _Compiler_normalModuleFactoryResolveForScheme, _Compiler_decorateUpdateDisabledHooks, _Compiler_createRegisterTaps, _Compiler_createCompilation, _Compiler_resetThisCompilation, _Compiler_newCompilationParams;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Compiler = void 0;
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/Compiler.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+const binding = __importStar(require("@rspack/binding"));
 const index_1 = require("./index");
 const fs_1 = __importDefault(require("fs"));
 const tapable = __importStar(require("tapable"));
 const liteTapable = __importStar(require("./lite-tapable"));
 const tapable_1 = require("tapable");
+const config_1 = require("./config");
 const RuleSetCompiler_1 = require("./RuleSetCompiler");
 const Stats_1 = require("./Stats");
 const Compilation_1 = require("./Compilation");
 const ContextModuleFactory_1 = require("./ContextModuleFactory");
 const ResolverFactory_1 = __importDefault(require("./ResolverFactory"));
-const config_1 = require("./config");
 const ConcurrentCompilationError_1 = __importDefault(require("./error/ConcurrentCompilationError"));
 const fileSystem_1 = require("./fileSystem");
 const Cache_1 = __importDefault(require("./lib/Cache"));
@@ -58,8 +68,6 @@ const Logger_1 = require("./logging/Logger");
 const NormalModuleFactory_1 = require("./NormalModuleFactory");
 const bindingVersionCheck_1 = require("./util/bindingVersionCheck");
 const Watching_1 = require("./Watching");
-const NormalModule_1 = require("./NormalModule");
-const normalization_1 = require("./util/normalization");
 const builtin_plugin_1 = require("./builtin-plugin");
 const rspackOptionsApply_1 = require("./rspackOptionsApply");
 const defaults_1 = require("./config/defaults");
@@ -69,6 +77,7 @@ const HookWebpackError_1 = require("./lib/HookWebpackError");
 const Module_1 = require("./Module");
 const base_1 = require("./builtin-plugin/base");
 const ExecuteModulePlugin_1 = __importDefault(require("./ExecuteModulePlugin"));
+const Chunk_1 = require("./Chunk");
 class Compiler {
     constructor(context, options) {
         _Compiler_instances.add(this);
@@ -77,6 +86,8 @@ class Compiler {
         // TODO: remove this after remove rebuild on the rust side.
         this.first = true;
         _Compiler_disabledHooks.set(this, void 0);
+        _Compiler_nonSkippableRegisters.set(this, void 0);
+        _Compiler_registers.set(this, void 0);
         _Compiler_moduleExecutionResultsMap.set(this, void 0);
         this.outputFileSystem = fs_1.default;
         this.options = options;
@@ -98,9 +109,9 @@ class Compiler {
             afterDone: new tapable.SyncHook(["stats"]),
             beforeRun: new tapable.AsyncSeriesHook(["compiler"]),
             run: new tapable.AsyncSeriesHook(["compiler"]),
-            emit: new tapable.AsyncSeriesHook(["compilation"]),
-            assetEmitted: new tapable.AsyncSeriesHook(["file", "info"]),
-            afterEmit: new tapable.AsyncSeriesHook(["compilation"]),
+            emit: new liteTapable.AsyncSeriesHook(["compilation"]),
+            assetEmitted: new liteTapable.AsyncSeriesHook(["file", "info"]),
+            afterEmit: new liteTapable.AsyncSeriesHook(["compilation"]),
             thisCompilation: new liteTapable.SyncHook(["compilation", "params"]),
             compilation: new liteTapable.SyncHook([
                 "compilation",
@@ -126,14 +137,15 @@ class Compiler {
             make: new liteTapable.AsyncParallelHook(["compilation"]),
             beforeCompile: new tapable.AsyncSeriesHook(["params"]),
             afterCompile: new tapable.AsyncSeriesHook(["compilation"]),
-            finishMake: new tapable.AsyncSeriesHook(["compilation"]),
-            finishModules: new tapable.AsyncSeriesHook(["modules"]),
+            finishMake: new liteTapable.AsyncSeriesHook(["compilation"]),
             entryOption: new tapable.SyncBailHook(["context", "entry"])
         };
         this.modifiedFiles = undefined;
         this.removedFiles = undefined;
         __classPrivateFieldSet(this, _Compiler_disabledHooks, [], "f");
+        __classPrivateFieldSet(this, _Compiler_nonSkippableRegisters, [], "f");
         __classPrivateFieldSet(this, _Compiler_moduleExecutionResultsMap, new Map(), "f");
+        new builtin_plugin_1.JsLoaderRspackPlugin(this).apply(this);
         new ExecuteModulePlugin_1.default().apply(this);
     }
     /**
@@ -485,7 +497,7 @@ class Compiler {
     }
 }
 exports.Compiler = Compiler;
-_Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Compiler_moduleExecutionResultsMap = new WeakMap(), _Compiler_instances = new WeakSet(), _Compiler_getInstance = function _Compiler_getInstance(callback) {
+_Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Compiler_nonSkippableRegisters = new WeakMap(), _Compiler_registers = new WeakMap(), _Compiler_moduleExecutionResultsMap = new WeakMap(), _Compiler_instances = new WeakSet(), _Compiler_getInstance = function _Compiler_getInstance(callback) {
     const error = (0, bindingVersionCheck_1.checkVersion)();
     if (error) {
         return callback(error);
@@ -502,40 +514,92 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
     options.builtins = (0, builtin_plugin_1.deprecated_resolveBuiltins)(options.builtins, options);
     const rawOptions = (0, config_1.getRawOptions)(options, this);
     const instanceBinding = require("@rspack/binding");
-    __classPrivateFieldSet(this, _Compiler_instance, new instanceBinding.Rspack(rawOptions, this.builtinPlugins, {
-        finishMake: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_finishMake).bind(this),
-        emit: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_emit).bind(this),
-        assetEmitted: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_assetEmitted).bind(this),
-        afterEmit: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_afterEmit).bind(this),
-        afterProcessAssets: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_afterProcessAssets).bind(this),
-        optimizeModules: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_optimizeModules).bind(this),
-        afterOptimizeModules: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_afterOptimizeModules).bind(this),
-        optimizeTree: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_optimizeTree).bind(this),
-        optimizeChunkModules: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_optimizeChunkModules).bind(this),
-        finishModules: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_finishModules).bind(this),
-        normalModuleFactoryCreateModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_normalModuleFactoryCreateModule).bind(this),
-        normalModuleFactoryResolveForScheme: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_normalModuleFactoryResolveForScheme).bind(this),
-        chunkAsset: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_chunkAsset).bind(this),
-        afterResolve: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_afterResolve).bind(this),
-        contextModuleFactoryBeforeResolve: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_contextModuleFactoryBeforeResolve).bind(this),
-        contextModuleFactoryAfterResolve: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_contextModuleFactoryAfterResolve).bind(this),
-        succeedModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_succeedModule).bind(this),
-        stillValidModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_stillValidModule).bind(this),
-        buildModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_buildModule).bind(this),
-        executeModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_executeModule).bind(this),
-        runtimeModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_runtimeModule).bind(this)
-    }, {
-        registerCompilerThisCompilationTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.hooks.thisCompilation, queried => (native) => {
+    __classPrivateFieldSet(this, _Compiler_registers, {
+        registerCompilerThisCompilationTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilerThisCompilation, () => this.hooks.thisCompilation, queried => (native) => {
             if (this.compilation === undefined) {
                 __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createCompilation).call(this, native);
             }
             queried.call(this.compilation, this.compilationParams);
         }),
-        registerCompilerCompilationTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.hooks.compilation, queried => () => queried.call(this.compilation, this.compilationParams)),
-        registerCompilerMakeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.hooks.make, queried => async () => await queried.promise(this.compilation)),
-        registerCompilerShouldEmitTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.hooks.shouldEmit, queried => () => queried.call(this.compilation)),
-        registerCompilationProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilation.hooks.processAssets, queried => async () => await queried.promise(this.compilation.assets)),
-        registerNormalModuleFactoryBeforeResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilationParams.normalModuleFactory.hooks.beforeResolve, queried => async (resolveData) => {
+        registerCompilerCompilationTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilerCompilation, () => this.hooks.compilation, queried => () => queried.call(this.compilation, this.compilationParams)),
+        registerCompilerMakeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilerMake, () => this.hooks.make, queried => async () => await queried.promise(this.compilation)),
+        registerCompilerFinishMakeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilerFinishMake, () => this.hooks.finishMake, queried => async () => await queried.promise(this.compilation)),
+        registerCompilerShouldEmitTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilerShouldEmit, () => this.hooks.shouldEmit, queried => () => queried.call(this.compilation)),
+        registerCompilerEmitTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilerEmit, () => this.hooks.emit, queried => async () => await queried.promise(this.compilation)),
+        registerCompilerAfterEmitTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilerAfterEmit, () => this.hooks.afterEmit, queried => async () => await queried.promise(this.compilation)),
+        registerCompilerAssetEmittedTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilerAssetEmitted, () => this.hooks.assetEmitted, queried => async ({ filename, targetPath, outputPath }) => await queried.promise(filename, {
+            compilation: this.compilation,
+            targetPath,
+            outputPath,
+            get source() {
+                var _a;
+                return (_a = this.compilation.getAsset(filename)) === null || _a === void 0 ? void 0 : _a.source;
+            },
+            get content() {
+                var _a;
+                return (_a = this.source) === null || _a === void 0 ? void 0 : _a.buffer();
+            }
+        })),
+        registerCompilationRuntimeModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationRuntimeModule, () => this.compilation.hooks.runtimeModule, queried => ({ module, chunk }) => {
+            var _a, _b;
+            const originSource = (_a = module.source) === null || _a === void 0 ? void 0 : _a.source;
+            queried.call(module, Chunk_1.Chunk.__from_binding(chunk, this.compilation));
+            const newSource = (_b = module.source) === null || _b === void 0 ? void 0 : _b.source;
+            if (newSource && newSource !== originSource) {
+                return module;
+            }
+            return;
+        }),
+        registerCompilationBuildModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationBuildModule, () => this.compilation.hooks.buildModule, queired => (m) => queired.call(Module_1.Module.__from_binding(m))),
+        registerCompilationStillValidModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationStillValidModule, () => this.compilation.hooks.stillValidModule, queired => (m) => queired.call(Module_1.Module.__from_binding(m))),
+        registerCompilationSucceedModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationSucceedModule, () => this.compilation.hooks.succeedModule, queired => (m) => queired.call(Module_1.Module.__from_binding(m))),
+        registerCompilationExecuteModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationExecuteModule, () => this.compilation.hooks.executeModule, queried => ({ entry, id, codegenResults, runtimeModules }) => {
+            const __webpack_require__ = (id) => {
+                const cached = moduleCache[id];
+                if (cached !== undefined) {
+                    if (cached.error)
+                        throw cached.error;
+                    return cached.exports;
+                }
+                var execOptions = {
+                    id,
+                    module: {
+                        id,
+                        exports: {},
+                        loaded: false,
+                        error: undefined
+                    },
+                    require: __webpack_require__
+                };
+                interceptModuleExecution.forEach((handler) => handler(execOptions));
+                const result = codegenResults.map[id]["build time"];
+                const moduleObject = execOptions.module;
+                if (id)
+                    moduleCache[id] = moduleObject;
+                (0, HookWebpackError_1.tryRunOrWebpackError)(() => queried.call({
+                    codeGenerationResult: new Module_1.CodeGenerationResult(result),
+                    moduleObject
+                }, { __webpack_require__ }), "Compilation.hooks.executeModule");
+                moduleObject.loaded = true;
+                return moduleObject.exports;
+            };
+            const moduleCache = (__webpack_require__[RuntimeGlobals_1.RuntimeGlobals.moduleCache.replace(`${RuntimeGlobals_1.RuntimeGlobals.require}.`, "")] = {});
+            const interceptModuleExecution = (__webpack_require__[RuntimeGlobals_1.RuntimeGlobals.interceptModuleExecution.replace(`${RuntimeGlobals_1.RuntimeGlobals.require}.`, "")] = []);
+            for (const runtimeModule of runtimeModules) {
+                __webpack_require__(runtimeModule);
+            }
+            const executeResult = __webpack_require__(entry);
+            __classPrivateFieldGet(this, _Compiler_moduleExecutionResultsMap, "f").set(id, executeResult);
+        }),
+        registerCompilationFinishModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationFinishModules, () => this.compilation.hooks.finishModules, queried => async () => await queried.promise(this.compilation.modules)),
+        registerCompilationOptimizeModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationOptimizeModules, () => this.compilation.hooks.optimizeModules, queried => () => queried.call(this.compilation.modules)),
+        registerCompilationAfterOptimizeModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterOptimizeModules, () => this.compilation.hooks.afterOptimizeModules, queried => () => queried.call(this.compilation.modules)),
+        registerCompilationOptimizeTreeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationOptimizeTree, () => this.compilation.hooks.optimizeTree, queried => async () => await queried.promise(this.compilation.chunks, this.compilation.modules)),
+        registerCompilationOptimizeChunkModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationOptimizeChunkModules, () => this.compilation.hooks.optimizeChunkModules, queried => async () => await queried.promise(this.compilation.chunks, this.compilation.modules)),
+        registerCompilationChunkAssetTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationChunkAsset, () => this.compilation.hooks.chunkAsset, queried => ({ chunk, filename }) => queried.call(Chunk_1.Chunk.__from_binding(chunk, this.compilation), filename)),
+        registerCompilationProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationProcessAssets, () => this.compilation.hooks.processAssets, queried => async () => await queried.promise(this.compilation.assets)),
+        registerCompilationAfterProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterProcessAssets, () => this.compilation.hooks.afterProcessAssets, queried => () => queried.call(this.compilation.assets)),
+        registerNormalModuleFactoryBeforeResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.NormalModuleFactoryBeforeResolve, () => this.compilationParams.normalModuleFactory.hooks.beforeResolve, queried => async (resolveData) => {
             const normalizedResolveData = {
                 request: resolveData.request,
                 context: resolveData.context,
@@ -547,34 +611,59 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
             resolveData.request = normalizedResolveData.request;
             resolveData.context = normalizedResolveData.context;
             return [ret, resolveData];
+        }),
+        registerNormalModuleFactoryAfterResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.NormalModuleFactoryAfterResolve, () => this.compilationParams.normalModuleFactory.hooks.afterResolve, queried => async (arg) => {
+            const data = {
+                request: arg.request,
+                context: arg.context,
+                fileDependencies: arg.fileDependencies,
+                missingDependencies: arg.missingDependencies,
+                contextDependencies: arg.contextDependencies,
+                factoryMeta: arg.factoryMeta,
+                createData: arg.createData
+            };
+            const ret = await queried.promise(data);
+            return [ret, data.createData];
+        }),
+        registerContextModuleFactoryBeforeResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, binding.RegisterJsTapKind.ContextModuleFactoryBeforeResolve, () => this.compilationParams.contextModuleFactory.hooks.beforeResolve, queried => async (arg) => {
+            const data = {
+                request: arg.request,
+                context: arg.context,
+                fileDependencies: [],
+                missingDependencies: [],
+                contextDependencies: []
+            };
+            const ret = await queried.promise(data);
+            return [ret, data];
         })
-    }, (0, fileSystem_1.createThreadsafeNodeFSFromRaw)(this.outputFileSystem)), "f");
+    }, "f");
+    __classPrivateFieldSet(this, _Compiler_instance, new instanceBinding.Rspack(rawOptions, this.builtinPlugins, {
+        normalModuleFactoryCreateModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_normalModuleFactoryCreateModule).bind(this),
+        normalModuleFactoryResolveForScheme: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_normalModuleFactoryResolveForScheme).bind(this),
+        contextModuleFactoryAfterResolve: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_contextModuleFactoryAfterResolve).bind(this)
+    }, __classPrivateFieldGet(this, _Compiler_registers, "f"), (0, fileSystem_1.createThreadsafeNodeFSFromRaw)(this.outputFileSystem)), "f");
     callback(null, __classPrivateFieldGet(this, _Compiler_instance, "f"));
+}, _Compiler_updateNonSkippableRegisters = function _Compiler_updateNonSkippableRegisters() {
+    const kinds = [];
+    for (const { getHook, registerKind } of Object.values(__classPrivateFieldGet(this, _Compiler_registers, "f"))) {
+        const hook = getHook();
+        if (hook.isUsed()) {
+            kinds.push(registerKind);
+        }
+    }
+    if (__classPrivateFieldGet(this, _Compiler_nonSkippableRegisters, "f").join() !== kinds.join()) {
+        __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_getInstance).call(this, (error, instance) => {
+            instance.setNonSkippableRegisters(kinds);
+            __classPrivateFieldSet(this, _Compiler_nonSkippableRegisters, kinds, "f");
+        });
+    }
 }, _Compiler_updateDisabledHooks = function _Compiler_updateDisabledHooks(callback) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c;
     const disabledHooks = [];
     const hookMap = {
-        finishMake: this.hooks.finishMake,
-        emit: this.hooks.emit,
-        assetEmitted: this.hooks.assetEmitted,
-        afterEmit: this.hooks.afterEmit,
-        afterProcessAssets: this.compilation.hooks.afterProcessAssets,
-        optimizeTree: this.compilation.hooks.optimizeTree,
-        finishModules: this.compilation.hooks.finishModules,
-        optimizeModules: this.compilation.hooks.optimizeModules,
-        afterOptimizeModules: this.compilation.hooks.afterOptimizeModules,
-        chunkAsset: this.compilation.hooks.chunkAsset,
-        afterResolve: (_a = this.compilationParams) === null || _a === void 0 ? void 0 : _a.normalModuleFactory.hooks.afterResolve,
-        succeedModule: this.compilation.hooks.succeedModule,
-        stillValidModule: this.compilation.hooks.stillValidModule,
-        buildModule: this.compilation.hooks.buildModule,
-        optimizeChunkModules: this.compilation.hooks.optimizeChunkModules,
-        contextModuleFactoryBeforeResolve: (_b = this.compilationParams) === null || _b === void 0 ? void 0 : _b.contextModuleFactory.hooks.beforeResolve,
-        contextModuleFactoryAfterResolve: (_c = this.compilationParams) === null || _c === void 0 ? void 0 : _c.contextModuleFactory.hooks.afterResolve,
-        normalModuleFactoryCreateModule: (_d = this.compilationParams) === null || _d === void 0 ? void 0 : _d.normalModuleFactory.hooks.createModule,
-        normalModuleFactoryResolveForScheme: (_e = this.compilationParams) === null || _e === void 0 ? void 0 : _e.normalModuleFactory.hooks.resolveForScheme,
-        executeModule: undefined,
-        runtimeModule: this.compilation.hooks.runtimeModule
+        contextModuleFactoryAfterResolve: (_a = this.compilationParams) === null || _a === void 0 ? void 0 : _a.contextModuleFactory.hooks.afterResolve,
+        normalModuleFactoryCreateModule: (_b = this.compilationParams) === null || _b === void 0 ? void 0 : _b.normalModuleFactory.hooks.createModule,
+        normalModuleFactoryResolveForScheme: (_c = this.compilationParams) === null || _c === void 0 ? void 0 : _c.normalModuleFactory.hooks.resolveForScheme
     };
     for (const [name, hook] of Object.entries(hookMap)) {
         if (typeof hook !== "undefined" &&
@@ -596,31 +685,6 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
             __classPrivateFieldSet(this, _Compiler_disabledHooks, disabledHooks, "f");
         });
     }
-}, _Compiler_finishMake = async function _Compiler_finishMake() {
-    await this.hooks.finishMake.promise(this.compilation);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_buildModule = async function _Compiler_buildModule(module) {
-    const normalized = (0, normalization_1.normalizeJsModule)(module);
-    this.compilation.hooks.buildModule.call(normalized);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_afterProcessAssets = async function _Compiler_afterProcessAssets() {
-    await this.compilation.hooks.afterProcessAssets.promise(this.compilation.assets);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_afterResolve = async function _Compiler_afterResolve(resolveData) {
-    let res = await this.compilationParams.normalModuleFactory.hooks.afterResolve.promise(resolveData);
-    NormalModule_1.NormalModule.getCompilationHooks(this.compilation).loader.tap("sideEffectFreePropPlugin", (loaderContext) => {
-        loaderContext._module = {
-            factoryMeta: {
-                sideEffectFree: !!resolveData.factoryMeta.sideEffectFree
-            }
-        };
-    });
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-    return [res, resolveData.createData];
-}, _Compiler_contextModuleFactoryBeforeResolve = async function _Compiler_contextModuleFactoryBeforeResolve(resourceData) {
-    let res = await this.compilationParams.contextModuleFactory.hooks.beforeResolve.promise(resourceData);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-    return res;
 }, _Compiler_contextModuleFactoryAfterResolve = async function _Compiler_contextModuleFactoryAfterResolve(resourceData) {
     let res = await this.compilationParams.contextModuleFactory.hooks.afterResolve.promise(resourceData);
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
@@ -640,101 +704,6 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
         resourceData: input.resourceData,
         stop: stop === true
     };
-}, _Compiler_optimizeChunkModules = async function _Compiler_optimizeChunkModules() {
-    await this.compilation.hooks.optimizeChunkModules.promise(this.compilation.chunks, this.compilation.modules);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_optimizeTree = async function _Compiler_optimizeTree() {
-    await this.compilation.hooks.optimizeTree.promise(this.compilation.chunks, this.compilation.modules);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_optimizeModules = async function _Compiler_optimizeModules() {
-    await this.compilation.hooks.optimizeModules.promise(this.compilation.modules);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_afterOptimizeModules = async function _Compiler_afterOptimizeModules() {
-    await this.compilation.hooks.afterOptimizeModules.promise(this.compilation.modules);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_chunkAsset = function _Compiler_chunkAsset(assetArg) {
-    this.compilation.hooks.chunkAsset.call(assetArg.chunk, assetArg.filename);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_finishModules = async function _Compiler_finishModules() {
-    await this.compilation.hooks.finishModules.promise(this.compilation.modules);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_emit = async function _Compiler_emit() {
-    await this.hooks.emit.promise(this.compilation);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_assetEmitted = async function _Compiler_assetEmitted(args) {
-    const filename = args.filename;
-    const info = {
-        compilation: this.compilation,
-        outputPath: args.outputPath,
-        targetPath: args.targetPath,
-        get source() {
-            var _a;
-            return (_a = this.compilation.getAsset(args.filename)) === null || _a === void 0 ? void 0 : _a.source;
-        },
-        get content() {
-            var _a;
-            return (_a = this.source) === null || _a === void 0 ? void 0 : _a.buffer();
-        }
-    };
-    await this.hooks.assetEmitted.promise(filename, info);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_afterEmit = async function _Compiler_afterEmit() {
-    await this.hooks.afterEmit.promise(this.compilation);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_succeedModule = function _Compiler_succeedModule(module) {
-    this.compilation.hooks.succeedModule.call(module);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_stillValidModule = function _Compiler_stillValidModule(module) {
-    this.compilation.hooks.stillValidModule.call(module);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_runtimeModule = function _Compiler_runtimeModule(arg) {
-    var _a, _b;
-    let { module, chunk } = arg;
-    const originSource = (_a = module.source) === null || _a === void 0 ? void 0 : _a.source;
-    this.compilation.hooks.runtimeModule.call(module, chunk);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-    const newSource = (_b = module.source) === null || _b === void 0 ? void 0 : _b.source;
-    if (newSource && newSource !== originSource) {
-        return module;
-    }
-    return;
-}, _Compiler_executeModule = async function _Compiler_executeModule({ entry, request, options, runtimeModules, codegenResults, id }) {
-    const __webpack_require__ = (id) => {
-        const cached = moduleCache[id];
-        if (cached !== undefined) {
-            if (cached.error)
-                throw cached.error;
-            return cached.exports;
-        }
-        var execOptions = {
-            id,
-            module: {
-                id,
-                exports: {},
-                loaded: false,
-                error: undefined
-            },
-            require: __webpack_require__
-        };
-        interceptModuleExecution.forEach((handler) => handler(execOptions));
-        const result = codegenResults.map[id]["build time"];
-        const moduleObject = execOptions.module;
-        if (id)
-            moduleCache[id] = moduleObject;
-        (0, HookWebpackError_1.tryRunOrWebpackError)(() => this.compilation.hooks.executeModule.call({
-            codeGenerationResult: new Module_1.CodeGenerationResult(result),
-            moduleObject
-        }, { __webpack_require__ }), "Compilation.hooks.executeModule");
-        moduleObject.loaded = true;
-        return moduleObject.exports;
-    };
-    const moduleCache = (__webpack_require__[RuntimeGlobals_1.RuntimeGlobals.moduleCache.replace(`${RuntimeGlobals_1.RuntimeGlobals.require}.`, "")] = {});
-    const interceptModuleExecution = (__webpack_require__[RuntimeGlobals_1.RuntimeGlobals.interceptModuleExecution.replace(`${RuntimeGlobals_1.RuntimeGlobals.require}.`, "")] = []);
-    for (const runtimeModule of runtimeModules) {
-        __webpack_require__(runtimeModule);
-    }
-    const executeResult = __webpack_require__(entry);
-    __classPrivateFieldGet(this, _Compiler_moduleExecutionResultsMap, "f").set(id, executeResult);
 }, _Compiler_decorateUpdateDisabledHooks = function _Compiler_decorateUpdateDisabledHooks(jsTaps) {
     if (jsTaps.length > 0) {
         const last = jsTaps[jsTaps.length - 1];
@@ -744,15 +713,17 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
             if (result && typeof result.then === "function") {
                 return result.then((r) => {
                     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
+                    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateNonSkippableRegisters).call(this);
                     return r;
                 });
             }
             __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
+            __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateNonSkippableRegisters).call(this);
             return result;
         };
     }
-}, _Compiler_createRegisterTaps = function _Compiler_createRegisterTaps(getHook, createTap) {
-    return stages => {
+}, _Compiler_createRegisterTaps = function _Compiler_createRegisterTaps(registerKind, getHook, createTap) {
+    const getTaps = (stages) => {
         const hook = getHook();
         if (!hook.isUsed())
             return [];
@@ -777,6 +748,9 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
         __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_decorateUpdateDisabledHooks).call(this, jsTaps);
         return jsTaps;
     };
+    getTaps.registerKind = registerKind;
+    getTaps.getHook = getHook;
+    return getTaps;
 }, _Compiler_createCompilation = function _Compiler_createCompilation(native) {
     const compilation = new Compilation_1.Compilation(this, native);
     compilation.name = this.name;

package/dist/ContextModuleFactory.d.ts

@@ -1,13 +1,10 @@
 import { AsyncSeriesBailHook } from "tapable";
-type ResolveData = {
-    context?: string;
-    request: string;
-};
+import * as liteTapable from "./lite-tapable";
+import { ResolveData } from "./Module";
 export declare class ContextModuleFactory {
     hooks: {
-        beforeResolve: AsyncSeriesBailHook<[ResolveData], boolean | void>;
-        afterResolve: AsyncSeriesBailHook<[ResolveData], boolean | void>;
+        beforeResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
+        afterResolve: AsyncSeriesBailHook<[ResolveData], false | void>;
     };
     constructor();
 }
-export {};

package/dist/ContextModuleFactory.js

@@ -1,7 +1,31 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextModuleFactory = void 0;
 const tapable_1 = require("tapable");
+const liteTapable = __importStar(require("./lite-tapable"));
 class ContextModuleFactory {
     constructor() {
         this.hooks = {
@@ -18,7 +42,7 @@ class ContextModuleFactory {
             // /** @type {AsyncSeriesBailHook<[ResolveData], Module>} */
             // factorize: new AsyncSeriesBailHook(["resolveData"]),
             // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
-            beforeResolve: new tapable_1.AsyncSeriesBailHook(["resolveData"]),
+            beforeResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
             afterResolve: new tapable_1.AsyncSeriesBailHook(["resolveData"])
             // /** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
             // createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),

package/dist/Module.d.ts

@@ -1,10 +1,32 @@
-import { JsCodegenerationResult, JsCodegenerationResults, JsModule } from "@rspack/binding";
+import { JsCodegenerationResult, JsCodegenerationResults, JsCreateData, JsFactoryMeta, JsModule } from "@rspack/binding";
+import { Source } from "webpack-sources";
+export type ResourceData = {
+    resource: string;
+    path: string;
+    query?: string;
+    fragment?: string;
+};
+export type ResourceDataWithData = ResourceData & {
+    data?: Record<string, any>;
+};
+export type CreateData = Partial<JsCreateData>;
+export type ResolveData = {
+    context: string;
+    request: string;
+    fileDependencies: string[];
+    missingDependencies: string[];
+    contextDependencies: string[];
+    factoryMeta?: JsFactoryMeta;
+    createData?: CreateData;
+};
 export declare class Module {
     #private;
+    _originalSource?: Source;
     static __from_binding(module: JsModule): Module;
     constructor(module: JsModule);
     get context(): string | undefined;
     get resource(): string | undefined;
+    get originalSource(): Source | null;
     identifier(): string;
     nameForCondition(): string | null;
 }

package/dist/Module.js

@@ -13,6 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _Module_inner, _CodeGenerationResult_inner, _CodeGenerationResults_inner;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodeGenerationResults = exports.CodeGenerationResult = exports.Module = void 0;
+const createSource_1 = require("./util/createSource");
 class Module {
     static __from_binding(module) {
         return new Module(module);
@@ -27,6 +28,17 @@ class Module {
     get resource() {
         return __classPrivateFieldGet(this, _Module_inner, "f").resource;
     }
+    get originalSource() {
+        if (this._originalSource)
+            return this._originalSource;
+        if (__classPrivateFieldGet(this, _Module_inner, "f").originalSource) {
+            this._originalSource = (0, createSource_1.createSourceFromRaw)(__classPrivateFieldGet(this, _Module_inner, "f").originalSource);
+            return this._originalSource;
+        }
+        else {
+            return null;
+        }
+    }
     identifier() {
         return __classPrivateFieldGet(this, _Module_inner, "f").moduleIdentifier;
     }

package/dist/NormalModuleFactory.d.ts

@@ -1,22 +1,7 @@
 import { AsyncSeriesBailHook, HookMap } from "tapable";
 import * as liteTapable from "./lite-tapable";
 import type * as binding from "@rspack/binding";
-type ResourceData = {
-    resource: string;
-    path: string;
-    query?: string;
-    fragment?: string;
-};
-type ResourceDataWithData = ResourceData & {
-    data?: Record<string, any>;
-};
-type ResolveData = {
-    context?: string;
-    request: string;
-    fileDependencies: string[];
-    missingDependencies: string[];
-    contextDependencies: string[];
-};
+import { ResolveData, ResourceDataWithData } from "./Module";
 type CreateModuleData = binding.CreateModuleData & {
     settings: {};
     matchResource: string;
@@ -25,7 +10,7 @@ export declare class NormalModuleFactory {
     hooks: {
         resolveForScheme: HookMap<AsyncSeriesBailHook<[ResourceDataWithData], true | void>>;
         beforeResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
-        afterResolve: AsyncSeriesBailHook<[ResolveData], boolean | void>;
+        afterResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
         createModule: AsyncSeriesBailHook<[CreateModuleData, {}], void>;
     };
     constructor();

package/dist/NormalModuleFactory.js

@@ -42,7 +42,7 @@ class NormalModuleFactory {
             // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
             beforeResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
             // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
-            afterResolve: new tapable_1.AsyncSeriesBailHook(["resolveData"]),
+            afterResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
             // /** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
             createModule: new tapable_1.AsyncSeriesBailHook(["createData", "resolveData"])
             // /** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], Module>} */