@rspack-debug/core 1.3.14

package/dist/lib/cache/getLazyHashedEtag.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/cache/getLazyHashedEtag.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type Hash from "../../util/hash";
+export type HashConstructor = typeof Hash;
+export interface HashableObject {
+    updateHash(hash: Hash): void;
+}
+declare class LazyHashedEtag {
+    _obj: HashableObject;
+    _hash?: string;
+    _hashFunction: string | HashConstructor;
+    /**
+     * @param obj object with updateHash method
+     * @param hashFunction the hash function to use
+     */
+    constructor(obj: HashableObject, hashFunction?: string | HashConstructor);
+    /**
+     * @returns hash of object
+     */
+    toString(): string;
+}
+/**
+ * @param obj object with updateHash method
+ * @param ashFunction the hash function to use
+ * @returns etag
+ */
+export declare const getter: (obj: HashableObject, hashFunction?: string | HashConstructor) => LazyHashedEtag;
+export default getter;

package/dist/lib/cache/mergeEtags.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/cache/mergeEtags.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Etag } from "../Cache";
+/**
+ * @param first first
+ * @param second second
+ * @returns result
+ */
+export declare const mergeEtags: (first: Etag, second: Etag) => Etag;
+export default mergeEtags;

package/dist/loader-runner/LoaderLoadingError.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The following code is from
+ * https://github.com/webpack/loader-runner
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/loader-runner/blob/main/LICENSE
+ */
+declare class LoadingLoaderError extends Error {
+    constructor(message: string);
+}
+export default LoadingLoaderError;

package/dist/loader-runner/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/loader-runner
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/loader-runner/blob/main/LICENSE
+ */
+import { type JsLoaderContext, type JsLoaderItem } from "@rspack/binding";
+import type { Compiler } from "../Compiler";
+export declare class LoaderObject {
+    request: string;
+    path: string;
+    query: string;
+    fragment: string;
+    options?: string | object;
+    ident: string;
+    normal?: Function;
+    pitch?: Function;
+    raw?: boolean;
+    type?: "module" | "commonjs";
+    parallel?: boolean;
+    /**
+     * @internal This field is rspack internal. Do not edit.
+     */
+    loaderItem: JsLoaderItem;
+    constructor(loaderItem: JsLoaderItem, compiler: Compiler);
+    get pitchExecuted(): boolean;
+    set pitchExecuted(value: boolean);
+    get normalExecuted(): boolean;
+    set normalExecuted(value: boolean);
+    set noPitch(value: boolean);
+    shouldYield(): boolean;
+    static __from_binding(loaderItem: JsLoaderItem, compiler: Compiler): LoaderObject;
+    static __to_binding(loader: LoaderObject): JsLoaderItem;
+}
+export declare function runLoaders(compiler: Compiler, context: JsLoaderContext): Promise<JsLoaderContext>;
+export declare function parsePathQueryFragment(str: string): {
+    path: string;
+    query: string;
+    fragment: string;
+};

package/dist/loader-runner/loadLoader.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The following code is from
+ * https://github.com/webpack/loader-runner
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/loader-runner/blob/main/LICENSE
+ */
+import type { LoaderObject } from ".";
+export default function loadLoader(loader: LoaderObject, callback: (err: unknown) => void): void;

package/dist/loader-runner/service.d.ts

