@rspack-debug/browser 0.0.0-alpha.0 → 1.6.4

package/dist/builtin-plugin/html-plugin/options.d.ts

@@ -0,0 +1,82 @@
+import { Compilation } from "../../Compilation";
+export type TemplateRenderFunction = (params: Record<string, any>) => string | Promise<string>;
+export type TemplateParamFunction = (params: Record<string, any>) => Record<string, any> | Promise<Record<string, any>>;
+export type HtmlRspackPluginOptions = {
+    /** The title to use for the generated HTML document. */
+    title?: string;
+    /**
+     * The file to write the HTML to. You can specify a subdirectory here too (e.g.: `"pages/index.html"`).
+     * @default "index.html"
+     */
+    filename?: string | ((entry: string) => string);
+    /** The template file path. */
+    template?: string;
+    /**
+     * The template file content, priority is greater than `template` option.
+     *
+     * When using a function, pass in the template parameters and use the returned string as the template content.
+     */
+    templateContent?: string | TemplateRenderFunction;
+    /**
+     * Allows to overwrite the parameters used in the template.
+     *
+     * When using a function, pass in the original template parameters and use the returned object as the final template parameters.
+     */
+    templateParameters?: Record<string, string> | boolean | TemplateParamFunction;
+    /**
+     * The script and link tag inject position in template. Use `false` to not inject.
+     * If not specified, it will be automatically determined based on `scriptLoading` value.
+     * @default true
+     */
+    inject?: boolean | "head" | "body";
+    /** The public path used for script and link tags. */
+    publicPath?: string;
+    /** Inject a [`base`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base) tag. */
+    base?: string | {
+        href?: string;
+        target?: "_self" | "_blank" | "_parent" | "_top";
+    };
+    /**
+     * Modern browsers support non-blocking JavaScript loading ([`defer` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#defer)) to improve the page startup performance.
+     *
+     * Setting this option to `'module'` adds attribute `type="module"` to the `script`. This also implies `defer` attribute on the `script`, since modules are automatically deferred.
+     * @default "defer"
+     * */
+    scriptLoading?: "blocking" | "defer" | "module" | "systemjs-module";
+    /** Allows you to add only some chunks. */
+    chunks?: string[];
+    /** Allows you to skip some chunks. */
+    excludeChunks?: string[];
+    /**
+     * Allows to control how chunks should be sorted before they are included to the HTML.
+     * @default "auto"
+     */
+    chunksSortMode?: "auto" | "manual";
+    /**
+     * Configure the SRI hash algorithm, which is disabled by default.
+     * @deprecated Use `experiments.SubresourceIntegrityPlugin` instead.
+     */
+    sri?: "sha256" | "sha384" | "sha512";
+    /**
+     * Controls whether to minify the output, disabled by default.
+     */
+    minify?: boolean;
+    /** Adds the given favicon path to the output HTML. */
+    favicon?: string;
+    /**
+     * Allows to inject meta-tags.
+     * @default {}
+     */
+    meta?: Record<string, string | Record<string, string>>;
+    /**
+     * If `true` then append a unique Rspack compilation hash to all included scripts and CSS files. This is useful for cache busting.
+     */
+    hash?: boolean;
+    /**
+     * Any other options will be passed by hooks.
+     */
+    [key: string]: any;
+};
+export declare const getPluginOptions: (compilation: Compilation, uid: number) => any;
+export declare const setPluginOptions: (compilation: Compilation, uid: number, options: HtmlRspackPluginOptions) => void;
+export declare const cleanPluginOptions: (compilation: Compilation, uid: number) => void;

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

@@ -0,0 +1,24 @@
+import { type JsHtmlPluginTag } from "../../binding";
+import type { Compilation } from "../../Compilation";
+import type { Compiler } from "../../Compiler";
+import { type HtmlRspackPluginHooks } from "./hooks";
+import { type HtmlRspackPluginOptions } from "./options";
+declare const HtmlRspackPluginImpl: {
+    new (c?: HtmlRspackPluginOptions | undefined): {
+        name: string;
+        _args: [c?: HtmlRspackPluginOptions | undefined];
+        affectedHooks: keyof import("../../Compiler").CompilerHooks | undefined;
+        raw(compiler: Compiler): import("../../binding").BuiltinPlugin;
+        apply(compiler: Compiler): void;
+    };
+};
+declare const HtmlRspackPlugin: typeof HtmlRspackPluginImpl & {
+    /**
+     * @deprecated Use `getCompilationHooks` instead.
+     */
+    getHooks: (compilation: Compilation) => HtmlRspackPluginHooks;
+    getCompilationHooks: (compilation: Compilation) => HtmlRspackPluginHooks;
+    createHtmlTagObject: (tagName: string, attributes?: Record<string, string | boolean>, innerHTML?: string) => JsHtmlPluginTag;
+    version: number;
+};
+export { HtmlRspackPlugin };

