extension-develop 2.0.0-rc.9 → 2.0.1

package/dist/webpack/plugin-browsers/run-chromium/master-preferences.d.ts

@@ -0,0 +1,161 @@
+declare const chromeMasterPreferences: {
+    alternate_error_pages: {
+        enabled: boolean;
+    };
+    autofill: {
+        enabled: boolean;
+    };
+    browser: {
+        check_default_browser: boolean;
+        default_browser_setting_enabled: boolean;
+    };
+    default_apps: string;
+    distribution: {
+        alternate_shortcut_text: boolean;
+        auto_launch_chrome: boolean;
+        import_bookmarks: boolean;
+        import_history: boolean;
+        import_home_page: boolean;
+        import_search_engine: boolean;
+        suppress_first_run_bubble: boolean;
+        do_not_register_for_update_launch: boolean;
+        make_chrome_default: boolean;
+        make_chrome_default_for_user: boolean;
+        require_eula: boolean;
+        suppress_first_run_default_browser_prompt: boolean;
+    };
+    dns_prefetching: {
+        enabled: boolean;
+    };
+    download: {
+        default_directory: string;
+        directory_upgrade: boolean;
+        open_pdf_in_adobe_reader: boolean;
+        prompt_for_download: boolean;
+    };
+    enable_do_not_track: boolean;
+    extensions: {
+        theme: {
+            use_system: boolean;
+        };
+        toolbarsize: number;
+        ui: {
+            developer_mode: boolean;
+        };
+    };
+    plugins: {
+        plugins_list: {
+            enabled: boolean;
+            name: string;
+        }[];
+        show_details: boolean;
+    };
+    profile: {
+        password_manager_enabled: boolean;
+    };
+    safebrowsing: {
+        enabled: boolean;
+        safebrowsingextended_reporting_enabled: boolean;
+    };
+    savefile: {
+        default_directory: string;
+        type: number;
+    };
+    search: {
+        suggest_enabled: boolean;
+    };
+    session: {
+        restore_on_startup: number;
+    };
+    sync: {
+        suppress_start: boolean;
+    };
+    sync_promo: {
+        show_on_first_run_allowed: boolean;
+        show_ntp_bubble: boolean;
+    };
+    translate: {
+        enabled: boolean;
+    };
+};
+declare const edgeMasterPreferences: {
+    alternate_error_pages: {
+        enabled: boolean;
+    };
+    autofill: {
+        enabled: boolean;
+    };
+    browser: {
+        check_default_browser: boolean;
+        default_browser_setting_enabled: boolean;
+    };
+    default_apps: string;
+    distribution: {
+        alternate_shortcut_text: boolean;
+        auto_launch_chrome: boolean;
+        import_bookmarks: boolean;
+        import_history: boolean;
+        import_home_page: boolean;
+        import_search_engine: boolean;
+        suppress_first_run_bubble: boolean;
+        do_not_register_for_update_launch: boolean;
+        make_chrome_default: boolean;
+        make_chrome_default_for_user: boolean;
+        require_eula: boolean;
+        suppress_first_run_default_browser_prompt: boolean;
+    };
+    dns_prefetching: {
+        enabled: boolean;
+    };
+    download: {
+        default_directory: string;
+        directory_upgrade: boolean;
+        open_pdf_in_adobe_reader: boolean;
+        prompt_for_download: boolean;
+    };
+    enable_do_not_track: boolean;
+    extensions: {
+        theme: {
+            use_system: boolean;
+        };
+        toolbarsize: number;
+        ui: {
+            developer_mode: boolean;
+        };
+    };
+    plugins: {
+        plugins_list: {
+            enabled: boolean;
+            name: string;
+        }[];
+        show_details: boolean;
+    };
+    profile: {
+        password_manager_enabled: boolean;
+    };
+    safebrowsing: {
+        enabled: boolean;
+        safebrowsingextended_reporting_enabled: boolean;
+    };
+    savefile: {
+        default_directory: string;
+        type: number;
+    };
+    search: {
+        suggest_enabled: boolean;
+    };
+    session: {
+        restore_on_startup: number;
+    };
+    sync: {
+        suppress_start: boolean;
+    };
+    sync_promo: {
+        show_on_first_run_allowed: boolean;
+        show_ntp_bubble: boolean;
+    };
+    translate: {
+        enabled: boolean;
+    };
+};
+export { chromeMasterPreferences, edgeMasterPreferences };