@@ -0,0 +1,71 @@
+import type { Tinypool } from "../../compiled/tinypool/dist/index.js" with { "resolution-mode": "import" };
+type RunOptions = Parameters<Tinypool["run"]>[1];
+export interface WorkerResponseMessage {
+    type: "response";
+    id: number;
+    data: any;
+}
+export interface WorkerResponseErrorMessage {
+    type: "response-error";
+    id: number;
+    error: WorkerError;
+}
+interface WorkerDoneMessage {
+    type: "done";
+    data: WorkerArgs;
+}
+interface WorkerDoneErrorMessage {
+    type: "done-error";
+    error: WorkerError;
+}
+export interface WorkerRequestMessage {
+    type: "request";
+    id: number;
+    requestType: RequestType;
+    data: WorkerArgs;
+}
+export interface WorkerRequestSyncMessage {
+    type: "request-sync";
+    id: number;
+    requestType: RequestSyncType;
+    data: WorkerArgs;
+    sharedBuffer: SharedArrayBuffer;
+}
+export type WorkerMessage = WorkerResponseMessage | WorkerDoneMessage | WorkerRequestMessage | WorkerResponseErrorMessage | WorkerDoneErrorMessage | WorkerRequestSyncMessage;
+export declare function isWorkerResponseMessage(message: WorkerMessage): message is WorkerResponseMessage;
+export declare function isWorkerResponseErrorMessage(message: WorkerMessage): message is WorkerResponseErrorMessage;
+export declare enum RequestType {
+    AddDependency = "AddDependency",
+    AddContextDependency = "AddContextDependency",
+    AddMissingDependency = "AddMissingDependency",
+    AddBuildDependency = "AddBuildDependency",
+    GetDependencies = "GetDependencies",
+    GetContextDependencies = "GetContextDependencies",
+    GetMissingDependencies = "GetMissingDependencies",
+    ClearDependencies = "ClearDependencies",
+    Resolve = "Resolve",
+    GetResolve = "GetResolve",
+    GetLogger = "GetLogger",
+    EmitError = "EmitError",
+    EmitWarning = "EmitWarning",
+    EmitFile = "EmitFile",
+    EmitDiagnostic = "EmitDiagnostic",
+    SetCacheable = "SetCacheable",
+    ImportModule = "ImportModule",
+    UpdateLoaderObjects = "UpdateLoaderObjects",
+    CompilationGetPath = "CompilationGetPath",
+    CompilationGetPathWithInfo = "CompilationGetPathWithInfo",
+    CompilationGetAssetPath = "CompilationGetAssetPath",
+    CompilationGetAssetPathWithInfo = "CompilationGetAssetPathWithInfo"
+}
+export declare enum RequestSyncType {
+    WaitForPendingRequest = "WaitForPendingRequest"
+}
+export type HandleIncomingRequest = (requestType: RequestType, ...args: any[]) => Promise<any> | any;
+type WorkerArgs = any[];
+export type WorkerError = Error;
+export declare function serializeError(error: unknown): WorkerError;
+export declare const run: (task: any, options: RunOptions & {
+    handleIncomingRequest: HandleIncomingRequest;
+}) => Promise<WorkerArgs>;
+export {};

package/dist/loader-runner/utils.d.ts

@@ -0,0 +1,6 @@
+import type { LoaderObject } from ".";
+import type { LoaderContext } from "../config/adapterRuleUse";
+export declare function convertArgs(args: any[], raw: boolean): void;
+export declare const loadLoader: (loaderObject: LoaderObject) => Promise<void>;
+export declare const runSyncOrAsync: (arg1: Function, arg2: LoaderContext<{}>, arg3: any[]) => Promise<any[]>;
+export declare function extractLoaderName(loaderPath: string, cwd?: string): string;

package/dist/loader-runner/worker.d.ts

@@ -0,0 +1,14 @@
+import { type MessagePort } from "node:worker_threads";
+import { JsLoaderState } from "@rspack/binding";
+import type { LoaderContext } from "../config";
+interface WorkerOptions {
+    loaderContext: LoaderContext;
+    loaderState: JsLoaderState;
+    args: any[];
+    workerData?: {
+        workerPort: MessagePort;
+        workerSyncPort: MessagePort;
+    };
+}
+declare function worker(workerOptions: WorkerOptions): void;
+export default worker;