package/dist/builtin-plugin/html-plugin/taps.d.ts

@@ -0,0 +1,2 @@
+import type { CreatePartialRegisters } from "../../taps/types";
+export declare const createHtmlPluginHooksRegisters: CreatePartialRegisters<`HtmlPlugin`>;

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

@@ -0,0 +1,84 @@
+export * from "./APIPlugin";
+export * from "./ArrayPushCallbackChunkFormatPlugin";
+export * from "./AssetModulesPlugin";
+export * from "./AsyncWebAssemblyModulesPlugin";
+export * from "./BannerPlugin";
+export * from "./BundlerInfoRspackPlugin";
+export { createNativePlugin, RspackBuiltinPlugin } from "./base";
+export * from "./ChunkPrefetchPreloadPlugin";
+export * from "./CircularDependencyRspackPlugin";
+export * from "./CommonJsChunkFormatPlugin";
+export * from "./ContextReplacementPlugin";
+export * from "./CopyRspackPlugin";
+export * from "./CssChunkingPlugin";
+export * from "./CssModulesPlugin";
+export * from "./css-extract/index";
+export * from "./DataUriPlugin";
+export * from "./DefinePlugin";
+export * from "./DeterministicChunkIdsPlugin";
+export * from "./DeterministicModuleIdsPlugin";
+export * from "./DllEntryPlugin";
+export * from "./DllReferenceAgencyPlugin";
+export * from "./DynamicEntryPlugin";
+export * from "./ElectronTargetPlugin";
+export * from "./EnableChunkLoadingPlugin";
+export * from "./EnableLibraryPlugin";
+export * from "./EnableWasmLoadingPlugin";
+export * from "./EnsureChunkConditionsPlugin";
+export * from "./EntryPlugin";
+export * from "./EsmLibraryPlugin";
+export * from "./EvalDevToolModulePlugin";
+export * from "./EvalSourceMapDevToolPlugin";
+export * from "./ExternalsPlugin";
+export * from "./FetchCompileAsyncWasmPlugin";
+export * from "./FileUriPlugin";
+export * from "./FlagDependencyExportsPlugin";
+export * from "./FlagDependencyUsagePlugin";
+export * from "./HotModuleReplacementPlugin";
+export * from "./HttpExternalsRspackPlugin";
+export * from "./HttpUriPlugin";
+export * from "./html-plugin/index";
+export * from "./IgnorePlugin";
+export * from "./InferAsyncModulesPlugin";
+export * from "./InlineExportsPlugin";
+export * from "./JavascriptModulesPlugin";
+export * from "./JsLoaderRspackPlugin";
+export * from "./JsonModulesPlugin";
+export * from "./LibManifestPlugin";
+export * from "./LightningCssMinimizerRspackPlugin";
+export * from "./LightningCssMinimizerRspackPlugin";
+export * from "./LimitChunkCountPlugin";
+export * from "./lazy-compilation/middleware";
+export * from "./MangleExportsPlugin";
+export * from "./MergeDuplicateChunksPlugin";
+export * from "./ModuleChunkFormatPlugin";
+export * from "./ModuleConcatenationPlugin";
+export * from "./ModuleInfoHeaderPlugin";
+export * from "./NamedChunkIdsPlugin";
+export * from "./NamedModuleIdsPlugin";
+export * from "./NaturalChunkIdsPlugin";
+export * from "./NaturalModuleIdsPlugin";
+export * from "./NodeTargetPlugin";
+export * from "./NoEmitOnErrorsPlugin";
+export * from "./NormalModuleReplacementPlugin";
+export * from "./OccurrenceChunkIdsPlugin";
+export * from "./ProgressPlugin";
+export * from "./ProvidePlugin";
+export * from "./RealContentHashPlugin";
+export * from "./RemoveDuplicateModulesPlugin";
+export * from "./RemoveEmptyChunksPlugin";
+export * from "./RsdoctorPlugin";
+export * from "./RslibPlugin";
+export * from "./RstestPlugin";
+export * from "./RuntimeChunkPlugin";
+export * from "./RuntimePlugin";
+export * from "./SideEffectsFlagPlugin";
+export * from "./SizeLimitsPlugin";
+export * from "./SourceMapDevToolPlugin";
+export * from "./SplitChunksPlugin";
+export * from "./SubresourceIntegrityPlugin";
+export * from "./SwcJsMinimizerPlugin";
+export * from "./URLPlugin";
+export * from "./WarnCaseSensitiveModulesPlugin";
+export * from "./WebWorkerTemplatePlugin";
+export * from "./WorkerPlugin";

