extension 3.13.5 → 3.14.0-next.0

package/dist/browsers.cjs

@@ -209,6 +209,7 @@ var __webpack_modules__ = {
     },
     "./browsers/browsers-lib/content-script-contracts.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
+            F: ()=>CANONICAL_CONTENT_SCRIPT_ENTRY_PREFIX,
             Y: ()=>getCanonicalContentScriptEntryName
         });
         const CANONICAL_CONTENT_SCRIPT_ENTRY_PREFIX = "content_scripts/content-";
@@ -218,12 +219,23 @@ var __webpack_modules__ = {
     },
     "./browsers/browsers-lib/content-script-targets.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
+            Il: ()=>selectContentScriptRules,
+            iw: ()=>readContentScriptRules,
             lM: ()=>urlMatchesAnyContentScriptRule,
             nG: ()=>resolveEmittedContentScriptFile
         });
         var fs__rspack_import_0 = __webpack_require__("fs");
         var path__rspack_import_1 = __webpack_require__("path");
         var _content_script_contracts__rspack_import_2 = __webpack_require__("./browsers/browsers-lib/content-script-contracts.ts");
+        function isCanonicalContentScriptEntryName(entryName) {
+            return 'string' == typeof entryName && entryName.startsWith(_content_script_contracts__rspack_import_2.F);
+        }
+        function parseCanonicalContentScriptEntryIndex(entryName) {
+            if (!isCanonicalContentScriptEntryName(entryName)) return;
+            const suffix = entryName.slice(_content_script_contracts__rspack_import_2.F.length);
+            const index = Number(suffix);
+            return Number.isInteger(index) && index >= 0 ? index : void 0;
+        }
         function getCanonicalContentScriptJsAssetName(index) {
             return `${(0, _content_script_contracts__rspack_import_2.Y)(index)}.js`;
         }
@@ -242,6 +254,29 @@ var __webpack_modules__ = {
             } catch  {}
             return null;
         }