package/dist/webpack/plugin-browsers/run-chromium/setup-chrome-inspection/cdp-client.d.ts

@@ -0,0 +1,29 @@
+export declare class CDPClient {
+    private port;
+    private host;
+    private ws;
+    private messageId;
+    private pendingRequests;
+    private targetWebSocketUrl;
+    constructor(port?: number, host?: string);
+    connect(): Promise<void>;
+    disconnect(): void;
+    sendCommand(method: string, params?: any, sessionId?: string): Promise<any>;
+    private handleMessage;
+    getTargets(): Promise<any[]>;
+    createTarget(url: string): Promise<string>;
+    navigateToUrl(targetId: string, url: string): Promise<void>;
+    private establishBrowserConnection;
+    attachToTarget(targetId: string): Promise<string>;
+    navigate(sessionId: string, url: string): Promise<void>;
+    waitForLoadEvent(sessionId: string): Promise<void>;
+    waitForContentScriptInjection(sessionId: string): Promise<void>;
+    evaluate(sessionId: string, expression: string): Promise<any>;
+    getPageHTML(sessionId: string): Promise<string>;
+    closeTarget(targetId: string): Promise<void>;
+    forceReloadExtension(extensionId: string): Promise<boolean>;
+    getExtensionInfo(extensionId: string): Promise<any>;
+    loadUnpackedExtension(path: string): Promise<string>;
+    unloadExtension(extensionId: string): Promise<boolean>;
+}
+export declare function checkChromeRemoteDebugging(port?: number): Promise<boolean>;

package/dist/webpack/plugin-browsers/run-chromium/setup-chrome-inspection/index.d.ts

@@ -0,0 +1,25 @@
+import { type Compiler } from '@rspack/core';
+import { type DevOptions } from '../../../../develop-lib/config-types';
+export declare class SetupChromeInspectionStep {
+    private devOptions;
+    private cdpClient;
+    private currentTargetId;
+    private currentSessionId;
+    private isInitialized;
+    constructor(devOptions: DevOptions & {
+        startingUrl?: string;
+    });
+    private getCdpPort;
+    initialize(port?: number): Promise<void>;
+    inspectSource(url: string): Promise<string>;
+    startWatching(websocketServer: any): Promise<void>;
+    private setupWebSocketHandler;
+    private setupConnectionHandler;
+    stopWatching(): void;
+    private handleFileChange;
+    private reconnectToTarget;
+    printHTML(html: string): void;
+    printUpdatedHTML(html: string): void;
+    cleanup(): Promise<void>;
+    apply(compiler: Compiler): void;
+}

package/dist/webpack/plugin-browsers/run-firefox/firefox/binary-detector.d.ts

@@ -0,0 +1,15 @@
+export declare class FirefoxBinaryDetector {
+    static detectFirefoxBinary(customBinary?: string): Promise<string>;
+    private static detectFlatpakFirefox;
+    private static detectSnapFirefox;
+    private static detectTraditionalFirefox;
+    private static detectCustomFirefox;
+    static generateFirefoxArgs(binaryPath: string, profilePath: string, debugPort: number, additionalArgs?: string[]): {
+        binary: string;
+        args: string[];
+    };
+    static validateFirefoxBinary(binaryPath: string): Promise<{
+        version: string;
+        path: string;
+    }>;
+}

package/dist/webpack/plugin-browsers/run-firefox/firefox/browser-config.d.ts