package/dist/logging/Logger.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/logging/Logger.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+export declare const LogType: Readonly<{
+    error: "error";
+    warn: "warn";
+    info: "info";
+    log: "log";
+    debug: "debug";
+    trace: "trace";
+    group: "group";
+    groupCollapsed: "groupCollapsed";
+    groupEnd: "groupEnd";
+    profile: "profile";
+    profileEnd: "profileEnd";
+    time: "time";
+    clear: "clear";
+    status: "status";
+    cache: "cache";
+}>;
+export declare function getLogTypeBitFlag(type: LogTypeEnum): number;
+export declare function getLogTypesBitFlag(types: LogTypeEnum[]): number;
+export type LogTypeEnum = (typeof LogType)[keyof typeof LogType];
+declare const LOG_SYMBOL: unique symbol;
+declare const TIMERS_SYMBOL: unique symbol;
+declare const TIMERS_AGGREGATES_SYMBOL: unique symbol;
+export type LogFunction = (type: LogTypeEnum, args: any[]) => void;
+export type GetChildLogger = (name: string | (() => string)) => Logger;
+export declare class Logger {
+    getChildLogger: GetChildLogger;
+    [LOG_SYMBOL]: any;
+    [TIMERS_SYMBOL]: any;
+    [TIMERS_AGGREGATES_SYMBOL]: any;
+    constructor(log: LogFunction, getChildLogger: GetChildLogger);
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    debug(...args: string[]): void;
+    assert(assertion: any, ...args: any[]): void;
+    trace(): void;
+    clear(): void;
+    status(...args: any[]): void;
+    group(...args: any[]): void;
+    groupCollapsed(...args: any[]): void;
+    groupEnd(...args: any[]): void;
+    profile(label: any): void;
+    profileEnd(label: any): void;
+    time(label: any): void;
+    timeLog(label: any): void;
+    timeEnd(label: any): void;
+    timeAggregate(label: any): void;
+    timeAggregateEnd(label: any): void;
+}
+export {};

package/dist/logging/createConsoleLogger.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/logging/createConsoleLogger.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { FilterTypes } from "../config";
+import { type LogTypeEnum } from "./Logger";
+export type FilterFunction = (ident: string) => boolean;
+export type LoggerConsole = {
+    clear: () => void;
+    trace: () => void;
+    info: (...args: any[]) => void;
+    log: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    debug?: (...args: any[]) => void;
+    group?: (...args: any[]) => void;
+    groupCollapsed?: (...args: any[]) => void;
+    groupEnd?: (...args: any[]) => void;
+    status?: (...args: any[]) => void;
+    profile?: (...args: any[]) => void;
+    profileEnd?: (...args: any[]) => void;
+    logTime?: (...args: any[]) => void;
+};
+export type LoggerOptions = {
+    level: "none" | "error" | "warn" | "info" | "log" | "verbose" | boolean;
+    debug: FilterTypes | boolean;
+    console: LoggerConsole;
+};
+declare const createConsoleLogger: ({ level, debug, console }: LoggerOptions) => (name: string, type: LogTypeEnum, args: any[]) => void;
+export { createConsoleLogger };

package/dist/logging/truncateArgs.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/logging/truncateArgs.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+/**
+ * @param args items to be truncated
+ * @param maxLength maximum length of args including spaces between
+ * @returns truncated args
+ */
+declare const truncateArgs: (args: any[], maxLength: number) => string[];
+export { truncateArgs };

package/dist/moduleFederationDefaultRuntime.js