package/dist/builtin-plugin/lazy-compilation/lazyCompilation.d.ts

@@ -0,0 +1,10 @@
+import type { Module } from "../../Module";
+export declare const BuiltinLazyCompilationPlugin: {
+    new (currentActiveModules: () => Set<string>, entries: boolean, imports: boolean, client: string, test?: RegExp | ((module: Module) => boolean) | undefined): {
+        name: string;
+        _args: [currentActiveModules: () => Set<string>, entries: boolean, imports: boolean, client: string, test?: RegExp | ((module: Module) => boolean) | undefined];
+        affectedHooks: keyof import("../..").CompilerHooks | undefined;
+        raw(compiler: import("../..").Compiler): import("../../binding").BuiltinPlugin;
+        apply(compiler: import("../..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/lazy-compilation/middleware.d.ts

@@ -0,0 +1,4 @@
+import { type Compiler, MultiCompiler } from "../..";
+import type { MiddlewareHandler } from "../../config/devServer";
+export declare const LAZY_COMPILATION_PREFIX = "/lazy-compilation-using-";
+export declare const lazyCompilationMiddleware: (compiler: Compiler | MultiCompiler) => MiddlewareHandler;

package/dist/config/adapter.d.ts

@@ -0,0 +1,8 @@
+import { type RawOptions } from "../binding";
+import type { Compiler } from "../Compiler";
+import { type LoaderContext, type LoaderDefinition, type LoaderDefinitionFunction, type PitchLoaderDefinitionFunction } from "./adapterRuleUse";
+import type { RspackOptionsNormalized } from "./normalization";
+import type { Resolve } from "./types";
+export type { LoaderContext, LoaderDefinition, LoaderDefinitionFunction, PitchLoaderDefinitionFunction };
+export declare const getRawOptions: (options: RspackOptionsNormalized, compiler: Compiler) => RawOptions;
+export declare function getRawResolve(resolve: Resolve): RawOptions["resolve"];

package/dist/config/adapterRuleUse.d.ts

@@ -0,0 +1,391 @@
+import type { AssetInfo, RawModuleRuleUse, RawOptions } from "../binding";
+import type { Compilation } from "../Compilation";
+import type { Compiler } from "../Compiler";
+import { type LoaderObject } from "../loader-runner";
+import type { Logger } from "../logging/Logger";
+import type { Module } from "../Module";
+import type { ResolveRequest } from "../Resolver";
+import type Hash from "../util/hash";
+import type { RspackOptionsNormalized } from "./normalization";
+import type { Mode, PublicPath, Resolve, RuleSetUseItem, Target } from "./types";
+export declare const BUILTIN_LOADER_PREFIX = "builtin:";
+export interface ComposeJsUseOptions {
+    context: RawOptions["context"];
+    mode: RawOptions["mode"];
+    experiments: RawOptions["experiments"];
+    compiler: Compiler;
+}
+export interface RawSourceMap {
+    /**
+     * The version of the source map format, always 3
+     */
+    version: number;
+    /**
+     * A list of original sources used by the mappings field
+     */
+    sources: string[];
+    /**
+     * A string with the encoded mapping data
+     */
+    mappings: string;
+    /**
+     * The filename of the generated code that this source map is associated with
+     */
+    file: string;
+    /**
+     * An optional source root string, used for relocating source files on a server
+     * or removing repeated values in the sources entry.
+     */
+    sourceRoot?: string;
+    /**
+     * An array containing the actual content of the original source files
+     */
+    sourcesContent?: string[];
+    /**
+     * A list of symbol names which may be used by the mappings field.
+     */
+    names: string[];
+    /**
+     * A unique identifier for debugging purposes
+     */
+    debugId?: string;
+    /**
+     * An array of indices into the sources array, indicating which sources
+     * should be ignored by debuggers
+     */
+    ignoreList?: number[];
+}
+export interface AdditionalData {
+    [index: string]: any;
+}
+export type LoaderContextCallback = (err?: Error | null, content?: string | Buffer, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => void;
+export type ErrorWithDetails = Error & {
+    details?: string;
+};
+export type ResolveCallback = (err: null | ErrorWithDetails, res?: string | false, req?: ResolveRequest) => void;
+export interface DiagnosticLocation {
+    /** Text for highlighting the location */
+    text?: string;
+    /** 1-based line */
+    line: number;
+    /** 0-based column in bytes */
+    column: number;
+    /** Length in bytes */
+    length: number;
+}
+export interface Diagnostic {
+    message: string;
+    help?: string;
+    sourceCode?: string;
+    /**
+     * Location to the source code.
+     * If `sourceCode` is not provided, location will be omitted.
+     */
+    location?: DiagnosticLocation;
+    /**
+     * Optional filename to show.
+     * If provided, it becomes the `StatsError.file` value in stats.
+     */
+    file?: string;
+    severity: "error" | "warning";
+}
+export interface LoaderExperiments {
+    emitDiagnostic(diagnostic: Diagnostic): void;
+}
+export interface ImportModuleOptions {
+    /**
+     * Specify a layer in which this module is placed/compiled
+     */
+    layer?: string;
+    /**
+     * The public path used for the built modules
+     */
+    publicPath?: PublicPath;
+    /**
+     * Target base uri
+     */
+    baseUri?: string;
+}
+export interface LoaderContext<OptionsType = {}> {
+    /**
+     * The version number of the loader API. Currently 2.
+     * This is useful for providing backwards compatibility. Using the version you can specify
+     * custom logic or fallbacks for breaking changes.
+     */
+    version: 2;
+    /**
+     * The path string of the current module.
+     * @example `'/abc/resource.js?query#hash'`.
+     */
+    resource: string;
+    /**
+     * The path string of the current module, excluding the query and fragment parameters.
+     * @example `'/abc/resource.js?query#hash'` in `'/abc/resource.js'`.
+     */
+    resourcePath: string;
+    /**
+     * The query parameter for the path string of the current module.
+     * @example `'?query'` in `'/abc/resource.js?query#hash'`.
+     */
+    resourceQuery: string;
+    /**
+     * The fragment parameter of the current module's path string.
+     * @example `'#hash'` in `'/abc/resource.js?query#hash'`.
+     */
+    resourceFragment: string;
+    /**
+     * Tells Rspack that this loader will be called asynchronously. Returns `this.callback`.
+     */
+    async(): LoaderContextCallback;
+    /**
+     * A function that can be called synchronously or asynchronously in order to return multiple
+     * results. The expected arguments are:
+     *
+     * 1. The first parameter must be `Error` or `null`, which marks the current module as a
+     * compilation failure.
+     * 2. The second argument is a `string` or `Buffer`, which indicates the contents of the file
+     * after the module has been processed by the loader.
+     * 3. The third parameter is a source map that can be processed by the loader.
+     * 4. The fourth parameter is ignored by Rspack and can be anything (e.g. some metadata).
+     */
+    callback: LoaderContextCallback;
+    /**
+     * A function that sets the cacheable flag.
+     * By default, the processing results of the loader are marked as cacheable.
+     * Calling this method and passing `false` turns off the loader's ability to
+     * cache processing results.
+     */
+    cacheable(cacheable?: boolean): void;
+    /**
+     * Tells if source map should be generated. Since generating source maps can be an expensive task,
+     * you should check if source maps are actually requested.
+     */
+    sourceMap: boolean;
+    /**
+     * The base path configured in Rspack config via `context`.
+     */
+    rootContext: string;
+    /**
+     * The directory path of the currently processed module, which changes with the
+     * location of each processed module.
+     * For example, if the loader is processing `/project/src/components/Button.js`,
+     * then the value of `this.context` would be `/project/src/components`.
+     */
+    context: string | null;
+    /**
+     * The index in the loaders array of the current loader.
+     */
+    loaderIndex: number;
+    remainingRequest: string;
+    currentRequest: string;
+    previousRequest: string;
+    /**
+     * The module specifier string after being resolved.
+     * For example, if a `resource.js` is processed by `loader1.js` and `loader2.js`, the value of
+     * `this.request` will be `/path/to/loader1.js!/path/to/loader2.js!/path/to/resource.js`.
+     */
+    request: string;
+    /**
+     * An array of all the loaders. It is writeable in the pitch phase.
+     * loaders = [{request: string, path: string, query: string, module: function}]
+     *
+     * In the example:
+     * [
+     *   { request: "/abc/loader1.js?xyz",
+     *     path: "/abc/loader1.js",
+     *     query: "?xyz",
+     *     module: [Function]
+     *   },
+     *   { request: "/abc/node_modules/loader2/index.js",
+     *     path: "/abc/node_modules/loader2/index.js",
+     *     query: "",
+     *     module: [Function]
+     *   }
+     * ]
+     */
+    loaders: LoaderObject[];
+    /**
+     * The value of `mode` is read when Rspack is run.
+     * The possible values are: `'production'`, `'development'`, `'none'`
+     */
+    mode?: Mode;
+    /**
+     * The current compilation target. Passed from `target` configuration options.
+     */
+    target?: Target;
+    /**
+     * Whether HMR is enabled.
+     */
+    hot?: boolean;
+    /**
+     * Get the options passed in by the loader's user.
+     * @param schema To provide the best performance, Rspack does not perform the schema
+     * validation. If your loader requires schema validation, please call scheme-utils or
+     * zod on your own.
+     */
+    getOptions(schema?: any): OptionsType;
+    /**
+     * Resolve a module specifier.
+     * @param context The absolute path to a directory. This directory is used as the starting
+     * location for resolving.
+     * @param request The module specifier to be resolved.
+     * @param callback A callback function that gives the resolved path.
+     */
+    resolve(context: string, request: string, callback: (arg0: null | Error, arg1?: string | false, arg2?: ResolveRequest) => void): void;
+    /**
+     * Create a resolver like `this.resolve`.
+     */
+    getResolve(options: Resolve): ((context: string, request: string, callback: ResolveCallback) => void) | ((context: string, request: string) => Promise<string | false | undefined>);
+    /**
+     * Get the logger of this compilation, through which messages can be logged.
+     */
+    getLogger(name: string): Logger;
+    /**
+     * Emit an error. Unlike `throw` and `this.callback(err)` in the loader, it does not
+     * mark the current module as a compilation failure, it just adds an error to Rspack's
+     * Compilation and displays it on the command line at the end of this compilation.
+     */
+    emitError(error: Error): void;
+    /**
+     * Emit a warning.
+     */
+    emitWarning(warning: Error): void;
+    /**
+     * Emit a new file. This method allows you to create new files during the loader execution.
+     */
+    emitFile(name: string, content: string | Buffer, sourceMap?: string, assetInfo?: AssetInfo): void;
+    /**
+     * Add a file as a dependency on the loader results so that any changes to them can be listened to.
+     * For example, `sass-loader`, `less-loader` use this trick to recompile when the imported style
+     * files change.
+     */
+    addDependency(file: string): void;
+    /**
+     * Alias of `this.addDependency()`.
+     */
+    dependency(file: string): void;
+    /**
+     * Add the directory as a dependency for the loader results so that any changes to the
+     * files in the directory can be listened to.
+     */
+    addContextDependency(context: string): void;
+    /**
+     * Add a currently non-existent file as a dependency of the loader result, so that its
+     * creation and any changes can be listened. For example, when a new file is created at
+     * that path, it will trigger a rebuild.
+     */
+    addMissingDependency(missing: string): void;
+    /**
+     * Removes all dependencies of the loader result.
+     */
+    clearDependencies(): void;
+    getDependencies(): string[];
+    getContextDependencies(): string[];
+    getMissingDependencies(): string[];
+    addBuildDependency(file: string): void;
+    /**
+     * Compile and execute a module at the build time.
+     * This is an alternative lightweight solution for the child compiler.
+     * `importModule` will return a Promise if no callback is provided.
+     *
+     * @example
+     * ```ts
+     * const modulePath = path.resolve(__dirname, 'some-module.ts');
+     * const moduleExports = await this.importModule(modulePath, {
+     *   // optional options
+     * });
+     * ```
+     */
+    importModule<T = any>(request: string, options: ImportModuleOptions | undefined, callback: (err?: null | Error, exports?: T) => any): void;
+    importModule<T = any>(request: string, options?: ImportModuleOptions): Promise<T>;
+    /**
+     * Access to the `compilation` object's `inputFileSystem` property.
+     */
+    fs: any;
+    /**
+     * This is an experimental API and maybe subject to change.
+     * @experimental
+     */
+    experiments: LoaderExperiments;
+    /**
+     * Access to some utilities.
+     */
+    utils: {
+        /**
+         * Return a new request string using absolute paths when possible.
+         */
+        absolutify: (context: string, request: string) => string;
+        /**
+         * Return a new request string avoiding absolute paths when possible.
+         */
+        contextify: (context: string, request: string) => string;
+        /**
+         * Return a new Hash object from provided hash function.
+         */
+        createHash: (algorithm?: string) => Hash;
+    };
+    /**
+     * The value depends on the loader configuration:
+     * - If the current loader was configured with an options object, `this.query` will
+     * point to that object.
+     * - If the current loader has no options, but was invoked with a query string, this
+     * will be a string starting with `?`.
+     */
+    query: string | OptionsType;
+    /**
+     * A data object shared between the pitch and the normal phase.
+     */
+    data: unknown;
+    /**
+     * Access to the current Compiler object of Rspack.
+     */
+    _compiler: Compiler;
+    /**
+     * Access to the current Compilation object of Rspack.
+     */
+    _compilation: Compilation;
+    /**
+     * @deprecated Hacky access to the Module object being loaded.
+     */
+    _module: Module;
+    /**
+     * Note: This is not a Rspack public API, maybe removed in future.
+     * Store some data from loader, and consume it from parser, it may be removed in the future
+     *
+     * @internal
+     */
+    __internal__setParseMeta: (key: string, value: string) => void;
+}
+export type LoaderDefinitionFunction<OptionsType = {}, ContextAdditions = {}> = (this: LoaderContext<OptionsType> & ContextAdditions, content: string, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => string | void | Buffer | Promise<string | Buffer | void>;
+export type PitchLoaderDefinitionFunction<OptionsType = {}, ContextAdditions = {}> = (this: LoaderContext<OptionsType> & ContextAdditions, remainingRequest: string, previousRequest: string, data: object) => string | void | Buffer | Promise<string | Buffer | void>;
+/**
+ * Defines a loader for Rspack.
+ * A loader is a transformer that converts various types of modules into Rspack
+ * supported types. By using different kinds of loaders, you can extend Rspack to
+ * process additional module types, including JSX, Markdown, Sass, Less, and more.
+ *
+ * @template OptionsType - The type of options that the loader accepts
+ * @template ContextAdditions - Additional properties to add to the loader context
+ *
+ * @example
+ * ```ts
+ * import type { LoaderDefinition } from '@rspack/core';
+ *
+ * type MyLoaderOptions = {
+ *   foo: string;
+ * };
+ *
+ * const myLoader: LoaderDefinition<MyLoaderOptions> = function(source) {
+ *   return someOperation(source);
+ * };
+ *
+ * export default myLoader;
+ * ```
+ */
+export type LoaderDefinition<OptionsType = {}, ContextAdditions = {}> = LoaderDefinitionFunction<OptionsType, ContextAdditions> & {
+    raw?: false;
+    pitch?: PitchLoaderDefinitionFunction;
+};
+export declare function createRawModuleRuleUses(uses: RuleSetUseItem | RuleSetUseItem[], path: string, options: ComposeJsUseOptions): RawModuleRuleUse[];
+export declare function isUseSourceMap(devtool: RspackOptionsNormalized["devtool"]): boolean;
+export declare function isUseSimpleSourceMap(devtool: RspackOptionsNormalized["devtool"]): boolean;

package/dist/config/browserslistTargetHandler.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/config/browserslistTargetHandler.js
+ *
+ * MIT Licensed
+ * Author Sergey Melyukov @smelukov
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { ApiTargetProperties, EcmaTargetProperties, PlatformTargetProperties } from "./target";
+/**
+ * @param browsers supported browsers list
+ * @returns target properties
+ */
+export declare const resolve: (browsers: string[]) => EcmaTargetProperties & PlatformTargetProperties & ApiTargetProperties;

package/dist/config/defaults.d.ts

@@ -0,0 +1,4 @@
+import type { RspackOptionsNormalized } from "./normalization";
+export declare const applyRspackOptionsDefaults: (options: RspackOptionsNormalized) => void;
+export declare const applyRspackOptionsBaseDefaults: (options: RspackOptionsNormalized) => void;
+export declare const getPnpDefault: () => boolean;