@@ -0,0 +1,7 @@
+import { Compilation } from '@rspack/core';
+import { type DevOptions, type BrowserConfig } from '../../../../develop-lib/config-types';
+export declare function browserConfig(compilation: Compilation, configOptions: DevOptions & BrowserConfig & {
+    keepProfileChanges?: boolean;
+    copyFromProfile?: string;
+    instanceId?: string;
+}): Promise<string>;

package/dist/webpack/plugin-browsers/run-firefox/firefox/create-profile.d.ts

@@ -0,0 +1,13 @@
+import { Compilation } from '@rspack/core';
+import FirefoxProfile from 'firefox-profile';
+import { BrowserConfig, DevOptions } from '../../../../develop-lib/config-types';
+interface FirefoxProfileOptions {
+    browser: DevOptions['browser'];
+    userProfilePath: string | false | undefined;
+    configPreferences: BrowserConfig['preferences'];
+    keepProfileChanges?: boolean;
+    copyFromProfile?: string;
+    instanceId?: string;
+}
+export declare function createProfile(compilation: Compilation, { browser, userProfilePath, configPreferences, instanceId }: FirefoxProfileOptions): FirefoxProfile;
+export {};

package/dist/webpack/plugin-browsers/run-firefox/firefox/master-preferences.d.ts

@@ -0,0 +1,95 @@
+declare const masterPreferences: {
+    'app.update.enabled': boolean;
+    'browser.dom.window.dump.enabled': boolean;
+    'browser.formfill.enable': boolean;
+    'browser.link.open_newwindow': number;
+    'browser.sessionstore.enabled': boolean;
+    'browser.shell.checkDefaultBrowser': boolean;
+    'browser.sync.enabled': boolean;
+    'browser.startup.page': number;
+    'browser.startup.homepage_welcome_url': string;
+    'browser.startup.homepage_welcome_url_additional': string;
+    'browser.urlbar.suggest.bookmark': boolean;
+    'browser.urlbar.suggest.clipboard': boolean;
+    'browser.urlbar.suggest.history': boolean;
+    'browser.urlbar.suggest.openpage': boolean;
+    'browser.urlbar.suggest.remotetab': boolean;
+    'browser.urlbar.suggest.searches': boolean;
+    'browser.urlbar.suggest.topsites': boolean;
+    'browser.urlbar.suggest.engines': boolean;
+    'browser.urlbar.suggest.calculator': boolean;
+    'browser.urlbar.suggest.recentsearches': boolean;
+    'datareporting.policy.dataSubmissionEnabled': boolean;
+    'datareporting.policy.firstRunURL': string;
+    'devtools.browserconsole.contentMessages': boolean;
+    'devtools.chrome.enabled': boolean;
+    'devtools.debugger.prompt-connection': boolean;
+    'devtools.debugger.remote-enabled': boolean;
+    'devtools.errorconsole.enabled': boolean;
+    'extensions.installDistroAddons': boolean;
+    'extensions.autoDisableScopes': number;
+    'extensions.chrome.enabled': boolean;
+    'extensions.logging.enabled': boolean;
+    'extensions.checkCompatibility.nightly': boolean;
+    'extensions.update.enabled': boolean;
+    'extensions.update.notifyUser': boolean;
+    'extensions.enabledScopes': number;
+    'extensions.getAddons.cache.enabled': boolean;
+    'network.prefetch.next': boolean;
+    'network.speculative.preconnect.enabled': boolean;
+    'toolkit.telemetry.enabled': boolean;
+    'toolkit.telemetry.archive.enabled': boolean;
+    'toolkit.telemetry.newProfilePing.enabled': boolean;
+    'toolkit.recovery.enabled': boolean;
+    'urlclassifier.updateinterval': number;
+    'security.enterprise_roots.enabled': boolean;
+    'xpinstall.signatures.required': boolean;
+};
+export default masterPreferences;
+export declare function getPreferences(customPrefs: Record<string, any>): {
+    'app.update.enabled': boolean;
+    'browser.dom.window.dump.enabled': boolean;
+    'browser.formfill.enable': boolean;
+    'browser.link.open_newwindow': number;
+    'browser.sessionstore.enabled': boolean;
+    'browser.shell.checkDefaultBrowser': boolean;
+    'browser.sync.enabled': boolean;
+    'browser.startup.page': number;
+    'browser.startup.homepage_welcome_url': string;
+    'browser.startup.homepage_welcome_url_additional': string;
+    'browser.urlbar.suggest.bookmark': boolean;
+    'browser.urlbar.suggest.clipboard': boolean;
+    'browser.urlbar.suggest.history': boolean;
+    'browser.urlbar.suggest.openpage': boolean;
+    'browser.urlbar.suggest.remotetab': boolean;
+    'browser.urlbar.suggest.searches': boolean;
+    'browser.urlbar.suggest.topsites': boolean;
+    'browser.urlbar.suggest.engines': boolean;
+    'browser.urlbar.suggest.calculator': boolean;
+    'browser.urlbar.suggest.recentsearches': boolean;
+    'datareporting.policy.dataSubmissionEnabled': boolean;
+    'datareporting.policy.firstRunURL': string;
+    'devtools.browserconsole.contentMessages': boolean;
+    'devtools.chrome.enabled': boolean;
+    'devtools.debugger.prompt-connection': boolean;
+    'devtools.debugger.remote-enabled': boolean;
+    'devtools.errorconsole.enabled': boolean;
+    'extensions.installDistroAddons': boolean;
+    'extensions.autoDisableScopes': number;
+    'extensions.chrome.enabled': boolean;
+    'extensions.logging.enabled': boolean;
+    'extensions.checkCompatibility.nightly': boolean;
+    'extensions.update.enabled': boolean;
+    'extensions.update.notifyUser': boolean;
+    'extensions.enabledScopes': number;
+    'extensions.getAddons.cache.enabled': boolean;
+    'network.prefetch.next': boolean;
+    'network.speculative.preconnect.enabled': boolean;
+    'toolkit.telemetry.enabled': boolean;
+    'toolkit.telemetry.archive.enabled': boolean;
+    'toolkit.telemetry.newProfilePing.enabled': boolean;
+    'toolkit.recovery.enabled': boolean;
+    'urlclassifier.updateinterval': number;
+    'security.enterprise_roots.enabled': boolean;
+    'xpinstall.signatures.required': boolean;
+};