@@ -0,0 +1 @@
+var __module_federation_bundler_runtime__,__module_federation_runtime_plugins__,__module_federation_remote_infos__,__module_federation_container_name__,__module_federation_share_strategy__;module.exports=function(){if((__webpack_require__.initializeSharingData||__webpack_require__.initializeExposesData)&&__webpack_require__.federation){var __webpack_require___remotesLoadingData,__webpack_require___remotesLoadingData1,__webpack_require___initializeSharingData,__webpack_require___consumesLoadingData,__webpack_require___consumesLoadingData1,__webpack_require___initializeExposesData,__webpack_require___consumesLoadingData2;const override=(obj,key,value)=>{if(!obj)return;if(obj[key])obj[key]=value};const merge=(obj,key,fn)=>{const value=fn();if(Array.isArray(value)){var _obj,_key;var _;(_=(_obj=obj)[_key=key])!==null&&_!==void 0?_:_obj[_key]=[];obj[key].push(...value)}else if(typeof value==="object"&&value!==null){var _obj1,_key1;var _1;(_1=(_obj1=obj)[_key1=key])!==null&&_1!==void 0?_1:_obj1[_key1]={};Object.assign(obj[key],value)}};const early=(obj,key,initial)=>{var _obj,_key;var _;(_=(_obj=obj)[_key=key])!==null&&_!==void 0?_:_obj[_key]=initial()};var __webpack_require___remotesLoadingData_chunkMapping;const remotesLoadingChunkMapping=(__webpack_require___remotesLoadingData_chunkMapping=(__webpack_require___remotesLoadingData=__webpack_require__.remotesLoadingData)===null||__webpack_require___remotesLoadingData===void 0?void 0:__webpack_require___remotesLoadingData.chunkMapping)!==null&&__webpack_require___remotesLoadingData_chunkMapping!==void 0?__webpack_require___remotesLoadingData_chunkMapping:{};var __webpack_require___remotesLoadingData_moduleIdToRemoteDataMapping;const remotesLoadingModuleIdToRemoteDataMapping=(__webpack_require___remotesLoadingData_moduleIdToRemoteDataMapping=(__webpack_require___remotesLoadingData1=__webpack_require__.remotesLoadingData)===null||__webpack_require___remotesLoadingData1===void 0?void 0:__webpack_require___remotesLoadingData1.moduleIdToRemoteDataMapping)!==null&&__webpack_require___remotesLoadingData_moduleIdToRemoteDataMapping!==void 0?__webpack_require___remotesLoadingData_moduleIdToRemoteDataMapping:{};var __webpack_require___initializeSharingData_scopeToSharingDataMapping;const initializeSharingScopeToInitDataMapping=(__webpack_require___initializeSharingData_scopeToSharingDataMapping=(__webpack_require___initializeSharingData=__webpack_require__.initializeSharingData)===null||__webpack_require___initializeSharingData===void 0?void 0:__webpack_require___initializeSharingData.scopeToSharingDataMapping)!==null&&__webpack_require___initializeSharingData_scopeToSharingDataMapping!==void 0?__webpack_require___initializeSharingData_scopeToSharingDataMapping:{};var __webpack_require___consumesLoadingData_chunkMapping;const consumesLoadingChunkMapping=(__webpack_require___consumesLoadingData_chunkMapping=(__webpack_require___consumesLoadingData=__webpack_require__.consumesLoadingData)===null||__webpack_require___consumesLoadingData===void 0?void 0:__webpack_require___consumesLoadingData.chunkMapping)!==null&&__webpack_require___consumesLoadingData_chunkMapping!==void 0?__webpack_require___consumesLoadingData_chunkMapping:{};var __webpack_require___consumesLoadingData_moduleIdToConsumeDataMapping;const consumesLoadingModuleToConsumeDataMapping=(__webpack_require___consumesLoadingData_moduleIdToConsumeDataMapping=(__webpack_require___consumesLoadingData1=__webpack_require__.consumesLoadingData)===null||__webpack_require___consumesLoadingData1===void 0?void 0:__webpack_require___consumesLoadingData1.moduleIdToConsumeDataMapping)!==null&&__webpack_require___consumesLoadingData_moduleIdToConsumeDataMapping!==void 0?__webpack_require___consumesLoadingData_moduleIdToConsumeDataMapping:{};const consumesLoadinginstalledModules={};const initializeSharingInitPromises=[];const initializeSharingInitTokens={};const containerShareScope=(__webpack_require___initializeExposesData=__webpack_require__.initializeExposesData)===null||__webpack_require___initializeExposesData===void 0?void 0:__webpack_require___initializeExposesData.shareScope;for(const key in __module_federation_bundler_runtime__){__webpack_require__.federation[key]=__module_federation_bundler_runtime__[key]}early(__webpack_require__.federation,"consumesLoadingModuleToHandlerMapping",()=>{const consumesLoadingModuleToHandlerMapping={};for(let[moduleId,data]of Object.entries(consumesLoadingModuleToConsumeDataMapping)){consumesLoadingModuleToHandlerMapping[moduleId]={getter:data.fallback,shareInfo:{shareConfig:{fixedDependencies:false,requiredVersion:data.requiredVersion,strictVersion:data.strictVersion,singleton:data.singleton,eager:data.eager},scope:[data.shareScope]},shareKey:data.shareKey}}return consumesLoadingModuleToHandlerMapping});early(__webpack_require__.federation,"initOptions",()=>({}));early(__webpack_require__.federation.initOptions,"name",()=>__module_federation_container_name__);early(__webpack_require__.federation.initOptions,"shareStrategy",()=>__module_federation_share_strategy__);early(__webpack_require__.federation.initOptions,"shared",()=>{const shared={};for(let[scope,stages]of Object.entries(initializeSharingScopeToInitDataMapping)){for(let stage of stages){if(typeof stage==="object"&&stage!==null){const{name,version,factory,eager,singleton,requiredVersion,strictVersion}=stage;const shareConfig={};const isValidValue=function(val){return typeof val!=="undefined"};if(isValidValue(singleton)){shareConfig.singleton=singleton}if(isValidValue(requiredVersion)){shareConfig.requiredVersion=requiredVersion}if(isValidValue(eager)){shareConfig.eager=eager}if(isValidValue(strictVersion)){shareConfig.strictVersion=strictVersion}const options={version,scope:[scope],shareConfig,get:factory};if(shared[name]){shared[name].push(options)}else{shared[name]=[options]}}}}return shared});merge(__webpack_require__.federation.initOptions,"remotes",()=>Object.values(__module_federation_remote_infos__).flat().filter(remote=>remote.externalType==="script"));merge(__webpack_require__.federation.initOptions,"plugins",()=>__module_federation_runtime_plugins__);early(__webpack_require__.federation,"bundlerRuntimeOptions",()=>({}));early(__webpack_require__.federation.bundlerRuntimeOptions,"remotes",()=>({}));early(__webpack_require__.federation.bundlerRuntimeOptions.remotes,"chunkMapping",()=>remotesLoadingChunkMapping);early(__webpack_require__.federation.bundlerRuntimeOptions.remotes,"idToExternalAndNameMapping",()=>{const remotesLoadingIdToExternalAndNameMappingMapping={};for(let[moduleId,data]of Object.entries(remotesLoadingModuleIdToRemoteDataMapping)){remotesLoadingIdToExternalAndNameMappingMapping[moduleId]=[data.shareScope,data.name,data.externalModuleId,data.remoteName]}return remotesLoadingIdToExternalAndNameMappingMapping});early(__webpack_require__.federation.bundlerRuntimeOptions.remotes,"webpackRequire",()=>__webpack_require__);merge(__webpack_require__.federation.bundlerRuntimeOptions.remotes,"idToRemoteMap",()=>{const idToRemoteMap={};for(let[id,remoteData]of Object.entries(remotesLoadingModuleIdToRemoteDataMapping)){const info=__module_federation_remote_infos__[remoteData.remoteName];if(info)idToRemoteMap[id]=info}return idToRemoteMap});override(__webpack_require__,"S",__webpack_require__.federation.bundlerRuntime.S);if(__webpack_require__.federation.attachShareScopeMap){__webpack_require__.federation.attachShareScopeMap(__webpack_require__)}override(__webpack_require__.f,"remotes",(chunkId,promises)=>__webpack_require__.federation.bundlerRuntime.remotes({chunkId,promises,chunkMapping:remotesLoadingChunkMapping,idToExternalAndNameMapping:__webpack_require__.federation.bundlerRuntimeOptions.remotes.idToExternalAndNameMapping,idToRemoteMap:__webpack_require__.federation.bundlerRuntimeOptions.remotes.idToRemoteMap,webpackRequire:__webpack_require__}));override(__webpack_require__.f,"consumes",(chunkId,promises)=>__webpack_require__.federation.bundlerRuntime.consumes({chunkId,promises,chunkMapping:consumesLoadingChunkMapping,moduleToHandlerMapping:__webpack_require__.federation.consumesLoadingModuleToHandlerMapping,installedModules:consumesLoadinginstalledModules,webpackRequire:__webpack_require__}));override(__webpack_require__,"I",(name,initScope)=>__webpack_require__.federation.bundlerRuntime.I({shareScopeName:name,initScope,initPromises:initializeSharingInitPromises,initTokens:initializeSharingInitTokens,webpackRequire:__webpack_require__}));override(__webpack_require__,"initContainer",(shareScope,initScope,remoteEntryInitOptions)=>__webpack_require__.federation.bundlerRuntime.initContainerEntry({shareScope,initScope,remoteEntryInitOptions,shareScopeKey:containerShareScope,webpackRequire:__webpack_require__}));override(__webpack_require__,"getContainer",(module1,getScope)=>{var moduleMap=__webpack_require__.initializeExposesData.moduleMap;__webpack_require__.R=getScope;getScope=Object.prototype.hasOwnProperty.call(moduleMap,module1)?moduleMap[module1]():Promise.resolve().then(()=>{throw new Error('Module "'+module1+'" does not exist in container.')});__webpack_require__.R=undefined;return getScope});__webpack_require__.federation.instance=__webpack_require__.federation.runtime.init(__webpack_require__.federation.initOptions);if((__webpack_require___consumesLoadingData2=__webpack_require__.consumesLoadingData)===null||__webpack_require___consumesLoadingData2===void 0?void 0:__webpack_require___consumesLoadingData2.initialConsumes){__webpack_require__.federation.bundlerRuntime.installInitialConsumes({webpackRequire:__webpack_require__,installedModules:consumesLoadinginstalledModules,initialConsumes:__webpack_require__.consumesLoadingData.initialConsumes,moduleToHandlerMapping:__webpack_require__.federation.consumesLoadingModuleToHandlerMapping})}}};

