extension-develop 4.0.11 → 4.0.12

package/dist/plugin-web-extension/feature-manifest/steps/apply-dev-defaults-lib/patch-web-resources.d.ts

@@ -0,0 +1,19 @@
+import { type Manifest } from '../../../../types';
+declare function patchWebResourcesV2(manifest: Manifest): string[];
+declare function patchWebResourcesV3(manifest: Manifest): ((string & {
+    resources: string[];
+    use_dynamic_url?: boolean | undefined;
+} & {
+    extension_ids: string[];
+    matches?: string[] | undefined;
+}) | (string & {
+    resources: string[];
+    use_dynamic_url?: boolean | undefined;
+} & {
+    matches: string[];
+    extension_ids?: string[] | undefined;
+}) | {
+    resources: string[];
+    matches: string[];
+})[];
+export { patchWebResourcesV2, patchWebResourcesV3 };

package/dist/plugin-web-extension/feature-manifest/steps/apply-dev-defaults.d.ts

@@ -0,0 +1,12 @@
+import { Compiler } from '@rspack/core';
+import type { PluginInterface } from '../../../types';
+/**
+ * Applies dev-only manifest patches (CSP, permissions, background, WAR for reload).
+ * Runs only in development mode, after WAR patching (REPORT+100).
+ */
+export declare class ApplyDevDefaults {
+    private readonly manifestPath?;
+    private readonly browser;
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-manifest/steps/emit-manifest.d.ts

@@ -0,0 +1,7 @@
+import { Compiler } from '@rspack/core';
+import { type PluginInterface } from '../../../types';
+export declare class EmitManifest {
+    readonly manifestPath: string;
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-manifest/steps/legacy-warnings.d.ts

@@ -0,0 +1,5 @@
+import { type Compiler } from '@rspack/core';
+export declare class ManifestLegacyWarnings {
+    static readonly name: string;
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-manifest/steps/patch-chromium-background.d.ts

@@ -0,0 +1,15 @@
+import { type Manifest, type DevOptions } from '../../../types';
+/**
+ * Chromium does not run MV3 `background.scripts` — the extension fails to load
+ * ("The 'background.scripts' key cannot be used with manifest_version 3"),
+ * while Firefox happily uses it as an event page. The mirror of
+ * patch-gecko-background: the scripts array is bundled into a single classic
+ * file regardless of target, so for Chromium-family MV3 targets we repoint
+ * `background` at that emitted bundle via `service_worker` and drop the
+ * `scripts` key Chromium rejects. The bundle is classic (no `type: module`),
+ * which a classic service worker runs as-is.
+ *
+ * No-op for Gecko targets, MV2, manifests that already declare a
+ * `background.service_worker`, and manifests with no scripts array.
+ */
+export declare function patchChromiumBackground(manifest: Manifest, browser: DevOptions['browser']): Manifest;

package/dist/plugin-web-extension/feature-manifest/steps/patch-dev-content-script-manifest-paths.d.ts

@@ -0,0 +1,11 @@
+import type { Compilation } from '@rspack/core';
+import type { Manifest } from '../../../types';
+/**
+ * After each dev compile, canonical content bundles emit as
+ * `content_scripts/content-N.<fullhash>.js`. Point manifest `content_scripts` at those
+ * filenames so page reloads load the same bytes as reinject (avoids stale cache).
+ *
+ * Also removes stale hashed files from previous builds so resolveEmittedContentScriptFile
+ * always finds the current bundle unambiguously.
+ */
+export declare function patchDevContentScriptManifestPaths(compilation: Compilation, manifest: Manifest): Manifest;

package/dist/plugin-web-extension/feature-manifest/steps/patch-gecko-background.d.ts

@@ -0,0 +1,15 @@
+import { type Manifest, type DevOptions } from '../../../types';
+/**
+ * Firefox does not run MV3 `background.service_worker` — it is disabled, and the
+ * add-on fails to install ("background.service_worker is currently disabled. Add
+ * background.scripts."). Firefox uses an event page via `background.scripts`.
+ *
+ * The user's background bundle is emitted regardless of target, so for Gecko
+ * targets we repoint `background` at that emitted file via `scripts` and drop
+ * the `service_worker`/`type` keys Firefox rejects. This keeps a single
+ * `background.service_worker` source authoring cross-browser.
+ *
+ * No-op for Chromium, for manifests that already declare `background.scripts`,
+ * and for manifests with no service worker.
+ */
+export declare function patchGeckoBackground(manifest: Manifest, browser: DevOptions['browser']): Manifest;

package/dist/plugin-web-extension/feature-manifest/steps/patch-war.d.ts

@@ -0,0 +1,15 @@
+import { Compiler } from '@rspack/core';
+import type { PluginInterface, DevOptions } from '../../../types';
+/**
+ * Patches manifest.json with web_accessible_resources from content script
+ * imports. Depends on CollectContentEntryImports (feature-web-resources)
+ * populating getSharedFor(compilation).entryImports before this runs.
+ */
+export declare class PatchWAR {
+    readonly manifestPath: string;
+    readonly browser?: DevOptions['browser'];
+    constructor(options: PluginInterface & {
+        browser?: DevOptions['browser'];
+    });
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-manifest/steps/persist-manifest.d.ts

@@ -0,0 +1,4 @@
+import { Compiler } from '@rspack/core';
+export declare class PersistManifestToDisk {
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-manifest/steps/update-manifest.d.ts

@@ -0,0 +1,9 @@
+import { Compiler } from '@rspack/core';
+import { PluginInterface, DevOptions } from '../../../types';
+export declare class UpdateManifest {
+    readonly manifestPath: string;
+    readonly browser: DevOptions['browser'];
+    constructor(options: PluginInterface);
+    private applyDevOverrides;
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-scripts/contracts.d.ts

@@ -0,0 +1,12 @@
+export declare const EXTENSIONJS_CONTENT_SCRIPT_LAYER = "extensionjs-content-script";
+export declare const CANONICAL_CONTENT_SCRIPT_ENTRY_PREFIX = "content_scripts/content-";
+export declare function getCanonicalContentScriptEntryName(index: number): string;
+export declare function getCanonicalContentScriptJsAssetName(index: number): string;
+export declare function getCanonicalContentScriptCssAssetName(index: number): string;
+export declare function parseCanonicalContentScriptEntryIndex(entryName: string): number | undefined;
+export declare function isCanonicalContentScriptEntryName(entryName: string): boolean;
+export declare function parseCanonicalContentScriptAsset(assetName: string): {
+    index: number;
+    extension: 'js' | 'css';
+} | undefined;
+export declare function isCanonicalContentScriptAsset(assetName: string): boolean;

package/dist/plugin-web-extension/feature-scripts/index.d.ts

@@ -0,0 +1,19 @@
+import { type Compiler } from '@rspack/core';
+import type { FilepathList, PluginInterface, DevOptions } from '../../types';
+/**
+ * Feature-scripts is the official scripts pipeline:
+ * - content scripts use the inline lifecycle runtime only
+ * - targeted reinjection stays browser-owned
+ * - background/manifest changes stay on the full-reload path
+ *
+ * The dev-only reload/HMR strategy is NOT part of this feature — it lives
+ * in plugin-reload, which registers after this plugin and decorates the
+ * entries AddScripts declares here.
+ */
+export declare class ScriptsPlugin {
+    readonly manifestPath: string;
+    readonly includeList?: FilepathList;
+    readonly browser?: DevOptions['browser'];
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-scripts/messages.d.ts

@@ -0,0 +1,7 @@
+export declare function importScriptsDependencyMissing(workerPath: string, literal: string, expectedPath: string, sourceSibling?: string): string;
+export declare function injectedFileDependencyMissing(assetName: string, literal: string, expectedPath: string, sourceSibling?: string): string;
+export declare function fetchedFileDependencyMissing(assetName: string, literal: string, expectedPath: string): string;
+export declare function getURLDependencyMissing(assetName: string, literal: string, expectedPath: string): string;
+export declare function runtimeSetSurfaceDependencyMissing(assetName: string, literal: string, expectedPath: string): string;
+export declare function staticImportDependencyMissing(assetName: string, literal: string, expectedPath: string): string;
+export declare function reservedScriptsFolder(relPath: string, indicators: string[]): string;

package/dist/plugin-web-extension/feature-scripts/scripts-lib/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function getScriptEntries(scriptPath: string | string[] | undefined): string[];
+export declare function getCssEntries(scriptPath: string | string[] | undefined): string[];

package/dist/plugin-web-extension/feature-scripts/steps/add-content-script-wrapper/classic-concat-loader.d.ts

@@ -0,0 +1,8 @@
+interface ClassicConcatLoaderContext {
+    resourcePath: string;
+    resourceQuery: string;
+    addDependency(dep: string): void;
+    callback(err: Error | null, content?: string, sourceMap?: any): void;
+}
+export default function classicConcatLoader(this: ClassicConcatLoaderContext, _source: string): void;
+export {};

package/dist/plugin-web-extension/feature-scripts/steps/add-content-script-wrapper/content-script-wrapper.d.ts

@@ -0,0 +1,13 @@
+interface ContentScriptLoaderContext {
+    getOptions(): {
+        manifestPath: string;
+        mode?: string;
+    };
+    _compilation?: any;
+    resourcePath: string;
+    resourceQuery?: string;
+    emitWarning?(warning: Error): void;
+    callback(err: Error | null, content?: string, sourceMap?: any): void;
+}
+export default function contentScriptWrapper(this: ContentScriptLoaderContext, source: string, inputSourceMap?: any): string | void;
+export {};

package/dist/plugin-web-extension/feature-scripts/steps/add-content-script-wrapper/get-bridge-scripts.d.ts

@@ -0,0 +1,6 @@
+import type { DevOptions, FilepathList } from '../../../../types';
+export declare function resolveMainWorldBridgeSourcePath(options?: {
+    lookupDir?: string;
+    packageRoot?: string;
+}): string | undefined;
+export declare function getMainWorldBridgeScripts(manifestPath: string, browser?: DevOptions['browser']): FilepathList;

package/dist/plugin-web-extension/feature-scripts/steps/add-content-script-wrapper/index.d.ts

@@ -0,0 +1,11 @@
+import { type Compiler } from '@rspack/core';
+import type { PluginInterface, DevOptions, FilepathList } from '../../../../types';
+export declare class AddContentScriptWrapper {
+    static getBridgeScripts(manifestPath: string, browser?: DevOptions['browser']): FilepathList;
+    private readonly manifestPath;
+    private readonly browser;
+    constructor(options: PluginInterface);
+    private resolveLoader;
+    private resolveConcatLoader;
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-scripts/steps/add-public-path-runtime-module.d.ts

@@ -0,0 +1,4 @@
+import { type Compiler } from '@rspack/core';
+export declare class AddPublicPathRuntimeModule {
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-scripts/steps/add-scripts.d.ts

@@ -0,0 +1,9 @@
+import { type Compiler } from '@rspack/core';
+import { type DevOptions, type FilepathList, type PluginInterface } from '../../../types';
+export declare class AddScripts {
+    readonly manifestPath: string;
+    readonly includeList: FilepathList;
+    readonly browser: DevOptions['browser'];
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-scripts/steps/keep-geturl-imports-native.d.ts

@@ -0,0 +1,15 @@
+import { type Compiler } from '@rspack/core';
+import type { PluginInterface } from '../../../types';
+/**
+ * Registers the loader that keeps `import(chrome.runtime.getURL(...))`
+ * native. The argument is an absolute chrome-extension:// URL at runtime, so
+ * the bundler's module map can never satisfy it — lowered calls throw
+ * `Cannot find module 'chrome-extension://<id>/...'` in real Chrome while
+ * the source loads fine unpacked. TraceRuntimeLoadedFiles ships the target
+ * files; this step keeps the call site resolvable by the browser.
+ */
+export declare class KeepGetURLImportsNative {
+    private readonly manifestPath;
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-scripts/steps/native-geturl-import-loader.d.ts

@@ -0,0 +1,3 @@
+export declare function annotateGetURLDynamicImports(source: string): string;
+/** Loader entry: source-to-source, before the swc transform. */
+export default function nativeGetURLImportLoader(this: unknown, source: string): string;

package/dist/plugin-web-extension/feature-scripts/steps/trace-runtime-loaded-files.d.ts

@@ -0,0 +1,41 @@
+import { type Compiler } from '@rspack/core';
+export declare class TraceRuntimeLoadedFiles {
+    readonly manifestPath: string;
+    constructor(options: {
+        manifestPath: string;
+    });
+    apply(compiler: Compiler): void;
+    private readManifest;
+    private traceWorkerImportScripts;
+    private traceFetchedFiles;
+    private traceGetURLFiles;
+    private traceWebpackChunkSiblings;
+    private traceInjectedFilePayloads;
+}
+/**
+ * Resolve a runtime URL literal the way the browser does — against a base
+ * path inside the extension origin — and return the extension-root-relative
+ * output path, or null for anything that isn't a same-origin file reference
+ * (remote URLs, other schemes, protocol-relative URLs).
+ */
+export declare function resolveExtensionPath(literal: string, basePath: string): string | null;
+/**
+ * Extract HTML surface paths set at runtime: chrome.action.setPopup(
+ * {popup: "Alt.html"}) (plus browserAction/pageAction MV2 variants) and
+ * chrome.sidePanel.setOptions({path: "panel.html"}). Chrome resolves these
+ * against the extension root, but they are not manifest refs, so the page
+ * pipeline never compiles them — untraced they silently vanish from dist and
+ * the surface opens a 404 panel. Matching on the member chain
+ * (`action.setPopup(`) keeps user-defined functions out while surviving
+ * minification, mirroring extractGetURLLiterals.
+ */
+export declare function extractRuntimeSurfaceLiterals(source: string): string[];
+/**
+ * Extract module specifiers a raw (unbundled) ES module resolves against its
+ * own URL at runtime: static `import ... from "./x.js"`, side-effect
+ * `import "./x.js"`, re-exports (`export {a} from` / `export * from`), and
+ * literal dynamic `import("./x.js")`. Only same-origin file specifiers
+ * (./ ../ or /-anchored) qualify — bare package specifiers cannot resolve in
+ * the browser and belong to the bundler, not the copy-through path.
+ */
+export declare function extractStaticImportLiterals(source: string): string[];

package/dist/plugin-web-extension/feature-scripts/steps/validate-content-script-syntax.d.ts

@@ -0,0 +1,18 @@
+import { Compiler } from '@rspack/core';
+/**
+ * Parse-check every emitted content-script bundle and FAIL the compile on a
+ * SyntaxError. swc tolerates some early errors (e.g. a top-level `let x` +
+ * `const {x}` redeclaration) and happily emits them into the bundle — and the
+ * browser then silently skips the unparsable file: no console error, no
+ * injection, dev's "Reloading content_script…" reloading nothing. Real-world
+ * hit: Origin-pod__OriginBrain shipped exactly that shape and looked healthy
+ * everywhere while its content script never ran.
+ *
+ * `new Function(source)` only COMPILES the source (nothing executes), so this
+ * is a cheap, safe V8 parse — the same engine family that will load the file.
+ * Content scripts are always injected as classic scripts, so function-body
+ * parsing is the right (slightly lenient) approximation.
+ */
+export declare class ValidateContentScriptSyntax {
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-web-resources/collect-entry-imports.d.ts

@@ -0,0 +1,3 @@
+import type { Compilation } from '@rspack/core';
+import type { FilepathList } from '../../types';
+export declare function collectContentScriptEntryImports(compilation: Compilation, includeList?: FilepathList): Record<string, string[]>;

package/dist/plugin-web-extension/feature-web-resources/index.d.ts

@@ -0,0 +1,19 @@
+import { Compiler } from '@rspack/core';
+import { type FilepathList, type PluginInterface } from '../../types';
+/**
+ * ResourcesPlugin collects content script imports for manifest WAR patching.
+ * Actual manifest patching is done by ManifestPlugin (PatchWAR step) so all
+ * manifest writes stay consolidated in feature-manifest.
+ *
+ * Feature supported:
+ *
+ * - Collects assets imported from content_scripts files.
+ * - WAR patching uses this data (via getSharedFor) in manifest:patch-war.
+ */
+export declare class WebResourcesPlugin {
+    readonly manifestPath: string;
+    readonly includeList?: FilepathList;
+    readonly browser?: string;
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-web-resources/steps/collect-content-entry-imports.d.ts

@@ -0,0 +1,10 @@
+import { Compiler } from '@rspack/core';
+import type { FilepathList } from '../../../types';
+export declare class CollectContentEntryImports {
+    readonly includeList?: FilepathList;
+    constructor(options: {
+        manifestPath: string;
+        includeList?: FilepathList;
+    });
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/feature-web-resources/web-resources-lib/clean-matches.d.ts

@@ -0,0 +1,7 @@
+/**
+ * From the docs at https://developer.chrome.com/docs/extensions/reference/manifest/web-accessible-resources#manifest_declaration
+ * > Google Chrome emits an "Invalid match pattern" error if the pattern has a path other than '/*'.
+ *
+ * We need to ensure that paths are cleaned up from the matches to avoid this error.
+ */
+export declare function cleanMatches(matches: string[]): string[];

package/dist/plugin-web-extension/feature-web-resources/web-resources-lib/generate-manifest.d.ts

@@ -0,0 +1,11 @@
+import { Compilation } from '@rspack/core';
+type WarV3Group = {
+    resources: string[];
+    matches: string[];
+    [key: string]: unknown;
+};
+export declare function mergeIntoV3Group(groups: WarV3Group[], normalizedMatches: string[], resources: string[], options?: {
+    createGroupWhenMissing?: boolean;
+}): void;
+export declare function generateManifestPatches(compilation: Compilation, manifestPath: string, entryImports: Record<string, string[]>, browser?: string): void;
+export {};

package/dist/plugin-web-extension/feature-web-resources/web-resources-lib/messages.d.ts

@@ -0,0 +1,10 @@
+export declare function warFieldError(filePath: string, opts?: {
+    overrideNotFoundPath?: string;
+    publicRootHint?: boolean;
+    relativeRef?: string;
+    sourceSibling?: string;
+}): string;
+export declare function warStringEntryInMv3(entry: string): string;
+export declare function warInvalidMatchPattern(pattern: string): string;
+export declare function entryImportsSummary(entryCount: number, totalResources: number): string;
+export declare function warPatchedSummary(v3Groups: number, v3ResourcesTotal: number, v2Resources: number): string;

package/dist/plugin-web-extension/feature-web-resources/web-resources-lib/resolve-war.d.ts

@@ -0,0 +1,9 @@
+import { Compilation } from '@rspack/core';
+export declare function resolveUserDeclaredWAR(compilation: Compilation, manifestPath: string, manifest: unknown, browser?: string): {
+    v2: Set<string>;
+    v3: {
+        matches: string[];
+        resources: Set<string>;
+        extra?: Record<string, unknown>;
+    }[];
+};

package/dist/plugin-web-extension/feature-web-resources/web-resources-lib/shared.d.ts

@@ -0,0 +1,4 @@
+export type WebResourcesShared = {
+    entryImports: Record<string, string[]>;
+};
+export declare function getSharedFor(compilation: object): WebResourcesShared;

package/dist/plugin-web-extension/index.d.ts

@@ -0,0 +1,9 @@
+import { Compiler } from '@rspack/core';
+import type { PluginInterface, DevOptions } from '../types';
+export declare class WebExtensionPlugin {
+    static readonly name: string;
+    readonly manifestPath: string;
+    readonly browser: DevOptions['browser'];
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}

package/dist/plugin-web-extension/shared/classic-concat.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Classic scripts loaded side by side (content_scripts arrays, multiple
+ * <script src> tags in one HTML page) share a single global scope in the
+ * browser: a top-level `var storage` in one file is visible to its siblings.
+ * Bundling each file as a separate ES module isolates those scopes and breaks
+ * the implicit cross-file globals. When every file in a group is classic (no
+ * top-level import/export), the group is concatenated into one module by the
+ * classic-concat loader instead — matching browser semantics.
+ */
+export declare function isClassicScript(filePath: string): boolean;
+/**
+ * Build the stub entry the classic-concat loader consumes. Instead of baking
+ * file contents into a data: URI (which rspack never watches and cannot
+ * source-map), the stub resolves to a real file (the first one) carrying a
+ * query with the full file list; the loader reads each file via addDependency
+ * (enabling watch-mode rebuilds) and generates a V3 source map.
+ */
+export declare function classicConcatEntry(feature: string, jsFiles: string[]): string;

package/dist/plugin-web-extension/shared/compilation-issues.d.ts

@@ -0,0 +1,6 @@
+import type { Compilation, Compiler } from '@rspack/core';
+export type IssueType = 'error' | 'warning';
+export declare function createIssue(compiler: Compiler, message: string, type?: IssueType): Error & {
+    name?: string;
+};
+export declare function reportToCompilation(compilation: Compilation, compiler: Compiler, message: string, type?: IssueType, file?: string): void;

package/dist/plugin-web-extension/shared/manifest-fields-change-detector.d.ts

@@ -0,0 +1,12 @@
+import { Compiler } from '@rspack/core';
+import type { DevOptions, PluginInterface } from '../../types';
+export declare class ManifestFieldsChangeDetector {
+    readonly manifestPath: string;
+    readonly browser: DevOptions['browser'];
+    private prev;
+    private pending;
+    constructor(options: PluginInterface);
+    private readSnapshot;
+    apply(compiler: Compiler): void;
+    private emitErrors;
+}

package/dist/plugin-web-extension/shared/paths.d.ts

@@ -0,0 +1,26 @@
+import { type FilepathList } from '../../types';
+export declare function isFromFilepathList(filePath: string, filepathList?: FilepathList): boolean;
+export declare function getFilename(feature: string, filePath: string): string;
+/**
+ * Change the path from win style to unix style
+ */
+export declare function unixify(filePath: string): string;
+/**
+ * Resolve a root-absolute reference (`/nscl/main.js`, `url(/img/warn.svg)`)
+ * against the EXTENSION ROOT, the way Chrome does.
+ *
+ * Chrome resolves a leading `/` from the extension root — which, for a vanilla
+ * (non-bundled) extension, is the source directory. Extension.js only ever
+ * looked such refs up in `public/`, so wild extensions that keep their assets
+ * at the root failed to build (hackademix/noscript, mozilla/multi-account-containers).
+ *
+ * Strictly additive: `public/` still wins when it has the file, and we only
+ * claim a ref that actually exists at the root — so a ref that was already
+ * broken stays broken (and still reported).
+ *
+ * Returns the absolute source path to copy into the output root, or undefined
+ * when the ref is not ours to satisfy.
+ */
+export declare function resolveRootAbsoluteRef(ref: string, projectRoot: string, publicRoot?: string): string | undefined;
+/** Root-absolute refs in HTML (`src`/`href`) and CSS (`url(...)`). */
+export declare function collectRootAbsoluteRefs(source: string): Set<string>;

package/dist/preview-entry.d.ts

@@ -0,0 +1,3 @@
+export { extensionPreview } from './command-preview';
+export type { ResolvedPreviewOptions, PreviewLauncherFn } from './command-preview';
+export type { PreviewOptions } from './types';

package/dist/rslib.config.d.ts

@@ -0,0 +1,3 @@
+import type { RslibConfig } from '@rslib/core';
+declare const _default: RslibConfig;
+export default _default;

package/dist/rspack-config.d.ts

@@ -0,0 +1,4 @@
+import { type Configuration } from '@rspack/core';
+import { type ProjectStructure } from './lib/project';
+import type { WebpackConfigOptions } from './types';
+export default function webpackConfig(projectStructure: ProjectStructure, devOptions: WebpackConfigOptions): Configuration;