@rspack/core 0.5.8 → 0.5.9

package/dist/Chunk.d.ts

@@ -1,5 +1,6 @@
 import { type JsChunk, type JsCompilation } from "@rspack/binding";
 import { ChunkGroup } from "./ChunkGroup";
+import { Compilation } from ".";
 export declare class Chunk {
     #private;
     name?: string;
@@ -15,6 +16,7 @@ export declare class Chunk {
     renderedHash?: string;
     chunkReasons: Array<string>;
     auxiliaryFiles: Array<string>;
+    static __from_binding(chunk: JsChunk, compilation: Compilation): Chunk;
     static __from_binding(chunk: JsChunk, compilation: JsCompilation): Chunk;
     constructor(chunk: JsChunk, compilation: JsCompilation);
     isOnlyInitial(): boolean;

package/dist/Chunk.js

@@ -16,8 +16,12 @@ exports.Chunk = void 0;
 const binding_1 = require("@rspack/binding");
 const ChunkGroup_1 = require("./ChunkGroup");
 const comparators_1 = require("./util/comparators");
+const _1 = require(".");
 class Chunk {
     static __from_binding(chunk, compilation) {
+        if (compilation instanceof _1.Compilation) {
+            return new Chunk(chunk, compilation.__internal_getInner());
+        }
         return new Chunk(chunk, compilation);
     }
     constructor(chunk, compilation) {

package/dist/Compilation.d.ts

@@ -10,8 +10,8 @@
  */
 import * as tapable from "tapable";
 import { Source } from "webpack-sources";
-import type { ExternalObject, JsAssetInfo, JsChunk, JsCompatSource, JsCompilation, JsModule, JsRuntimeModule, JsStatsChunk, JsStatsError, PathData } from "@rspack/binding";
-import { RspackOptionsNormalized, StatsOptions, OutputNormalized, StatsValue, RspackPluginInstance } from "./config";
+import type { ExternalObject, JsAssetInfo, JsCompatSource, JsCompilation, JsModule, JsRuntimeModule, JsStatsChunk, JsStatsError, PathData } from "@rspack/binding";
+import { RspackOptionsNormalized, StatsOptions, OutputNormalized, StatsValue, RspackPluginInstance, Filename } from "./config";
 import * as liteTapable from "./lite-tapable";
 import { ContextModuleFactory } from "./ContextModuleFactory";
 import ResolverFactory from "./ResolverFactory";
@@ -21,10 +21,9 @@ import { NormalModuleFactory } from "./NormalModuleFactory";
 import { Stats } from "./Stats";
 import { StatsFactory } from "./stats/StatsFactory";
 import { StatsPrinter } from "./stats/StatsPrinter";
-import { NormalizedJsModule } from "./util/normalization";
 import MergeCaller from "./util/MergeCaller";
 import { Chunk } from "./Chunk";
-import { CodeGenerationResult } from "./Module";
+import { CodeGenerationResult, Module } from "./Module";
 import { ChunkGraph } from "./ChunkGraph";
 import { Entrypoint } from "./Entrypoint";
 export type AssetInfo = Partial<JsAssetInfo> & Record<string, any>;
@@ -64,33 +63,33 @@ export declare class Compilation {
     #private;
     hooks: {
         processAssets: liteTapable.AsyncSeriesHook<Assets>;
-        afterProcessAssets: tapable.SyncHook<Assets>;
+        afterProcessAssets: liteTapable.SyncHook<Assets>;
         childCompiler: tapable.SyncHook<[Compiler, string, number]>;
         log: tapable.SyncBailHook<[string, LogEntry], true>;
         additionalAssets: any;
-        optimizeModules: tapable.SyncBailHook<Iterable<JsModule>, void>;
-        afterOptimizeModules: tapable.SyncHook<Iterable<JsModule>, void>;
-        optimizeTree: tapable.AsyncSeriesBailHook<[
+        optimizeModules: liteTapable.SyncBailHook<Iterable<Module>, void>;
+        afterOptimizeModules: liteTapable.SyncHook<Iterable<Module>, void>;
+        optimizeTree: liteTapable.AsyncSeriesHook<[
             Iterable<Chunk>,
-            Iterable<JsModule>
-        ], void>;
-        optimizeChunkModules: tapable.AsyncSeriesBailHook<[
+            Iterable<Module>
+        ]>;
+        optimizeChunkModules: liteTapable.AsyncSeriesBailHook<[
             Iterable<Chunk>,
-            Iterable<JsModule>
+            Iterable<Module>
         ], void>;
-        finishModules: tapable.AsyncSeriesHook<[Iterable<JsModule>], void>;
-        chunkAsset: tapable.SyncHook<[JsChunk, string], void>;
+        finishModules: liteTapable.AsyncSeriesHook<[Iterable<Module>], void>;
+        chunkAsset: liteTapable.SyncHook<[Chunk, string], void>;
         processWarnings: tapable.SyncWaterfallHook<[Error[]]>;
-        succeedModule: tapable.SyncHook<[JsModule], void>;
-        stillValidModule: tapable.SyncHook<[JsModule], void>;
+        succeedModule: liteTapable.SyncHook<[Module], void>;
+        stillValidModule: liteTapable.SyncHook<[Module], void>;
         statsFactory: tapable.SyncHook<[StatsFactory, StatsOptions], void>;
         statsPrinter: tapable.SyncHook<[StatsPrinter, StatsOptions], void>;
-        buildModule: tapable.SyncHook<[NormalizedJsModule]>;
-        executeModule: tapable.SyncHook<[
+        buildModule: liteTapable.SyncHook<[Module]>;
+        executeModule: liteTapable.SyncHook<[
             ExecuteModuleArgument,
             ExecuteModuleContext
         ]>;
-        runtimeModule: tapable.SyncHook<[JsRuntimeModule, JsChunk], void>;
+        runtimeModule: liteTapable.SyncHook<[JsRuntimeModule, Chunk], void>;
     };
     options: RspackOptionsNormalized;
     outputOptions: OutputNormalized;
@@ -197,10 +196,10 @@ export declare class Compilation {
             };
         };
     };
-    getPath(filename: string, data?: PathData): string;
-    getPathWithInfo(filename: string, data?: PathData): import("@rspack/binding").PathWithInfo;
-    getAssetPath(filename: string, data?: PathData): string;
-    getAssetPathWithInfo(filename: string, data?: PathData): import("@rspack/binding").PathWithInfo;
+    getPath(filename: Filename, data?: PathData): string;
+    getPathWithInfo(filename: Filename, data?: PathData): import("@rspack/binding").PathWithInfo;
+    getAssetPath(filename: Filename, data?: PathData): string;
+    getAssetPathWithInfo(filename: Filename, data?: PathData): import("@rspack/binding").PathWithInfo;
     getLogger(name: string | (() => string)): Logger;
     fileDependencies: {
         [Symbol.iterator](): Generator<string, void, unknown>;
@@ -226,7 +225,7 @@ export declare class Compilation {
         add: (dep: string) => void;
         addAll: (deps: Iterable<string>) => void;
     };
-    get modules(): NormalizedJsModule[];
+    get modules(): Module[];
     get chunks(): Chunk[];
     /**
      * Get the named chunks.
@@ -266,8 +265,8 @@ export declare class Compilation {
     __internal__getChunks(): Chunk[];
     getStats(): Stats;
     createChildCompiler(name: string, outputOptions: OutputNormalized, plugins: RspackPluginInstance[]): Compiler;
-    _rebuildModuleCaller: MergeCaller<[string, (err: any, m: JsModule) => void]>;
-    rebuildModule(m: JsModule, f: (err: any, m: JsModule) => void): void;
+    _rebuildModuleCaller: MergeCaller<[string, (err: Error, m: Module) => void]>;
+    rebuildModule(m: Module, f: (err: Error, m: Module) => void): void;
     /**
      * Get the `Source` of a given asset filename.
      *

package/dist/Compilation.js

@@ -59,10 +59,10 @@ const StatsPrinter_1 = require("./stats/StatsPrinter");
 const util_1 = require("./util");
 const createSource_1 = require("./util/createSource");
 const fake_1 = require("./util/fake");
-const normalization_1 = require("./util/normalization");
 const MergeCaller_1 = __importDefault(require("./util/MergeCaller"));
 const memoize_1 = require("./util/memoize");
 const Chunk_1 = require("./Chunk");
+const Module_1 = require("./Module");
 const ChunkGraph_1 = require("./ChunkGraph");
 const Entrypoint_1 = require("./Entrypoint");
 class Compilation {
@@ -85,7 +85,7 @@ class Compilation {
                 for (const [id, callback] of args) {
                     const m = modules.find(item => item.moduleIdentifier === id);
                     if (m) {
-                        callback(err, m);
+                        callback(err, Module_1.Module.__from_binding(m));
                     }
                     else {
                         callback(err || new Error("module no found"), null);
@@ -129,7 +129,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
         };
         this.hooks = {
             processAssets: processAssetsHook,
-            afterProcessAssets: new tapable.SyncHook(["assets"]),
+            afterProcessAssets: new liteTapable.SyncHook(["assets"]),
             /** @deprecated */
             additionalAssets: createProcessAssetsHook("additionalAssets", Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL, () => []),
             childCompiler: new tapable.SyncHook([
@@ -138,23 +138,23 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 "compilerIndex"
             ]),
             log: new tapable.SyncBailHook(["origin", "logEntry"]),
-            optimizeModules: new tapable.SyncBailHook(["modules"]),
-            afterOptimizeModules: new tapable.SyncBailHook(["modules"]),
-            optimizeTree: new tapable.AsyncSeriesBailHook(["chunks", "modules"]),
-            optimizeChunkModules: new tapable.AsyncSeriesBailHook([
+            optimizeModules: new liteTapable.SyncBailHook(["modules"]),
+            afterOptimizeModules: new liteTapable.SyncBailHook(["modules"]),
+            optimizeTree: new liteTapable.AsyncSeriesHook(["chunks", "modules"]),
+            optimizeChunkModules: new liteTapable.AsyncSeriesBailHook([
                 "chunks",
                 "modules"
             ]),
-            finishModules: new tapable.AsyncSeriesHook(["modules"]),
-            chunkAsset: new tapable.SyncHook(["chunk", "filename"]),
+            finishModules: new liteTapable.AsyncSeriesHook(["modules"]),
+            chunkAsset: new liteTapable.SyncHook(["chunk", "filename"]),
             processWarnings: new tapable.SyncWaterfallHook(["warnings"]),
-            succeedModule: new tapable.SyncHook(["module"]),
-            stillValidModule: new tapable.SyncHook(["module"]),
+            succeedModule: new liteTapable.SyncHook(["module"]),
+            stillValidModule: new liteTapable.SyncHook(["module"]),
             statsFactory: new tapable.SyncHook(["statsFactory", "options"]),
             statsPrinter: new tapable.SyncHook(["statsPrinter", "options"]),
-            buildModule: new tapable.SyncHook(["module"]),
-            executeModule: new tapable.SyncHook(["options", "context"]),
-            runtimeModule: new tapable.SyncHook(["module", "chunk"])
+            buildModule: new liteTapable.SyncHook(["module"]),
+            executeModule: new liteTapable.SyncHook(["options", "context"]),
+            runtimeModule: new liteTapable.SyncHook(["module", "chunk"])
         };
         this.compiler = compiler;
         this.resolverFactory = compiler.resolverFactory;
@@ -549,7 +549,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
     }
     get modules() {
         return (0, memoize_1.memoizeValue)(() => {
-            return this.__internal__getModules().map(item => (0, normalization_1.normalizeJsModule)(item));
+            return this.__internal__getModules().map(item => Module_1.Module.__from_binding(item));
         });
     }
     // FIXME: This is not aligned with Webpack.
@@ -644,7 +644,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
         return this.compiler.createChildCompiler(this, name, idx, outputOptions, plugins);
     }
     rebuildModule(m, f) {
-        this._rebuildModuleCaller.push([m.moduleIdentifier, f]);
+        this._rebuildModuleCaller.push([m.identifier(), f]);
     }
     /**
      * Get the `Source` of a given asset filename.

package/dist/Compiler.d.ts

@@ -26,6 +26,14 @@ import { NormalModuleFactory } from "./NormalModuleFactory";
 import { WatchFileSystem } from "./util/fs";
 import { Watching } from "./Watching";
 import { FileSystemInfoEntry } from "./FileSystemInfo";
+import { Source } from "webpack-sources";
+export interface AssetEmittedInfo {
+    content: Buffer;
+    source: Source;
+    outputPath: string;
+    targetPath: string;
+    compilation: Compilation;
+}
 declare class Compiler {
     #private;
     webpack: typeof import("./rspack").rspack & typeof import("./exports") & {
@@ -71,9 +79,9 @@ declare class Compiler {
         infrastructureLog: tapable.SyncBailHook<[string, string, any[]], true>;
         beforeRun: tapable.AsyncSeriesHook<[Compiler]>;
         run: tapable.AsyncSeriesHook<[Compiler]>;
-        emit: tapable.AsyncSeriesHook<[Compilation]>;
-        assetEmitted: tapable.AsyncSeriesHook<[string, any]>;
-        afterEmit: tapable.AsyncSeriesHook<[Compilation]>;
+        emit: liteTapable.AsyncSeriesHook<[Compilation]>;
+        assetEmitted: liteTapable.AsyncSeriesHook<[string, AssetEmittedInfo]>;
+        afterEmit: liteTapable.AsyncSeriesHook<[Compilation]>;
         failed: tapable.SyncHook<[Error]>;
         shutdown: tapable.AsyncSeriesHook<[]>;
         watchRun: tapable.AsyncSeriesHook<[Compiler]>;
@@ -85,8 +93,7 @@ declare class Compiler {
         make: liteTapable.AsyncParallelHook<[Compilation]>;
         beforeCompile: tapable.AsyncSeriesHook<[CompilationParams]>;
         afterCompile: tapable.AsyncSeriesHook<[Compilation]>;
-        finishModules: tapable.AsyncSeriesHook<[any]>;
-        finishMake: tapable.AsyncSeriesHook<[Compilation]>;
+        finishMake: liteTapable.AsyncSeriesHook<[Compilation]>;
         entryOption: tapable.SyncBailHook<[string, EntryNormalized], any>;
     };
     options: RspackOptionsNormalized;

package/dist/Compiler.js

@@ -36,7 +36,7 @@ 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_moduleExecutionResultsMap, _Compiler_getInstance, _Compiler_updateDisabledHooks, _Compiler_afterProcessAssets, _Compiler_afterResolve, _Compiler_contextModuleFactoryBeforeResolve, _Compiler_contextModuleFactoryAfterResolve, _Compiler_normalModuleFactoryCreateModule, _Compiler_normalModuleFactoryResolveForScheme, _Compiler_optimizeChunkModules, _Compiler_optimizeTree, _Compiler_decorateUpdateDisabledHooks, _Compiler_createRegisterTaps, _Compiler_createCompilation, _Compiler_resetThisCompilation, _Compiler_newCompilationParams;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Compiler = void 0;
 const index_1 = require("./index");
@@ -44,12 +44,12 @@ 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"));
@@ -59,7 +59,6 @@ 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 +68,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);
@@ -98,9 +98,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,8 +126,7 @@ 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;
@@ -503,27 +502,11 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
     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)
+        contextModuleFactoryAfterResolve: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_contextModuleFactoryAfterResolve).bind(this)
     }, {
         registerCompilerThisCompilationTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.hooks.thisCompilation, queried => (native) => {
             if (this.compilation === undefined) {
@@ -533,8 +516,82 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
         }),
         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)),
+        registerCompilerFinishMakeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.hooks.finishMake, 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)),
+        registerCompilerEmitTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.hooks.emit, queried => async () => await queried.promise(this.compilation)),
+        registerCompilerAfterEmitTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.hooks.afterEmit, queried => async () => await queried.promise(this.compilation)),
+        registerCompilerAssetEmittedTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => 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, () => 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, () => this.compilation.hooks.buildModule, queired => (m) => queired.call(Module_1.Module.__from_binding(m))),
+        registerCompilationStillValidModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilation.hooks.stillValidModule, queired => (m) => queired.call(Module_1.Module.__from_binding(m))),
+        registerCompilationSucceedModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilation.hooks.succeedModule, queired => (m) => queired.call(Module_1.Module.__from_binding(m))),
+        registerCompilationExecuteModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => 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, () => this.compilation.hooks.finishModules, queried => async () => await queried.promise(this.compilation.modules)),
+        registerCompilationOptimizeModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilation.hooks.optimizeModules, queried => () => queried.call(this.compilation.modules)),
+        registerCompilationAfterOptimizeModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilation.hooks.afterOptimizeModules, queried => () => queried.call(this.compilation.modules)),
+        registerCompilationOptimizeTreeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => 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, () => 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, () => 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, () => this.compilation.hooks.processAssets, queried => async () => await queried.promise(this.compilation.assets)),
+        registerCompilationAfterProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilation.hooks.afterProcessAssets, queried => () => queried.call(this.compilation.assets)),
         registerNormalModuleFactoryBeforeResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilationParams.normalModuleFactory.hooks.beforeResolve, queried => async (resolveData) => {
             const normalizedResolveData = {
                 request: resolveData.request,
@@ -554,27 +611,11 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
     var _a, _b, _c, _d, _e;
     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
+        normalModuleFactoryResolveForScheme: (_e = this.compilationParams) === null || _e === void 0 ? void 0 : _e.normalModuleFactory.hooks.resolveForScheme
     };
     for (const [name, hook] of Object.entries(hookMap)) {
         if (typeof hook !== "undefined" &&
@@ -596,13 +637,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);
@@ -646,95 +680,6 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
 }, _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];

package/dist/Module.d.ts

@@ -1,10 +1,13 @@
 import { JsCodegenerationResult, JsCodegenerationResults, JsModule } from "@rspack/binding";
+import { Source } from "webpack-sources";
 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/builtin-plugin/ArrayPushCallbackChunkFormatPlugin.d.ts

@@ -3,7 +3,7 @@ export declare const ArrayPushCallbackChunkFormatPlugin: {
     new (): {
         name: BuiltinPluginName;
         _options: void;
-        affectedHooks: "emit" | "done" | "compilation" | "make" | "compile" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishModules" | "finishMake" | "entryOption" | undefined;
+        affectedHooks: "make" | "compile" | "emit" | "afterEmit" | "invalid" | "done" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | undefined;
         raw(): import("@rspack/binding").BuiltinPlugin;
         apply(compiler: import("../Compiler").Compiler): void;
     };

package/dist/builtin-plugin/AssetModulesPlugin.d.ts

@@ -3,7 +3,7 @@ export declare const AssetModulesPlugin: {
     new (): {
         name: BuiltinPluginName;
         _options: void;
-        affectedHooks: "emit" | "done" | "compilation" | "make" | "compile" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishModules" | "finishMake" | "entryOption" | undefined;
+        affectedHooks: "make" | "compile" | "emit" | "afterEmit" | "invalid" | "done" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | undefined;
         raw(): import("@rspack/binding").BuiltinPlugin;
         apply(compiler: import("../Compiler").Compiler): void;
     };