package/dist/node/NodeEnvironmentPlugin.d.ts

@@ -0,0 +1,10 @@
+import type { Compiler } from "..";
+import type { InfrastructureLogging } from "../config";
+export interface NodeEnvironmentPluginOptions {
+    infrastructureLogging: InfrastructureLogging;
+}
+export default class NodeEnvironmentPlugin {
+    options: NodeEnvironmentPluginOptions;
+    constructor(options: NodeEnvironmentPluginOptions);
+    apply(compiler: Compiler): void;
+}

package/dist/node/NodeTemplatePlugin.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/node/NodeTemplatePlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Compiler } from "../Compiler";
+export type NodeTemplatePluginOptions = {
+    asyncChunkLoading?: boolean;
+};
+export default class NodeTemplatePlugin {
+    private _options;
+    constructor(_options?: NodeTemplatePluginOptions);
+    apply(compiler: Compiler): void;
+}

package/dist/node/NodeWatchFileSystem.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/node/NodeWatchFileSystem.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type Watchpack from "../../compiled/watchpack";
+import type { FileSystemInfoEntry, InputFileSystem, WatchFileSystem, Watcher } from "../util/fs";
+export default class NodeWatchFileSystem implements WatchFileSystem {
+    inputFileSystem: InputFileSystem;
+    watcherOptions: Watchpack.WatchOptions;
+    watcher?: Watchpack;
+    constructor(inputFileSystem: InputFileSystem);
+    watch(files: Iterable<string>, directories: Iterable<string>, missing: Iterable<string>, startTime: number, options: Watchpack.WatchOptions, callback: (error: Error | null, fileTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">, contextTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">, changedFiles: Set<string>, removedFiles: Set<string>) => void, callbackUndelayed: (fileName: string, changeTime: number) => void): Watcher;
+}

