extension-develop 3.12.0 → 3.13.0

package/dist/preview.cjs

@@ -0,0 +1,1461 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_modules__ = {
+    "./webpack/webpack-lib/messages.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            BX: ()=>isUsingExperimentalConfig,
+            F$: ()=>downloadingProjectPath,
+            GW: ()=>failedToDownloadOrExtractZIPFileError,
+            H3: ()=>managedDependencyConflict,
+            SG: ()=>debugDirs,
+            Ud: ()=>downloadingText,
+            V_: ()=>previewing,
+            W4: ()=>creatingProjectPath,
+            _A: ()=>debugBrowser,
+            ax: ()=>downloadedProjectFolderNotFound,
+            dx: ()=>manifestNotFoundError,
+            f7: ()=>configLoadingError,
+            gC: ()=>unpackagingExtension,
+            jV: ()=>debugPreviewOutput,
+            k4: ()=>previewSkippedNoBrowser,
+            tQ: ()=>fetchingProjectPath,
+            tc: ()=>invalidRemoteZip,
+            zM: ()=>unpackagedSuccessfully
+        });
+        __webpack_require__("fs");
+        var path__rspack_import_1 = __webpack_require__("path");
+        var pintor__rspack_import_2 = __webpack_require__("pintor");
+        var pintor__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_2);
+        __webpack_require__("./package.json");
+        const fmt = {
+            heading: (title)=>pintor__rspack_import_2_default().underline(pintor__rspack_import_2_default().blue(title)),
+            label: (key)=>pintor__rspack_import_2_default().gray(key.toUpperCase()),
+            val: (value)=>pintor__rspack_import_2_default().underline(value),
+            code: (value)=>pintor__rspack_import_2_default().blue(value),
+            bullet: (value)=>`- ${value}`,
+            block (title, rows) {
+                const head = fmt.heading(title);
+                const body = rows.map(([key, value])=>`${fmt.label(key)} ${value}`).join('\n');
+                return `${head}\n${body}`;
+            },
+            truncate (input, max = 800) {
+                const s = (()=>{
+                    try {
+                        return 'string' == typeof input ? input : JSON.stringify(input);
+                    } catch  {
+                        return String(input);
+                    }
+                })();
+                return s.length > max ? s.slice(0, max) + '…' : s;
+            }
+        };
+        function getLoggingPrefix(type) {
+            const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+            if (isAuthor) {
+                const base = 'error' === type ? 'ERROR Author says' : '⏵⏵⏵ Author says';
+                return pintor__rspack_import_2_default().brightMagenta(base);
+            }
+            if ('error' === type) return pintor__rspack_import_2_default().red('ERROR');
+            if ('warn' === type) return pintor__rspack_import_2_default().brightYellow('⏵⏵⏵');
+            if ('info' === type) return pintor__rspack_import_2_default().gray('⏵⏵⏵');
+            return pintor__rspack_import_2_default().green('⏵⏵⏵');
+        }
+        function isPathLike(input) {
+            return input.includes('/') || input.includes('\\') || path__rspack_import_1.isAbsolute(input);
+        }
+        function manifestNotFoundError(manifestPath) {
+            return `${getLoggingPrefix('error')} Manifest file not found.\n${pintor__rspack_import_2_default().red('Ensure the path to your extension exists and try again.')}\n${pintor__rspack_import_2_default().red('NOT FOUND')}\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(manifestPath)}`;
+        }
+        function previewing(browser) {
+            return `${getLoggingPrefix('info')} Previewing the extension on ${capitalizedBrowserName(browser)}...`;
+        }
+        function previewSkippedNoBrowser(browser) {
+            return `${getLoggingPrefix('info')} Skipping browser launch for ${capitalizedBrowserName(browser)} (no-browser).`;
+        }
+        function fetchingProjectPath(owner, project) {
+            return fmt.block('Fetching project', [
+                [
+                    'URL',
+                    fmt.val(`https://github.com/${owner}/${project}`)
+                ]
+            ]);
+        }
+        function downloadingProjectPath(projectName) {
+            const formatted = isPathLike(projectName) ? pintor__rspack_import_2_default().underline(projectName) : pintor__rspack_import_2_default().yellow(projectName);
+            return `${getLoggingPrefix('info')} Downloading ${formatted}...`;
+        }
+        function creatingProjectPath(projectPath) {
+            return `${getLoggingPrefix('info')} Creating a new browser extension...\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(projectPath)}`;
+        }
+        function downloadedProjectFolderNotFound(cwd, candidates) {
+            return `${getLoggingPrefix('error')} Downloaded project folder not found.\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(cwd)}\n${pintor__rspack_import_2_default().gray('Tried')} ${pintor__rspack_import_2_default().underline(candidates.join(', '))}`;
+        }
+        function downloadingText(url) {
+            return fmt.block('Downloading extension', [
+                [
+                    'URL',
+                    fmt.val(url)
+                ]
+            ]);
+        }
+        function unpackagingExtension(zipFilePath) {
+            return `${getLoggingPrefix('info')} Unpackaging browser extension...\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(zipFilePath)}`;
+        }
+        function unpackagedSuccessfully() {
+            return `${getLoggingPrefix('info')} Browser extension unpackaged ${pintor__rspack_import_2_default().green('successfully')}.`;
+        }
+        function failedToDownloadOrExtractZIPFileError(error) {
+            return `${getLoggingPrefix('error')} Failed to download or extract ZIP file.\n${pintor__rspack_import_2_default().red(error)}`;
+        }
+        function invalidRemoteZip(url, contentType) {
+            return `${getLoggingPrefix('error')} Remote URL does not appear to be a ZIP archive.\n${pintor__rspack_import_2_default().gray('URL')} ${pintor__rspack_import_2_default().underline(url)}\n${pintor__rspack_import_2_default().gray('Content-Type')} ${pintor__rspack_import_2_default().underline(contentType || 'unknown')}`;
+        }
+        function capitalizedBrowserName(browser) {
+            const b = String(browser || '');
+            const cap = b.charAt(0).toUpperCase() + b.slice(1);
+            return pintor__rspack_import_2_default().yellow(`${cap}`);
+        }
+        function isUsingExperimentalConfig(integration) {
+            return `${getLoggingPrefix('info')} Using ${pintor__rspack_import_2_default().yellow(integration)}.`;
+        }
+        function debugDirs(manifestDir, packageJsonDir) {
+            return `${getLoggingPrefix('info')} Directories\n${pintor__rspack_import_2_default().gray('MANIFEST_DIR')} ${pintor__rspack_import_2_default().underline(manifestDir)}\n${pintor__rspack_import_2_default().gray('PACKAGE_JSON_DIR')} ${pintor__rspack_import_2_default().underline(packageJsonDir)}`;
+        }
+        function debugBrowser(browser, chromiumBinary, geckoBinary) {
+            return `${getLoggingPrefix('info')} Browser Target\n${pintor__rspack_import_2_default().gray('BROWSER')} ${pintor__rspack_import_2_default().yellow(String(browser))}\n${pintor__rspack_import_2_default().gray('CHROMIUM_BINARY')} ${pintor__rspack_import_2_default().underline(String(chromiumBinary || 'auto'))}\n${pintor__rspack_import_2_default().gray('GECKO_BINARY')} ${pintor__rspack_import_2_default().underline(String(geckoBinary || 'auto'))}`;
+        }
+        function debugPreviewOutput(outputPath, distPath) {
+            return `${getLoggingPrefix('info')} Preview Output\n${pintor__rspack_import_2_default().gray('OUTPUT')} ${pintor__rspack_import_2_default().underline(outputPath)}\n${pintor__rspack_import_2_default().gray('DIST')} ${pintor__rspack_import_2_default().underline(distPath)}`;
+        }
+        function configLoadingError(configPath, error) {
+            return `${pintor__rspack_import_2_default().red('ERROR')} ${pintor__rspack_import_2_default().brightBlue('config load failed')}\n${fmt.label('PATH')} ${fmt.val(configPath)}\n` + pintor__rspack_import_2_default().red(fmt.truncate(error, 1200));
+        }
+        function managedDependencyConflict(duplicates, userPackageJsonPath) {
+            const list = duplicates.map((d)=>`- ${pintor__rspack_import_2_default().yellow(d)}`).join('\n');
+            return `${getLoggingPrefix('error')} Your project declares dependencies that are managed by ${pintor__rspack_import_2_default().blue('Extension.js')} and referenced in ${pintor__rspack_import_2_default().underline('extension.config.js')}\n${pintor__rspack_import_2_default().red('This can cause version conflicts and break the development/build process.')}\n\n${pintor__rspack_import_2_default().gray('Managed dependencies (remove these from your package.json):')}\n${list}\n\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(userPackageJsonPath)}\nIf you need a different version, open an issue so we can consider bundling it safely.\nOperation aborted.`;
+        }
+    },
+    "adm-zip" (module) {
+        module.exports = require("adm-zip");
+    },
+    fs (module) {
+        module.exports = require("fs");
+    },
+    path (module) {
+        module.exports = require("path");
+    },
+    pintor (module) {
+        module.exports = require("pintor");
+    },
+    "./package.json" (module) {
+        module.exports = JSON.parse('{"rE":"3.13.0","El":{"@prefresh/core":"1.5.9","@prefresh/utils":"1.2.1","@rspack/core":"^1.7.5","@rspack/dev-server":"^1.2.1","@rspack/plugin-preact-refresh":"1.1.4","@rspack/plugin-react-refresh":"1.6.0","@swc/core":"^1.15.8","@swc/helpers":"^0.5.18","@vue/compiler-sfc":"3.5.26","adm-zip":"^0.5.16","browser-extension-manifest-fields":"^2.2.1","case-sensitive-paths-webpack-plugin":"^2.4.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","extension-from-store":"^0.1.1","go-git-it":"^5.1.5","ignore":"^7.0.5","less":"4.5.1","less-loader":"12.3.0","loader-utils":"^3.3.1","magic-string":"^0.30.21","parse5":"^8.0.0","parse5-utilities":"^1.0.0","pintor":"0.3.0","postcss":"8.5.6","postcss-loader":"8.2.0","postcss-preset-env":"11.1.1","postcss-scss":"4.0.9","preact":"10.27.3","react-refresh":"0.18.0","sass-loader":"16.0.6","schema-utils":"^4.3.3","svelte-loader":"3.2.4","tiny-glob":"^0.2.9","typescript":"5.9.3","unique-names-generator":"^4.7.1","vue":"3.5.26","vue-loader":"17.4.2","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3"}}');
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.f = {};
+    __webpack_require__.e = (chunkId)=>Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key)=>{
+            __webpack_require__.f[key](chunkId, promises);
+            return promises;
+        }, []));
+})();
+(()=>{
+    __webpack_require__.u = (chunkId)=>"" + chunkId + ".cjs";
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+(()=>{
+    var installedChunks = {
+        534: 1
+    };
+    var installChunk = (chunk)=>{
+        var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;
+        for(var moduleId in moreModules)if (__webpack_require__.o(moreModules, moduleId)) __webpack_require__.m[moduleId] = moreModules[moduleId];
+        if (runtime) runtime(__webpack_require__);
+        for(var i = 0; i < chunkIds.length; i++)installedChunks[chunkIds[i]] = 1;
+    };
+    __webpack_require__.f.require = (chunkId, promises)=>{
+        if (!installedChunks[chunkId]) installChunk(require("./" + __webpack_require__.u(chunkId)));
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        extensionPreview: ()=>extensionPreview
+    });
+    var external_path_ = __webpack_require__("path");
+    var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_);
+    var external_fs_ = __webpack_require__("fs");
+    var webpack_lib_messages = __webpack_require__("./webpack/webpack-lib/messages.ts");
+    async function findUpLocal(filename, options) {
+        const root = external_path_.parse(options.cwd).root;
+        let currentDir = options.cwd;
+        while(true){
+            const candidate = external_path_.join(currentDir, filename);
+            try {
+                const stat = await external_fs_.promises.stat(candidate);
+                if (stat.isFile()) return candidate;
+            } catch  {}
+            if (currentDir === root) return;
+            currentDir = external_path_.dirname(currentDir);
+        }
+    }
+    async function findNearestPackageJson(manifestPath) {
+        try {
+            const manifestDir = external_path_.dirname(manifestPath);
+            const packageJsonPath = await findUpLocal('package.json', {
+                cwd: manifestDir
+            });
+            return packageJsonPath || null;
+        } catch (error) {
+            console.warn('Failed to find package.json:', error);
+            return null;
+        }
+    }
+    function validatePackageJson(packageJsonPath) {
+        try {
+            if (!external_fs_.existsSync(packageJsonPath)) return false;
+            const content = external_fs_.readFileSync(packageJsonPath, 'utf-8');
+            JSON.parse(content);
+            return true;
+        } catch (error) {
+            console.warn('Invalid package.json at:', packageJsonPath, error);
+            return false;
+        }
+    }
+    const isUrl = (url)=>{
+        try {
+            new URL(url);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    };
+    async function importUrlSourceFromGithub(pathOrRemoteUrl, text) {
+        const cwd = process.cwd();
+        const url = new URL(pathOrRemoteUrl);
+        const segments = url.pathname.split('/').filter(Boolean);
+        const repoName = segments.length >= 2 ? segments[1] : segments[segments.length - 1];
+        const treeIndex = segments.indexOf('tree');
+        const expectedName = -1 !== treeIndex && segments.length > treeIndex + 2 ? segments[segments.length - 1] : repoName;
+        const expectedPath = external_path_.resolve(cwd, expectedName);
+        if (external_fs_.existsSync(expectedPath)) try {
+            const entries = external_fs_.readdirSync(expectedPath);
+            if (0 === entries.length) external_fs_.rmSync(expectedPath, {
+                recursive: true,
+                force: true
+            });
+            else {
+                const hasManifest = (dir)=>{
+                    const stack = [
+                        dir
+                    ];
+                    while(stack.length){
+                        const current = stack.pop();
+                        const items = external_fs_.readdirSync(current, {
+                            withFileTypes: true
+                        });
+                        for (const it of items){
+                            if (it.isFile() && 'manifest.json' === it.name) return true;
+                            if (it.isDirectory() && 'node_modules' !== it.name && 'dist' !== it.name && !it.name.startsWith('.')) stack.push(external_path_.join(current, it.name));
+                        }
+                    }
+                    return false;
+                };
+                if (hasManifest(expectedPath)) return expectedPath;
+                external_fs_.rmSync(expectedPath, {
+                    recursive: true,
+                    force: true
+                });
+            }
+        } catch  {}
+        async function tryGitClone() {
+            const { default: goGitIt } = await import("go-git-it");
+            await goGitIt(pathOrRemoteUrl, cwd, text);
+        }
+        async function tryZipFallback() {
+            const branch = -1 !== treeIndex && segments.length > treeIndex + 1 ? segments[treeIndex + 1] : 'main';
+            const owner = segments[0];
+            const repo = segments[1];
+            const subdir = -1 !== treeIndex && segments.length > treeIndex + 2 ? segments.slice(treeIndex + 2).join('/') : '';
+            const zipUrl = `https://codeload.github.com/${owner}/${repo}/zip/refs/heads/${branch}`;
+            const extractedPath = await importUrlSourceFromZip(zipUrl);
+            const extractedDirs = external_fs_.readdirSync(extractedPath, {
+                withFileTypes: true
+            }).filter((d)=>d.isDirectory()).map((d)=>d.name);
+            const repoRootDir = extractedDirs.find((d)=>d.startsWith(`${repo}-${branch}`));
+            const repoRoot = repoRootDir ? external_path_.join(extractedPath, repoRootDir) : extractedPath;
+            return subdir ? external_path_.join(repoRoot, subdir) : repoRoot;
+        }
+        try {
+            await tryGitClone();
+        } catch  {
+            return await tryZipFallback();
+        }
+        const candidates = [];
+        if (-1 !== treeIndex && segments.length > treeIndex + 2) candidates.push(segments[segments.length - 1]);
+        candidates.push(repoName);
+        for (const name of candidates){
+            const p = external_path_.resolve(cwd, name);
+            if (external_fs_.existsSync(p)) return p;
+        }
+        const dirs = external_fs_.readdirSync(cwd, {
+            withFileTypes: true
+        }).filter((d)=>d.isDirectory()).map((d)=>d.name);
+        for (const dir of dirs){
+            const manifestPath = external_path_.join(cwd, dir, 'manifest.json');
+            if (external_fs_.existsSync(manifestPath)) return external_path_.join(cwd, dir);
+        }
+        try {
+            const dirs = external_fs_.readdirSync(cwd, {
+                withFileTypes: true
+            }).filter((d)=>d.isDirectory()).map((d)=>d.name);
+            const ghRoot = dirs.find((d)=>/-main$|-master$/.test(d));
+            if (ghRoot) return external_path_.join(cwd, ghRoot);
+        } catch  {}
+        throw new Error(webpack_lib_messages.ax(cwd, candidates));
+    }
+    async function importUrlSourceFromZip(pathOrRemoteUrl) {
+        const cwd = process.cwd();
+        const { downloadAndExtractZip } = await __webpack_require__.e("419").then(__webpack_require__.bind(__webpack_require__, "./webpack/webpack-lib/zip.ts"));
+        const extractedPath = await downloadAndExtractZip(pathOrRemoteUrl, cwd);
+        return extractedPath;
+    }
+    async function getProjectPath(pathOrRemoteUrl) {
+        if (!pathOrRemoteUrl) return process.cwd();
+        if (isUrl(pathOrRemoteUrl)) {
+            const url = new URL(pathOrRemoteUrl);
+            if (url.protocol.startsWith('http')) {
+                const pathname = url.pathname.toLowerCase();
+                if (pathname.endsWith('.zip')) return await importUrlSourceFromZip(pathOrRemoteUrl);
+                if ('https://github.com' !== url.origin) {
+                    const urlSource = await importUrlSourceFromZip(pathOrRemoteUrl);
+                    return urlSource;
+                }
+                const urlData = url.pathname.split('/');
+                const owner = urlData.slice(1, 3)[0];
+                const project = urlData.slice(1, 3)[1];
+                console.log(webpack_lib_messages.tQ(owner, project));
+                const projectName = external_path_.basename(url.pathname);
+                const urlSource = await importUrlSourceFromGithub(pathOrRemoteUrl, webpack_lib_messages.F$(projectName));
+                console.log(webpack_lib_messages.W4(url.pathname));
+                return urlSource;
+            }
+        }
+        return external_path_.resolve(process.cwd(), pathOrRemoteUrl);
+    }
+    async function getProjectStructure(pathOrRemoteUrl) {
+        const projectPath = await getProjectPath(pathOrRemoteUrl);
+        const isUnderDir = (baseDir, candidatePath)=>{
+            const rel = external_path_.relative(baseDir, candidatePath);
+            return Boolean(rel && !rel.startsWith('..') && !external_path_.isAbsolute(rel));
+        };
+        const packageJsonPathFromProject = await findNearestPackageJson(external_path_.join(projectPath, 'manifest.json'));
+        const packageJsonDirFromProject = packageJsonPathFromProject ? external_path_.dirname(packageJsonPathFromProject) : void 0;
+        const rootManifestPath = external_path_.join(projectPath, 'manifest.json');
+        const srcManifestPath = external_path_.join(projectPath, 'src', 'manifest.json');
+        let manifestPath = external_fs_.existsSync(srcManifestPath) ? srcManifestPath : rootManifestPath;
+        if (!external_fs_.existsSync(manifestPath)) {
+            if (packageJsonDirFromProject) throw new Error(webpack_lib_messages.dx(manifestPath));
+            const findManifest = (dir)=>{
+                const files = external_fs_.readdirSync(dir, {
+                    withFileTypes: true
+                });
+                for (const file of files){
+                    if (file.isFile() && 'manifest.json' === file.name) return external_path_.join(dir, file.name);
+                    if (file.isDirectory() && !file.name.startsWith('.') && 'node_modules' !== file.name && 'dist' !== file.name && 'public' !== file.name) {
+                        const found = findManifest(external_path_.join(dir, file.name));
+                        if (found) return found;
+                    }
+                }
+                return null;
+            };
+            const foundManifest = findManifest(projectPath);
+            if (foundManifest) manifestPath = foundManifest;
+            else throw new Error(webpack_lib_messages.dx(manifestPath));
+        }
+        const packageJsonPath = await findNearestPackageJson(manifestPath);
+        const packageJsonDir = packageJsonPath ? external_path_.dirname(packageJsonPath) : void 0;
+        if (packageJsonDir) {
+            const publicRoot = external_path_.join(packageJsonDir, 'public');
+            if (isUnderDir(publicRoot, manifestPath)) {
+                const fallbackSrc = external_path_.join(packageJsonDir, 'src', 'manifest.json');
+                const fallbackRoot = external_path_.join(packageJsonDir, 'manifest.json');
+                if (external_fs_.existsSync(fallbackSrc)) manifestPath = fallbackSrc;
+                else if (external_fs_.existsSync(fallbackRoot)) manifestPath = fallbackRoot;
+                else throw new Error(webpack_lib_messages.dx(fallbackRoot));
+            }
+        }
+        if (!packageJsonPath || !validatePackageJson(packageJsonPath)) return {
+            manifestPath
+        };
+        return {
+            manifestPath,
+            packageJsonPath
+        };
+    }
+    const external_os_namespaceObject = require("os");
+    const external_vm_namespaceObject = require("vm");
+    const external_url_namespaceObject = require("url");
+    const external_module_namespaceObject = require("module");
+    const external_dotenv_namespaceObject = require("dotenv");
+    var external_dotenv_default = /*#__PURE__*/ __webpack_require__.n(external_dotenv_namespaceObject);
+    function loadCommonJsConfigWithStableDirname(absolutePath) {
+        const code = external_fs_.readFileSync(absolutePath, 'utf-8');
+        const dirname = external_path_.dirname(absolutePath);
+        const requireFn = (0, external_module_namespaceObject.createRequire)(absolutePath);
+        const module = {
+            exports: {}
+        };
+        const exports1 = module.exports;
+        const wrapped = `(function (exports, require, module, __filename, __dirname) {\n${code}\n})`;
+        const fn = new external_vm_namespaceObject.Script(wrapped, {
+            filename: absolutePath
+        }).runInThisContext();
+        fn(exports1, requireFn, module, absolutePath, dirname);
+        return module.exports?.default || module.exports;
+    }
+    function findNearestWorkspaceRoot(startDir) {
+        let current = external_path_.resolve(startDir);
+        while(true){
+            if (external_fs_.existsSync(external_path_.join(current, 'pnpm-workspace.yaml'))) return current;
+            const parent = external_path_.dirname(current);
+            if (parent === current) return;
+            current = parent;
+        }
+    }
+    function preloadEnvFilesFromDir(envDir, options) {
+        let loadedAny = false;
+        try {
+            const defaultsPath = external_path_.join(envDir, '.env.defaults');
+            if (external_fs_.existsSync(defaultsPath)) {
+                external_dotenv_default().config({
+                    path: defaultsPath,
+                    override: Boolean(options?.override),
+                    quiet: true
+                });
+                loadedAny = true;
+            }
+            const envCandidates = [
+                '.env.development',
+                '.env.local',
+                '.env'
+            ];
+            for (const filename of envCandidates){
+                const filePath = external_path_.join(envDir, filename);
+                if (external_fs_.existsSync(filePath)) {
+                    external_dotenv_default().config({
+                        path: filePath,
+                        override: Boolean(options?.override),
+                        quiet: true
+                    });
+                    loadedAny = true;
+                    break;
+                }
+            }
+        } catch  {}
+        return {
+            loadedAny,
+            envDir
+        };
+    }
+    function preloadEnvFiles(projectDir) {
+        const local = preloadEnvFilesFromDir(projectDir);
+        if (local.loadedAny) return local;
+        const workspaceRoot = findNearestWorkspaceRoot(projectDir);
+        if (workspaceRoot && workspaceRoot !== projectDir) return preloadEnvFilesFromDir(workspaceRoot);
+        return local;
+    }
+    async function loadConfigFile(configPath) {
+        const absolutePath = external_path_.resolve(configPath);
+        const projectDir = external_path_.dirname(absolutePath);
+        preloadEnvFiles(projectDir);
+        try {
+            if (absolutePath.endsWith('.cjs')) {
+                const requireFn = (0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+                const required = requireFn(absolutePath);
+                return required?.default || required;
+            }
+            let esmImportPath = absolutePath;
+            try {
+                const originalContent = external_fs_.readFileSync(absolutePath, 'utf-8');
+                if (originalContent.includes('import.meta.env')) {
+                    const tmpDir = external_fs_.mkdtempSync(external_path_.join(external_os_namespaceObject.tmpdir(), 'extension-config-esm-'));
+                    const tmpPath = external_path_.join(tmpDir, external_path_.basename(absolutePath));
+                    const envObjectLiteral = JSON.stringify(Object.fromEntries(Object.entries(process.env).map(([k, v])=>[
+                            k,
+                            v
+                        ])), null, 0);
+                    const shimHeader = `const __IMPORT_META_ENV__ = Object.freeze(${envObjectLiteral});\n`;
+                    const replaced = originalContent.replace(/import\.meta\.env/g, '__IMPORT_META_ENV__');
+                    external_fs_.writeFileSync(tmpPath, `${shimHeader}${replaced}`, 'utf-8');
+                    esmImportPath = tmpPath;
+                }
+            } catch  {}
+            const module = await import((0, external_url_namespaceObject.pathToFileURL)(esmImportPath).href);
+            return module.default || module;
+        } catch (err) {
+            const error = err;
+            try {
+                if (!absolutePath.endsWith('.mjs')) {
+                    const requireFn = (0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+                    let required;
+                    try {
+                        required = requireFn(absolutePath);
+                    } catch (requireErr) {
+                        const message = String(error?.message || '') + ' ' + String(requireErr?.message || '');
+                        const looksLikeCommonJsInEsm = message.includes('require is not defined in ES module scope') || message.includes('Cannot use import statement outside a module') || message.includes('ERR_REQUIRE_ESM');
+                        if (looksLikeCommonJsInEsm) try {
+                            required = loadCommonJsConfigWithStableDirname(absolutePath);
+                        } catch  {
+                            const tmpDir = external_fs_.mkdtempSync(external_path_.join(external_os_namespaceObject.tmpdir(), 'extension-config-'));
+                            const tmpCjsPath = external_path_.join(tmpDir, external_path_.basename(absolutePath, external_path_.extname(absolutePath)) + '.cjs');
+                            external_fs_.copyFileSync(absolutePath, tmpCjsPath);
+                            required = requireFn(tmpCjsPath);
+                        }
+                        else throw requireErr;
+                    }
+                    return required?.default || required;
+                }
+            } catch  {}
+            try {
+                const content = external_fs_.readFileSync(absolutePath, 'utf-8');
+                return JSON.parse(content);
+            } catch (jsonErr) {
+                throw new Error(`Failed to load config file: ${configPath}\nError: ${error.message || error}`);
+            }
+        }
+    }
+    async function loadCommandConfig(projectPath, command) {
+        const userConfigPath = external_path_.join(projectPath, 'extension.config.js');
+        const moduleUserConfigPath = external_path_.join(projectPath, 'extension.config.mjs');
+        const commonJsUserConfigPath = external_path_.join(projectPath, 'extension.config.cjs');
+        const candidates = [
+            userConfigPath,
+            moduleUserConfigPath,
+            commonJsUserConfigPath
+        ];
+        const configPath = candidates.find((p)=>external_fs_.existsSync(p));
+        if (configPath) {
+            if (await isUsingExperimentalConfig(projectPath)) try {
+                const userConfig = await loadConfigFile(configPath);
+                const baseExtensions = userConfig && userConfig.extensions ? {
+                    extensions: userConfig.extensions
+                } : {};
+                const baseTranspilePackages = userConfig && Array.isArray(userConfig.transpilePackages) ? {
+                    transpilePackages: userConfig.transpilePackages
+                } : {};
+                const perCommand = userConfig && userConfig.commands && userConfig.commands[command] ? userConfig.commands[command] : {};
+                return {
+                    ...baseExtensions,
+                    ...baseTranspilePackages,
+                    ...perCommand
+                };
+            } catch (err) {
+                const error = err;
+                console.error(webpack_lib_messages.f7(configPath, error));
+                throw err;
+            }
+        }
+        return {};
+    }
+    async function loadBrowserConfig(projectPath, browser = 'chrome') {
+        const userConfigPath = external_path_.join(projectPath, 'extension.config.js');
+        const moduleUserConfigPath = external_path_.join(projectPath, 'extension.config.mjs');
+        const commonJsUserConfigPath = external_path_.join(projectPath, 'extension.config.cjs');
+        const candidates = [
+            userConfigPath,
+            moduleUserConfigPath,
+            commonJsUserConfigPath
+        ];
+        const configPath = candidates.find((p)=>external_fs_.existsSync(p));
+        if (configPath) {
+            if (await isUsingExperimentalConfig(projectPath)) try {
+                const userConfig = await loadConfigFile(configPath);
+                if (userConfig && userConfig.browser) {
+                    const browsers = userConfig.browser;
+                    if ('chromium-based' === browser) {
+                        if (browsers['chromium-based']) return browsers['chromium-based'];
+                        if (browsers.chromium) return browsers.chromium;
+                    } else if ('gecko-based' === browser) {
+                        if (browsers['gecko-based']) return browsers['gecko-based'];
+                        if (browsers.firefox) return browsers.firefox;
+                    } else {
+                        const direct = browsers[browser];
+                        if (direct) return direct;
+                    }
+                }
+            } catch (err) {
+                const error = err;
+                console.error(webpack_lib_messages.f7(configPath, error));
+                throw err;
+            }
+        }
+        return {
+            browser: browser || 'chrome'
+        };
+    }
+    let userMessageDelivered = false;
+    async function isUsingExperimentalConfig(projectPath) {
+        const userConfigPath = external_path_.join(projectPath, 'extension.config.js');
+        const moduleUserConfigPath = external_path_.join(projectPath, 'extension.config.mjs');
+        const commonJsUserConfigPath = external_path_.join(projectPath, 'extension.config.cjs');
+        const candidates = [
+            userConfigPath,
+            moduleUserConfigPath,
+            commonJsUserConfigPath
+        ];
+        const configPath = candidates.find((p)=>external_fs_.existsSync(p));
+        if (configPath) {
+            if (!userMessageDelivered) {
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(webpack_lib_messages.BX('extension.config.js'));
+                userMessageDelivered = true;
+            }
+            return true;
+        }
+        return false;
+    }
+    var package_0 = __webpack_require__("./package.json");
+    function assertNoManagedDependencyConflicts(userPackageJsonPath, projectPath) {
+        try {
+            const raw = external_fs_.readFileSync(userPackageJsonPath, 'utf-8');
+            const userPackageJson = JSON.parse(raw);
+            const userDeps = Array.from(new Set([
+                ...Object.keys(userPackageJson.dependencies || {}),
+                ...Object.keys(userPackageJson.devDependencies || {}),
+                ...Object.keys(userPackageJson.optionalDependencies || {}),
+                ...Object.keys(userPackageJson.peerDependencies || {})
+            ]));
+            const managedDeps = new Set([
+                ...Object.keys(package_0.El || {}),
+                ...Object.keys(package_0.optionalDependencies || {})
+            ]);
+            managedDeps.delete('webpack');
+            const userConfigJs = external_path_.join(projectPath, 'extension.config.js');
+            const userConfigMjs = external_path_.join(projectPath, 'extension.config.mjs');
+            const hasConfig = external_fs_.existsSync(userConfigJs) || external_fs_.existsSync(userConfigMjs);
+            if (!hasConfig) return;
+            const configPath = external_fs_.existsSync(userConfigJs) ? userConfigJs : userConfigMjs;
+            const configSource = external_fs_.readFileSync(configPath, 'utf-8');
+            const duplicates = userDeps.filter((d)=>managedDeps.has(d)).filter((d)=>configSource.includes(d)).sort();
+            if (duplicates.length > 0) {
+                console.error(webpack_lib_messages.H3(duplicates, userPackageJsonPath));
+                process.exit(1);
+            }
+        } catch (error) {
+            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(error);
+        }
+    }
+    require("crypto");
+    (0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+    if (!process.env.EXTENSION_JS_OPTIONAL_DEPS_VERSION) process.env.EXTENSION_JS_OPTIONAL_DEPS_VERSION = package_0.rE;
+    function asAbsolute(p) {
+        return external_path_.isAbsolute(p) ? p : external_path_.resolve(p);
+    }
+    function getDirs(struct) {
+        const manifestDir = asAbsolute(external_path_.dirname(struct.manifestPath));
+        const packageJsonDir = asAbsolute(struct.packageJsonPath ? external_path_.dirname(struct.packageJsonPath) : manifestDir);
+        return {
+            manifestDir,
+            packageJsonDir
+        };
+    }
+    function normalizeBrowser(browser, chromiumBinary, geckoBinary) {
+        const requested = String(browser || '');
+        if (chromiumBinary) {
+            if (!requested || 'chromium-based' === requested) return 'chromium-based';
+            if ('chromium' === requested) return 'chromium';
+            if ('edge' === requested) return 'edge';
+            if ('chrome' === requested) return 'chrome';
+        }
+        if (geckoBinary) {
+            if (!requested || 'gecko-based' === requested || 'firefox-based' === requested) return 'gecko-based';
+            if ('firefox' === requested) return 'firefox';
+        }
+        switch(requested){
+            case 'chrome':
+                return 'chrome';
+            case 'edge':
+                return 'edge';
+            case 'chromium':
+                return 'chromium';
+            case 'chromium-based':
+                return 'chromium-based';
+            case 'firefox':
+                return 'firefox';
+            case 'gecko-based':
+            case 'firefox-based':
+                return 'gecko-based';
+            default:
+                return browser || 'chrome';
+        }
+    }
+    function getDistPath(packageJsonDir, browser) {
+        return asAbsolute(external_path_.join(packageJsonDir, 'dist', browser));
+    }
+    function computePreviewOutputPath(struct, browser, explicitOutputPath) {
+        const { manifestDir, packageJsonDir } = getDirs(struct);
+        if (explicitOutputPath) return asAbsolute(explicitOutputPath);
+        if (struct.packageJsonPath) {
+            const distDir = getDistPath(packageJsonDir, browser);
+            try {
+                if (external_fs_.existsSync(external_path_.join(distDir, 'manifest.json'))) return distDir;
+            } catch  {}
+        }
+        return manifestDir;
+    }
+    function devtoolsEngineFor(browser) {
+        switch(browser){
+            case 'chrome':
+                return 'chrome';
+            case 'edge':
+                return 'edge';
+            case 'chromium':
+            case 'chromium-based':
+                return 'chromium';
+            case 'firefox':
+            case 'gecko-based':
+                return 'firefox';
+            default:
+                return 'chrome';
+        }
+    }
+    function _define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    function nowISO() {
+        return new Date().toISOString();
+    }
+    function createRunId() {
+        return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+    }
+    function plugin_playwright_ensureDirSync(dirPath) {
+        try {
+            external_fs_.mkdirSync(dirPath, {
+                recursive: true
+            });
+        } catch  {}
+    }
+    function writeJsonAtomic(filePath, value) {
+        try {
+            const tmpPath = `${filePath}.tmp-${process.pid}`;
+            external_fs_.writeFileSync(tmpPath, JSON.stringify(value, null, 2) + '\n', 'utf-8');
+            external_fs_.renameSync(tmpPath, filePath);
+        } catch  {}
+    }
+    function getPlaywrightMetadataDir(packageJsonDir, browser) {
+        return asAbsolute(external_path_.join(packageJsonDir, 'dist', 'extension-js', browser));
+    }
+    function createPlaywrightMetadataWriter(options) {
+        const metadataDir = getPlaywrightMetadataDir(options.packageJsonDir, options.browser);
+        const readyPath = asAbsolute(external_path_.join(metadataDir, 'ready.json'));
+        const eventsPath = asAbsolute(external_path_.join(metadataDir, 'events.ndjson'));
+        const base = {
+            command: options.command,
+            browser: options.browser,
+            runId: createRunId(),
+            startedAt: nowISO(),
+            distPath: options.distPath,
+            manifestPath: options.manifestPath,
+            port: (()=>{
+                if ('number' == typeof options.port && Number.isFinite(options.port)) return options.port;
+                if ('string' == typeof options.port) {
+                    const parsed = parseInt(options.port, 10);
+                    return Number.isFinite(parsed) ? parsed : null;
+                }
+                return null;
+            })()
+        };
+        function writeReady(status, extra) {
+            plugin_playwright_ensureDirSync(metadataDir);
+            const payload = {
+                ...base,
+                status,
+                pid: process.pid,
+                ts: nowISO(),
+                compiledAt: extra?.compiledAt ?? null,
+                errors: Array.isArray(extra?.errors) ? extra.errors : []
+            };
+            if (extra?.code) payload.code = extra.code;
+            if (extra?.message) payload.message = extra.message;
+            writeJsonAtomic(readyPath, payload);
+        }
+        function appendEvent(event) {
+            plugin_playwright_ensureDirSync(metadataDir);
+            try {
+                external_fs_.appendFileSync(eventsPath, `${JSON.stringify(event)}\n`, 'utf-8');
+            } catch  {}
+        }
+        return {
+            metadataDir,
+            readyPath,
+            eventsPath,
+            writeStarting () {
+                writeReady('starting');
+            },
+            writeReady (compiledAt) {
+                writeReady('ready', {
+                    compiledAt: compiledAt || nowISO()
+                });
+            },
+            writeError (code, message, errors) {
+                writeReady('error', {
+                    code,
+                    message,
+                    errors: Array.isArray(errors) ? errors : [],
+                    compiledAt: null
+                });
+            },
+            appendEvent
+        };
+    }
+    class PlaywrightPlugin {
+        apply(compiler) {
+            this.writer.writeStarting();
+            compiler.hooks.compile.tap(PlaywrightPlugin.name, ()=>{
+                this.writer.appendEvent({
+                    type: 'compile_start',
+                    ts: nowISO(),
+                    command: this.command,
+                    browser: this.browser
+                });
+            });
+            compiler.hooks.done.tap(PlaywrightPlugin.name, (stats)=>{
+                const durationMs = Number((stats?.compilation?.endTime || 0) - (stats?.compilation?.startTime || 0));
+                const hasErrors = Boolean(stats?.hasErrors?.());
+                const errorsCount = Number(Array.isArray(stats?.toJson?.({
+                    all: false,
+                    errors: true
+                })?.errors) ? stats.toJson({
+                    all: false,
+                    errors: true
+                }).errors.length : 0);
+                if (hasErrors) {
+                    this.writer.appendEvent({
+                        type: 'compile_error',
+                        ts: nowISO(),
+                        command: this.command,
+                        browser: this.browser,
+                        durationMs: Number.isFinite(durationMs) ? durationMs : void 0,
+                        errorCount: Number.isFinite(errorsCount) ? errorsCount : 1
+                    });
+                    this.writer.writeError('compile_error', 'Compilation failed', [
+                        `errors: ${String(errorsCount || 1)}`
+                    ]);
+                    return;
+                }
+                this.writer.appendEvent({
+                    type: 'compile_success',
+                    ts: nowISO(),
+                    command: this.command,
+                    browser: this.browser,
+                    durationMs: Number.isFinite(durationMs) ? durationMs : void 0,
+                    errorCount: 0
+                });
+                this.writer.writeReady(nowISO());
+            });
+            compiler.hooks.failed.tap(PlaywrightPlugin.name, (error)=>{
+                this.writer.appendEvent({
+                    type: 'compile_error',
+                    ts: nowISO(),
+                    command: this.command,
+                    browser: this.browser,
+                    errorCount: 1
+                });
+                this.writer.writeError('compile_failed', error instanceof Error ? error.message : String(error));
+            });
+            compiler.hooks.watchClose.tap(PlaywrightPlugin.name, ()=>{
+                this.writer.appendEvent({
+                    type: 'shutdown',
+                    ts: nowISO(),
+                    command: this.command,
+                    browser: this.browser
+                });
+            });
+        }
+        constructor(options){
+            _define_property(this, "writer", void 0);
+            _define_property(this, "command", void 0);
+            _define_property(this, "browser", void 0);
+            this.browser = String(options.browser || 'chromium');
+            this.command = options.command || ('development' === options.mode ? 'dev' : 'start');
+            this.writer = createPlaywrightMetadataWriter({
+                packageJsonDir: options.packageJsonDir,
+                browser: this.browser,
+                command: this.command,
+                distPath: options.outputPath,
+                manifestPath: options.manifestPath,
+                port: options.port
+            });
+        }
+    }
+    _define_property(PlaywrightPlugin, "name", 'plugin-playwright');
+    function sanitize(obj) {
+        return Object.fromEntries(Object.entries(obj || {}).filter(([, value])=>void 0 !== value));
+    }
+    const external_extension_from_store_namespaceObject = require("extension-from-store");
+    function isDir(p) {
+        try {
+            return external_fs_.existsSync(p) && external_fs_.statSync(p).isDirectory();
+        } catch  {
+            return false;
+        }
+    }
+    function isFile(p) {
+        try {
+            return external_fs_.existsSync(p) && external_fs_.statSync(p).isFile();
+        } catch  {
+            return false;
+        }
+    }
+    function toAbs(projectRoot, p) {
+        return external_path_.isAbsolute(p) ? p : external_path_.resolve(projectRoot, p);
+    }
+    function isValidExtensionRoot(dir) {
+        if (!isDir(dir)) return false;
+        return isFile(external_path_.join(dir, 'manifest.json'));
+    }
+    function normalizeCompanionConfig(config) {
+        const explicitPaths = [];
+        let scanDir;
+        if (Array.isArray(config)) explicitPaths.push(...config.filter((p)=>'string' == typeof p));
+        else if (config && 'object' == typeof config) {
+            if (Array.isArray(config.paths)) explicitPaths.push(...config.paths.filter((p)=>'string' == typeof p));
+            if ('string' == typeof config.dir && config.dir.trim().length > 0) scanDir = config.dir.trim();
+        }
+        return {
+            dir: scanDir,
+            paths: explicitPaths
+        };
+    }
+    function isPathLike(value) {
+        if (external_path_.isAbsolute(value)) return true;
+        if (value.startsWith('./') || value.startsWith('../')) return true;
+        return value.includes('/') || value.includes('\\');
+    }
+    function isSubpathOf(parent, child) {
+        const rel = external_path_.relative(parent, child);
+        return '' !== rel && !rel.startsWith('..') && !external_path_.isAbsolute(rel);
+    }
+    function getBrowserFolder(browser) {
+        if ('firefox' === browser || 'gecko-based' === browser || 'firefox-based' === browser) return 'firefox';
+        if ('edge' === browser) return 'edge';
+        return 'chrome';
+    }
+    function parseChromeWebStoreId(url) {
+        if ('chromewebstore.google.com' !== url.hostname) return null;
+        const match = url.pathname.match(/\/([a-z]{32})(?:\/|$)/i);
+        return match ? match[1] : null;
+    }
+    function parseEdgeAddonsId(url) {
+        if ('microsoftedge.microsoft.com' !== url.hostname) return null;
+        const match = url.pathname.match(/\/([a-z]{32})(?:\/|$)/i);
+        return match ? match[1] : null;
+    }
+    function parseAmoSlug(url) {
+        if ('addons.mozilla.org' !== url.hostname) return null;
+        const match = url.pathname.match(/\/addon\/([^/]+)(?:\/|$)/i);
+        return match ? match[1] : null;
+    }
+    function parseStoreUrl(raw) {
+        let url;
+        try {
+            url = new URL(raw);
+        } catch  {
+            return null;
+        }
+        const chromeId = parseChromeWebStoreId(url);
+        if (chromeId) return {
+            browser: 'chrome',
+            id: chromeId
+        };
+        const edgeId = parseEdgeAddonsId(url);
+        if (edgeId) return {
+            browser: 'edge',
+            id: edgeId
+        };
+        const amoSlug = parseAmoSlug(url);
+        if (amoSlug) return {
+            browser: 'firefox',
+            id: amoSlug
+        };
+        return null;
+    }
+    function ensurePathsUnderExtensions(projectRoot, paths) {
+        const extensionsRoot = external_path_.resolve(projectRoot, 'extensions');
+        return paths.map((p)=>{
+            const abs = toAbs(projectRoot, p);
+            if (abs !== extensionsRoot && !isSubpathOf(extensionsRoot, abs) && external_path_.resolve(abs) !== extensionsRoot) throw new Error(`Companion extensions must be inside ${extensionsRoot}.\nInvalid path: ${abs}`);
+            return abs;
+        });
+    }
+    function findExtensionRoots(dir, maxDepth = 3) {
+        const found = [];
+        function walk(current, depth) {
+            if (depth > maxDepth) return;
+            if (!isDir(current)) return;
+            if (isValidExtensionRoot(current)) return void found.push(current);
+            let entries = [];
+            try {
+                entries = external_fs_.readdirSync(current, {
+                    withFileTypes: true
+                });
+            } catch  {
+                return;
+            }
+            for (const ent of entries)if (ent.isDirectory()) {
+                if (!ent.name.startsWith('.')) walk(external_path_.join(current, ent.name), depth + 1);
+            }
+        }
+        walk(dir, 0);
+        return found;
+    }
+    async function runExtensionFromStore(url, outDir) {
+        const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+        await (0, external_extension_from_store_namespaceObject.fetchExtensionFromStore)(url, {
+            outDir,
+            extract: true,
+            logger: isAuthor ? {
+                onInfo: (message)=>console.log(message),
+                onWarn: (message)=>console.warn(message),
+                onError: (message, error)=>console.error(message, error)
+            } : void 0
+        });
+    }
+    async function resolveStoreExtensionToPath(opts) {
+        const { projectRoot, storeUrl, browser, id } = opts;
+        const extensionsRoot = external_path_.resolve(projectRoot, 'extensions');
+        const targetRoot = external_path_.join(extensionsRoot, browser, id);
+        const manifestPath = external_path_.join(targetRoot, 'manifest.json');
+        if (isFile(manifestPath)) return targetRoot;
+        await runExtensionFromStore(storeUrl, external_path_.join(extensionsRoot, browser));
+        const candidates = findExtensionRoots(external_path_.join(extensionsRoot, browser));
+        let selected;
+        if (1 === candidates.length) selected = candidates[0];
+        else if (candidates.length > 1) {
+            const directMatch = candidates.find((c)=>external_path_.basename(c) === id);
+            const versionedMatch = candidates.find((c)=>external_path_.basename(c).startsWith(`${id}@`));
+            if (directMatch) selected = directMatch;
+            else if (versionedMatch) selected = versionedMatch;
+        }
+        if (!selected) throw new Error(`Could not locate an unpacked extension from ${storeUrl}.`);
+        external_fs_.mkdirSync(external_path_.dirname(targetRoot), {
+            recursive: true
+        });
+        if (external_path_.basename(selected).startsWith(`${id}@`)) external_fs_.renameSync(selected, targetRoot);
+        return targetRoot;
+    }
+    async function resolveCompanionExtensionsConfig(opts) {
+        const { projectRoot, browser, config } = opts;
+        if (!config) return;
+        const normalized = normalizeCompanionConfig(config);
+        const runtimeBrowser = getBrowserFolder(browser);
+        const resolvedPaths = [];
+        const localPaths = [];
+        for (const entry of normalized.paths){
+            const parsedStore = parseStoreUrl(entry);
+            if (parsedStore) {
+                if (parsedStore.browser !== runtimeBrowser) continue;
+                const resolvedPath = await resolveStoreExtensionToPath({
+                    projectRoot,
+                    storeUrl: entry,
+                    browser: parsedStore.browser,
+                    id: parsedStore.id
+                });
+                resolvedPaths.push(resolvedPath);
+                continue;
+            }
+            if (isPathLike(entry)) localPaths.push(entry);
+        }
+        if (localPaths.length > 0) {
+            const absLocalPaths = ensurePathsUnderExtensions(projectRoot, localPaths);
+            resolvedPaths.push(...absLocalPaths);
+        }
+        const output = {};
+        if ('string' == typeof normalized.dir) {
+            const absDir = toAbs(projectRoot, normalized.dir);
+            const extensionsRoot = external_path_.resolve(projectRoot, 'extensions');
+            if (absDir !== extensionsRoot && !isSubpathOf(extensionsRoot, absDir)) throw new Error(`extensions.dir must be inside ${extensionsRoot}.\nInvalid dir: ${absDir}`);
+            output.dir = normalized.dir;
+        }
+        if (resolvedPaths.length > 0) output.paths = resolvedPaths;
+        return output;
+    }
+    function resolveCompanionExtensionDirs(opts) {
+        const { projectRoot, config } = opts;
+        const normalized = normalizeCompanionConfig(config);
+        const explicitPaths = normalized.paths;
+        const scanDir = normalized.dir;
+        const found = [];
+        for (const p of explicitPaths){
+            const abs = toAbs(projectRoot, p);
+            if (isValidExtensionRoot(abs)) found.push(abs);
+        }
+        if (scanDir) {
+            const absScan = toAbs(projectRoot, scanDir);
+            if (isDir(absScan)) {
+                let entries = [];
+                try {
+                    entries = external_fs_.readdirSync(absScan, {
+                        withFileTypes: true
+                    });
+                } catch  {
+                    entries = [];
+                }
+                const scanOneLevel = (rootDir)=>{
+                    let dirEntries = [];
+                    try {
+                        dirEntries = external_fs_.readdirSync(rootDir, {
+                            withFileTypes: true
+                        });
+                    } catch  {
+                        dirEntries = [];
+                    }
+                    for (const ent of dirEntries){
+                        if (!ent.isDirectory()) continue;
+                        if (ent.name.startsWith('.')) continue;
+                        const candidate = external_path_.join(rootDir, ent.name);
+                        if (isValidExtensionRoot(candidate)) found.push(candidate);
+                    }
+                };
+                scanOneLevel(absScan);
+                if ('extensions' === external_path_.basename(absScan)) for (const ent of entries){
+                    if (!ent.isDirectory()) continue;
+                    if (ent.name.startsWith('.')) continue;
+                    const browserDir = external_path_.join(absScan, ent.name);
+                    scanOneLevel(browserDir);
+                }
+            }
+        }
+        const unique = [];
+        const seen = new Set();
+        for (const p of found)if (!seen.has(p)) {
+            seen.add(p);
+            unique.push(p);
+        }
+        return unique;
+    }
+    const external_browser_extension_manifest_fields_namespaceObject = require("browser-extension-manifest-fields");
+    function isUnderPublicDir(entry, projectRoot, publicDir) {
+        if (!entry) return false;
+        const normalizedEntry = String(entry);
+        const candidate = external_path_default().isAbsolute(normalizedEntry) ? normalizedEntry : external_path_default().join(projectRoot, normalizedEntry);
+        const rel = external_path_default().relative(publicDir, candidate);
+        return Boolean(rel && !rel.startsWith('..') && !external_path_default().isAbsolute(rel));
+    }
+    function filterPublicEntrypoints(list, projectRoot, publicDir) {
+        const next = {};
+        for (const [key, value] of Object.entries(list || {})){
+            if (Array.isArray(value)) {
+                const filtered = value.filter((entry)=>!isUnderPublicDir(String(entry), projectRoot, publicDir));
+                if (filtered.length > 0) next[key] = filtered;
+                continue;
+            }
+            if ('string' == typeof value) {
+                if (!isUnderPublicDir(value, projectRoot, publicDir)) next[key] = value;
+                continue;
+            }
+        }
+        return next;
+    }
+    function getSpecialFoldersDataForProjectRoot(projectRoot) {
+        const publicDir = external_path_default().join(projectRoot, 'public');
+        const data = (0, external_browser_extension_manifest_fields_namespaceObject.getSpecialFoldersData)({
+            manifestPath: external_path_default().join(projectRoot, 'package.json')
+        });
+        return finalizeSpecialFoldersData(data, projectRoot, publicDir);
+    }
+    function finalizeSpecialFoldersData(data, projectRoot, publicDir) {
+        return {
+            ...data,
+            pages: filterPublicEntrypoints(data.pages, projectRoot, publicDir),
+            scripts: filterPublicEntrypoints(data.scripts, projectRoot, publicDir),
+            extensions: {
+                dir: './extensions'
+            }
+        };
+    }
+    function hasNewTabOverride(extensionDir) {
+        const manifestPath = external_path_.join(extensionDir, 'manifest.json');
+        if (!external_fs_.existsSync(manifestPath)) return false;
+        try {
+            const raw = external_fs_.readFileSync(manifestPath, 'utf-8');
+            const manifest = JSON.parse(raw);
+            const newtab = manifest?.chrome_url_overrides?.newtab;
+            return 'string' == typeof newtab && newtab.trim().length > 0;
+        } catch  {
+            return false;
+        }
+    }
+    function resolveBuiltInExtensionForBrowser(input) {
+        const engine = devtoolsEngineFor(input.browser);
+        const packageRelativeCandidates = [
+            external_path_.join('dist', input.packageName, engine)
+        ];
+        const normalizedBaseDir = external_path_.normalize(input.baseDir);
+        const parentName = external_path_.basename(external_path_.dirname(normalizedBaseDir));
+        const baseName = external_path_.basename(normalizedBaseDir);
+        if ('programs' === parentName && 'develop' === baseName) packageRelativeCandidates.push(external_path_.join('..', '..', 'extensions', input.packageName, 'dist', engine));
+        for (const rel of packageRelativeCandidates){
+            const candidate = external_path_.resolve(input.baseDir, rel);
+            if (external_fs_.existsSync(candidate)) return candidate;
+        }
+    }
+    function computeExtensionsToLoad(baseDir, mode, browser, userExtensionOutputPath, extraExtensionDirs = [], userManifestPath) {
+        const list = [];
+        try {
+            const devtoolsForBrowser = resolveBuiltInExtensionForBrowser({
+                baseDir,
+                packageName: 'extension-js-devtools',
+                browser
+            });
+            const themeForBrowser = resolveBuiltInExtensionForBrowser({
+                baseDir,
+                packageName: 'extension-js-theme',
+                browser
+            });
+            const userHasNewTabOverride = hasNewTabOverride(userExtensionOutputPath) || ('string' == typeof userManifestPath ? hasNewTabOverride(external_path_.dirname(userManifestPath)) : false);
+            const devtoolsHasNewTabOverride = devtoolsForBrowser ? hasNewTabOverride(devtoolsForBrowser) : false;
+            const shouldSkipDevtoolsForNtpConflict = userHasNewTabOverride && devtoolsHasNewTabOverride;
+            if (devtoolsForBrowser && !shouldSkipDevtoolsForNtpConflict) list.push(devtoolsForBrowser);
+            if (themeForBrowser) list.push(themeForBrowser);
+        } catch  {}
+        for (const p of extraExtensionDirs)list.push(p);
+        list.push(userExtensionOutputPath);
+        return list;
+    }
+    function getDarkModeDefaults(browser) {
+        if ('chrome' === browser || 'edge' === browser || 'chromium' === browser || 'chromium-based' === browser) return {
+            browserFlags: [
+                '--force-dark-mode',
+                '--enable-features=WebUIDarkMode'
+            ],
+            preferences: {}
+        };
+        if ('firefox' === browser || 'gecko-based' === browser || 'firefox-based' === browser) return {
+            browserFlags: [],
+            preferences: {
+                'ui.systemUsesDarkTheme': 1,
+                'layout.css.prefers-color-scheme.content-override': 2,
+                'devtools.theme': 'dark'
+            }
+        };
+        return {
+            browserFlags: [],
+            preferences: {}
+        };
+    }
+    function withDarkMode(config) {
+        const defaults = getDarkModeDefaults(config.browser);
+        const existingFlags = Array.isArray(config.browserFlags) ? [
+            ...config.browserFlags
+        ] : [];
+        const nextFlags = [
+            ...existingFlags
+        ];
+        for (const flag of defaults.browserFlags || [])if (!nextFlags.some((f)=>String(f).trim() === flag)) nextFlags.push(flag);
+        const nextPreferences = {
+            ...config.preferences || {},
+            ...Object.fromEntries(Object.entries(defaults.preferences || {}).filter(([k])=>!(k in (config.preferences || {}))))
+        };
+        return {
+            ...config,
+            browserFlags: nextFlags,
+            preferences: nextPreferences
+        };
+    }
+    var external_pintor_ = __webpack_require__("pintor");
+    var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_);
+    function readJsonRecord(filePath) {
+        try {
+            return JSON.parse(external_fs_.readFileSync(filePath, 'utf8'));
+        } catch  {
+            return null;
+        }
+    }
+    function capitalizeToken(value) {
+        return value.split('-').filter(Boolean).map((token)=>token.charAt(0).toUpperCase() + token.slice(1)).join('-');
+    }
+    function getExtensionVersion() {
+        return process.env.EXTENSION_DEVELOP_VERSION || process.env.EXTENSION_CLI_VERSION || (()=>{
+            try {
+                return __webpack_require__("./package.json").rE;
+            } catch  {
+                return 'unknown';
+            }
+        })();
+    }
+    function browserRunnerDisabled(args) {
+        const manifest = readJsonRecord(args.manifestPath);
+        const ready = readJsonRecord(args.readyPath);
+        const browserLabel = capitalizeToken(String(args.browser || 'unknown'));
+        const runId = String(ready?.runId || '').trim();
+        const pid = Number.isInteger(ready?.pid) ? String(ready?.pid) : '';
+        const runLabel = runId ? `${external_pintor_default().gray(runId)}${pid ? ` · ${external_pintor_default().gray(`PID ${pid}`)}` : ''}` : pid ? external_pintor_default().gray(`PID ${pid}`) : external_pintor_default().gray('n/a');
+        const extensionName = String(manifest?.name || 'Extension');
+        const extensionVersion = String(manifest?.version || '').trim();
+        const extensionLabel = extensionVersion ? `${extensionName} ${extensionVersion}` : extensionName;
+        const extensionJsVersion = getExtensionVersion();
+        return [
+            ` 🧩 ${external_pintor_default().brightBlue('Extension.js')} ${external_pintor_default().gray(extensionJsVersion)}`,
+            `    Browser        ${external_pintor_default().gray(args.browserModeLabel || `${browserLabel} (build-only mode)`)}`,
+            `    Extension      ${external_pintor_default().gray(extensionLabel)}`,
+            `    Run ID         ${runLabel}`
+        ].join('\n');
+    }
+    function spacerLine() {
+        return ' ';
+    }
+    async function extensionPreview(pathOrRemoteUrl, previewOptions, browserLauncher) {
+        const projectStructure = await getProjectStructure(pathOrRemoteUrl);
+        const debug = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+        const { manifestDir, packageJsonDir } = getDirs(projectStructure);
+        if (projectStructure.packageJsonPath) assertNoManagedDependencyConflicts(projectStructure.packageJsonPath, packageJsonDir);
+        const browser = normalizeBrowser(previewOptions.browser || 'chrome', previewOptions.chromiumBinary, previewOptions.geckoBinary || previewOptions.firefoxBinary);
+        const outputPath = computePreviewOutputPath(projectStructure, browser, previewOptions.outputPath);
+        const distPath = getDistPath(packageJsonDir, browser);
+        const metadataCommand = 'start' === previewOptions.metadataCommand ? 'start' : 'preview';
+        const metadata = createPlaywrightMetadataWriter({
+            packageJsonDir,
+            browser: String(browser),
+            command: metadataCommand,
+            distPath,
+            manifestPath: projectStructure.manifestPath,
+            port: 'number' == typeof previewOptions.port ? previewOptions.port : 'string' == typeof previewOptions.port ? parseInt(previewOptions.port, 10) : null
+        });
+        metadata.writeStarting();
+        if (debug) {
+            console.log(webpack_lib_messages.SG(manifestDir, packageJsonDir));
+            console.log(webpack_lib_messages._A(browser, previewOptions.chromiumBinary, previewOptions.geckoBinary || previewOptions.firefoxBinary));
+            console.log(webpack_lib_messages.jV(outputPath, distPath));
+        }
+        const manifestAtOutput = external_path_.join(outputPath, 'manifest.json');
+        if (!external_fs_.existsSync(manifestAtOutput)) {
+            metadata.writeError('preview_manifest_missing', `Expected manifest at ${manifestAtOutput}`);
+            throw new Error(`Preview is run-only and does not compile.\nExpected an unpacked extension at:\n  ${manifestAtOutput}\n\nRun \`extension build\` or \`extension dev\` first, or pass --output-path to an existing unpacked extension directory.`);
+        }
+        const commandConfig = await loadCommandConfig(packageJsonDir, 'preview');
+        const browserConfig = await loadBrowserConfig(packageJsonDir, browser);
+        console.log(webpack_lib_messages.V_(browser));
+        if (previewOptions.noBrowser) {
+            console.log(webpack_lib_messages.k4(browser));
+            metadata.writeReady();
+            console.log(spacerLine());
+            const browserLabel = String(browser || 'unknown');
+            console.log(browserRunnerDisabled({
+                browser: browserLabel,
+                manifestPath: projectStructure.manifestPath,
+                readyPath: metadata.readyPath,
+                browserModeLabel: `${browserLabel.charAt(0).toUpperCase() + browserLabel.slice(1)} (no-browser mode)`
+            }));
+            return;
+        }
+        const safeBrowserConfig = sanitize(browserConfig);
+        const safeCommandConfig = sanitize(commandConfig);
+        const safePreviewOptions = sanitize(previewOptions);
+        const specialFoldersData = getSpecialFoldersDataForProjectRoot(packageJsonDir);
+        const mergedExtensionsConfig = safePreviewOptions.extensions ?? safeCommandConfig.extensions ?? safeBrowserConfig.extensions ?? specialFoldersData.extensions;
+        const resolvedExtensionsConfig = await resolveCompanionExtensionsConfig({
+            projectRoot: packageJsonDir,
+            browser,
+            config: mergedExtensionsConfig
+        });
+        const mergedGeckoBinary = safePreviewOptions.geckoBinary || safePreviewOptions.firefoxBinary || safeCommandConfig.geckoBinary || safeCommandConfig.firefoxBinary || safeBrowserConfig.geckoBinary || safeBrowserConfig.firefoxBinary;
+        const mergedChromiumBinary = safePreviewOptions.chromiumBinary || safeCommandConfig.chromiumBinary || safeBrowserConfig.chromiumBinary;
+        const merged = {
+            ...safeBrowserConfig,
+            ...safeCommandConfig,
+            ...safePreviewOptions,
+            extensions: resolvedExtensionsConfig,
+            chromiumBinary: mergedChromiumBinary,
+            geckoBinary: mergedGeckoBinary
+        };
+        const darkDefaults = withDarkMode({
+            browser,
+            browserFlags: merged.browserFlags,
+            preferences: merged.preferences
+        });
+        const companionUnpackedExtensionDirs = resolveCompanionExtensionDirs({
+            projectRoot: packageJsonDir,
+            config: merged.extensions
+        });
+        const unpackedExtensionDirsToLoad = computeExtensionsToLoad(external_path_.resolve(__dirname, '..'), 'production', browser, outputPath, companionUnpackedExtensionDirs, projectStructure.manifestPath);
+        const resolvedOpts = {
+            browser,
+            outPath: outputPath,
+            contextDir: packageJsonDir,
+            readyPath: metadata.readyPath,
+            extensionsToLoad: unpackedExtensionDirsToLoad,
+            noOpen: merged.noOpen,
+            profile: merged.profile,
+            persistProfile: merged.persistProfile,
+            preferences: darkDefaults.preferences,
+            browserFlags: darkDefaults.browserFlags,
+            excludeBrowserFlags: merged.excludeBrowserFlags,
+            startingUrl: merged.startingUrl,
+            chromiumBinary: merged.chromiumBinary,
+            geckoBinary: merged.geckoBinary,
+            instanceId: merged.instanceId,
+            port: merged.port,
+            dryRun: merged.dryRun
+        };
+        if (!browserLauncher) throw new Error("extensionPreview requires a browserLauncher callback. The browser launch code has moved to programs/browser/.");
+        await browserLauncher(resolvedOpts);
+        metadata.writeReady();
+    }
+})();
+exports.extensionPreview = __webpack_exports__.extensionPreview;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "extensionPreview"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});