package/dist/webpack/plugin-browsers/run-firefox/index.d.ts

@@ -0,0 +1,26 @@
+import { type PluginInterface } from '../browsers-types';
+import { DevOptions } from '../../../develop-lib/config-types';
+export declare class RunFirefoxPlugin {
+    readonly extension: string | string[];
+    readonly browser: DevOptions['browser'];
+    readonly browserFlags?: string[];
+    readonly profile?: string | false;
+    readonly preferences?: Record<string, any>;
+    readonly startingUrl?: string;
+    readonly autoReload?: boolean;
+    readonly stats?: boolean;
+    readonly geckoBinary?: string;
+    readonly port?: number | string;
+    readonly instanceId?: string;
+    readonly keepProfileChanges?: boolean;
+    readonly copyFromProfile?: string;
+    readonly source?: string | boolean;
+    readonly watchSource?: boolean;
+    readonly reuseProfile?: boolean;
+    readonly dryRun?: boolean;
+    constructor(options: PluginInterface);
+    private launchFirefox;
+    apply(compiler: any): void;
+    private setupProcessSignalHandlers;
+    private cleanupInstance;
+}

package/dist/webpack/plugin-browsers/run-firefox/remote-firefox/index.d.ts

@@ -0,0 +1,13 @@
+import { Compilation } from '@rspack/core';
+import { type PluginInterface } from '../../browsers-types';
+export declare class RemoteFirefox {
+    private readonly options;
+    private client;
+    constructor(configOptions: PluginInterface);
+    private connectClient;
+    installAddons(compilation: Compilation): Promise<void>;
+    inspectSource(compilation: Compilation, opts: {
+        startingUrl?: string;
+        source?: string | boolean;
+    }): Promise<void>;
+}