package/dist/node/nodeConsole.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/node/nodeConsole.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { LoggerConsole } from "../logging/createConsoleLogger";
+export default function ({ colors, appendOnly, stream }: {
+    colors?: boolean;
+    appendOnly?: boolean;
+    stream: NodeJS.WritableStream;
+}): LoggerConsole;

package/dist/rspack.d.ts

@@ -0,0 +1,16 @@
+import type { Callback } from "@rspack/lite-tapable";
+import { Compiler } from "./Compiler";
+import { MultiCompiler, type MultiRspackOptions } from "./MultiCompiler";
+import MultiStats from "./MultiStats";
+import { Stats } from "./Stats";
+import { type RspackOptions } from "./config";
+declare function createMultiCompiler(options: MultiRspackOptions): MultiCompiler;
+declare function createCompiler(userOptions: RspackOptions): Compiler;
+declare function rspack(options: MultiRspackOptions): MultiCompiler;
+declare function rspack(options: RspackOptions): Compiler;
+declare function rspack(options: MultiRspackOptions | RspackOptions): MultiCompiler | Compiler;
+declare function rspack(options: MultiRspackOptions, callback?: Callback<Error, MultiStats>): null | MultiCompiler;
+declare function rspack(options: RspackOptions, callback?: Callback<Error, Stats>): null | Compiler;
+declare function rspack(options: MultiRspackOptions | RspackOptions, callback?: Callback<Error, MultiStats | Stats>): null | MultiCompiler | Compiler;
+export { createCompiler, createMultiCompiler, MultiStats, rspack, Stats };
+export default rspack;