+        function readContentScriptRules(compilation, extensionRoot) {
+            const manifest = readManifestFromCompilation(compilation) || readManifestFromDisk(extensionRoot) || {};
+            return getContentScriptRulesFromManifest(manifest);
+        }
+        function getContentScriptRulesFromManifest(manifest) {
+            const contentScripts = Array.isArray(manifest?.content_scripts) ? manifest.content_scripts : [];
+            return contentScripts.map((contentScript, index)=>({
+                    index,
+                    world: contentScript?.world === 'MAIN' ? 'main' : 'extension',
+                    matches: normalizeStringArray(contentScript?.matches),
+                    excludeMatches: normalizeStringArray(contentScript?.exclude_matches),
+                    includeGlobs: normalizeStringArray(contentScript?.include_globs),
+                    excludeGlobs: normalizeStringArray(contentScript?.exclude_globs)
+                }));
+        }
+        function selectContentScriptRules(rules, entryNames) {
+            const selectedIndices = new Set();
+            for (const entryName of entryNames){
+                const index = parseCanonicalContentScriptEntryIndex(entryName);
+                if (void 0 !== index) selectedIndices.add(index);
+            }
+            return rules.filter((rule)=>selectedIndices.has(rule.index));
+        }
         function urlMatchesContentScriptRule(rawUrl, rule) {
             const url = safeParseUrl(rawUrl);
             if (!url) return false;
@@ -254,6 +289,28 @@ var __webpack_modules__ = {
         function urlMatchesAnyContentScriptRule(rawUrl, rules) {
             return rules.some((rule)=>urlMatchesContentScriptRule(rawUrl, rule));
         }
+        function readManifestFromCompilation(compilation) {
+            try {
+                const asset = compilation.getAsset?.('manifest.json');
+                if (!asset?.source) return;
+                return JSON.parse(String(asset.source.source()));
+            } catch  {
+                return;
+            }
+        }
+        function readManifestFromDisk(extensionRoot) {
+            if (!extensionRoot) return;
+            try {
+                const manifestPath = path__rspack_import_1.join(extensionRoot, 'manifest.json');
+                if (!fs__rspack_import_0.existsSync(manifestPath)) return;
+                return JSON.parse(fs__rspack_import_0.readFileSync(manifestPath, 'utf8'));
+            } catch  {
+                return;
+            }
+        }
+        function normalizeStringArray(input) {
+            return Array.isArray(input) ? input.filter((value)=>'string' == typeof value).map((value)=>value.trim()).filter(Boolean) : [];
+        }
         function safeParseUrl(rawUrl) {
             try {
                 return new URL(rawUrl);
@@ -1442,7 +1499,8 @@ var __webpack_modules__ = {
             '--disable-sync',
             '--no-pings',
             '--enable-features=SidePanelUpdates',
-            '--disable-features=DisableLoadExtensionCommandLineSwitch'
+            '--disable-features=DisableLoadExtensionCommandLineSwitch',
+            '--enable-unsafe-extension-debugging'
         ];
         function isPlainObject(value) {
             return !!value && 'object' == typeof value && !Array.isArray(value);
@@ -1541,7 +1599,8 @@ var __webpack_modules__ = {
             const excludeFlags = configOptions.excludeBrowserFlags || [];
             const filteredFlags = (0, shared_utils.ov)(DEFAULT_BROWSER_FLAGS, excludeFlags);
             const cdpPort = (0, shared_utils.jl)(configOptions.port, configOptions.instanceId);
-            const linuxCiSandboxFlags = 'linux' === process.platform && 'true' === process.env.CI ? [
+            const isLinuxContainer = 'linux' === process.platform && ('true' === process.env.CI || external_fs_.existsSync('/.dockerenv') || external_fs_.existsSync('/run/.containerenv') || 'true' === process.env.REMOTE_CONTAINERS || 'true' === process.env.CODESPACES || null != process.env.container);
+            const linuxContainerSandboxFlags = isLinuxContainer ? [
                 '--no-sandbox',
                 '--disable-setuid-sandbox'
             ] : [];
@@ -1561,11 +1620,12 @@ var __webpack_modules__ = {
                 ...userProfilePath ? [
                     `--user-data-dir=${userProfilePath}`
                 ] : [],
-                ...linuxCiSandboxFlags,
+                ...linuxContainerSandboxFlags,
                 ...aiOptimizedFlags,
                 ...sourceEnabled || devWantsCDP ? [
                     `--remote-debugging-port=${cdpPort}`,
-                    '--remote-debugging-address=127.0.0.1'
+                    '--remote-debugging-address=127.0.0.1',
+                    '--remote-debugging-pipe'
                 ] : [],
                 ...filteredFlags,
                 ...configOptions.browserFlags || []
@@ -2011,8 +2071,13 @@ var __webpack_modules__ = {
                     enableCdp
                 });
                 if (this.options.dryRun) return void logChromiumDryRun(browserBinaryLocation, chromiumConfig);
-                await this.launchWithDirectSpawn(browserBinaryLocation, chromiumConfig);
-                if (enableCdp) {
+                const usePipe = chromiumConfig.includes('--remote-debugging-pipe');
+                const child = await this.launchWithDirectSpawn(browserBinaryLocation, chromiumConfig, usePipe);
+                const pipeStreams = usePipe && child?.stdio?.[3] && child?.stdio?.[4] ? {
+                    input: child.stdio[4],
+                    output: child.stdio[3]
+                } : void 0;
+                if (enableCdp && !pipeStreams) {
                     let portReady = false;
                     for(let attempt = 0; attempt < 10; attempt++){
                         portReady = await (0, discovery.z)(selectedPort);
@@ -2056,15 +2121,15 @@ var __webpack_modules__ = {
                         browserVersionLine
                     };
                     if (enableCdp) {
-                        const mod = await __webpack_require__.e("728").then(__webpack_require__.bind(__webpack_require__, "./browsers/run-chromium/chromium-launch/setup-cdp-after-launch.ts"));
-                        await mod.setupCdpAfterLaunch(compilation, cdpConfig, chromiumConfig);
+                        const mod = await __webpack_require__.e("631").then(__webpack_require__.bind(__webpack_require__, "./browsers/run-chromium/chromium-launch/setup-cdp-after-launch.ts"));
+                        await mod.setupCdpAfterLaunch(compilation, cdpConfig, chromiumConfig, pipeStreams);
                         if (cdpConfig.cdpController) this.ctx.setController(cdpConfig.cdpController, selectedPort);
                     }
                 } catch (error) {
                     if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn('[browser] CDP post-launch setup failed:', String(error));
                 }
             }
-            async launchWithDirectSpawn(binary, chromeFlags) {
+            async launchWithDirectSpawn(binary, chromeFlags, usePipe = false) {
                 if ('true' === process.env.EXTENSION_AUTHOR_MODE) this.logger.info(messages.xyq());
                 const launchArgs = this.options?.startingUrl ? [
                     ...chromeFlags,
@@ -2072,7 +2137,13 @@ var __webpack_modules__ = {
                 ] : [
                     ...chromeFlags
                 ];
-                const stdio = 'ignore';
+                const stdio = usePipe ? [
+                    'ignore',
+                    'ignore',
+                    'ignore',
+                    'pipe',
+                    'pipe'
+                ] : 'ignore';
                 const normalizedBinary = normalizeBinaryPathForWsl(binary);
                 try {
                     const child = await spawnChromiumProcess({
@@ -2090,6 +2161,7 @@ var __webpack_modules__ = {
                         this.logger.error(messages.Cny(error));
                     });
                     setupProcessSignalHandlers(this.options?.browser, child, ()=>{});
+                    return child;
                 } catch (error) {
                     this.logger.error(messages.wk1(error));
                     throw error;
@@ -2181,7 +2253,7 @@ var __webpack_modules__ = {
             }
             throw new Error('No CDP WebSocket URL available');
         }
-        async function checkChromeRemoteDebugging(port = 9222) {
+        async function checkChromeRemoteDebugging(port = 9222, host = '127.0.0.1') {
             return new Promise((resolve)=>{
                 const socket = new external_net_.Socket();
                 socket.on('connect', ()=>{
@@ -2196,7 +2268,7 @@ var __webpack_modules__ = {
                     resolve(false);
                 });
                 socket.setTimeout(2000);
-                socket.connect(port, 'localhost');
+                socket.connect(port, host);
             });
         }
     },
@@ -2513,14 +2585,14 @@ var __webpack_modules__ = {
             return obj;
         }
         class RdpTransport extends external_events_default() {
-            async connect(port) {
+            async connect(port, host = '127.0.0.1') {
                 await new Promise((resolve, reject)=>{
                     try {
                         const c = external_net_default().createConnection({
-                            host: '127.0.0.1',
+                            host,
                             port
                         }, ()=>{
-                            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(messages.EIQ('127.0.0.1', port));
+                            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(messages.EIQ(host, port));
                             resolve();
                         });
                         this.conn = c;
@@ -4167,8 +4239,40 @@ var __webpack_modules__ = {
         }
         const external_util_namespaceObject = require("util");
         const execFile = (0, external_util_namespaceObject.promisify)(external_child_process_.execFile);
+        function parseFlatpakBinary(binary) {
+            if (!binary || !binary.startsWith('flatpak:')) return null;
+            const appId = binary.substring(8).trim();
+            return appId ? {
+                appId
+            } : null;
+        }
         class FirefoxBinaryDetector {
             static generateFirefoxArgs(binaryPath, profilePath, debugPort, additionalArgs = []) {
+                const flatpak = parseFlatpakBinary(binaryPath);
+                if (flatpak) {
+                    const args = [
+                        'run',
+                        `--filesystem=${profilePath}`,
+                        flatpak.appId,
+                        '--no-remote',
+                        '--new-instance',
+                        '-profile',
+                        profilePath,
+                        ...debugPort > 0 ? [
+                            '-start-debugger-server',
+                            String(debugPort)
+                        ] : [],
+                        '--foreground',
+                        '--disable-background-timer-throttling',
+                        '--disable-backgrounding-occluded-windows',
+                        '--disable-renderer-backgrounding',
+                        ...additionalArgs
+                    ];
+                    return {
+                        binary: 'flatpak',
+                        args
+                    };
+                }
                 const args = [
                     '--no-remote',
                     '--new-instance',
@@ -4372,11 +4476,15 @@ var __webpack_modules__ = {
                     }
                 }
                 try {
-                    if (this.host.geckoBinary && 'string' == typeof this.host.geckoBinary) {
+                    if (this.host.geckoBinary && 'string' == typeof this.host.geckoBinary) if (parseFlatpakBinary(this.host.geckoBinary)) {
+                        browserBinaryLocation = this.host.geckoBinary;
+                        skipDetection = true;
+                    } else {
                         const normalized = normalizePath(this.host.geckoBinary);
                         if (normalized) browserBinaryLocation = normalized;
                         else failGeckoBinaryRequirement();
-                    } else if (!skipDetection) if (engineBased) failGeckoBinaryRequirement();
+                    }
+                    else if (!skipDetection) if (engineBased) failGeckoBinaryRequirement();
                     else {
                         const cacheRoot = (0, output_binaries_resolver.LB)(compilation);
                         const env = {
@@ -4392,7 +4500,8 @@ var __webpack_modules__ = {
                 } catch (_error) {
                     failGeckoBinaryRequirement();
                 }
-                if (!browserBinaryLocation || !browserBinaryLocation.trim() || !external_fs_.existsSync(browserBinaryLocation)) {
+                const isFlatpak = !!parseFlatpakBinary(browserBinaryLocation || '');
+                if (!isFlatpak && (!browserBinaryLocation || !browserBinaryLocation.trim() || !external_fs_.existsSync(browserBinaryLocation))) {
                     const normalizedFallback = resolveManagedBinary();
                     if (normalizedFallback) browserBinaryLocation = normalizedFallback;
                     else if (engineBased || this.host.geckoBinary) failGeckoBinaryRequirement();
@@ -4407,14 +4516,16 @@ var __webpack_modules__ = {
                 }
                 const binaryPath = browserBinaryLocation;
                 const wslFallbackBinary = isWslEnv() && !engineBased ? resolveWslFallback() : null;
-                try {
-                    this.host.browserVersionLine = (0, external_firefox_location2_.getFirefoxVersion)(binaryPath, {
-                        allowExec: true
-                    }) || '';
-                } catch  {}
-                try {
-                    await FirefoxBinaryDetector.validateFirefoxBinary(binaryPath);
-                } catch  {}
+                if (!isFlatpak) {
+                    try {
+                        this.host.browserVersionLine = (0, external_firefox_location2_.getFirefoxVersion)(binaryPath, {
+                            allowExec: true
+                        }) || '';
+                    } catch  {}
+                    try {
+                        await FirefoxBinaryDetector.validateFirefoxBinary(binaryPath);
+                    } catch  {}
+                }
                 const extensionsToLoad = (0, runtime_options.fT)(this.host.extension);
                 (0, runtime_options.sl)(extensionsToLoad, 'function' == typeof this.ctx.setExtensionRoot ? this.ctx.setExtensionRoot : void 0);
                 const desiredDebugPort = (0, shared_utils.jl)(this.host.port, this.host.instanceId);
@@ -4805,15 +4916,16 @@ var __webpack_exports__ = {};
     __webpack_require__.r(__webpack_exports__);
     __webpack_require__.d(__webpack_exports__, {
         launchBrowser: ()=>launchBrowser,
-        runOnlyPreviewBrowser: ()=>_run_only__rspack_import_3.E
+        runOnlyPreviewBrowser: ()=>_run_only__rspack_import_4.E
     });
     var _browsers_lib_output_binaries_resolver__rspack_import_0 = __webpack_require__("./browsers/browsers-lib/output-binaries-resolver.ts");
-    var _browsers_lib_runtime_options__rspack_import_6 = __webpack_require__("./browsers/browsers-lib/runtime-options.ts");
-    var _run_chromium_chromium_context__rspack_import_4 = __webpack_require__("./browsers/run-chromium/chromium-context/index.ts");
-    var _run_chromium_chromium_launch__rspack_import_1 = __webpack_require__("./browsers/run-chromium/chromium-launch/index.ts");
-    var _run_firefox_firefox_context__rspack_import_5 = __webpack_require__("./browsers/run-firefox/firefox-context/index.ts");
-    var _run_firefox_firefox_launch__rspack_import_2 = __webpack_require__("./browsers/run-firefox/firefox-launch/index.ts");
-    var _run_only__rspack_import_3 = __webpack_require__("./browsers/run-only.ts");
+    var _browsers_lib_runtime_options__rspack_import_7 = __webpack_require__("./browsers/browsers-lib/runtime-options.ts");
+    var _browsers_lib_content_script_targets__rspack_import_1 = __webpack_require__("./browsers/browsers-lib/content-script-targets.ts");
+    var _run_chromium_chromium_context__rspack_import_5 = __webpack_require__("./browsers/run-chromium/chromium-context/index.ts");
+    var _run_chromium_chromium_launch__rspack_import_2 = __webpack_require__("./browsers/run-chromium/chromium-launch/index.ts");
+    var _run_firefox_firefox_context__rspack_import_6 = __webpack_require__("./browsers/run-firefox/firefox-context/index.ts");
+    var _run_firefox_firefox_launch__rspack_import_3 = __webpack_require__("./browsers/run-firefox/firefox-launch/index.ts");
+    var _run_only__rspack_import_4 = __webpack_require__("./browsers/run-only.ts");
     function createCompilationLike(opts) {
         return {
             options: {
@@ -4828,6 +4940,12 @@ var __webpack_exports__ = {};
             }
         };
     }
+    function resolveContentScriptRulesForReload(compilationLike, extensionsToLoad, entries) {
+        if (!entries || 0 === entries.length) return [];
+        const extensionRoot = extensionsToLoad?.[0];
+        const rules = (0, _browsers_lib_content_script_targets__rspack_import_1.iw)(compilationLike, extensionRoot);
+        return (0, _browsers_lib_content_script_targets__rspack_import_1.Il)(rules, entries);
+    }
     function isChromiumBrowser(browser) {
         return 'chrome' === browser || 'edge' === browser || 'chromium' === browser || 'chromium-based' === browser;
     }
@@ -4877,8 +4995,8 @@ var __webpack_exports__ = {};
             logUrl: opts.logUrl,
             logTab: opts.logTab
         };
-        const ctx = (0, _run_chromium_chromium_context__rspack_import_4.g)();
-        const launcher = new _run_chromium_chromium_launch__rspack_import_1.f(chromiumOpts, ctx);
+        const ctx = (0, _run_chromium_chromium_context__rspack_import_5.g)();
+        const launcher = new _run_chromium_chromium_launch__rspack_import_2.f(chromiumOpts, ctx);
         const enableCdp = 'development' === mode;
         await launcher.runOnce(compilationLike, {
             enableCdpPostLaunch: enableCdp
@@ -4890,7 +5008,11 @@ var __webpack_exports__ = {};
                 if (!cdpController) return;
                 if (instruction?.type === "content-scripts") {
                     const ctrl = cdpController;
-                    if ('function' == typeof ctrl.reloadMatchingTabsForContentScripts) return void await ctrl.reloadMatchingTabsForContentScripts(instruction.changedContentScriptEntries || []);
+                    if ('function' == typeof ctrl.reloadMatchingTabsForContentScripts) {
+                        const rules = resolveContentScriptRulesForReload(compilationLike, opts.extensionsToLoad, instruction.changedContentScriptEntries);
+                        await ctrl.reloadMatchingTabsForContentScripts(rules);
+                        return;
+                    }
                 }
                 const ctrl = cdpController;
                 if ('function' == typeof ctrl.hardReload) await ctrl.hardReload(instruction?.changedAssets);
@@ -4905,8 +5027,7 @@ var __webpack_exports__ = {};
                     urlFilter: logOpts.urlFilter,
                     tabFilter: logOpts.tabFilter
                 });
-            },
-            async close () {}
+            }
         };
     }
     async function launchFirefox(opts, compilationLike, mode) {
@@ -4920,7 +5041,27 @@ var __webpack_exports__ = {};
             geckoBinary: opts.geckoBinary,
             instanceId: opts.instanceId,
             port: opts.port,
-            dryRun: opts.dryRun
+            dryRun: opts.dryRun,
+            source: opts.source,
+            watchSource: opts.watchSource,
+            sourceFormat: opts.sourceFormat,
+            sourceSummary: opts.sourceSummary,
+            sourceMeta: opts.sourceMeta,
+            sourceProbe: opts.sourceProbe,
+            sourceTree: opts.sourceTree,
+            sourceConsole: opts.sourceConsole,
+            sourceDom: opts.sourceDom,
+            sourceMaxBytes: opts.sourceMaxBytes,
+            sourceRedact: opts.sourceRedact,
+            sourceIncludeShadow: opts.sourceIncludeShadow,
+            sourceDiff: opts.sourceDiff,
+            logLevel: opts.logLevel,
+            logContexts: opts.logContexts,
+            logFormat: opts.logFormat,
+            logTimestamps: opts.logTimestamps,
+            logColor: opts.logColor,
+            logUrl: opts.logUrl,
+            logTab: opts.logTab
         };
         const pluginOptions = {
             extension: opts.extensionsToLoad,
@@ -4937,17 +5078,40 @@ var __webpack_exports__ = {};
             port: opts.port,
             dryRun: opts.dryRun
         };
-        const ctx = (0, _run_firefox_firefox_context__rspack_import_5.D)();
-        const launcher = new _run_firefox_firefox_launch__rspack_import_2.c(firefoxOpts, ctx);
-        const launchRequest = (0, _browsers_lib_runtime_options__rspack_import_6.zU)(pluginOptions, mode, {
+        const ctx = (0, _run_firefox_firefox_context__rspack_import_6.D)();
+        const launcher = new _run_firefox_firefox_launch__rspack_import_3.c(firefoxOpts, ctx);
+        const launchRequest = (0, _browsers_lib_runtime_options__rspack_import_7.zU)(pluginOptions, mode, {
             persistProfile: opts.persistProfile,
             geckoBinary: opts.geckoBinary
         });
         await launcher.runOnce(compilationLike, launchRequest);
+        const rdpController = ctx.getController?.();
         return {
-            async reload () {},
-            async enableUnifiedLogging () {},
-            async close () {}
+            async reload (instruction) {
+                if (!rdpController) return;
+                if (instruction?.type === "content-scripts") {
+                    const rules = resolveContentScriptRulesForReload(compilationLike, opts.extensionsToLoad, instruction.changedContentScriptEntries);
+                    try {
+                        await rdpController.reloadMatchingTabsForContentScripts(rules);
+                        return;
+                    } catch  {}
+                }
+                try {
+                    await rdpController.hardReload(compilationLike, instruction?.changedAssets || []);
+                } catch  {}
+            },
+            async enableUnifiedLogging (logOpts) {
+                if (!rdpController?.enableUnifiedLogging) return;
+                await rdpController.enableUnifiedLogging({
+                    level: logOpts.level,
+                    contexts: logOpts.contexts,
+                    format: logOpts.format,
+                    timestamps: logOpts.timestamps,
+                    color: logOpts.color,
+                    urlFilter: logOpts.urlFilter,
+                    tabFilter: logOpts.tabFilter
+                });
+            }
         };
     }
 })();