package/dist/webpack/plugin-browsers/run-firefox/remote-firefox/message-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function requestErrorToMessage(err: any): string;
+export declare function isErrorWithCode(codeWanted: any, error: any): boolean;

package/dist/webpack/plugin-browsers/run-firefox/remote-firefox/messaging-client.d.ts

@@ -0,0 +1,42 @@
+import EventEmitter from 'events';
+export declare class MessagingClient extends EventEmitter {
+    private incomingData;
+    private pendingRequests;
+    private readonly activeRequests;
+    private connection?;
+    connect(port: number): Promise<void>;
+    disconnect(): void;
+    private rejectAllRequests;
+    request(requestProps: any): Promise<any>;
+    private flushPendingRequests;
+    private expectReply;
+    private onData;
+    private readMessage;
+    private handleMessage;
+    onError(error: Error): void;
+    onEnd(): void;
+    onTimeout(): void;
+    getTargets(): Promise<any>;
+    navigate(tabId: string, url: string): Promise<void>;
+    attach(tabId: string): Promise<any>;
+    getTargetFromDescriptor(descriptorId: string): Promise<{
+        targetActor: any;
+        consoleActor: any;
+    } | {
+        targetActor?: undefined;
+        consoleActor?: undefined;
+    }>;
+    addTab(url: string): Promise<any>;
+    navigateViaScript(consoleActor: string, url: string): Promise<void>;
+    waitForPageReady(consoleActor: string, url: string, timeoutMs?: number): Promise<void>;
+    waitForLoadEvent(tabId: string): Promise<void>;
+    evaluate(tabId: string, expression: string): Promise<any>;
+    evaluateRaw(tabId: string, expression: string): Promise<any>;
+    private coerceResponseToString;
+    private resolveActorForEvaluation;
+    private serializeDocument;
+    private extractShadowContent;
+    private mergeShadowIntoMain;
+    getPageHTML(descriptorActor: string, consoleActorHint?: string): Promise<string>;
+    closeTab(tabId: string): Promise<void>;
+}

package/dist/webpack/plugin-browsers/run-firefox/remote-firefox/setup-firefox-inspection.d.ts

@@ -0,0 +1,31 @@
+import { type Compiler } from '@rspack/core';
+import { DevOptions } from '../../../../develop-lib/config-types';
+interface SetupFirefoxInspectionStepOptions extends DevOptions {
+    startingUrl?: string;
+    instanceId?: string;
+}
+export declare class SetupFirefoxInspectionStep {
+    private readonly devOptions;
+    private client;
+    private currentConsoleActor;
+    private currentTabActor;
+    private isWatching;
+    private debounceTimer;
+    private initialized;
+    private lastUrlToInspect;
+    constructor(devOptions: SetupFirefoxInspectionStepOptions);
+    private getRdpPort;
+    private initialize;
+    private resolveUrlToInspect;
+    private selectActors;
+    private ensureNavigatedAndLoaded;
+    private ensureUrlAndReady;
+    private resolveConsoleActor;
+    private printHTML;
+    private waitForContentScriptInjection;
+    private setupWebSocketHandler;
+    private attachConnection;
+    private handleFileChange;
+    apply(compiler: Compiler): void;
+}
+export {};

package/dist/webpack/plugin-compatibility/feature-browser-specific-fields.d.ts

@@ -0,0 +1,9 @@
+import { type Compiler } from '@rspack/core';
+import { type PluginInterface, type Manifest } from '../webpack-types';
+export declare class BrowserSpecificFieldsPlugin {
+    private readonly browser;
+    private readonly manifestPath;
+    constructor(options: PluginInterface);
+    patchManifest(manifest: Manifest): string;
+    apply(compiler: Compiler): void;
+}