package/dist/rspackOptionsApply.d.ts

@@ -0,0 +1,4 @@
+import type { Compiler, RspackOptionsNormalized } from ".";
+export declare class RspackOptionsApply {
+    process(options: RspackOptionsNormalized, compiler: Compiler): void;
+}

package/dist/runtime/cssExtractHmr.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeUrl(url: string): string;
+declare function noop(): void;
+declare function cssReload(moduleId: string, options: Record<string, any>): typeof noop;
+export { cssReload };

package/dist/runtime/moduleFederationDefaultRuntime.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(): void;
+export = _exports;

package/dist/sharing/ConsumeSharedPlugin.d.ts

@@ -0,0 +1,41 @@
+import { type BuiltinPlugin, BuiltinPluginName } from "@rspack/binding";
+import type { Compiler } from "../Compiler";
+import { RspackBuiltinPlugin } from "../builtin-plugin/base";
+export type ConsumeSharedPluginOptions = {
+    consumes: Consumes;
+    shareScope?: string;
+    enhanced?: boolean;
+};
+export type Consumes = (ConsumesItem | ConsumesObject)[] | ConsumesObject;
+export type ConsumesItem = string;
+export type ConsumesObject = {
+    [k: string]: ConsumesConfig | ConsumesItem;
+};
+export type ConsumesConfig = {
+    eager?: boolean;
+    import?: false | ConsumesItem;
+    packageName?: string;
+    requiredVersion?: false | string;
+    shareKey?: string;
+    shareScope?: string;
+    singleton?: boolean;
+    strictVersion?: boolean;
+};
+export declare class ConsumeSharedPlugin extends RspackBuiltinPlugin {
+    name: BuiltinPluginName;
+    _options: {
+        consumes: [string, {
+            import: string | undefined;
+            shareScope: string;
+            shareKey: string;
+            requiredVersion: string | false | undefined;
+            strictVersion: boolean;
+            packageName: string | undefined;
+            singleton: boolean;
+            eager: boolean;
+        }][];
+        enhanced: boolean;
+    };
+    constructor(options: ConsumeSharedPluginOptions);
+    raw(compiler: Compiler): BuiltinPlugin;
+}

package/dist/sharing/ProvideSharedPlugin.d.ts

