extension-develop 4.1.31 → 4.1.32

package/dist/363~0.mjs

@@ -0,0 +1,1874 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import { Compilation, DefinePlugin, ProvidePlugin, WebpackError, sources } from "@rspack/core";
+import { createRequire } from "node:module";
+import pintor from "pintor";
+import { publicRelativePath, findPublicFile, inspectPublicFolders } from "./105~0.mjs";
+import { isChromiumBasedBrowser, CHROMIUM_FAMILY_ALIASES, GECKO_FAMILY_ALIASES, isWebkitBasedBrowser, stripBom, parseJsonSafe, isGeckoBasedBrowser } from "./937~0.mjs";
+import { parseCanonicalContentScriptAsset, getCanonicalContentScriptJsAssetName, getCanonicalContentScriptCssAssetName } from "./640~0.mjs";
+import { debugLine, isDebug, humanLine, prefix as messaging_prefix } from "./852~0.mjs";
+import { filterKeysForThisBrowser } from "./143~0.mjs";
+import { displayPath } from "./469~0.mjs";
+import { getPreloadedEnvKeys } from "./846~0.mjs";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
+import * as __rspack_external_node_path_806ed179 from "node:path";
+import * as __rspack_external_dotenv from "dotenv";
+const ACTION_HTML_FEATURE = 'action/index';
+const BROWSER_ACTION_HTML_FEATURE = 'browser_action/index';
+const PAGE_ACTION_HTML_FEATURE = 'page_action/index';
+const OPTIONS_HTML_FEATURE = 'options/index';
+const SIDEBAR_HTML_FEATURE = 'sidebar/index';
+const SIDEBAR_ACTION_HTML_FEATURE = 'sidebar_action/index';
+const ACTION_HTML_OUTPUT = 'action/index.html';
+const BROWSER_ACTION_HTML_OUTPUT = 'browser_action/index.html';
+const PAGE_ACTION_HTML_OUTPUT = 'page_action/index.html';
+const SIDEBAR_HTML_OUTPUT = 'sidebar/index.html';
+const SIDEBAR_ACTION_HTML_OUTPUT = 'sidebar_action/index.html';
+function readPageRef(value, key) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return;
+    const page = value[key];
+    if ('string' != typeof page) return;
+    const trimmed = page.trim();
+    return trimmed || void 0;
+}
+function readDefaultPopup(value) {
+    return readPageRef(value, 'default_popup');
+}
+function normalizePopupRef(ref) {
+    return String(ref || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+/, '');
+}
+function popupRefsShareSource(a, b) {
+    if ('string' != typeof a || 'string' != typeof b) return false;
+    const left = normalizePopupRef(a);
+    const right = normalizePopupRef(b);
+    return Boolean(left) && left === right;
+}
+function resolveManifestHtmlPath(context, relativePath, projectPath) {
+    const unix = relativePath.replace(/\\/g, '/');
+    const manifestPath = __rspack_external_node_path_806ed179.join(context, 'manifest.json');
+    const hosted = findPublicFile(manifestPath, projectPath, unix);
+    if (/^(?:\/public\/|(?:\.\/)?public\/)/i.test(unix)) return hosted || __rspack_external_node_path_806ed179.join(context, 'public', publicRelativePath(unix));
+    const beside = /^\//.test(unix) ? __rspack_external_node_path_806ed179.join(context, unix.slice(1)) : __rspack_external_node_path_806ed179.join(context, unix);
+    if (hosted && !__rspack_external_node_fs_1b05aee1.existsSync(beside)) return hosted;
+    return beside;
+}
+function actionPopupRef(manifest) {
+    if (!manifest) return;
+    return readDefaultPopup(manifest.action) || readDefaultPopup(manifest.browser_action);
+}
+function browserActionOwnPopupRef(manifest) {
+    if (!manifest) return;
+    const action = readDefaultPopup(manifest.action);
+    const browserAction = readDefaultPopup(manifest.browser_action);
+    if (!action || !browserAction) return;
+    if (popupRefsShareSource(action, browserAction)) return;
+    return browserAction;
+}
+function browserActionOutputTarget(manifest) {
+    return browserActionOwnPopupRef(manifest) ? BROWSER_ACTION_HTML_OUTPUT : ACTION_HTML_OUTPUT;
+}
+function pageActionPopupRef(manifest) {
+    if (!manifest) return;
+    return readDefaultPopup(manifest.page_action);
+}
+function sidebarPanelRef(manifest) {
+    if (!manifest) return;
+    return readPageRef(manifest.side_panel, 'default_path') || readPageRef(manifest.sidebar_action, 'default_panel');
+}
+function sidebarActionOwnPanelRef(manifest) {
+    if (!manifest) return;
+    const sidePanel = readPageRef(manifest.side_panel, 'default_path');
+    const sidebarAction = readPageRef(manifest.sidebar_action, 'default_panel');
+    if (!sidePanel || !sidebarAction) return;
+    if (popupRefsShareSource(sidePanel, sidebarAction)) return;
+    return sidebarAction;
+}
+function sidebarActionOutputTarget(manifest) {
+    return sidebarActionOwnPanelRef(manifest) ? SIDEBAR_ACTION_HTML_OUTPUT : SIDEBAR_HTML_OUTPUT;
+}
+function optionsPageRef(manifest) {
+    if (!manifest) return;
+    const modern = manifest.options_ui?.page;
+    if ('string' == typeof modern && modern.trim()) return modern.trim();
+    const legacy = manifest.options_page;
+    if ('string' == typeof legacy && legacy.trim()) return legacy.trim();
+}
+function isPageActionLiveSurface(manifest, browser) {
+    if (isGeckoBasedBrowser(String(browser || ''))) return true;
+    const version = Number(manifest?.manifest_version);
+    return Number.isFinite(version) && version < 3;
+}
+function pageActionDropReason(manifest, browser) {
+    if (!manifest || 'object' != typeof manifest) return;
+    if (!('page_action' in manifest) || null == manifest.page_action) return;
+    if (!isPageActionLiveSurface(manifest, browser)) return 'unsupported';
+    if (isChromiumBasedBrowser(String(browser || '')) && (null != manifest.browser_action || shouldFoldActionIntoBrowserAction(manifest))) return 'conflicts';
+}
+function shouldDropPageAction(manifest, browser) {
+    return void 0 !== pageActionDropReason(manifest, browser);
+}
+function dropPageAction(manifest) {
+    if (!manifest || !('page_action' in manifest)) return manifest;
+    const rest = {
+        ...manifest
+    };
+    delete rest.page_action;
+    return rest;
+}
+function isBrowserActionLiveSurface(manifest) {
+    const version = Number(manifest?.manifest_version);
+    return !Number.isFinite(version) || version < 3;
+}
+function shouldFoldBrowserActionIntoAction(manifest) {
+    if (!manifest || 'object' != typeof manifest) return false;
+    if (!('browser_action' in manifest) || null == manifest.browser_action) return false;
+    if (isBrowserActionLiveSurface(manifest)) return false;
+    return null == manifest.action;
+}
+function foldBrowserActionIntoAction(manifest) {
+    if (!shouldFoldBrowserActionIntoAction(manifest)) return manifest;
+    const { browser_action: folded, ...rest } = manifest;
+    return {
+        ...rest,
+        action: folded
+    };
+}
+function shouldFoldActionIntoBrowserAction(manifest) {
+    if (!manifest || 'object' != typeof manifest) return false;
+    if (!('action' in manifest) || null == manifest.action) return false;
+    const version = Number(manifest.manifest_version);
+    if (2 !== version) return false;
+    return null == manifest.browser_action;
+}
+function foldActionIntoBrowserAction(manifest) {
+    if (!shouldFoldActionIntoBrowserAction(manifest)) return manifest;
+    const { action: folded, ...rest } = manifest;
+    return {
+        ...rest,
+        browser_action: folded,
+        ...renameExecuteActionCommand(manifest)
+    };
+}
+function renameExecuteActionCommand(manifest) {
+    const commands = manifest.commands;
+    if (!commands || 'object' != typeof commands) return {};
+    if (!('_execute_action' in commands)) return {};
+    if ('_execute_browser_action' in commands) return {};
+    const { _execute_action: shortcut, ...others } = commands;
+    return {
+        commands: {
+            ...others,
+            _execute_browser_action: shortcut
+        }
+    };
+}
+function sidebarFoldTarget(manifest, browser) {
+    if (!manifest || 'object' != typeof manifest) return;
+    const hasSidePanel = null != manifest.side_panel;
+    const hasSidebarAction = null != manifest.sidebar_action;
+    if (hasSidePanel === hasSidebarAction) return;
+    const target = String(browser || '');
+    if (hasSidebarAction) {
+        if (!readPageRef(manifest.sidebar_action, 'default_panel')) return;
+        if (!isChromiumBasedBrowser(target)) return;
+        if ('opera' === target) return;
+        const version = Number(manifest.manifest_version);
+        return version >= 3 ? 'side_panel' : void 0;
+    }
+    if (!readPageRef(manifest.side_panel, 'default_path')) return;
+    return isGeckoBasedBrowser(target) ? 'sidebar_action' : void 0;
+}
+const SIDE_PANEL_PERMISSION = 'sidePanel';
+function withSidePanelPermission(manifest) {
+    const current = Array.isArray(manifest.permissions) ? manifest.permissions : [];
+    return current.includes(SIDE_PANEL_PERMISSION) ? current : [
+        ...current,
+        SIDE_PANEL_PERMISSION
+    ];
+}
+function foldSidebarKeyForBrowser(manifest, browser) {
+    const target = sidebarFoldTarget(manifest, browser);
+    if (!target) return manifest;
+    if ('side_panel' === target) {
+        const panel = readPageRef(manifest.sidebar_action, 'default_panel');
+        const { sidebar_action: _folded, ...rest } = manifest;
+        return {
+            ...rest,
+            side_panel: {
+                default_path: panel
+            },
+            permissions: withSidePanelPermission(manifest)
+        };
+    }
+    const panel = readPageRef(manifest.side_panel, 'default_path');
+    const { side_panel: _folded, ...rest } = manifest;
+    return {
+        ...rest,
+        sidebar_action: {
+            default_panel: panel,
+            ...sidebarActionStyle(manifest)
+        }
+    };
+}
+function sidebarActionStyle(manifest) {
+    const version = Number(manifest.manifest_version);
+    if (2 !== version) return {};
+    const source = manifest.side_panel;
+    const own = source?.browser_style;
+    return {
+        browser_style: 'boolean' == typeof own ? own : false
+    };
+}
+function pageActionOutputTarget(manifest) {
+    const actionRef = actionPopupRef(manifest);
+    const browserActionRef = browserActionOwnPopupRef(manifest);
+    const pageRef = pageActionPopupRef(manifest);
+    if (actionRef && pageRef && popupRefsShareSource(actionRef, pageRef)) return ACTION_HTML_OUTPUT;
+    if (browserActionRef && pageRef && popupRefsShareSource(browserActionRef, pageRef)) return BROWSER_ACTION_HTML_OUTPUT;
+    return PAGE_ACTION_HTML_OUTPUT;
+}
+function applyIndependentHtmlSurfaces(html, manifest, context, browser, projectPath) {
+    const next = {
+        ...html || {}
+    };
+    const optionsRef = optionsPageRef(manifest);
+    if (optionsRef) next[OPTIONS_HTML_FEATURE] = resolveManifestHtmlPath(context, optionsRef, projectPath);
+    const resolve = (ref)=>ref ? resolveManifestHtmlPath(context, ref, projectPath) : void 0;
+    const assign = (feature, resolved)=>{
+        if (resolved) next[feature] = resolved;
+        else delete next[feature];
+    };
+    assign(SIDEBAR_HTML_FEATURE, resolve(sidebarPanelRef(manifest)));
+    assign(SIDEBAR_ACTION_HTML_FEATURE, resolve(sidebarActionOwnPanelRef(manifest)));
+    const actionRef = actionPopupRef(manifest);
+    const pageRef = pageActionPopupRef(manifest);
+    assign(ACTION_HTML_FEATURE, resolve(actionRef));
+    assign(BROWSER_ACTION_HTML_FEATURE, resolve(browserActionOwnPopupRef(manifest)));
+    const pageOwnsItsPage = pageRef && !pageActionDropReason(manifest, browser) && pageActionOutputTarget(manifest) === PAGE_ACTION_HTML_OUTPUT;
+    assign(PAGE_ACTION_HTML_FEATURE, pageOwnsItsPage ? resolve(pageRef) : void 0);
+    return leavePublicPagesToCopier(next, context, projectPath);
+}
+function leavePublicPagesToCopier(html, context, projectPath) {
+    const manifestPath = __rspack_external_node_path_806ed179.join(context, 'manifest.json');
+    const { fromRoot, fromManifest } = inspectPublicFolders(manifestPath, projectPath);
+    const roots = [
+        fromRoot,
+        fromManifest
+    ].map((root)=>__rspack_external_node_path_806ed179.resolve(root));
+    for (const [feature, resolved] of Object.entries(html)){
+        if ('string' != typeof resolved) continue;
+        const hosted = roots.some((root)=>{
+            const rel = __rspack_external_node_path_806ed179.relative(root, __rspack_external_node_path_806ed179.resolve(resolved));
+            return Boolean(rel) && !rel.startsWith('..') && !__rspack_external_node_path_806ed179.isAbsolute(rel);
+        });
+        if (hosted) delete html[feature];
+    }
+    return html;
+}
+function isFromFilepathList(filePath, filepathList) {
+    return Object.values(filepathList || {}).some((value)=>value === filePath);
+}
+function isFolder(filePath) {
+    try {
+        return __rspack_external_node_fs_1b05aee1.statSync(filePath).isDirectory();
+    } catch  {
+        return false;
+    }
+}
+function getFilename(feature, filePath) {
+    const entryExt = __rspack_external_node_path_806ed179.extname(filePath);
+    let fileOutputpath = feature;
+    if ([
+        '.js',
+        '.jsx',
+        '.tsx',
+        '.ts',
+        '.vue',
+        '.svelte'
+    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.js');
+    if ([
+        '.html',
+        '.njk',
+        '.nunjucks'
+    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.html');
+    if ([
+        '.css',
+        '.scss',
+        '.sass',
+        '.less'
+    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.css');
+    return unixify(fileOutputpath || '');
+}
+function unixify(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+function resolveRootAbsoluteRef(ref, projectRoot, publicRoot) {
+    if (!ref || !ref.startsWith('/')) return;
+    if (projectRoot && ref.startsWith(projectRoot)) return;
+    if (ref.startsWith('//')) return;
+    const trimmed = ref.replace(/^\/+/, '');
+    if (!trimmed) return;
+    if (publicRoot && __rspack_external_node_fs_1b05aee1.existsSync(__rspack_external_node_path_806ed179.join(publicRoot, trimmed))) return;
+    const candidate = __rspack_external_node_path_806ed179.resolve(projectRoot, trimmed);
+    const rel = __rspack_external_node_path_806ed179.relative(projectRoot, candidate);
+    if (rel.startsWith('..') || __rspack_external_node_path_806ed179.isAbsolute(rel)) return;
+    if (!__rspack_external_node_fs_1b05aee1.existsSync(candidate) || !__rspack_external_node_fs_1b05aee1.statSync(candidate).isFile()) return;
+    return candidate;
+}
+function collectRootAbsoluteRefs(source) {
+    const refs = new Set();
+    const attrRe = /(?:src|href)\s*=\s*["'](\/[^"'#?]*)["']/gi;
+    const urlRe = /url\(\s*["']?(\/[^"')#?]+)["']?\s*\)/gi;
+    let m;
+    while(m = attrRe.exec(source))refs.add(m[1]);
+    while(m = urlRe.exec(source))refs.add(m[1]);
+    return refs;
+}
+function isManifestAddress(value) {
+    if ('string' != typeof value) return false;
+    const trimmed = value.trim();
+    return /^[a-z][a-z0-9+.-]+:/i.test(trimmed) || trimmed.startsWith('//');
+}
+function backgroundPage(manifest) {
+    return manifest.background?.page && {
+        background: {
+            page: (()=>{
+                const raw = String(manifest.background.page);
+                return getFilename('background/index.html', raw);
+            })()
+        }
+    };
+}
+function normalizeManifestOutputPath(originalPath) {
+    if (!originalPath) return originalPath;
+    const unixPath = originalPath.replace(/\\/g, '/');
+    if (/^\/public\//i.test(unixPath)) return unixPath.replace(/^\/public\//i, '');
+    if (/^(?:\.\/)?public\//i.test(unixPath)) return unixPath.replace(/^(?:\.\/)?public\//i, '');
+    if (/^\//.test(unixPath)) return unixPath.replace(/^\//, '');
+    return unixPath;
+}
+function manifestPageOutputTarget(raw, compiledTarget, manifestPath, projectPath) {
+    const unixPath = raw.replace(/\\/g, '/');
+    if (/^(?:\/public\/|(?:\.\/)?public\/)/i.test(unixPath)) return normalizeManifestOutputPath(unixPath);
+    if (/^\//.test(unixPath)) {
+        const rest = unixPath.replace(/^\/+/, '');
+        if (manifestPath && rest) {
+            const manifestDir = __rspack_external_node_path_806ed179.dirname(manifestPath);
+            const inPublic = Boolean(findPublicFile(manifestPath, projectPath, rest));
+            const inRoot = __rspack_external_node_fs_1b05aee1.existsSync(__rspack_external_node_path_806ed179.join(manifestDir, rest));
+            if (inRoot && !inPublic) return compiledTarget;
+        }
+        return normalizeManifestOutputPath(unixPath);
+    }
+    const rest = unixPath.replace(/^\.\//, '');
+    if (!manifestPath || !rest || rest.split('/').includes('..')) return compiledTarget;
+    if (__rspack_external_node_fs_1b05aee1.existsSync(__rspack_external_node_path_806ed179.join(__rspack_external_node_path_806ed179.dirname(manifestPath), rest))) return compiledTarget;
+    if (findPublicFile(manifestPath, projectPath, rest)) return rest;
+    return compiledTarget;
+}
+function manifestJsonOutputTarget(raw, compiledTarget, manifestPath, projectPath) {
+    return manifestPageOutputTarget(raw, compiledTarget, manifestPath, projectPath);
+}
+function pathEscapesExtensionRoot(normalized) {
+    return !normalized || normalized.split('/').includes('..') || /^[A-Za-z]:/.test(normalized);
+}
+function externalAssetOutputPath(normalized, root) {
+    const unix = normalized.replace(/\\/g, '/');
+    const noDrive = unix.replace(/^([A-Za-z]):(?:\/|$)/, '_drive_$1/');
+    const safe = noDrive.split('/').map((segment)=>{
+        if ('..' === segment) return '_';
+        if ('.' === segment || !segment) return '';
+        return segment.replace(/[<>:"|?*\x00-\x1F]/g, '_');
+    }).filter(Boolean).join('/');
+    return safe ? `${root}/${safe}` : `${root}/external`;
+}
+function iconOutputPath(raw) {
+    if (/^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw)) return normalizeManifestOutputPath(raw);
+    const normalized = normalizeManifestOutputPath(raw).replace(/^\.\//, '');
+    if (!pathEscapesExtensionRoot(normalized)) return normalized;
+    return externalAssetOutputPath(normalized, 'icons');
+}
+function themeIconOutputPath(raw, folder) {
+    return featureAssetOutputPath(raw, folder);
+}
+function themeImageOutputPath(raw) {
+    return featureAssetOutputPath(raw, 'theme/images');
+}
+function featureAssetOutputPath(raw, folder) {
+    if (/^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw)) return normalizeManifestOutputPath(raw);
+    const normalized = normalizeManifestOutputPath(raw).replace(/^\.\//, '');
+    if (!pathEscapesExtensionRoot(normalized)) return `${folder}/${normalized}`;
+    return externalAssetOutputPath(normalized, folder);
+}
+function chromeUrlOverrides(manifest, manifestPath, projectPath) {
+    return manifest.chrome_url_overrides && {
+        chrome_url_overrides: {
+            ...manifest.chrome_url_overrides.bookmarks && {
+                bookmarks: (()=>{
+                    const raw = String(manifest.chrome_url_overrides.bookmarks);
+                    return getFilename(manifestPageOutputTarget(raw, 'chrome_url_overrides/bookmarks.html', manifestPath, projectPath), raw);
+                })()
+            },
+            ...manifest.chrome_url_overrides.history && {
+                history: (()=>{
+                    const raw = String(manifest.chrome_url_overrides.history);
+                    return getFilename(manifestPageOutputTarget(raw, 'chrome_url_overrides/history.html', manifestPath, projectPath), raw);
+                })()
+            },
+            ...manifest.chrome_url_overrides.newtab && {
+                newtab: (()=>{
+                    const raw = String(manifest.chrome_url_overrides.newtab);
+                    return getFilename(manifestPageOutputTarget(raw, 'chrome_url_overrides/newtab.html', manifestPath, projectPath), raw);
+                })()
+            }
+        }
+    };
+}
+function commands_commands(manifest) {
+    return manifest.commands && {
+        commands: manifest.commands
+    };
+}
+function isBundledContentPath(filePath, ext) {
+    const normalized = String(filePath || '').replace(/\\/g, '/');
+    const bundledAsset = parseCanonicalContentScriptAsset(normalized);
+    return bundledAsset?.extension === ext;
+}
+function isHollowContentScript(entry) {
+    const contentObj = entry || {};
+    const js = Array.isArray(contentObj.js) ? contentObj.js : [];
+    const css = Array.isArray(contentObj.css) ? contentObj.css : [];
+    return 0 === js.length && 0 === css.length;
+}
+function isAlreadyBundledContentScripts(contentScripts) {
+    if (!Array.isArray(contentScripts)) return false;
+    const filled = contentScripts.filter((contentObj)=>!isHollowContentScript(contentObj));
+    if (0 === filled.length) return false;
+    return filled.every((contentObj)=>{
+        const js = Array.isArray(contentObj?.js) ? contentObj.js : [];
+        const css = Array.isArray(contentObj?.css) ? contentObj.css : [];
+        return js.every((filePath)=>isBundledContentPath(filePath, 'js')) && css.every((filePath)=>isBundledContentPath(filePath, 'css'));
+    });
+}
+function content_scripts_contentScripts(manifest, manifestPath) {
+    if (!manifest.content_scripts) return;
+    const original = manifest.content_scripts;
+    if (isAlreadyBundledContentScripts(original)) return {
+        content_scripts: original
+    };
+    const originalCount = original.length;
+    const result = [];
+    let bridgeOrdinal = 0;
+    for(let index = 0; index < original.length; index++){
+        const contentObj = original[index] || {};
+        if (isHollowContentScript(contentObj)) continue;
+        const contentJs = [
+            ...new Set(contentObj.js || [])
+        ];
+        const contentCss = [
+            ...new Set(contentObj.css || [])
+        ];
+        if ('MAIN' === contentObj.world) {
+            const bridgeIndex = originalCount + bridgeOrdinal++;
+            const { world: _ignoredWorld, js: _ignoredJs, css: _ignoredCss, ...rest } = contentObj;
+            result.push({
+                ...rest,
+                js: [
+                    getFilename(getCanonicalContentScriptJsAssetName(bridgeIndex), 'main-world-bridge.js')
+                ],
+                css: []
+            });
+        }
+        result.push({
+            ...original[index] || {},
+            js: [
+                ...new Set(contentJs.map((js)=>getFilename(getCanonicalContentScriptJsAssetName(index), js)))
+            ],
+            css: [
+                ...new Set(contentCss.map((css)=>getFilename(getCanonicalContentScriptCssAssetName(index), css)))
+            ]
+        });
+    }
+    return {
+        content_scripts: result
+    };
+}
+function hasMv3StringPolicy(manifest) {
+    if (3 !== Number(manifest.manifest_version)) return false;
+    return 'string' == typeof manifest.content_security_policy;
+}
+function contentSecurityPolicy(manifest) {
+    if (!manifest.content_security_policy) return;
+    if (hasMv3StringPolicy(manifest)) return {
+        content_security_policy: {
+            extension_pages: manifest.content_security_policy
+        }
+    };
+    return {
+        content_security_policy: manifest.content_security_policy
+    };
+}
+function devtoolsPage(manifest, manifestPath, projectPath) {
+    return manifest.devtools_page && {
+        devtools_page: (()=>{
+            const raw = String(manifest.devtools_page);
+            return getFilename(manifestPageOutputTarget(raw, 'devtools/index.html', manifestPath, projectPath), raw);
+        })()
+    };
+}
+function icons(manifest) {
+    return manifest.icons && {
+        icons: Object.fromEntries(Object.entries(manifest.icons).map(([size, icon])=>{
+            const raw = String(icon);
+            return [
+                size,
+                getFilename(iconOutputPath(raw), raw)
+            ];
+        }))
+    };
+}
+function omnibox_omnibox(manifest) {
+    const omnibox = manifest.omnibox;
+    return omnibox && {
+        omnibox: {
+            ...omnibox,
+            ...omnibox.default_icon && {
+                default_icon: 'string' == typeof omnibox.default_icon ? getFilename(iconOutputPath(omnibox.default_icon), omnibox.default_icon) : Object.fromEntries(Object.entries(omnibox.default_icon).map(([size, icon])=>[
+                        size,
+                        getFilename(iconOutputPath(icon), icon)
+                    ]))
+            }
+        }
+    };
+}
+function optionsPage(manifest, manifestPath, projectPath) {
+    return manifest.options_page && {
+        options_page: (()=>{
+            const raw = String(manifest.options_page);
+            return getFilename(manifestPageOutputTarget(raw, 'options/index.html', manifestPath, projectPath), raw);
+        })()
+    };
+}
+function options_ui_optionsUi(manifest, manifestPath, projectPath) {
+    return manifest.options_ui && {
+        options_ui: {
+            ...manifest.options_ui,
+            ...manifest.options_ui.page && {
+                page: (()=>{
+                    const raw = String(manifest.options_ui.page);
+                    return getFilename(manifestPageOutputTarget(raw, 'options/index.html', manifestPath, projectPath), raw);
+                })()
+            }
+        }
+    };
+}
+function permissions(manifest) {
+    return manifest.permissions && {
+        permissions: manifest.permissions
+    };
+}
+function sandbox(manifest, manifestPath, projectPath) {
+    return manifest.sandbox && {
+        sandbox: {
+            ...manifest.sandbox,
+            ...manifest.sandbox.pages && {
+                pages: manifest.sandbox.pages.map((page, index)=>getFilename(manifestPageOutputTarget(page, `sandbox/page-${index}.html`, manifestPath, projectPath), page))
+            }
+        }
+    };
+}
+function storage(manifest, manifestPath, projectPath) {
+    return manifest.storage && {
+        storage: {
+            ...manifest.storage.managed_schema && {
+                managed_schema: (()=>{
+                    const raw = String(manifest.storage.managed_schema);
+                    return getFilename(manifestJsonOutputTarget(raw, 'storage/managed_schema.json', manifestPath, projectPath), raw);
+                })()
+            }
+        }
+    };
+}
+const rewriteThemeImage = (value, manifestPath, projectPath)=>getFilename(manifestPageOutputTarget(value, themeImageOutputPath(value), manifestPath, projectPath), value);
+function theme(manifest, manifestPath, projectPath) {
+    return manifest.theme && {
+        theme: {
+            ...manifest.theme,
+            ...manifest.theme.images && {
+                images: Object.fromEntries(Object.entries(manifest.theme.images).map(([key, value])=>[
+                        key,
+                        Array.isArray(value) ? value.map((entry)=>rewriteThemeImage(entry, manifestPath, projectPath)) : rewriteThemeImage(value, manifestPath, projectPath)
+                    ]))
+            }
+        }
+    };
+}
+function userScripts(manifest) {
+    return manifest.user_scripts && {
+        user_scripts: {
+            ...manifest.user_scripts,
+            ...manifest.user_scripts.api_script && {
+                api_script: getFilename("user_scripts/api_script.js", manifest.user_scripts.api_script)
+            }
+        }
+    };
+}
+function normalizeOutputPath(originalPath) {
+    if (!originalPath) return originalPath;
+    const unix = originalPath.replace(/\\/g, '/');
+    if (/[*?[\]{}]/.test(unix)) return unix;
+    if (/^\/public\//i.test(unix)) return unix.replace(/^\/public\//i, '');
+    if (/^(?:\.\/)?public\//i.test(unix)) return unix.replace(/^(?:\.\/)?public\//i, '');
+    if (/^\//.test(unix)) return unix.replace(/^\//, '');
+    return unix;
+}
+function webAccessibleResources(manifest) {
+    if (!manifest.web_accessible_resources || !manifest.web_accessible_resources.length) return;
+    const mapResource = (resource)=>getFilename(normalizeOutputPath(resource), resource);
+    const entries = manifest.web_accessible_resources.map((entry)=>{
+        if ('string' == typeof entry) return mapResource(entry);
+        if (!entry || !Array.isArray(entry.resources)) return;
+        return {
+            ...entry,
+            resources: entry.resources.map(mapResource)
+        };
+    }).filter((entry)=>void 0 !== entry);
+    if (0 === entries.length) return;
+    return {
+        web_accessible_resources: entries
+    };
+}
+function manifestCommon(manifest, manifestPath, projectPath) {
+    return {
+        ...backgroundPage(manifest),
+        ...chromeUrlOverrides(manifest, manifestPath, projectPath),
+        ...content_scripts_contentScripts(manifest, manifestPath),
+        ...devtoolsPage(manifest, manifestPath, projectPath),
+        ...icons(manifest),
+        ...commands_commands(manifest),
+        ...permissions(manifest),
+        ...optionsPage(manifest, manifestPath, projectPath),
+        ...options_ui_optionsUi(manifest, manifestPath, projectPath),
+        ...sandbox(manifest, manifestPath, projectPath),
+        ...storage(manifest, manifestPath, projectPath),
+        ...theme(manifest, manifestPath, projectPath),
+        ...userScripts(manifest),
+        ...webAccessibleResources(manifest),
+        ...contentSecurityPolicy(manifest),
+        ...omnibox_omnibox(manifest)
+    };
+}
+function pageAction(manifest, manifestPath, projectPath) {
+    return manifest.page_action && {
+        page_action: {
+            ...manifest.page_action,
+            ...manifest.page_action.default_popup && {
+                default_popup: getFilename(manifestPageOutputTarget(String(manifest.page_action.default_popup), pageActionOutputTarget(manifest), manifestPath, projectPath), String(manifest.page_action.default_popup))
+            },
+            ...manifest.page_action.default_icon && {
+                default_icon: 'string' == typeof manifest.page_action.default_icon ? (()=>{
+                    const raw = String(manifest.page_action.default_icon);
+                    return getFilename(iconOutputPath(raw), raw);
+                })() : Object.fromEntries(Object.entries(manifest.page_action.default_icon).map(([size, icon])=>{
+                    const raw = String(icon);
+                    return [
+                        size,
+                        getFilename(iconOutputPath(raw), raw)
+                    ];
+                }))
+            }
+        }
+    };
+}
+function sidebar_action_sidebarAction(manifest, manifestPath, projectPath) {
+    return manifest.sidebar_action && {
+        sidebar_action: {
+            ...manifest.sidebar_action,
+            ...manifest.sidebar_action.default_panel && {
+                default_panel: (()=>{
+                    const raw = String(manifest.sidebar_action.default_panel);
+                    return getFilename(manifestPageOutputTarget(raw, sidebarActionOutputTarget(manifest), manifestPath, projectPath), raw);
+                })()
+            },
+            ...manifest.sidebar_action.default_icon && {
+                default_icon: 'string' == typeof manifest.sidebar_action.default_icon ? (()=>{
+                    const raw = String(manifest.sidebar_action.default_icon);
+                    return getFilename(iconOutputPath(raw), raw);
+                })() : Object.fromEntries(Object.entries(manifest.sidebar_action.default_icon).map(([size, icon])=>{
+                    const raw = String(icon);
+                    return [
+                        size,
+                        getFilename(iconOutputPath(raw), raw)
+                    ];
+                }))
+            }
+        }
+    };
+}
+function background(manifest) {
+    return manifest.background?.scripts && {
+        background: {
+            scripts: [
+                ...new Set(manifest.background.scripts.map((script)=>getFilename("background/scripts.js", String(script))))
+            ]
+        }
+    };
+}
+function browser_action_browserAction(manifest, manifestPath, projectPath) {
+    return manifest.browser_action && {
+        browser_action: {
+            ...manifest.browser_action,
+            ...manifest.browser_action.default_popup && {
+                default_popup: getFilename(manifestPageOutputTarget(String(manifest.browser_action.default_popup), browserActionOutputTarget(manifest), manifestPath, projectPath), String(manifest.browser_action.default_popup))
+            },
+            ...manifest.browser_action.default_icon && {
+                default_icon: 'string' == typeof manifest.browser_action.default_icon ? (()=>{
+                    const raw = String(manifest.browser_action.default_icon);
+                    return getFilename(iconOutputPath(raw), raw);
+                })() : Object.fromEntries(Object.entries(manifest.browser_action.default_icon).map(([size, icon])=>{
+                    const raw = String(icon);
+                    return [
+                        size,
+                        getFilename(iconOutputPath(raw), raw)
+                    ];
+                }))
+            },
+            ...manifest.browser_action.theme_icons && {
+                theme_icons: manifest.browser_action.theme_icons.map((themeIcon)=>({
+                        ...themeIcon,
+                        ...themeIcon.light && {
+                            light: getFilename(themeIconOutputPath(String(themeIcon.light), 'browser_action'), String(themeIcon.light))
+                        },
+                        ...themeIcon.dark && {
+                            dark: getFilename(themeIconOutputPath(String(themeIcon.dark), 'browser_action'), String(themeIcon.dark))
+                        }
+                    }))
+            }
+        }
+    };
+}
+function chromeSettingsOverrides(manifest, manifestPath, projectPath) {
+    const overrides = manifest.chrome_settings_overrides;
+    return overrides && {
+        chrome_settings_overrides: {
+            ...overrides.homepage && {
+                homepage: overrides.homepage
+            },
+            ...overrides.search_provider && {
+                search_provider: {
+                    ...overrides.search_provider,
+                    ...overrides.search_provider.favicon_url && {
+                        favicon_url: (()=>{
+                            const fav = String(overrides.search_provider.favicon_url);
+                            if (isManifestAddress(fav)) return fav;
+                            return getFilename(manifestPageOutputTarget(fav, `chrome_settings_overrides/${__rspack_external_node_path_806ed179.basename(fav)}`, manifestPath, projectPath), fav);
+                        })()
+                    }
+                }
+            },
+            ...overrides.startup_pages && {
+                startup_pages: overrides.startup_pages.map((page, index)=>isManifestAddress(page) ? page : getFilename(manifestPageOutputTarget(page, `chrome_settings_overrides/startup-${index}.html`, manifestPath, projectPath), page))
+            }
+        }
+    };
+}
+function asPolicyObject(policy) {
+    if (!policy || 'object' != typeof policy || Array.isArray(policy)) return;
+    return policy;
+}
+function content_security_policy_contentSecurityPolicy(manifest) {
+    if (2 !== manifest.manifest_version) return;
+    const policy = asPolicyObject(manifest.content_security_policy);
+    if (!policy) return;
+    if ('string' != typeof policy.extension_pages) return;
+    return {
+        content_security_policy: policy.extension_pages
+    };
+}
+function hasMv2SandboxPolicy(manifest) {
+    if (2 !== manifest.manifest_version) return false;
+    const policy = asPolicyObject(manifest.content_security_policy);
+    return 'string' == typeof policy?.sandbox;
+}
+function dropMv2ObjectPolicy(manifest) {
+    if (2 !== manifest.manifest_version) return manifest;
+    if (!asPolicyObject(manifest.content_security_policy)) return manifest;
+    const { content_security_policy: _dropped, ...rest } = manifest;
+    return rest;
+}
+const MV2_HOST_KEYS = [
+    'host_permissions',
+    'optional_host_permissions'
+];
+function appendUnique(base, extra) {
+    const list = [
+        ...Array.isArray(base) ? base : [],
+        ...Array.isArray(extra) ? extra : []
+    ].filter((entry)=>'string' == typeof entry);
+    return [
+        ...new Set(list)
+    ];
+}
+function hostPermissions(manifest) {
+    if (2 !== manifest.manifest_version) return;
+    const result = {};
+    if (Array.isArray(manifest.host_permissions)) result.permissions = appendUnique(manifest.permissions, manifest.host_permissions);
+    if (Array.isArray(manifest.optional_host_permissions)) result.optional_permissions = appendUnique(manifest.optional_permissions, manifest.optional_host_permissions);
+    return Object.keys(result).length ? result : void 0;
+}
+function dropMv2HostKeys(manifest) {
+    if (2 !== manifest.manifest_version) return manifest;
+    const rest = {
+        ...manifest
+    };
+    for (const key of MV2_HOST_KEYS)delete rest[key];
+    return rest;
+}
+const getBasename = (filepath)=>__rspack_external_node_path_806ed179.basename(filepath);
+function themeExperiment(manifest, manifestPath, projectPath) {
+    const te = manifest.theme_experiment;
+    return te && {
+        theme_experiment: {
+            ...te,
+            ...'string' == typeof te.stylesheet && {
+                stylesheet: getFilename(manifestPageOutputTarget(te.stylesheet, `theme_experiment/${getBasename(te.stylesheet)}`, manifestPath, projectPath), te.stylesheet)
+            }
+        }
+    };
+}
+function manifestV2(manifest, manifestPath, projectPath) {
+    return {
+        ...background(manifest),
+        ...browser_action_browserAction(manifest, manifestPath, projectPath),
+        ...pageAction(manifest, manifestPath, projectPath),
+        ...sidebar_action_sidebarAction(manifest, manifestPath, projectPath),
+        ...chromeSettingsOverrides(manifest, manifestPath, projectPath),
+        ...hostPermissions(manifest),
+        ...content_security_policy_contentSecurityPolicy(manifest),
+        ...themeExperiment(manifest, manifestPath, projectPath)
+    };
+}
+function action_action(manifest, manifestPath, projectPath) {
+    return manifest.action && {
+        action: {
+            ...manifest.action,
+            ...manifest.action.default_popup && {
+                default_popup: getFilename(manifestPageOutputTarget(String(manifest.action.default_popup), 'action/index.html', manifestPath, projectPath), String(manifest.action.default_popup))
+            },
+            ...manifest.action.default_icon && {
+                default_icon: 'string' == typeof manifest.action.default_icon ? (()=>{
+                    const raw = String(manifest.action.default_icon);
+                    return getFilename(iconOutputPath(raw), raw);
+                })() : Object.fromEntries(Object.entries(manifest.action.default_icon).map(([size, icon])=>{
+                    const raw = String(icon);
+                    return [
+                        size,
+                        getFilename(iconOutputPath(raw), raw)
+                    ];
+                }))
+            },
+            ...manifest.action.theme_icons && {
+                theme_icons: manifest.action.theme_icons.map((themeIcon)=>({
+                        ...themeIcon,
+                        ...themeIcon.light && {
+                            light: getFilename(themeIconOutputPath(String(themeIcon.light), 'action'), String(themeIcon.light))
+                        },
+                        ...themeIcon.dark && {
+                            dark: getFilename(themeIconOutputPath(String(themeIcon.dark), 'action'), String(themeIcon.dark))
+                        }
+                    }))
+            }
+        }
+    };
+}
+function backgroundServiceWorker(manifest) {
+    return manifest.background?.service_worker && {
+        background: {
+            service_worker: (()=>{
+                const raw = String(manifest.background.service_worker);
+                return getFilename('background/service_worker.js', raw);
+            })()
+        }
+    };
+}
+function declarativeNetRequest(manifest, manifestPath, projectPath) {
+    return manifest.declarative_net_request && {
+        declarative_net_request: {
+            ...manifest.declarative_net_request,
+            ...Array.isArray(manifest.declarative_net_request.rule_resources) && {
+                rule_resources: manifest.declarative_net_request.rule_resources.map((resourceObj)=>({
+                        ...resourceObj,
+                        path: resourceObj.path && getFilename(manifestJsonOutputTarget(resourceObj.path, `declarative_net_request/${resourceObj.id}.json`, manifestPath, projectPath), resourceObj.path)
+                    }))
+            }
+        }
+    };
+}
+function host_permissions_hostPermissions(manifest) {
+    return manifest.host_permissions && {
+        host_permissions: manifest.host_permissions
+    };
+}
+function side_panel_sidePanel(manifest, manifestPath, projectPath) {
+    return manifest.side_panel && {
+        side_panel: {
+            ...manifest.side_panel,
+            ...manifest.side_panel.default_path && {
+                default_path: (()=>{
+                    const raw = String(manifest.side_panel.default_path);
+                    return getFilename(manifestPageOutputTarget(raw, 'sidebar/index.html', manifestPath, projectPath), raw);
+                })()
+            }
+        }
+    };
+}
+function manifestV3(manifest, manifestPath, projectPath) {
+    return {
+        ...action_action(manifest, manifestPath, projectPath),
+        ...pageAction(manifest, manifestPath, projectPath),
+        ...backgroundServiceWorker(manifest),
+        ...declarativeNetRequest(manifest, manifestPath, projectPath),
+        ...host_permissions_hostPermissions(manifest),
+        ...side_panel_sidePanel(manifest, manifestPath, projectPath)
+    };
+}
+function getManifestOverrides(manifestPath, manifest, projectPath) {
+    const manifestContent = manifest || JSON.parse(stripBom(__rspack_external_node_fs_1b05aee1.readFileSync(manifestPath, 'utf8')));
+    const omit = (obj, key)=>{
+        if (!obj) return {};
+        const { [key]: _ignored, ...rest } = obj;
+        return rest;
+    };
+    const pickBackground = (obj)=>{
+        const value = obj.background;
+        return value && 'object' == typeof value ? value : {};
+    };
+    const common = manifestCommon(manifestContent, manifestPath, projectPath);
+    const mv2 = manifestV2(manifestContent, manifestPath, projectPath);
+    const mv3 = manifestV3(manifestContent, manifestPath, projectPath);
+    const backgroundMerged = {
+        ...manifestContent.background || {},
+        ...pickBackground(common),
+        ...pickBackground(mv2),
+        ...pickBackground(mv3)
+    };
+    const merged = {
+        ...manifestContent,
+        ...omit(common, 'background'),
+        ...omit(mv2, 'background'),
+        ...omit(mv3, 'background')
+    };
+    if (Object.keys(backgroundMerged).length) merged.background = backgroundMerged;
+    return JSON.stringify(dropMv2ObjectPolicy(dropMv2HostKeys(merged)), null, 2);
+}
+function serverRestartRequiredFromManifestError(fileAdded, fileRemoved) {
+    const lines = [];
+    lines.push("Entrypoint references changed.");
+    if (fileRemoved) lines.push(`${pintor.gray('EXPECTED')} ${pintor.underline(fileRemoved)}`);
+    if (fileAdded) lines.push(`${pintor.gray('GOT')} ${pintor.underline(fileAdded)}`);
+    lines.push("Restart the dev server to pick up changes to manifest entrypoints.");
+    return lines.join('\n');
+}
+function manifestFilesInTurnedOffPublic(files) {
+    return [
+        'manifest.json names files that the build did not emit:',
+        ...files.map((file)=>`  - ${pintor.underline(file)}`),
+        `The public folder is turned off, ${pintor.blue('folders.public')} is ${pintor.blue('false')} in extension.config.js, so nothing inside public/ ships.`,
+        'Turn the folder back on, or move these files out of public/ and name them by their path in the project.'
+    ].join('\n');
+}
+function legacyManifestPathWarning(field, legacyPath, modernPath) {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} The ${pintor.blue(field)} field uses a deprecated scaffold path.`);
+    lines.push(`${pintor.gray('PATH')} ${pintor.underline(legacyPath)}`);
+    lines.push(`Point it at ${pintor.underline(modernPath)}, Extension.js already emits the page there.`);
+    return lines.join('\n');
+}
+function fatalManifestShapeFixed(field, detail) {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} Repaired the ${pintor.blue(field)} field, which Chrome refuses to load the extension over.`);
+    lines.push(`${pintor.gray('REASON')} ${pintor.underline(detail)}`);
+    lines.push(`Fix the field in your ${pintor.blue('manifest.json')} file.`);
+    return lines.join('\n');
+}
+function manifestFieldMistyped(field, expected, received) {
+    const lines = [];
+    lines.push(`The ${pintor.blue(field)} field in your ${pintor.blue('manifest.json')} must be ${expected}.`);
+    lines.push(`${pintor.gray('GOT')} ${pintor.underline(received)}`);
+    lines.push(`No browser loads the extension with it written this way, so the build stops here. Rewrite the field as ${expected} and try again.`);
+    return lines.join('\n');
+}
+function invalidThemeValue(field, detail, value) {
+    const lines = [];
+    lines.push(`Check the ${pintor.yellow(field)} field in your ${pintor.yellow('manifest.json')} file.`);
+    lines.push(detail);
+    lines.push(`Chrome rejects the whole extension when this value is malformed.\nThe build stops here to protect you.`);
+    lines.push('');
+    lines.push(`${pintor.red('INVALID VALUE')} ${value}`);
+    return lines.join('\n');
+}
+function themeNotSupportedByBrowser(browser) {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} ${pintor.blue(browser)} does not support the ${pintor.yellow('theme')} field.`);
+    lines.push("The field ships unchanged in the manifest and Safari ignores it.");
+    return lines.join('\n');
+}
+function missingGeckoDataCollectionPermissions() {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} addons.mozilla.org requires ${pintor.blue('browser_specific_settings.gecko.data_collection_permissions')} for new add-ons.`);
+    lines.push(`Declare ${pintor.blue('{"required": ["none"]}')} if this extension transmits no data.`);
+    lines.push(`See ${pintor.underline('https://extensionworkshop.com/documentation/develop/firefox-builtin-data-consent/')} for details.`);
+    return lines.join('\n');
+}
+function manifestInvalidError(error) {
+    const lines = [];
+    lines.push(`Can't read your ${pintor.blue('manifest.json')} file.`);
+    lines.push(`${pintor.gray('REASON')} ${pintor.underline(String(error))}`);
+    lines.push("Update your manifest and try again.");
+    return lines.join('\n');
+}
+function manifestIncludeSummary(browser, manifestPath) {
+    return `${messaging_prefix('debug')} manifest include browser=${browser} path=${manifestPath}`;
+}
+function manifestEmitSuccess() {
+    return `${messaging_prefix('debug')} manifest emitted=true schemaStripped=true`;
+}
+function manifestOverridesSummary(overrideKeys, devCssStubsAdded) {
+    return `${messaging_prefix('debug')} manifest overrides keys=${String(overrideKeys)} devCssStubs=${String(devCssStubsAdded)}`;
+}
+function manifestDepsTracked(addedCount) {
+    return `${messaging_prefix('debug')} manifest deps=${String(addedCount)}`;
+}
+function manifestLegacyWarningsSummary(count) {
+    return `${messaging_prefix('debug')} manifest legacyWarnings=${String(count)}`;
+}
+function pageActionNotSupportedByBrowser(browser) {
+    return `${messaging_prefix('warn')} ${pintor.blue(browser)} does not show the ${pintor.yellow('page_action')} address bar surface.\nThe field was dropped from the built manifest and its page was not emitted.`;
+}
+function pageActionDroppedForBrowserAction(browser) {
+    return `${messaging_prefix('warn')} ${pintor.blue(browser)} refuses a Manifest V2 manifest that declares both ${pintor.yellow('browser_action')} and ${pintor.yellow('page_action')}.\nThe build kept ${pintor.yellow('browser_action')} and dropped ${pintor.yellow('page_action')} from the built manifest, so its page was not emitted. Remove one of the two keys, or scope page_action with the firefox: prefix.`;
+}
+function vendorPrefixedKeyDropped(key, familyKey, vendor, browser) {
+    const vendorName = 'edge' === vendor ? 'Edge' : 'Chrome';
+    return `${messaging_prefix('warn')} ${pintor.yellow(key)} now applies only to ${vendorName} builds, so the ${pintor.blue(browser)} build dropped it.\nRename it to ${pintor.yellow(familyKey)} to keep it on every Chromium-based browser. Leave it as is if it's meant for ${vendorName} only.`;
+}
+function prefixScope(prefix) {
+    if ('chrome' === prefix) return 'Chrome';
+    if ('edge' === prefix) return 'Edge';
+    if ('chromium' === prefix) return 'Chromium-based';
+    if ('firefox' === prefix || 'gecko' === prefix) return 'Firefox-based';
+    if ('safari' === prefix || 'webkit' === prefix) return 'Safari';
+    return prefix;
+}
+function manifestVersionLostForBrowser(browser, prefixedKeys, resolved) {
+    const target = pintor.blue(browser);
+    const field = pintor.yellow('manifest_version');
+    const scoped = prefixedKeys.map((key)=>{
+        const scope = prefixScope(key.substring(0, key.indexOf(':')));
+        return `${pintor.yellow(key)} applies only to ${scope} builds`;
+    });
+    const lead = void 0 === resolved ? scoped.length ? `${scoped.join(', ')}, so the ${target} build has no ${field}.` : `The ${target} build has no ${field}.` : `The ${target} build resolved ${field} to ${pintor.yellow(JSON.stringify(resolved))}, and browsers load only 2 or 3.`;
+    return `${messaging_prefix('error')} ${lead}\nNo browser loads a manifest without it, so the build was refused. Add a plain ${field}, or scope one to this browser: ${pintor.yellow('chromium:manifest_version')} for every Chromium-based browser, ${pintor.yellow('firefox:manifest_version')} for Firefox.`;
+}
+function edgeStoreKeyDropped(browser) {
+    return `${messaging_prefix('warn')} Edge Add-ons refuses a package whose manifest carries ${pintor.yellow('key')}, so the ${pintor.blue(browser)} production build dropped it.\nPartner Center assigns the id that ${pintor.yellow('key')} pins everywhere else, so the field has no use in this package. Write it as ${pintor.yellow('chrome:key')} if it is meant for the Chrome Web Store build only.`;
+}
+function mv2SandboxPolicyDropped(browser) {
+    return `${messaging_prefix('warn')} ${pintor.blue(browser)} reads a Manifest V2 ${pintor.yellow('content_security_policy')} as one string, so the ${pintor.yellow('sandbox')} slot has nowhere to go.\nThe build wrote the ${pintor.yellow('extension_pages')} policy as that string and dropped the sandbox policy from the built manifest. Scope the object form with the chromium: prefix, or declare a Manifest V3 build for this browser.`;
+}
+function mv3StringPolicyRewritten(browser) {
+    return `${messaging_prefix('warn')} ${pintor.blue(browser)} reads a Manifest V3 ${pintor.yellow('content_security_policy')} as an object, and the manifest wrote the Manifest V2 string form.\nThe build moved that string into the ${pintor.yellow('extension_pages')} slot, which is what the browser refuses to install the extension without. Write the object form in manifest.json, or scope the string with the firefox: prefix for a Manifest V2 build.`;
+}
+function mv3BrowserActionFoldedIntoAction(browser) {
+    return `${messaging_prefix('warn')} ${pintor.blue(browser)} replaced ${pintor.yellow('browser_action')} with ${pintor.yellow('action')} in Manifest V3, so the toolbar button never opens under the old key.\nThe build wrote the key as ${pintor.yellow('action')} in the built manifest. Rename it in manifest.json, or scope it with the firefox: prefix for a Manifest V2 build.`;
+}
+function mv2ActionFoldedIntoBrowserAction(browser) {
+    return `${messaging_prefix('warn')} ${pintor.blue(browser)} resolved ${pintor.yellow('manifest_version')} to 2, and Manifest V2 has no ${pintor.yellow('action')} key, so the toolbar button and its popup never load.\nThe build wrote the key as ${pintor.yellow('browser_action')} in the built manifest, pointing at the same compiled popup. Scope the Manifest V3 key with the chromium: prefix, or declare ${pintor.yellow('firefox:manifest_version')} 3 to keep it.`;
+}
+function sidebarKeyTranslatedForBrowser(browser, from, to) {
+    const permission = 'side_panel' === to ? `, and added the ${pintor.yellow('sidePanel')} permission the panel needs to appear` : '';
+    return `${messaging_prefix('warn')} ${pintor.blue(browser)} reads a sidebar only from ${pintor.yellow(to)}, and the manifest declared ${pintor.yellow(from)} alone, so the panel never opens.\nThe build wrote the key as ${pintor.yellow(to)} in the built manifest${permission}, pointing at the same compiled page. Declare both keys to ship a panel of its own per vendor, or scope ${pintor.yellow(from)} with a prefix to keep it off this build.`;
+}
+function mv3BackgroundPageUnsupported(browser) {
+    return `${messaging_prefix('warn')} ${pintor.blue(browser)} has no ${pintor.yellow('background.page')} in Manifest V3, and the extension installs with no background context at all.\nNothing reports that at load time: the background code, the reload bridge and the control channel all go missing silently. The build kept the page as written, so the rest of the extension still loads. Declare ${pintor.yellow('background.service_worker')} instead, or scope the page with the firefox: prefix for a Manifest V2 build.`;
+}
+function geckoSidePanelUnsupported(file) {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} ${pintor.underline(file)} uses chrome.sidePanel, which is Chromium only.`);
+    lines.push(`Firefox opens a sidebar through the ${pintor.yellow('sidebar_action')} manifest key on every manifest version, and addons-linter flags the call as UNSUPPORTED_API.`);
+    lines.push(`Move the call behind a build-time branch on ${pintor.blue('import.meta.env.EXTENSION_PUBLIC_BROWSER')} so the Firefox bundle drops it.`);
+    return lines.join('\n');
+}
+function safariUnsupportedApi(file, api, detail) {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} ${pintor.underline(file)} calls chrome.${api}, which Safari does not have.`);
+    lines.push(detail);
+    lines.push(`Move the call behind a build-time branch on ${pintor.blue('import.meta.env.EXTENSION_PUBLIC_BROWSER')}, or guard it with ${pintor.yellow(`chrome.${api}?.`)}.`);
+    return lines.join('\n');
+}
+const safariBackgroundDies = "The call throws when the script runs, Safari drops the background, and nothing reports an error.";
+function safariSidePanelUnsupported(file) {
+    return safariUnsupportedApi(file, 'sidePanel', "The call throws when the script runs. In a background service worker, Safari then never starts the worker, and nothing reports an error.");
+}
+function safariOffscreenUnsupported(file) {
+    return safariUnsupportedApi(file, 'offscreen', `Safari has no offscreen documents, so that DOM work has no place to run. ${safariBackgroundDies}`);
+}
+function safariTabGroupsUnsupported(file) {
+    return safariUnsupportedApi(file, 'tabGroups', `Safari has no tab groups, and its tabs carry no group id. ${safariBackgroundDies}`);
+}
+function safariManagementUnsupported(file) {
+    return safariUnsupportedApi(file, 'management', `Safari exposes no management namespace at all, not even getSelf. ${safariBackgroundDies}`);
+}
+function safariUserScriptsUnsupported(file) {
+    return safariUnsupportedApi(file, 'userScripts', `Safari has no userScripts namespace, and scripting.registerContentScripts is the closest it offers. ${safariBackgroundDies}`);
+}
+function safariIdentityUnsupported(file) {
+    return safariUnsupportedApi(file, 'identity', `Safari has no identity namespace, and Apple points OAuth flows at a normal tab instead. ${safariBackgroundDies}`);
+}
+function safariNotificationsUnsupported(file) {
+    return safariUnsupportedApi(file, 'notifications', `Safari has no notifications namespace, so a page has to raise the web Notification instead. ${safariBackgroundDies}`);
+}
+function safariOmniboxUnsupported(file) {
+    return safariUnsupportedApi(file, 'omnibox', `Safari has no omnibox keyword API. ${safariBackgroundDies}`);
+}
+function safariBookmarksUnsupported(file) {
+    return safariUnsupportedApi(file, 'bookmarks', `Safari does not expose bookmarks to extensions on any version. ${safariBackgroundDies}`);
+}
+function safariHistoryUnsupported(file) {
+    return safariUnsupportedApi(file, 'history', `Safari does not expose browsing history to extensions on any version. ${safariBackgroundDies}`);
+}
+function safariDownloadsUnsupported(file) {
+    return safariUnsupportedApi(file, 'downloads', `Safari has no downloads namespace. ${safariBackgroundDies}`);
+}
+function safariIdleUnsupported(file) {
+    return safariUnsupportedApi(file, 'idle', `Safari has no idle namespace. ${safariBackgroundDies}`);
+}
+const safariMissingMemberDetails = {
+    'action.getUserSettings': `Safari has no pinned-state query for the toolbar button, so there is no function to call. ${safariBackgroundDies}`,
+    'action.getBadgeTextColor': `Safari draws the badge in its own colors and offers no badge text color call. ${safariBackgroundDies}`,
+    'action.setBadgeTextColor': `Safari draws the badge in its own colors and offers no badge text color call. ${safariBackgroundDies}`,
+    'action.onUserSettingsChanged': `Safari raises no event when the toolbar button settings change, so the listener attaches to nothing. ${safariBackgroundDies}`,
+    'storage.managed': `Safari has no managed storage area, since it carries no enterprise policy channel for web extensions. ${safariBackgroundDies}`,
+    'runtime.getContexts': `Safari keeps no inventory of extension contexts to hand back. ${safariBackgroundDies}`,
+    'runtime.onSuspend': `Safari tears a background down without announcing it, so this lifecycle event does not exist. ${safariBackgroundDies}`,
+    'runtime.onSuspendCanceled': `Safari tears a background down without announcing it, so this lifecycle event does not exist. ${safariBackgroundDies}`,
+    'runtime.onUpdateAvailable': `Safari ships an extension inside its host app, so the browser raises no update event for it. ${safariBackgroundDies}`,
+    'declarativeNetRequest.getAvailableStaticRuleCount': `Safari implements the blocking core of declarativeNetRequest and not its rule-budget queries. ${safariBackgroundDies}`,
+    'declarativeNetRequest.getDisabledRuleIds': `Safari cannot disable individual static rules, so it has nothing to report here. ${safariBackgroundDies}`,
+    'declarativeNetRequest.updateStaticRules': `Safari cannot toggle individual static rules, only whole rulesets through updateEnabledRulesets. ${safariBackgroundDies}`,
+    'declarativeNetRequest.testMatchOutcome': `Safari has no rule-matching test harness, which is a Chrome debugging aid. ${safariBackgroundDies}`,
+    'declarativeNetRequest.onRuleMatchedDebug': `Safari raises no rule-match debug event, which Chrome offers to unpacked extensions only. ${safariBackgroundDies}`,
+    'tabs.group': `Safari has no tab groups at all, so there is no group to move a tab into. ${safariBackgroundDies}`,
+    'tabs.ungroup': `Safari has no tab groups at all, so there is no group to take a tab out of. ${safariBackgroundDies}`,
+    'webNavigation.onCreatedNavigationTarget': `Safari reports the main navigation events only, and this one is not among them. ${safariBackgroundDies}`,
+    'webNavigation.onHistoryStateUpdated': `Safari reports the main navigation events only, so a History API navigation goes unannounced. ${safariBackgroundDies}`,
+    'webNavigation.onReferenceFragmentUpdated': `Safari reports the main navigation events only, so a fragment change goes unannounced. ${safariBackgroundDies}`,
+    'webNavigation.onTabReplaced': `Safari reports the main navigation events only, and this one is not among them. ${safariBackgroundDies}`,
+    'windows.onBoundsChanged': `Safari raises no event when a window is moved or resized. ${safariBackgroundDies}`
+};
+function safariMemberUnsupported(file, api, member, kind) {
+    const guard = 'call' === kind ? `chrome.${api}.${member}?.()` : `chrome.${api}.${member}?.`;
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} ${pintor.underline(file)} calls chrome.${api}.${member}, which Safari does not have.`);
+    lines.push(safariMissingMemberDetails[`${api}.${member}`] || `Safari ships chrome.${api} without this member. ${safariBackgroundDies}`);
+    lines.push(`Safari has ${pintor.blue(`chrome.${api}`)} itself, so a guard on the namespace does not help. Move the call behind a build-time branch on ${pintor.blue('import.meta.env.EXTENSION_PUBLIC_BROWSER')}, or guard it with ${pintor.yellow(guard)}.`);
+    return lines.join('\n');
+}
+function geckoActionUnsupportedOnMv2(file) {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} ${pintor.underline(file)} uses chrome.action, which Manifest V2 does not have on Firefox.`);
+    lines.push("Firefox Manifest V2 exposes the toolbar button as browserAction, and addons-linter flags the call as UNSUPPORTED_API.");
+    lines.push(`Use browserAction behind a build-time branch on ${pintor.blue('import.meta.env.EXTENSION_PUBLIC_BROWSER')}, or declare Manifest V3 for Firefox with ${pintor.yellow('firefox:manifest_version')}.`);
+    return lines.join('\n');
+}
+function contentScriptEntryDroppedForBrowser(index, browser, prefixedKeys) {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} ${pintor.yellow(`content_scripts[${String(index)}]`)} has no js and no css in the ${pintor.blue(browser)} build, so the build left it out.`);
+    if (prefixedKeys.length > 0) lines.push(`${prefixedKeys.map((key)=>pintor.yellow(key)).join(', ')} ${1 === prefixedKeys.length ? 'applies' : 'apply'} to another browser. Add ${pintor.yellow(`${browser}:js`)} or a plain ${pintor.yellow('js')} to keep the entry here.`);
+    return lines.join('\n');
+}
+function webkitUnsupportedKeysDropped(browser, dropped) {
+    const count = dropped.length;
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} Safari has no support for ${String(count)} manifest ${1 === count ? 'key' : 'keys'} this project declares, so the ${pintor.blue(browser)} build dropped ${1 === count ? 'it' : 'them'}.`);
+    for (const entry of dropped)lines.push(`${pintor.yellow(entry.path)} ${pintor.gray(entry.reason)}`);
+    lines.push(`Every key above is inert on Safari, so the built app lost nothing it could have run. Declare a Safari-only replacement with the ${pintor.yellow('safari:')} prefix if you have one.`);
+    return lines.join('\n');
+}
+const UNSUPPORTED_TOP_LEVEL_KEYS = {
+    side_panel: 'Safari has no side panel surface',
+    sidebar_action: 'Safari has no sidebar surface',
+    sandbox: 'Safari cannot run sandboxed extension pages',
+    user_scripts: 'Safari has no userScripts API',
+    omnibox: 'Safari has no omnibox keyword API',
+    chrome_settings_overrides: 'Safari lets no extension override these settings',
+    tts_engine: 'Safari has no speech engine API',
+    file_browser_handlers: 'ChromeOS only',
+    input_components: 'ChromeOS only',
+    cross_origin_embedder_policy: 'Safari reads no COEP key from a manifest',
+    cross_origin_opener_policy: 'Safari reads no COOP key from a manifest',
+    requirements: 'Chrome Web Store only',
+    oauth2: 'Safari has no identity API to consume it',
+    nacl_modules: 'Native Client is Chrome only',
+    replacement_web_app: 'Chrome Web Store only',
+    offline_enabled: 'Chrome Web Store only',
+    differential_fingerprint: 'Chrome Web Store only',
+    incognito: 'Safari always runs extensions in spanning mode and ignores the declared value'
+};
+const UNSUPPORTED_PERMISSIONS = new Set([
+    'accessibilityFeatures.modify',
+    'accessibilityFeatures.read',
+    'audio',
+    'background',
+    'bookmarks',
+    'browsingData',
+    'certificateProvider',
+    'clipboardRead',
+    'contentSettings',
+    'debugger',
+    'declarativeContent',
+    'desktopCapture',
+    'documentScan',
+    'downloads',
+    'enterprise.deviceAttributes',
+    'enterprise.platformKeys',
+    'experimental',
+    'favicon',
+    'fileSystemProvider',
+    'fontSettings',
+    'gcm',
+    'geolocation',
+    'history',
+    'identity',
+    'identity.email',
+    'idle',
+    'management',
+    'notifications',
+    'offscreen',
+    'pageCapture',
+    'platformKeys',
+    'power',
+    'printerProvider',
+    'privacy',
+    'processes',
+    'proxy',
+    'readingList',
+    'search',
+    'sessions',
+    'sidePanel',
+    'system.cpu',
+    'system.display',
+    'system.memory',
+    'system.storage',
+    'systemLog',
+    'tabCapture',
+    'tabGroups',
+    'topSites',
+    'tts',
+    'ttsEngine',
+    'userScripts',
+    'vpnProvider',
+    'wallpaper',
+    'webAuthenticationProxy',
+    'webRequestBlocking'
+]);
+const PERMISSION_LISTS = [
+    'permissions',
+    'optional_permissions'
+];
+function isWebkitUnsupportedPermission(permission, browser) {
+    return isWebkitBasedBrowser(String(browser)) && UNSUPPORTED_PERMISSIONS.has(permission);
+}
+const UNSUPPORTED_OPTIONS_UI_KEYS = {
+    open_in_tab: 'Safari always opens the options page in a tab'
+};
+function isPlainObject(value) {
+    return !!value && 'object' == typeof value && !Array.isArray(value);
+}
+function dropWebkitUnsupportedKeys(manifest, browser) {
+    const dropped = [];
+    if (!isWebkitBasedBrowser(String(browser))) return {
+        manifest,
+        dropped
+    };
+    const next = {
+        ...manifest
+    };
+    for (const [key, reason] of Object.entries(UNSUPPORTED_TOP_LEVEL_KEYS))if (key in next) {
+        delete next[key];
+        dropped.push({
+            path: key,
+            reason
+        });
+    }
+    for (const listName of PERMISSION_LISTS){
+        const list = next[listName];
+        if (!Array.isArray(list)) continue;
+        const kept = list.filter((entry)=>{
+            if ('string' != typeof entry || !UNSUPPORTED_PERMISSIONS.has(entry)) return true;
+            dropped.push({
+                path: `${listName}.${entry}`,
+                reason: `Safari has no ${entry} API`
+            });
+            return false;
+        });
+        if (kept.length !== list.length) if (0 === kept.length) delete next[listName];
+        else next[listName] = kept;
+    }
+    const optionsUi = next.options_ui;
+    if (isPlainObject(optionsUi)) {
+        const patched = {
+            ...optionsUi
+        };
+        let changed = false;
+        for (const [key, reason] of Object.entries(UNSUPPORTED_OPTIONS_UI_KEYS))if (key in patched) {
+            delete patched[key];
+            changed = true;
+            dropped.push({
+                path: `options_ui.${key}`,
+                reason
+            });
+        }
+        if (changed) next.options_ui = patched;
+    }
+    return {
+        manifest: next,
+        dropped
+    };
+}
+function omitWebkitDroppedEntries(entries, dropped) {
+    const owners = new Set(dropped.map((entry)=>entry.path));
+    if (0 === owners.size) return entries;
+    return Object.fromEntries(Object.entries(entries).filter(([feature])=>!owners.has(feature.split('/')[0])));
+}
+const reportedDrops = new Set();
+function reportWebkitDroppedKeys(dropped, browser) {
+    if (0 === dropped.length) return;
+    const signature = `${String(browser)}\0${dropped.map((entry)=>entry.path).join(',')}`;
+    if (reportedDrops.has(signature)) return;
+    reportedDrops.add(signature);
+    humanLine(webkitUnsupportedKeysDropped(String(browser), dropped));
+}
+const cjsRequire = createRequire(import.meta.url);
+const manifestSourceStore = new WeakMap();
+function manifestSourceEntry(compilation) {
+    let entry = manifestSourceStore.get(compilation);
+    if (!entry) {
+        entry = {};
+        manifestSourceStore.set(compilation, entry);
+    }
+    return entry;
+}
+function readAssetSource(asset) {
+    if (!asset) return '';
+    const source = asset.source;
+    if ('string' == typeof source) return source;
+    if ('function' == typeof source) {
+        const out = source();
+        return 'string' == typeof out ? out : String(out || '');
+    }
+    if (source && 'function' == typeof source.source) {
+        const out = source.source();
+        return 'string' == typeof out ? out : String(out || '');
+    }
+    return '';
+}
+function setOriginalManifestContent(compilation, source) {
+    manifestSourceEntry(compilation).original = source;
+}
+function getOriginalManifestContent(compilation) {
+    return manifestSourceStore.get(compilation)?.original;
+}
+function setCurrentManifestContent(compilation, source) {
+    manifestSourceEntry(compilation).current = source;
+}
+function getCurrentManifestContent(compilation) {
+    return manifestSourceStore.get(compilation)?.current;
+}
+function getManifestContent(compilation, manifestPath) {
+    const currentManifest = getCurrentManifestContent(compilation);
+    if (currentManifest) return parseJsonSafe(currentManifest);
+    const getAsset = compilation.getAsset;
+    if ('function' == typeof getAsset) {
+        const manifestAsset = getAsset.call(compilation, 'manifest.json');
+        const manifest = readAssetSource(manifestAsset);
+        if (manifest) return parseJsonSafe(manifest);
+    }
+    const manifestAsset = compilation.assets?.['manifest.json'];
+    if (manifestAsset) {
+        const manifest = readAssetSource(manifestAsset);
+        if (manifest) return parseJsonSafe(manifest);
+    }
+    const originalManifest = getOriginalManifestContent(compilation);
+    if (originalManifest) return parseJsonSafe(originalManifest);
+    try {
+        const text = __rspack_external_node_fs_1b05aee1.readFileSync(manifestPath, 'utf8');
+        return parseJsonSafe(text);
+    } catch  {
+        try {
+            const resolved = cjsRequire.resolve(manifestPath);
+            delete cjsRequire.cache[resolved];
+        } catch  {}
+        return cjsRequire(manifestPath);
+    }
+}
+function buildCanonicalManifestWithOverrides(manifestPath, manifest, browser, projectPath) {
+    const filteredManifest = filterKeysForThisBrowser(manifest, browser);
+    const withoutPageAction = shouldDropPageAction(filteredManifest, browser) ? dropPageAction(filteredManifest) : filteredManifest;
+    const forOverrides = foldBrowserActionIntoAction(withoutPageAction);
+    const overrides = getManifestOverrides(manifestPath, forOverrides, projectPath);
+    const canonical = dropMv2ObjectPolicy(dropMv2HostKeys({
+        ...forOverrides,
+        ...JSON.parse(overrides)
+    }));
+    const translated = foldActionIntoBrowserAction(foldSidebarKeyForBrowser(canonical, browser));
+    const webkit = dropWebkitUnsupportedKeys(translated, browser);
+    reportWebkitDroppedKeys(webkit.dropped, browser);
+    return {
+        manifest: webkit.manifest,
+        overrides
+    };
+}
+function boring(manifestName, durationMs, stats) {
+    const now = new Date();
+    const hh = String(now.getHours()).padStart(2, '0');
+    const mm = String(now.getMinutes()).padStart(2, '0');
+    const ss = String(now.getSeconds()).padStart(2, '0');
+    const timestamp = pintor.gray(`[${hh}:${mm}:${ss}]`);
+    const hasErrors = stats.hasErrors();
+    const hasWarnings = stats.hasWarnings();
+    const arrow = hasErrors ? messaging_prefix('error') : hasWarnings ? messaging_prefix('warn') : messaging_prefix('info');
+    const status = hasErrors ? `compiled ${pintor.red('with errors')}` : hasWarnings ? `compiled ${pintor.yellow('with warnings')}` : 'compiled';
+    const app = manifestName;
+    const time = `${durationMs} ms`;
+    return `${arrow} ${timestamp} ${app} ${status} in ${time}.`;
+}
+function cleanDistStarting(distPath) {
+    return `${messaging_prefix('debug')} clean    start path=${distPath}`;
+}
+function cleanDistRemovedSummary(removedCount, distPath) {
+    return `${messaging_prefix('debug')} clean    removed=${removedCount} path=${distPath}`;
+}
+function cleanDistSkippedNotFound(distPath) {
+    return `${messaging_prefix('debug')} clean    skipped=not-found path=${distPath}`;
+}
+function zipPackagingSkipped(reason) {
+    return `${messaging_prefix('debug')} zip      skipped=true reason="${reason}"`;
+}
+function envSelectedFile(envPath) {
+    return `${messaging_prefix('debug')} env      file=${envPath || 'none'}`;
+}
+function envInjectedPublicVars(count) {
+    return `${messaging_prefix('debug')} env      injected=${count} prefix=EXTENSION_PUBLIC_`;
+}
+function envValueBreaksJsonAsset(asset, names) {
+    return `${pintor.yellow(asset)} is not valid JSON after substituting ${names.map((name)=>pintor.yellow(`$${name}`)).join(', ')}.\nQuote the placeholder to get a JSON string: ${pintor.gray(`"$${names[0]}"`)}. An unquoted placeholder takes the value as written, so the value must be JSON itself.`;
+}
+function projectConfigChangedRestartRequired(configPath) {
+    return `${pintor.yellow(displayPath(configPath))} changed. This session keeps running the config it read at startup.\nStop it and run ${pintor.blue('extension dev')} again to apply the change.`;
+}
+function envChangedRestartRequired(envPath) {
+    return `${pintor.yellow(displayPath(envPath))} changed. The values this build inlined are the ones read when the compiler started.\nRestart the dev server to apply the change.`;
+}
+function envNoMatchingFile(browser, mode, presentFiles, expectedCandidates) {
+    return `Found ${presentFiles.map((file)=>pintor.yellow(file)).join(', ')}, but none match browser ${pintor.yellow(browser)} in mode ${pintor.yellow(mode)}.\nEXTENSION_PUBLIC_* variables read from code are ${pintor.yellow('undefined')} in this build.\nRename the file to one of these, in priority order: ${expectedCandidates.map((file)=>pintor.gray(file)).join(', ')}.\nFamily names apply to every family member, so ${pintor.yellow('.env.chrome')} also matches ${pintor.yellow('chromium')} and ${pintor.yellow('edge')} targets.`;
+}
+const DEV_SESSION_RESTART_DEBOUNCE_MS = 300;
+class DevSessionRestartScheduler {
+    debounceMs;
+    handler = null;
+    timer;
+    latest = null;
+    inFlight = false;
+    constructor(debounceMs = DEV_SESSION_RESTART_DEBOUNCE_MS){
+        this.debounceMs = Math.max(0, debounceMs);
+    }
+    setHandler(handler) {
+        this.handler = handler;
+    }
+    request(request) {
+        this.latest = request;
+        if (this.inFlight) return;
+        this.schedule();
+    }
+    isPending() {
+        return null != this.latest || this.inFlight;
+    }
+    dispose() {
+        if (this.timer) clearTimeout(this.timer);
+        this.timer = void 0;
+        this.latest = null;
+        this.handler = null;
+    }
+    schedule() {
+        if (this.timer) clearTimeout(this.timer);
+        if (0 === this.debounceMs) return void this.flush();
+        this.timer = setTimeout(()=>{
+            this.timer = void 0;
+            this.flush();
+        }, this.debounceMs);
+        this.timer.unref?.();
+    }
+    async flush() {
+        if (this.inFlight) return;
+        const request = this.latest;
+        const handler = this.handler;
+        if (!request || !handler) return;
+        this.latest = null;
+        this.inFlight = true;
+        try {
+            await handler(request);
+        } catch  {} finally{
+            this.inFlight = false;
+            if (this.latest) this.schedule();
+        }
+    }
+}
+let boundScheduler = null;
+const restartingCompilers = new WeakSet();
+function bindDevSessionRestart(scheduler) {
+    boundScheduler = scheduler;
+}
+function unbindDevSessionRestart() {
+    boundScheduler = null;
+}
+function requestDevSessionRestart(compiler, request) {
+    if (!boundScheduler) return false;
+    if (compiler) restartingCompilers.add(compiler);
+    boundScheduler.request(request);
+    return true;
+}
+function isCompilerRestarting(compiler) {
+    return null != compiler && restartingCompilers.has(compiler);
+}
+class WatchEnvFilesPlugin {
+    static name = 'plugin-compilation:watch-env-files';
+    candidates;
+    watched;
+    changedPath = null;
+    constructor(paths){
+        this.candidates = Array.from(new Set(paths.filter((file)=>Boolean(file)).map((file)=>__rspack_external_node_path_806ed179.resolve(file))));
+        this.watched = new Set(this.candidates);
+    }
+    collectChange(compiler) {
+        const touched = [
+            ...compiler.modifiedFiles || [],
+            ...compiler.removedFiles || []
+        ];
+        for (const file of touched){
+            const resolved = __rspack_external_node_path_806ed179.resolve(file);
+            if (this.watched.has(resolved)) {
+                this.changedPath = resolved;
+                return;
+            }
+        }
+    }
+    addDependencies(compilation) {
+        for (const candidate of this.candidates)if (__rspack_external_node_fs_1b05aee1.existsSync(candidate)) compilation.fileDependencies?.add(candidate);
+        else compilation.missingDependencies?.add(candidate);
+    }
+    apply(compiler) {
+        if (0 === this.candidates.length) return;
+        compiler.hooks.watchRun.tap(WatchEnvFilesPlugin.name, ()=>{
+            this.collectChange(compiler);
+        });
+        compiler.hooks.thisCompilation.tap(WatchEnvFilesPlugin.name, (compilation)=>{
+            this.addDependencies(compilation);
+            const changedPath = this.changedPath;
+            if (!changedPath) return;
+            this.changedPath = null;
+            if (requestDevSessionRestart(compiler, {
+                reason: 'env',
+                pathChanged: changedPath
+            })) return;
+            const warning = new WebpackError(envChangedRestartRequired(changedPath));
+            warning.name = 'EnvFileChange';
+            warning.file = __rspack_external_node_path_806ed179.basename(changedPath);
+            compilation.warnings?.push(warning);
+        });
+    }
+}
+const IMPORT_META_URL_RUNTIME = '(function(){var h=typeof document!=="undefined"&&document.baseURI||self.location.href;try{var g=globalThis,r=(g.browser||g.chrome).runtime.getURL("/");return h.indexOf(r)===0?h:r}catch(_){return h}})()';
+function importMetaUrlForEmitPath(emitPath) {
+    const request = emitPath.replace(/\\/g, '/').replace(/^\/+/, '');
+    return `(function(){try{var g=globalThis;return (g.browser||g.chrome).runtime.getURL(${toJsStringLiteral(request)})}catch(_){return ${IMPORT_META_URL_RUNTIME}}})()`;
+}
+function toJsStringLiteral(value) {
+    return JSON.stringify(value).replace(/[<>\u007f-\uffff]/g, (char)=>`\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`);
+}
+function escapeForJsonAsset(value) {
+    return JSON.stringify(value).slice(1, -1);
+}
+const HTML_ENTITIES = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;'
+};
+function rawTextElementAt(content, offset) {
+    const before = content.slice(0, offset).toLowerCase();
+    for (const tag of [
+        "script",
+        'style'
+    ]){
+        const open = before.lastIndexOf(`<${tag}`);
+        const openEnd = before.indexOf('>', open);
+        if (-1 !== open && open > before.lastIndexOf(`</${tag}`) && -1 !== openEnd) return {
+            tag,
+            textStart: openEnd + 1
+        };
+    }
+}
+function insideStringLiteral(text, quotes, templates) {
+    let quote = '';
+    const expressions = [];
+    for(let i = 0; i < text.length; i++){
+        const char = text[i];
+        if (quote) {
+            if ('\\' === char) i++;
+            else if ('`' === quote && '$' === char && '{' === text[i + 1]) {
+                expressions.push(0);
+                quote = '';
+                i++;
+            } else if (char === quote) quote = '';
+            continue;
+        }
+        if ('/' === char && '/' === text[i + 1]) {
+            const end = text.indexOf('\n', i);
+            if (-1 === end) return false;
+            i = end;
+        } else if ('/' === char && '*' === text[i + 1]) {
+            const end = text.indexOf('*/', i + 2);
+            if (-1 === end) return false;
+            i = end + 1;
+        } else if (quotes.includes(char) || templates && '`' === char) quote = char;
+        else if (expressions.length && '{' === char) expressions[expressions.length - 1]++;
+        else if (expressions.length && '}' === char) if (0 === expressions[expressions.length - 1]) {
+            expressions.pop();
+            quote = '`';
+        } else expressions[expressions.length - 1]--;
+    }
+    return '' !== quote;
+}
+function isInsideJsonString(content, offset) {
+    return insideStringLiteral(content.slice(0, offset), '"', false);
+}
+function substituteForJsonAsset(content, offset, value) {
+    return isInsideJsonString(content, offset) ? escapeForJsonAsset(value) : value;
+}
+function escapeForHtmlAsset(content, offset, value) {
+    const element = rawTextElementAt(content, offset);
+    if (element?.tag === "script") {
+        const script = content.slice(element.textStart, offset);
+        if (!insideStringLiteral(script, '"\'', true)) return value.replace(/<\/(script)/gi, '<\\/$1').replace(/<!--/g, '<\\!--');
+        return toJsStringLiteral(value).slice(1, -1).replace(/'/g, '\\u0027').replace(/`/g, '\\u0060').replace(/\$\{/g, '\\u0024{');
+    }
+    if (element?.tag === 'style') return value;
+    return value.replace(/[&<>"']/g, (char)=>HTML_ENTITIES[char]);
+}
+function parsesAsJson(text) {
+    try {
+        JSON.parse(text);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function resolveProcessShim() {
+    const candidate = __rspack_external_node_path_806ed179.join(__rspack_import_meta_dirname__, '..', 'runtime', 'process-shim.cjs');
+    try {
+        return __rspack_external_node_fs_1b05aee1.existsSync(candidate) ? candidate : void 0;
+    } catch  {
+        return;
+    }
+}
+function findNearestWorkspaceRoot(startDir) {
+    let current = __rspack_external_node_path_806ed179.isAbsolute(startDir) ? __rspack_external_node_path_806ed179.normalize(startDir) : __rspack_external_node_path_806ed179.resolve(startDir);
+    while(true){
+        if (__rspack_external_node_fs_1b05aee1.existsSync(__rspack_external_node_path_806ed179.join(current, 'pnpm-workspace.yaml'))) return current;
+        const parent = __rspack_external_node_path_806ed179.dirname(current);
+        if (parent === current) return;
+        current = parent;
+    }
+}
+function resolveEnvPaths(projectPath, envFiles) {
+    const localEnvPath = envFiles.map((file)=>__rspack_external_node_path_806ed179.join(projectPath, file)).find((filePath)=>__rspack_external_node_fs_1b05aee1.existsSync(filePath)) || '';
+    const localDefaultsPath = __rspack_external_node_path_806ed179.join(projectPath, '.env.defaults');
+    if (localEnvPath) return {
+        envPath: localEnvPath,
+        defaultsPath: localDefaultsPath
+    };
+    const workspaceRoot = findNearestWorkspaceRoot(projectPath);
+    if (workspaceRoot && workspaceRoot !== projectPath) {
+        const workspaceEnvPath = envFiles.map((file)=>__rspack_external_node_path_806ed179.join(workspaceRoot, file)).find((filePath)=>__rspack_external_node_fs_1b05aee1.existsSync(filePath)) || '';
+        const workspaceDefaultsPath = __rspack_external_node_path_806ed179.join(workspaceRoot, '.env.defaults');
+        if (workspaceEnvPath || __rspack_external_node_fs_1b05aee1.existsSync(workspaceDefaultsPath)) return {
+            envPath: workspaceEnvPath,
+            defaultsPath: __rspack_external_node_fs_1b05aee1.existsSync(localDefaultsPath) ? localDefaultsPath : workspaceDefaultsPath,
+            fallbackDefaultsPath: __rspack_external_node_fs_1b05aee1.existsSync(localDefaultsPath) ? workspaceDefaultsPath : void 0
+        };
+    }
+    if (__rspack_external_node_fs_1b05aee1.existsSync(localDefaultsPath)) return {
+        envPath: localEnvPath,
+        defaultsPath: localDefaultsPath
+    };
+    return {
+        envPath: '',
+        defaultsPath: localDefaultsPath
+    };
+}
+function getEnvFileCandidates(browser, mode) {
+    const browserName = String(browser);
+    const isChromiumTarget = isChromiumBasedBrowser(browserName) || 'safari' === browserName || browserName.includes('webkit');
+    const familyNames = isChromiumTarget ? CHROMIUM_FAMILY_ALIASES : isGeckoBasedBrowser(browserName) ? GECKO_FAMILY_ALIASES : [];
+    const names = [
+        browserName,
+        ...familyNames.filter((name)=>name !== browserName)
+    ];
+    return [
+        ...names.flatMap((name)=>[
+                `.env.${name}.${mode}`,
+                `.env.${name}`
+            ]),
+        `.env.${mode}`,
+        '.env.local',
+        '.env'
+    ];
+}
+class EnvPlugin {
+    browser;
+    manifestPath;
+    define;
+    constructor(options){
+        this.browser = options.browser || 'chrome';
+        this.manifestPath = options.manifestPath;
+        this.define = options.define;
+    }
+    apply(compiler) {
+        const projectPath = compiler.options.context || (this.manifestPath ? __rspack_external_node_path_806ed179.dirname(this.manifestPath) : '');
+        const mode = compiler.options.mode || 'development';
+        const envFiles = getEnvFileCandidates(this.browser, mode);
+        const { envPath, defaultsPath, fallbackDefaultsPath } = resolveEnvPaths(projectPath, envFiles);
+        if (isDebug()) debugLine(envSelectedFile(envPath));
+        if (projectPath && compiler.options.watchOptions) new WatchEnvFilesPlugin([
+            ...envFiles.map((file)=>__rspack_external_node_path_806ed179.join(projectPath, file)),
+            __rspack_external_node_path_806ed179.join(projectPath, '.env.defaults'),
+            envPath,
+            defaultsPath,
+            fallbackDefaultsPath
+        ]).apply(compiler);
+        if (!envPath && projectPath) {
+            let unmatchedEnvFiles = [];
+            try {
+                unmatchedEnvFiles = __rspack_external_node_fs_1b05aee1.readdirSync(projectPath).filter((file)=>file.startsWith('.env') && '.env.defaults' !== file && '.env.example' !== file).sort();
+            } catch  {}
+            if (unmatchedEnvFiles.length > 0) compiler.hooks.thisCompilation.tap('env:warn-unmatched', (compilation)=>{
+                const warn = new WebpackError(envNoMatchingFile(String(this.browser), String(mode), unmatchedEnvFiles, envFiles));
+                warn.name = 'EnvNoMatchingFile';
+                compilation.warnings.push(warn);
+            });
+        }
+        const envVars = envPath ? __rspack_external_dotenv.parse(__rspack_external_node_fs_1b05aee1.readFileSync(envPath)) : {};
+        const readDefaults = (filePath)=>filePath && __rspack_external_node_fs_1b05aee1.existsSync(filePath) ? __rspack_external_dotenv.parse(__rspack_external_node_fs_1b05aee1.readFileSync(filePath)) : {};
+        const defaultsVars = {
+            ...readDefaults(fallbackDefaultsPath),
+            ...readDefaults(defaultsPath)
+        };
+        const preloadedKeys = getPreloadedEnvKeys();
+        const systemEnv = Object.fromEntries(Object.entries(process.env).filter(([key])=>!preloadedKeys.has(key)));
+        const combinedVars = {
+            ...defaultsVars,
+            ...envVars,
+            ...systemEnv
+        };
+        const filteredEnvVars = Object.keys(combinedVars).filter((key)=>key.startsWith('EXTENSION_PUBLIC_')).reduce((obj, key)=>{
+            obj[`process.env.${key}`] = JSON.stringify(combinedVars[key]);
+            obj[`import.meta.env.${key}`] = JSON.stringify(combinedVars[key]);
+            return obj;
+        }, {});
+        filteredEnvVars['process.env.EXTENSION_PUBLIC_BROWSER'] = JSON.stringify(this.browser);
+        filteredEnvVars['import.meta.env.EXTENSION_PUBLIC_BROWSER'] = JSON.stringify(this.browser);
+        filteredEnvVars['process.env.EXTENSION_PUBLIC_MODE'] = JSON.stringify(mode);
+        filteredEnvVars['import.meta.env.EXTENSION_PUBLIC_MODE'] = JSON.stringify(mode);
+        filteredEnvVars['process.env.EXTENSION_BROWSER'] = JSON.stringify(this.browser);
+        filteredEnvVars['import.meta.env.EXTENSION_BROWSER'] = JSON.stringify(this.browser);
+        filteredEnvVars['process.env.EXTENSION_MODE'] = JSON.stringify(mode);
+        filteredEnvVars['import.meta.env.EXTENSION_MODE'] = JSON.stringify(mode);
+        filteredEnvVars['process.env.BROWSER'] = JSON.stringify(this.browser);
+        filteredEnvVars['import.meta.env.BROWSER'] = JSON.stringify(this.browser);
+        filteredEnvVars['process.env.MODE'] = JSON.stringify(mode);
+        filteredEnvVars['import.meta.env.MODE'] = JSON.stringify(mode);
+        const importMetaEnvObject = {};
+        for (const [key, value] of Object.entries(filteredEnvVars))if (key.startsWith('import.meta.env.')) importMetaEnvObject[key.slice(16)] = JSON.parse(value);
+        filteredEnvVars['import.meta.env'] = JSON.stringify(importMetaEnvObject);
+        filteredEnvVars['import.meta.dirname'] = 'undefined';
+        filteredEnvVars['import.meta.filename'] = 'undefined';
+        filteredEnvVars.global = 'globalThis';
+        for (const [key, value] of Object.entries(this.define || {}))filteredEnvVars[key] = JSON.stringify(value);
+        const injectedCount = Object.keys(filteredEnvVars).filter((k)=>k.startsWith('process.env.EXTENSION_PUBLIC_')).length;
+        if (isDebug()) debugLine(envInjectedPublicVars(injectedCount));
+        const processShim = resolveProcessShim();
+        if (!processShim) {
+            filteredEnvVars['process.env'] = '{}';
+            filteredEnvVars.process = '({env:{},argv:[],platform:"browser",browser:true,versions:{},nextTick:function(cb){Promise.resolve().then(function(){cb()})}})';
+        }
+        new DefinePlugin(filteredEnvVars).apply(compiler);
+        const importMetaUrl = new DefinePlugin({
+            'import.meta.url': IMPORT_META_URL_RUNTIME
+        });
+        importMetaUrl.affectedHooks = 'thisCompilation';
+        importMetaUrl.apply(compiler);
+        if (processShim) new ProvidePlugin({
+            process: processShim
+        }).apply(compiler);
+        const templateVars = buildTemplateVars(combinedVars, this.browser, mode);
+        compiler.hooks.thisCompilation.tap('manifest:update-manifest', (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: 'env:module',
+                stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+            }, (assets)=>{
+                const files = Object.keys(compilation.assets || assets);
+                files.forEach((filename)=>{
+                    if (filename.endsWith('.json') || filename.endsWith('.html')) {
+                        const isJsonAsset = filename.endsWith('.json');
+                        const original = String(compilation.assets[filename]?.source() ?? '');
+                        const substituted = new Set();
+                        const resolveVar = (name, offset)=>{
+                            if (!Object.prototype.hasOwnProperty.call(templateVars, name)) return `$${name}`;
+                            substituted.add(name);
+                            return isJsonAsset ? substituteForJsonAsset(original, offset, templateVars[name]) : escapeForHtmlAsset(original, offset, templateVars[name]);
+                        };
+                        const placeholder = /\$EXTENSION_[A-Z0-9_]+/g;
+                        const fileContent = original.replace(placeholder, (match, offset)=>resolveVar(match.slice(1), offset));
+                        const parsedBefore = ()=>parsesAsJson(original.replace(placeholder, (match, offset)=>substituted.has(match.slice(1)) ? isInsideJsonString(original, offset) ? '' : 'null' : match));
+                        if (isJsonAsset && substituted.size > 0 && !parsesAsJson(fileContent) && parsedBefore()) {
+                            const error = new WebpackError(envValueBreaksJsonAsset(filename, [
+                                ...substituted
+                            ]));
+                            error.name = 'EnvValueBreaksJsonAsset';
+                            error.file = filename;
+                            compilation.errors.push(error);
+                        }
+                        compilation.updateAsset(filename, new sources.RawSource(fileContent));
+                        if ('manifest.json' === filename) setCurrentManifestContent(compilation, fileContent);
+                    }
+                });
+            });
+        });
+    }
+}
+function buildTemplateVars(combinedVars, browser, mode) {
+    const vars = {};
+    for (const [key, value] of Object.entries(combinedVars))if ('string' == typeof value && key.startsWith('EXTENSION_')) vars[key] = value;
+    const browserValue = String(browser);
+    const modeValue = String(mode);
+    vars.EXTENSION_BROWSER = browserValue;
+    vars.EXTENSION_PUBLIC_BROWSER = browserValue;
+    vars.EXTENSION_MODE = modeValue;
+    vars.EXTENSION_PUBLIC_MODE = modeValue;
+    return vars;
+}
+export { DevSessionRestartScheduler, EnvPlugin, applyIndependentHtmlSurfaces, bindDevSessionRestart, boring, buildCanonicalManifestWithOverrides, cleanDistRemovedSummary, cleanDistSkippedNotFound, cleanDistStarting, collectRootAbsoluteRefs, contentScriptEntryDroppedForBrowser, dropWebkitUnsupportedKeys, edgeStoreKeyDropped, externalAssetOutputPath, fatalManifestShapeFixed, geckoActionUnsupportedOnMv2, geckoSidePanelUnsupported, getCurrentManifestContent, getManifestContent, getOriginalManifestContent, hasMv2SandboxPolicy, hasMv3StringPolicy, iconOutputPath, importMetaUrlForEmitPath, invalidThemeValue, isCompilerRestarting, isFolder, isFromFilepathList, isHollowContentScript, isManifestAddress, isWebkitUnsupportedPermission, legacyManifestPathWarning, manifestDepsTracked, manifestEmitSuccess, manifestFieldMistyped, manifestFilesInTurnedOffPublic, manifestIncludeSummary, manifestInvalidError, manifestLegacyWarningsSummary, manifestOverridesSummary, manifestVersionLostForBrowser, missingGeckoDataCollectionPermissions, mv2ActionFoldedIntoBrowserAction, mv2SandboxPolicyDropped, mv3BackgroundPageUnsupported, mv3BrowserActionFoldedIntoAction, mv3StringPolicyRewritten, normalizeManifestOutputPath, omitWebkitDroppedEntries, pageActionDropReason, pageActionDroppedForBrowserAction, pageActionNotSupportedByBrowser, projectConfigChangedRestartRequired, requestDevSessionRestart, resolveRootAbsoluteRef, safariBookmarksUnsupported, safariDownloadsUnsupported, safariHistoryUnsupported, safariIdentityUnsupported, safariIdleUnsupported, safariManagementUnsupported, safariMemberUnsupported, safariNotificationsUnsupported, safariOffscreenUnsupported, safariOmniboxUnsupported, safariSidePanelUnsupported, safariTabGroupsUnsupported, safariUserScriptsUnsupported, serverRestartRequiredFromManifestError, setCurrentManifestContent, setOriginalManifestContent, shouldFoldActionIntoBrowserAction, shouldFoldBrowserActionIntoAction, sidebarFoldTarget, sidebarKeyTranslatedForBrowser, themeIconOutputPath, themeImageOutputPath, themeNotSupportedByBrowser, toJsStringLiteral, unbindDevSessionRestart, unixify, vendorPrefixedKeyDropped, zipPackagingSkipped };