package/dist/webpack/plugin-compatibility/feature-polyfill.d.ts

@@ -0,0 +1,12 @@
+import { Compiler } from '@rspack/core';
+import { PluginInterface } from '../webpack-types';
+/**
+ * PolyfillPlugin is responsible for providing the `browser`
+ * global variable to the extension's codebase.
+ */
+export declare class PolyfillPlugin {
+    readonly manifestPath: string;
+    readonly browser?: string;
+    constructor(options: PluginInterface);
+    apply(compiler: Compiler): void;
+}

package/dist/webpack/plugin-compatibility/index.d.ts

@@ -0,0 +1,13 @@
+import { type Compiler } from '@rspack/core';
+import { PluginInterface } from '../webpack-types';
+import { type DevOptions } from '../../develop-lib/config-types';
+export declare class CompatibilityPlugin {
+    static readonly name: string;
+    readonly manifestPath: string;
+    readonly browser: DevOptions['browser'];
+    readonly polyfill: DevOptions['polyfill'];
+    constructor(options: PluginInterface & {
+        polyfill: DevOptions['polyfill'];
+    });
+    apply(compiler: Compiler): Promise<void>;
+}

package/dist/webpack/plugin-compilation/clean-dist.d.ts

@@ -0,0 +1,8 @@
+import { type Compiler } from '@rspack/core';
+export declare class CleanDistFolderPlugin {
+    private options;
+    constructor(options: {
+        browser: string;
+    });
+    apply(compiler: Compiler): void;
+}

package/dist/webpack/plugin-compilation/env.d.ts

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

package/dist/webpack/plugin-compilation/index.d.ts

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

package/dist/webpack/plugin-css/common-style-loaders.d.ts

@@ -0,0 +1,8 @@
+import { type RuleSetRule } from '@rspack/core';
+import { type DevOptions } from '../../develop-lib/config-types';
+export interface StyleLoaderOptions {
+    mode: DevOptions['mode'];
+    loader?: string;
+    loaderOptions?: Record<string, any>;
+}
+export declare function commonStyleLoaders(projectPath: string, opts: StyleLoaderOptions): Promise<RuleSetRule['use']>;

package/dist/webpack/plugin-css/css-in-content-script-loader.d.ts

@@ -0,0 +1,11 @@
+import { DevOptions } from '../../develop-lib/config-types';
+export declare function cssInContentScriptLoader(projectPath: string, mode: DevOptions['mode']): Promise<{
+    use: import("@rspack/core").RuleSetUse | undefined;
+    test: RegExp;
+    exclude: RegExp | undefined;
+    type: "asset";
+    generator: {
+        filename: string;
+    };
+    issuer: (issuer: string) => boolean;
+}[]>;

package/dist/webpack/plugin-css/css-in-html-loader.d.ts

@@ -0,0 +1,8 @@
+import { DevOptions } from '../../develop-lib/config-types';
+export declare function cssInHtmlLoader(projectPath: string, mode: DevOptions['mode']): Promise<{
+    use: import("@rspack/core").RuleSetUse | undefined;
+    test: RegExp;
+    exclude: RegExp | undefined;
+    type: string;
+    issuer: (issuer: string) => boolean;
+}[]>;

package/dist/webpack/plugin-css/css-tools/less.d.ts

@@ -0,0 +1,4 @@
+export declare function isUsingLess(projectPath: string): boolean;
+type Loader = Record<string, any>;
+export declare function maybeUseLess(projectPath: string): Promise<Loader[]>;
+export {};

package/dist/webpack/plugin-css/css-tools/postcss.d.ts

@@ -0,0 +1,3 @@
+import type { StyleLoaderOptions } from '../common-style-loaders';
+export declare function isUsingPostCss(projectPath: string): boolean;
+export declare function maybeUsePostCss(projectPath: string, opts: StyleLoaderOptions): Promise<Record<string, any>>;