@@ -0,0 +1,34 @@
+import { type BuiltinPlugin, BuiltinPluginName, type RawProvideOptions } from "@rspack/binding";
+import type { Compiler } from "../Compiler";
+import { RspackBuiltinPlugin } from "../builtin-plugin/base";
+export type ProvideSharedPluginOptions<Enhanced extends boolean = false> = {
+    provides: Provides<Enhanced>;
+    shareScope?: string;
+    enhanced?: Enhanced;
+};
+export type Provides<Enhanced extends boolean> = (ProvidesItem | ProvidesObject<Enhanced>)[] | ProvidesObject<Enhanced>;
+export type ProvidesItem = string;
+export type ProvidesObject<Enhanced extends boolean> = {
+    [k: string]: ProvidesConfig<Enhanced> | ProvidesItem;
+};
+export type ProvidesConfig<Enhanced extends boolean> = Enhanced extends true ? ProvidesEnhancedConfig : ProvidesV1Config;
+type ProvidesV1Config = {
+    eager?: boolean;
+    shareKey: string;
+    shareScope?: string;
+    version?: false | string;
+};
+type ProvidesEnhancedConfig = ProvidesV1Config & ProvidesEnhancedExtraConfig;
+type ProvidesEnhancedExtraConfig = {
+    singleton?: boolean;
+    strictVersion?: boolean;
+    requiredVersion?: false | string;
+};
+export declare class ProvideSharedPlugin<Enhanced extends boolean = false> extends RspackBuiltinPlugin {
+    name: BuiltinPluginName;
+    _provides: [string, Omit<RawProvideOptions, "key">][];
+    _enhanced?: Enhanced;
+    constructor(options: ProvideSharedPluginOptions<Enhanced>);
+    raw(compiler: Compiler): BuiltinPlugin;
+}
+export {};

package/dist/sharing/SharePlugin.d.ts

@@ -0,0 +1,51 @@
+import type { Compiler } from "../Compiler";
+export type SharePluginOptions = {
+    shareScope?: string;
+    shared: Shared;
+    enhanced: boolean;
+};
+export type Shared = (SharedItem | SharedObject)[] | SharedObject;
+export type SharedItem = string;
+export type SharedObject = {
+    [k: string]: SharedConfig | SharedItem;
+};
+export type SharedConfig = {
+    eager?: boolean;
+    import?: false | SharedItem;
+    packageName?: string;
+    requiredVersion?: false | string;
+    shareKey?: string;
+    shareScope?: string;
+    singleton?: boolean;
+    strictVersion?: boolean;
+    version?: false | string;
+};
+export declare class SharePlugin {
+    _shareScope: string | undefined;
+    _consumes: {
+        [x: string]: {
+            import: string | false | undefined;
+            shareKey: string;
+            shareScope: string | undefined;
+            requiredVersion: string | false | undefined;
+            strictVersion: boolean | undefined;
+            singleton: boolean | undefined;
+            packageName: string | undefined;
+            eager: boolean | undefined;
+        };
+    }[];
+    _provides: {
+        [x: string]: {
+            shareKey: string;
+            shareScope: string | undefined;
+            version: string | false | undefined;
+            eager: boolean | undefined;
+            singleton: boolean | undefined;
+            requiredVersion: string | false | undefined;
+            strictVersion: boolean | undefined;
+        };
+    }[];
+    _enhanced: boolean;
+    constructor(options: SharePluginOptions);
+    apply(compiler: Compiler): void;
+}

package/dist/sharing/ShareRuntimePlugin.d.ts

@@ -0,0 +1,9 @@
+import { type BuiltinPlugin, BuiltinPluginName } from "@rspack/binding";
+import type { Compiler } from "../Compiler";
+import { RspackBuiltinPlugin } from "../builtin-plugin/base";
+export declare class ShareRuntimePlugin extends RspackBuiltinPlugin {
+    private enhanced;
+    name: BuiltinPluginName;
+    constructor(enhanced?: boolean);
+    raw(compiler: Compiler): BuiltinPlugin | undefined;
+}

package/dist/sharing/utils.d.ts

@@ -0,0 +1 @@
+export declare function isRequiredVersion(str: string): boolean;

package/dist/stats/DefaultStatsFactoryPlugin.d.ts

@@ -0,0 +1,4 @@
+import type { Compiler } from "../Compiler";
+export declare class DefaultStatsFactoryPlugin {
+    apply(compiler: Compiler): void;
+}

package/dist/stats/DefaultStatsPresetPlugin.d.ts

@@ -0,0 +1,4 @@
+import type { Compiler } from "../Compiler";
+export declare class DefaultStatsPresetPlugin {
+    apply(compiler: Compiler): void;
+}

package/dist/stats/DefaultStatsPrinterPlugin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/tree/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/stats
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Compiler } from "../Compiler";
+export declare class DefaultStatsPrinterPlugin {
+    apply(compiler: Compiler): void;
+}