package/dist/webpack/plugin-css/css-tools/sass.d.ts

@@ -0,0 +1,4 @@
+export declare function isUsingSass(projectPath: string): boolean;
+type Loader = Record<string, any>;
+export declare function maybeUseSass(projectPath: string): Promise<Loader[]>;
+export {};

package/dist/webpack/plugin-css/css-tools/stylelint.d.ts

@@ -0,0 +1,4 @@
+import { type RspackPluginInstance } from '@rspack/core';
+export declare function getStylelintConfigFile(projectPath: string): string | undefined;
+export declare function isUsingStylelint(projectPath: string): boolean;
+export declare function maybeUseStylelint(projectPath: string): Promise<RspackPluginInstance[]>;

package/dist/webpack/plugin-css/css-tools/tailwind.d.ts

@@ -0,0 +1,2 @@
+export declare function isUsingTailwind(projectPath: string): boolean;
+export declare function getTailwindConfigFile(projectPath: string): string | undefined;

package/dist/webpack/plugin-css/index.d.ts

@@ -0,0 +1,9 @@
+import { type Compiler } from '@rspack/core';
+import { PluginInterface } from '../webpack-types';
+export declare class CssPlugin {
+    static readonly name: string;
+    readonly manifestPath: string;
+    constructor(options: PluginInterface);
+    private configureOptions;
+    apply(compiler: Compiler): Promise<void>;
+}

package/dist/webpack/plugin-css/is-content-script.d.ts

@@ -0,0 +1 @@
+export declare function isContentScriptEntry(absolutePath: string, manifestPath: string): boolean;

package/dist/webpack/plugin-extension/data/manifest-fields/html-fields/action.d.ts

@@ -0,0 +1,2 @@
+import { type Manifest } from '../../../../webpack-types';
+export declare function action(context: string, manifest: Manifest): string | undefined;

package/dist/webpack/plugin-extension/data/manifest-fields/html-fields/background.d.ts

@@ -0,0 +1,2 @@
+import { type Manifest } from '../../../../webpack-types';
+export declare function background(context: string, manifest: Manifest): string | undefined;

package/dist/webpack/plugin-extension/data/manifest-fields/html-fields/browser_action.d.ts

@@ -0,0 +1,2 @@
+import { type Manifest } from '../../../../webpack-types';
+export declare function browserAction(context: string, manifest: Manifest): string | undefined;

package/dist/webpack/plugin-extension/data/manifest-fields/html-fields/chrome_url_overrides.d.ts

@@ -0,0 +1,2 @@
+import { type Manifest } from '../../../../webpack-types';
+export declare function chromeUrlOverrides(context: string, manifest: Manifest): Record<string, Manifest | undefined>;

package/dist/webpack/plugin-extension/data/manifest-fields/html-fields/devtools_page.d.ts

@@ -0,0 +1,2 @@
+import { type Manifest } from '../../../../webpack-types';
+export declare function devtoolsPage(context: string, manifest: Manifest): string | undefined;

package/dist/webpack/plugin-extension/data/manifest-fields/html-fields/index.d.ts

@@ -0,0 +1,2 @@
+import { type Manifest } from '../../../../webpack-types';
+export declare function htmlFields(context: string, manifest: Manifest): Record<string, string | undefined>;

package/dist/webpack/plugin-extension/data/manifest-fields/html-fields/options_ui.d.ts

@@ -0,0 +1,2 @@
+import { type Manifest } from '../../../../webpack-types';
+export declare function optionsUi(context: string, manifest: Manifest): string | undefined;

package/dist/webpack/plugin-extension/data/manifest-fields/html-fields/page_action.d.ts

@@ -0,0 +1,2 @@
+import { type Manifest } from '../../../../webpack-types';
+export declare function pageAction(context: string, manifest: Manifest): string | undefined;