@addfox/core 0.1.1-beta.2

package/dist/cjs/index.cjs

@@ -0,0 +1,1729 @@
+"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_require__ = {};
+(()=>{
+    __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__.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 __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getScriptOnlyEntryNames: ()=>getScriptOnlyEntryNames,
+    resolveManifestChromium: ()=>resolveManifestChromium,
+    RSTEST_CONFIG_FILES: ()=>RSTEST_CONFIG_FILES,
+    MANIFEST_FILE_NAMES: ()=>MANIFEST_FILE_NAMES,
+    BROWSER_OUTPUT_PREFIX: ()=>BROWSER_OUTPUT_PREFIX,
+    getScriptInjectIfMatches: ()=>getScriptInjectIfMatches,
+    DEFAULT_ENV_PREFIXES: ()=>DEFAULT_ENV_PREFIXES,
+    getManifestRecordForTarget: ()=>getManifestRecordForTarget,
+    resolveManifestForTarget: ()=>resolveManifestForTarget,
+    toReloadManagerEntries: ()=>toReloadManagerEntries,
+    DEFAULT_BROWSER: ()=>DEFAULT_BROWSER,
+    ManifestLoader: ()=>ManifestLoader,
+    MANIFEST_ENTRY_KEYS: ()=>MANIFEST_ENTRY_KEYS,
+    getAllEntryNames: ()=>getAllEntryNames,
+    DEFAULT_OUT_DIR: ()=>DEFAULT_OUT_DIR,
+    SCRIPT_ONLY_ENTRY_NAMES: ()=>SCRIPT_ONLY_ENTRY_NAMES,
+    clearConfigCache: ()=>clearConfigCache,
+    extractEntriesFromManifest: ()=>extractEntriesFromManifest,
+    resolveAddfoxConfig: ()=>resolveAddfoxConfig,
+    resolveManifestInput: ()=>resolveManifestInput,
+    MANIFEST_ENTRY_PATHS: ()=>MANIFEST_ENTRY_PATHS,
+    MANIFEST_DIR: ()=>MANIFEST_DIR,
+    getResolvedConfigFilePath: ()=>getResolvedConfigFilePath,
+    buildForBrowser: ()=>buildForBrowser,
+    loadConfigFile: ()=>loadConfigFile,
+    parseAddfoxEntryFromHtml: ()=>parseAddfoxEntryFromHtml,
+    SUPPORTED_BROWSERS: ()=>SUPPORTED_BROWSERS,
+    CLI_COMMANDS: ()=>CLI_COMMANDS,
+    RELOAD_MANAGER_ENTRY_NAMES: ()=>RELOAD_MANAGER_ENTRY_NAMES,
+    HMR_WS_PORT: ()=>23333,
+    SCRIPT_EXTS: ()=>SCRIPT_EXTS,
+    getAddfoxVersion: ()=>getAddfoxVersion,
+    getHtmlEntryNames: ()=>getHtmlEntryNames,
+    isScriptSrcRelative: ()=>isScriptSrcRelative,
+    ADDFOX_OUTPUT_ROOT: ()=>ADDFOX_OUTPUT_ROOT,
+    DEFAULT_APP_DIR: ()=>"app",
+    RESERVED_ENTRY_NAMES: ()=>RESERVED_ENTRY_NAMES,
+    detectFrontendFramework: ()=>detectFrontendFramework,
+    HTML_ENTRY_NAMES: ()=>HTML_ENTRY_NAMES,
+    getResolvedRstestConfigFilePath: ()=>getResolvedRstestConfigFilePath,
+    discoverEntries: ()=>discoverEntries,
+    Pipeline: ()=>Pipeline,
+    resolveEntries: ()=>resolveEntries,
+    resolveManifestFirefox: ()=>resolveManifestFirefox,
+    CONFIG_FILES: ()=>CONFIG_FILES,
+    defineConfig: ()=>defineConfig,
+    SUPPORTED_LAUNCH_TARGETS: ()=>SUPPORTED_LAUNCH_TARGETS,
+    getBrowserOutputDir: ()=>getBrowserOutputDir,
+    resolveScriptFromHtmlStrict: ()=>resolveScriptFromHtmlStrict
+});
+function defineConfig(config) {
+    return config;
+}
+const external_module_namespaceObject = require("module");
+const external_path_namespaceObject = require("path");
+const external_fs_namespaceObject = require("fs");
+const CONFIG_FILES = [
+    "addfox.config.ts",
+    "addfox.config.js",
+    "addfox.config.mjs"
+];
+const SCRIPT_EXTS = [
+    ".js",
+    ".jsx",
+    ".ts",
+    ".tsx"
+];
+const RESERVED_ENTRY_NAMES = [
+    "popup",
+    "options",
+    "sidepanel",
+    "offscreen",
+    "sandbox",
+    "newtab",
+    "bookmarks",
+    "history",
+    "background",
+    "devtools",
+    "content"
+];
+const HTML_ENTRY_NAMES = [
+    "popup",
+    "options",
+    "sidepanel",
+    "devtools",
+    "offscreen",
+    "sandbox",
+    "newtab",
+    "bookmarks",
+    "history"
+];
+const SCRIPT_ONLY_ENTRY_NAMES = [
+    "background",
+    "content"
+];
+const RELOAD_MANAGER_ENTRY_NAMES = new Set(SCRIPT_ONLY_ENTRY_NAMES);
+const ADDFOX_OUTPUT_ROOT = ".addfox";
+const DEFAULT_OUT_DIR = "extension";
+const DEFAULT_ENV_PREFIXES = [
+    "ADDFOX_PUBLIC_"
+];
+const DEFAULT_BROWSER = "chromium";
+const SUPPORTED_BROWSERS = [
+    "chromium",
+    "firefox"
+];
+const BROWSER_OUTPUT_PREFIX = "extension";
+function getBrowserOutputDir(browser) {
+    return `${BROWSER_OUTPUT_PREFIX}-${browser}`;
+}
+const SUPPORTED_LAUNCH_TARGETS = [
+    "chrome",
+    "chromium",
+    "edge",
+    "brave",
+    "vivaldi",
+    "opera",
+    "santa",
+    "arc",
+    "yandex",
+    "browseros",
+    "custom",
+    "firefox"
+];
+const CLI_COMMANDS = [
+    "dev",
+    "build",
+    "test"
+];
+const RSTEST_CONFIG_FILES = [
+    "rstest.config.cts",
+    "rstest.config.mts",
+    "rstest.config.cjs",
+    "rstest.config.js",
+    "rstest.config.ts",
+    "rstest.config.mjs"
+];
+const MANIFEST_DIR = "manifest";
+const MANIFEST_FILE_NAMES = {
+    base: "manifest.json",
+    chromium: "manifest.chromium.json",
+    firefox: "manifest.firefox.json"
+};
+const MANIFEST_ENTRY_PATHS = {
+    background: "background/index.js",
+    content: "content/index.js",
+    popup: "popup/index.html",
+    options: "options/index.html",
+    sidepanel: "sidepanel/index.html",
+    devtools: "devtools/index.html",
+    offscreen: "offscreen/index.html",
+    sandbox: "sandbox/index.html",
+    newtab: "newtab/index.html",
+    bookmarks: "bookmarks/index.html",
+    history: "history/index.html"
+};
+const MANIFEST_ENTRY_KEYS = Object.keys(MANIFEST_ENTRY_PATHS);
+const common_namespaceObject = require("@addfox/common");
+function isScriptSrcRelative(src) {
+    const t = src.trim();
+    if (t.startsWith("/") || t.startsWith("\\")) return false;
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(t)) return false;
+    return true;
+}
+const ENTRY_SCRIPT_REGEX = /<script\b[^>]*data-addfox-entry[^>]*>[\s\S]*?<\/script>/gi;
+const HEAD_CLOSE_REGEX = /<\/head\s*>/i;
+const SCRIPT_WITH_SRC_REGEX = /<script\b[^>]*\ssrc\s*=\s*["']([^"']+)["'][^>]*>[\s\S]*?<\/script>/gi;
+function findFirstScriptWithRelativeSrc(html) {
+    const reg = new RegExp(SCRIPT_WITH_SRC_REGEX.source, "gi");
+    let match;
+    while(null !== (match = reg.exec(html))){
+        const src = match[1];
+        if (!isScriptSrcRelative(src)) continue;
+        return {
+            src,
+            fullTag: match[0],
+            tagStartIndex: match.index
+        };
+    }
+}
+function parseAddfoxEntryFromHtml(htmlPath) {
+    const raw = (0, external_fs_namespaceObject.readFileSync)(htmlPath, "utf-8");
+    const reg = new RegExp(ENTRY_SCRIPT_REGEX.source, "gi");
+    const match = reg.exec(raw);
+    if (match) {
+        const tag = match[0];
+        const tagStartIndex = match.index;
+        const srcMatch = tag.match(/src\s*=\s*["']([^"']+)["']/i);
+        if (srcMatch?.[1] && isScriptSrcRelative(srcMatch[1])) {
+            const src = srcMatch[1];
+            const headCloseMatch = raw.match(HEAD_CLOSE_REGEX);
+            const headCloseIndex = headCloseMatch?.index ?? -1;
+            const inject = headCloseIndex >= 0 && tagStartIndex < headCloseIndex ? "head" : "body";
+            const strippedHtml = raw.replace(ENTRY_SCRIPT_REGEX, "").trimEnd();
+            return {
+                src,
+                inject,
+                strippedHtml
+            };
+        }
+    }
+    const fallback = findFirstScriptWithRelativeSrc(raw);
+    if (!fallback) return;
+    const headCloseMatch = raw.match(HEAD_CLOSE_REGEX);
+    const headCloseIndex = headCloseMatch?.index ?? -1;
+    const inject = headCloseIndex >= 0 && fallback.tagStartIndex < headCloseIndex ? "head" : "body";
+    const strippedHtml = raw.replace(fallback.fullTag, "").trimEnd();
+    return {
+        src: fallback.src,
+        inject,
+        strippedHtml
+    };
+}
+function getScriptInjectIfMatches(htmlPath, scriptPath) {
+    try {
+        const parsed = parseAddfoxEntryFromHtml(htmlPath);
+        if (!parsed) return;
+        const resolvedFromHtml = (0, external_path_namespaceObject.resolve)((0, external_path_namespaceObject.dirname)(htmlPath), parsed.src);
+        return resolvedFromHtml === scriptPath ? parsed.inject : void 0;
+    } catch  {
+        return;
+    }
+}
+function resolveScriptFromHtmlStrict(htmlPath) {
+    const parsed = parseAddfoxEntryFromHtml(htmlPath);
+    if (!parsed) throw new Error("data-addfox-entry script must have a src attribute (relative path)");
+    if (!isScriptSrcRelative(parsed.src)) throw new Error(`data-addfox-entry src must be relative, got: ${JSON.stringify(parsed.src)}`);
+    const scriptPath = (0, external_path_namespaceObject.resolve)((0, external_path_namespaceObject.dirname)(htmlPath), parsed.src);
+    if (!(0, external_fs_namespaceObject.existsSync)(scriptPath)) throw new Error(`Entry script not found: ${scriptPath}`);
+    return {
+        scriptPath,
+        inject: parsed.inject
+    };
+}
+function readDirContents(dir) {
+    try {
+        const entries = (0, external_fs_namespaceObject.readdirSync)(dir, {
+            withFileTypes: true
+        });
+        return {
+            files: new Set(entries.filter((e)=>e.isFile()).map((e)=>e.name)),
+            dirs: new Set(entries.filter((e)=>e.isDirectory()).map((e)=>e.name))
+        };
+    } catch  {
+        return null;
+    }
+}
+function findScriptInDir(dir, scriptExts) {
+    const contents = readDirContents(dir);
+    if (!contents) return;
+    for (const ext of scriptExts)if (contents.files.has(`index${ext}`)) return (0, external_path_namespaceObject.resolve)(dir, `index${ext}`);
+}
+function findScriptInDirFromContents(dirPath, contents, scriptExts) {
+    if (!contents) return findScriptInDir(dirPath, scriptExts);
+    for (const ext of scriptExts)if (contents.files.has(`index${ext}`)) return (0, external_path_namespaceObject.resolve)(dirPath, `index${ext}`);
+}
+function findNamedScript(baseDir, name, scriptExts, baseContents) {
+    if (baseContents) {
+        for (const ext of scriptExts)if (baseContents.files.has(`${name}${ext}`)) return (0, external_path_namespaceObject.resolve)(baseDir, `${name}${ext}`);
+        return;
+    }
+    for (const ext of scriptExts){
+        const p = (0, external_path_namespaceObject.resolve)(baseDir, `${name}${ext}`);
+        if ((0, external_fs_namespaceObject.existsSync)(p)) return p;
+    }
+}
+function findNamedHtml(baseDir, name, baseContents) {
+    if (baseContents) return baseContents.files.has(`${name}.html`) ? (0, external_path_namespaceObject.resolve)(baseDir, `${name}.html`) : void 0;
+    const p = (0, external_path_namespaceObject.resolve)(baseDir, `${name}.html`);
+    return (0, external_fs_namespaceObject.existsSync)(p) ? p : void 0;
+}
+function isValidScriptExt(pathStr, scriptExts) {
+    const lower = pathStr.trim().toLowerCase();
+    return scriptExts.some((ext)=>lower.endsWith(ext));
+}
+function resolveScriptFromHtmlWithInjectStrict(htmlPath, scriptExts) {
+    const resolved = resolveScriptFromHtmlStrict(htmlPath);
+    if (!isValidScriptExt(resolved.scriptPath, scriptExts)) throw new common_namespaceObject.AddfoxError({
+        code: common_namespaceObject.ADDFOX_ERROR_CODES.ENTRY_SCRIPT_FROM_HTML,
+        message: "Invalid data-addfox-entry script in HTML",
+        details: `HTML: ${htmlPath}. Resolved path is not a supported script: ${resolved.scriptPath}`,
+        hint: "data-addfox-entry script must have a relative src and the file must exist"
+    });
+    return resolved;
+}
+function tryResolveEntryFromHtml(htmlPath, scriptExts) {
+    try {
+        const parsed = parseAddfoxEntryFromHtml(htmlPath);
+        if (!parsed) return;
+        return resolveScriptFromHtmlWithInjectStrict(htmlPath, scriptExts);
+    } catch (e) {
+        throw new common_namespaceObject.AddfoxError({
+            code: common_namespaceObject.ADDFOX_ERROR_CODES.ENTRY_SCRIPT_FROM_HTML,
+            message: "Invalid data-addfox-entry script in HTML",
+            details: `HTML: ${htmlPath}. ${e instanceof Error ? e.message : String(e)}`,
+            hint: "data-addfox-entry script must have a relative src and the file must exist"
+        });
+    }
+}
+function buildHtmlEntryInfo(name, htmlPath, conventionalScriptPath, scriptExts) {
+    const fromHtml = tryResolveEntryFromHtml(htmlPath, scriptExts);
+    if (fromHtml) return {
+        name,
+        scriptPath: fromHtml.scriptPath,
+        htmlPath,
+        html: true,
+        scriptInject: fromHtml.inject,
+        outputFollowsScriptPath: true
+    };
+    if (!conventionalScriptPath) return null;
+    return {
+        name,
+        scriptPath: conventionalScriptPath,
+        htmlPath,
+        html: true,
+        scriptInject: getScriptInjectIfMatches(htmlPath, conventionalScriptPath)
+    };
+}
+function discoverScriptOnlyEntry(baseDir, name, contents, options) {
+    const singleScript = findNamedScript(baseDir, name, options.scriptExts, contents);
+    if (singleScript) return {
+        name,
+        scriptPath: singleScript,
+        html: false
+    };
+    if (!contents?.dirs.has(name)) return null;
+    const scriptPath = findScriptInDir((0, external_path_namespaceObject.resolve)(baseDir, name), options.scriptExts);
+    return scriptPath ? {
+        name,
+        scriptPath,
+        html: false
+    } : null;
+}
+function discoverHtmlEntryFromFlat(baseDir, name, contents, options) {
+    const singleScript = findNamedScript(baseDir, name, options.scriptExts, contents);
+    const singleHtml = findNamedHtml(baseDir, name, contents);
+    if (singleScript && singleHtml) return buildHtmlEntryInfo(name, singleHtml, singleScript, options.scriptExts);
+    if (singleHtml) {
+        const conventional = findNamedScript(baseDir, name, options.scriptExts, contents);
+        return buildHtmlEntryInfo(name, singleHtml, conventional, options.scriptExts);
+    }
+    return null;
+}
+function discoverHtmlEntryFromDir(baseDir, name, contents, options) {
+    if (!contents?.dirs.has(name)) return null;
+    const dirPath = (0, external_path_namespaceObject.resolve)(baseDir, name);
+    const subContents = readDirContents(dirPath);
+    const htmlPath = subContents?.files.has("index.html") ? (0, external_path_namespaceObject.resolve)(dirPath, "index.html") : void 0;
+    const scriptPath = findScriptInDirFromContents(dirPath, subContents, options.scriptExts);
+    if (scriptPath && htmlPath) return buildHtmlEntryInfo(name, htmlPath, scriptPath, options.scriptExts);
+    if (scriptPath) return {
+        name,
+        scriptPath,
+        htmlPath,
+        html: true,
+        scriptInject: htmlPath ? getScriptInjectIfMatches(htmlPath, scriptPath) : void 0
+    };
+    if (!htmlPath) return null;
+    return buildHtmlEntryInfo(name, htmlPath, void 0, options.scriptExts);
+}
+function discoverHtmlEntry(baseDir, name, contents, options) {
+    return discoverHtmlEntryFromFlat(baseDir, name, contents, options) ?? discoverHtmlEntryFromDir(baseDir, name, contents, options);
+}
+function discoverEntriesInternal(baseDir, options) {
+    const contents = readDirContents(baseDir);
+    const entries = [];
+    for (const name of options.scriptOnlyNames){
+        const entry = discoverScriptOnlyEntry(baseDir, name, contents, options);
+        if (entry) entries.push(entry);
+    }
+    for (const name of options.htmlEntryNames){
+        const entry = discoverHtmlEntry(baseDir, name, contents, options);
+        if (entry) entries.push(entry);
+    }
+    return entries;
+}
+function createOptions(options = {}) {
+    return {
+        scriptExts: options.scriptExts ?? SCRIPT_EXTS,
+        scriptOnlyNames: options.scriptOnlyNames ?? SCRIPT_ONLY_ENTRY_NAMES,
+        htmlEntryNames: options.htmlEntryNames ?? HTML_ENTRY_NAMES
+    };
+}
+function discoverEntries(baseDir, options) {
+    return discoverEntriesInternal(baseDir, createOptions(options));
+}
+function getHtmlEntryNames(options) {
+    return [
+        ...options?.htmlEntryNames ?? HTML_ENTRY_NAMES
+    ];
+}
+function getScriptOnlyEntryNames(options) {
+    return [
+        ...options?.scriptOnlyNames ?? SCRIPT_ONLY_ENTRY_NAMES
+    ];
+}
+function getAllEntryNames(options) {
+    return [
+        ...getHtmlEntryNames(options),
+        ...getScriptOnlyEntryNames(options)
+    ];
+}
+function isSourceFilePath(path) {
+    const lower = path.trim().toLowerCase();
+    return /\.(ts|tsx|js|jsx)$/.test(lower) && !lower.includes("/dist/") && !lower.includes("\\dist\\");
+}
+function inferEntryNameFromPath(path) {
+    const cleanPath = path.replace(/^\.\/|^\//, "");
+    const firstSegment = cleanPath.split(/[\/\\]/)[0];
+    if (MANIFEST_ENTRY_KEYS.includes(firstSegment)) return firstSegment;
+    return null;
+}
+function extractServiceWorker(manifest, browser) {
+    const bg = manifest.background;
+    if (!bg) return null;
+    const serviceWorker = bg.service_worker;
+    if ("string" == typeof serviceWorker && isSourceFilePath(serviceWorker)) {
+        const entryName = inferEntryNameFromPath(serviceWorker) ?? "background";
+        return {
+            name: entryName,
+            value: serviceWorker.replace(/^\.\//, ""),
+            manifestPath: "background.service_worker"
+        };
+    }
+    const scripts = bg.scripts;
+    if (Array.isArray(scripts) && scripts.length > 0) {
+        const firstScript = scripts[0];
+        if ("string" == typeof firstScript && isSourceFilePath(firstScript)) {
+            const entryName = inferEntryNameFromPath(firstScript) ?? "background";
+            return {
+                name: entryName,
+                value: firstScript.replace(/^\.\//, ""),
+                manifestPath: "background.scripts[0]"
+            };
+        }
+    }
+    const page = bg.page;
+    if ("string" == typeof page && isSourceFilePath(page)) {
+        const entryName = inferEntryNameFromPath(page) ?? "background";
+        return {
+            name: entryName,
+            value: page.replace(/^\.\//, ""),
+            manifestPath: "background.page"
+        };
+    }
+    return null;
+}
+function extractPopup(manifest, browser) {
+    const mv = 2 === manifest.manifest_version ? 2 : 3;
+    let popupPath;
+    let manifestPath;
+    if (3 === mv) {
+        const action = manifest.action;
+        const defaultPopup = action?.default_popup;
+        if ("string" == typeof defaultPopup) {
+            popupPath = defaultPopup;
+            manifestPath = "action.default_popup";
+        }
+    } else {
+        const browserAction = manifest.browser_action;
+        const defaultPopup = browserAction?.default_popup;
+        if ("string" == typeof defaultPopup) {
+            popupPath = defaultPopup;
+            manifestPath = "browser_action.default_popup";
+        }
+    }
+    if (popupPath && isSourceFilePath(popupPath)) {
+        const entryName = inferEntryNameFromPath(popupPath) ?? "popup";
+        return {
+            name: entryName,
+            value: popupPath.replace(/^\.\//, ""),
+            manifestPath: manifestPath
+        };
+    }
+    return null;
+}
+function extractOptions(manifest) {
+    const mv = 2 === manifest.manifest_version ? 2 : 3;
+    let optionsPath;
+    let manifestPath;
+    if (3 === mv) {
+        const optionsUi = manifest.options_ui;
+        const page = optionsUi?.page;
+        if ("string" == typeof page) {
+            optionsPath = page;
+            manifestPath = "options_ui.page";
+        }
+    } else {
+        const optionsPage = manifest.options_page;
+        if ("string" == typeof optionsPage) {
+            optionsPath = optionsPage;
+            manifestPath = "options_page";
+        }
+    }
+    if (optionsPath && isSourceFilePath(optionsPath)) {
+        const entryName = inferEntryNameFromPath(optionsPath) ?? "options";
+        return {
+            name: entryName,
+            value: optionsPath.replace(/^\.\//, ""),
+            manifestPath: manifestPath
+        };
+    }
+    return null;
+}
+function extractDevtools(manifest) {
+    const devtoolsPage = manifest.devtools_page;
+    if ("string" == typeof devtoolsPage && isSourceFilePath(devtoolsPage)) {
+        const entryName = inferEntryNameFromPath(devtoolsPage) ?? "devtools";
+        return {
+            name: entryName,
+            value: devtoolsPage.replace(/^\.\//, ""),
+            manifestPath: "devtools_page"
+        };
+    }
+    return null;
+}
+function extractSidepanel(manifest) {
+    const sidePanel = manifest.side_panel;
+    const defaultPath = sidePanel?.default_path;
+    if ("string" == typeof defaultPath && isSourceFilePath(defaultPath)) {
+        const entryName = inferEntryNameFromPath(defaultPath) ?? "sidepanel";
+        return {
+            name: entryName,
+            value: defaultPath.replace(/^\.\//, ""),
+            manifestPath: "side_panel.default_path"
+        };
+    }
+    return null;
+}
+function extractSandbox(manifest) {
+    const sandbox = manifest.sandbox;
+    const pages = sandbox?.pages;
+    if (Array.isArray(pages) && pages.length > 0) {
+        const firstPage = pages[0];
+        if ("string" == typeof firstPage && isSourceFilePath(firstPage)) {
+            const entryName = inferEntryNameFromPath(firstPage) ?? "sandbox";
+            return {
+                name: entryName,
+                value: firstPage.replace(/^\.\//, ""),
+                manifestPath: "sandbox.pages[0]"
+            };
+        }
+    }
+    return null;
+}
+function extractOverrides(manifest) {
+    const entries = [];
+    const overrides = manifest.chrome_url_overrides;
+    if (!overrides) return entries;
+    const overrideKeys = [
+        "newtab",
+        "bookmarks",
+        "history"
+    ];
+    for (const key of overrideKeys){
+        const path = overrides[key];
+        if ("string" == typeof path && isSourceFilePath(path)) {
+            const entryName = inferEntryNameFromPath(path) ?? key;
+            entries.push({
+                name: entryName,
+                value: path.replace(/^\.\//, ""),
+                manifestPath: `chrome_url_overrides.${key}`
+            });
+        }
+    }
+    return entries;
+}
+function extractContentScripts(manifest) {
+    const contentScripts = manifest.content_scripts;
+    if (!Array.isArray(contentScripts) || 0 === contentScripts.length) return null;
+    for(let i = 0; i < contentScripts.length; i++){
+        const cs = contentScripts[i];
+        const js = cs.js;
+        if (Array.isArray(js) && js.length > 0) for(let j = 0; j < js.length; j++){
+            const path = js[j];
+            if ("string" == typeof path && isSourceFilePath(path)) {
+                const entryName = inferEntryNameFromPath(path) ?? "content";
+                return {
+                    name: entryName,
+                    value: path.replace(/^\.\//, ""),
+                    manifestPath: `content_scripts[${i}].js[${j}]`
+                };
+            }
+        }
+    }
+    return null;
+}
+function extractEntriesFromManifest(manifest, browser) {
+    const entries = {};
+    const replacementMap = new Map();
+    const extractors = [
+        ()=>extractServiceWorker(manifest, browser),
+        ()=>extractPopup(manifest, browser),
+        ()=>extractOptions(manifest),
+        ()=>extractDevtools(manifest),
+        ()=>extractSidepanel(manifest),
+        ()=>extractSandbox(manifest),
+        ()=>extractContentScripts(manifest),
+        ()=>extractOverrides(manifest)
+    ];
+    for (const extractor of extractors){
+        const result = extractor();
+        if (result) if (Array.isArray(result)) for (const entry of result){
+            entries[entry.name] = entry.value;
+            replacementMap.set(entry.manifestPath, entry.name);
+        }
+        else {
+            entries[result.name] = result.value;
+            replacementMap.set(result.manifestPath, result.name);
+        }
+    }
+    return {
+        entries,
+        replacementMap
+    };
+}
+const HTML_ENTRY_SET = new Set(HTML_ENTRY_NAMES);
+function isHtmlPath(pathStr) {
+    return pathStr.trim().toLowerCase().endsWith(".html");
+}
+function isScriptPath(pathStr) {
+    const lower = pathStr.trim().toLowerCase();
+    return SCRIPT_EXTS.some((ext)=>lower.endsWith(ext));
+}
+function resolver_findScriptInDir(dir) {
+    for (const ext of SCRIPT_EXTS){
+        const p = (0, external_path_namespaceObject.resolve)(dir, `index${ext}`);
+        if ((0, external_fs_namespaceObject.existsSync)(p)) return p;
+    }
+}
+function findScriptForHtmlDir(dir, htmlFilename) {
+    const stem = (0, external_path_namespaceObject.basename)(htmlFilename, ".html");
+    for (const ext of SCRIPT_EXTS){
+        const p = (0, external_path_namespaceObject.resolve)(dir, `${stem}${ext}`);
+        if ((0, external_fs_namespaceObject.existsSync)(p)) return p;
+    }
+    return resolver_findScriptInDir(dir);
+}
+function isEntryConfigObject(value) {
+    return "object" == typeof value && null !== value && "src" in value;
+}
+function resolveHtmlPath(baseDir, htmlValue) {
+    if (!htmlValue) return;
+    const resolved = (0, external_path_namespaceObject.resolve)(baseDir, htmlValue);
+    if (!isHtmlPath(resolved)) return;
+    return (0, external_fs_namespaceObject.existsSync)(resolved) ? resolved : void 0;
+}
+function resolveHtmlFlag(entryName, htmlValue, hasTemplate) {
+    if (false === htmlValue) return false;
+    if (true === htmlValue) return true;
+    if ("string" == typeof htmlValue) return hasTemplate;
+    return isHtmlEntryName(entryName);
+}
+function isHtmlEntryName(entryName) {
+    return HTML_ENTRY_SET.has(entryName);
+}
+function enrichEntryWithScriptInject(entry) {
+    if (!entry.htmlPath || !entry.scriptPath) return entry;
+    const scriptInject = getScriptInjectIfMatches(entry.htmlPath, entry.scriptPath);
+    return scriptInject ? {
+        ...entry,
+        scriptInject
+    } : entry;
+}
+function inferHtmlPathForReservedName(entryName, scriptPath) {
+    if (!HTML_ENTRY_SET.has(entryName)) return;
+    const dir = (0, external_path_namespaceObject.dirname)(scriptPath);
+    const htmlPath = (0, external_path_namespaceObject.resolve)(dir, "index.html");
+    return (0, external_fs_namespaceObject.existsSync)(htmlPath) ? htmlPath : void 0;
+}
+function resolveEntryFromObject(baseDir, name, value) {
+    const scriptPath = (0, external_path_namespaceObject.resolve)(baseDir, value.src);
+    if (!(0, external_fs_namespaceObject.existsSync)(scriptPath) || !isScriptPath(scriptPath)) return null;
+    const htmlPath = resolveHtmlPath(baseDir, "string" == typeof value.html ? value.html : void 0);
+    if ("string" == typeof value.html && !htmlPath) return null;
+    const inferredHtml = htmlPath ?? inferHtmlPathForReservedName(name, scriptPath);
+    const html = resolveHtmlFlag(name, value.html, Boolean(htmlPath));
+    return enrichEntryWithScriptInject({
+        name,
+        scriptPath,
+        htmlPath: inferredHtml,
+        html
+    });
+}
+function resolveEntryFromHtml(baseDir, name, pathStr) {
+    const htmlPath = (0, external_path_namespaceObject.resolve)(baseDir, pathStr);
+    const dir = (0, external_path_namespaceObject.dirname)(htmlPath);
+    let parsed;
+    try {
+        parsed = parseAddfoxEntryFromHtml(htmlPath);
+    } catch  {
+        parsed = void 0;
+    }
+    let scriptPath;
+    if (parsed) try {
+        scriptPath = resolveScriptFromHtmlStrict(htmlPath).scriptPath;
+    } catch (e) {
+        throw new common_namespaceObject.AddfoxError({
+            code: common_namespaceObject.ADDFOX_ERROR_CODES.ENTRY_SCRIPT_FROM_HTML,
+            message: "Invalid data-addfox-entry script in HTML",
+            details: `HTML: ${htmlPath}. ${e instanceof Error ? e.message : String(e)}`,
+            hint: "data-addfox-entry script must have a relative src and the file must exist"
+        });
+    }
+    else scriptPath = findScriptForHtmlDir(dir, (0, external_path_namespaceObject.basename)(htmlPath));
+    if (!scriptPath) return null;
+    return enrichEntryWithScriptInject({
+        name,
+        scriptPath,
+        htmlPath,
+        html: true,
+        outputFollowsScriptPath: Boolean(parsed)
+    });
+}
+function resolveEntryFromScript(baseDir, name, pathStr) {
+    const scriptPath = (0, external_path_namespaceObject.resolve)(baseDir, pathStr);
+    if (!(0, external_fs_namespaceObject.existsSync)(scriptPath)) return null;
+    const htmlPath = inferHtmlPathForReservedName(name, scriptPath);
+    const html = isHtmlEntryName(name);
+    return enrichEntryWithScriptInject({
+        name,
+        scriptPath,
+        htmlPath,
+        html
+    });
+}
+function resolveSingleEntry(baseDir, name, value) {
+    if (isEntryConfigObject(value)) return resolveEntryFromObject(baseDir, name, value);
+    const resolved = (0, external_path_namespaceObject.resolve)(baseDir, value);
+    if (!(0, external_fs_namespaceObject.existsSync)(resolved)) return null;
+    if (isHtmlPath(value)) return resolveEntryFromHtml(baseDir, name, value);
+    if (isScriptPath(value)) return resolveEntryFromScript(baseDir, name, value);
+    return null;
+}
+function resolveEntries(config, _root, baseDir, manifest, options) {
+    const browser = options?.browser ?? "chromium";
+    const defaultEntries = discoverEntries(baseDir, options?.entryDiscovererOptions);
+    const entryMap = new Map(defaultEntries.map((e)=>[
+            e.name,
+            e
+        ]));
+    let manifestReplacementMap;
+    const entryConfig = config.entry;
+    const hasExplicitEntryConfig = entryConfig && Object.keys(entryConfig).length > 0;
+    if (manifest && !hasExplicitEntryConfig) {
+        const manifestResult = extractEntriesFromManifest(manifest, browser);
+        manifestReplacementMap = manifestResult.replacementMap;
+        for (const [name, pathStr] of Object.entries(manifestResult.entries)){
+            const resolved = resolveSingleEntry(baseDir, name, pathStr);
+            if (resolved) entryMap.set(name, resolved);
+        }
+    }
+    if (hasExplicitEntryConfig) for (const [name, pathStr] of Object.entries(entryConfig)){
+        const resolved = resolveSingleEntry(baseDir, name, pathStr);
+        if (resolved) entryMap.set(name, resolved);
+        else entryMap.delete(name);
+    }
+    return {
+        entries: Array.from(entryMap.values()),
+        manifestReplacementMap
+    };
+}
+class ManifestLoader {
+    readManifestJson(filePath) {
+        if (!(0, external_fs_namespaceObject.existsSync)(filePath)) return null;
+        try {
+            const raw = (0, external_fs_namespaceObject.readFileSync)(filePath, "utf-8");
+            const data = JSON.parse(raw);
+            return "object" == typeof data && null !== data ? data : null;
+        } catch  {
+            return null;
+        }
+    }
+    isManifestPathConfig(m) {
+        if (!m || "object" != typeof m) return false;
+        const c = m;
+        return ("string" == typeof c.chromium || "string" == typeof c.firefox) && !("manifest_version" in c) && !("name" in c && "version" in c);
+    }
+    isChromiumFirefoxObject(m) {
+        return isChromiumFirefoxObjectValue(m);
+    }
+    deepMerge(base, override) {
+        const out = {
+            ...base
+        };
+        for (const key of Object.keys(override)){
+            const b = base[key];
+            const o = override[key];
+            if (null === o || "object" != typeof o || Array.isArray(o) || null === b || "object" != typeof b || Array.isArray(b)) out[key] = o;
+            else out[key] = this.deepMerge(b, o);
+        }
+        return out;
+    }
+    loadFromDir(dir) {
+        const basePath = (0, external_path_namespaceObject.resolve)(dir, MANIFEST_FILE_NAMES.base);
+        const chromPath = (0, external_path_namespaceObject.resolve)(dir, MANIFEST_FILE_NAMES.chromium);
+        const firefoxPath = (0, external_path_namespaceObject.resolve)(dir, MANIFEST_FILE_NAMES.firefox);
+        return {
+            base: this.readManifestJson(basePath),
+            chromium: this.readManifestJson(chromPath),
+            firefox: this.readManifestJson(firefoxPath)
+        };
+    }
+    hasAnyManifest(files) {
+        return null !== files.base || null !== files.chromium || null !== files.firefox;
+    }
+    buildConfigFromFiles(files) {
+        const base = files.base ?? files.chromium ?? files.firefox ?? null;
+        if (!base) return null;
+        const chromium = files.chromium ? this.deepMerge(base, files.chromium) : base;
+        const firefox = files.firefox ? this.deepMerge(base, files.firefox) : base;
+        return {
+            chromium,
+            firefox
+        };
+    }
+    resolve(input, root, appDir) {
+        if (null == input) {
+            const manifestSubdir = (0, external_path_namespaceObject.resolve)(appDir, MANIFEST_DIR);
+            const baseInApp = (0, external_path_namespaceObject.resolve)(appDir, MANIFEST_FILE_NAMES.base);
+            const baseInSub = (0, external_path_namespaceObject.resolve)(manifestSubdir, MANIFEST_FILE_NAMES.base);
+            const dir = (0, external_fs_namespaceObject.existsSync)(baseInApp) ? appDir : (0, external_fs_namespaceObject.existsSync)(baseInSub) ? manifestSubdir : null;
+            if (null !== dir) {
+                const files = this.loadFromDir(dir);
+                if (this.hasAnyManifest(files)) return validateAndReturn(this.buildConfigFromFiles(files));
+            }
+            return null;
+        }
+        if (this.isManifestPathConfig(input)) {
+            const result = {};
+            if (input.chromium) {
+                const obj = this.readManifestJson((0, external_path_namespaceObject.resolve)(appDir, input.chromium));
+                if (obj) result.chromium = obj;
+            }
+            if (input.firefox) {
+                const obj = this.readManifestJson((0, external_path_namespaceObject.resolve)(appDir, input.firefox));
+                if (obj) result.firefox = obj;
+            }
+            const chrom = result.chromium ?? result.firefox;
+            const ff = result.firefox ?? result.chromium;
+            if (!chrom && !ff) return null;
+            return validateAndReturn({
+                chromium: chrom ?? {},
+                firefox: ff ?? {}
+            });
+        }
+        this.isChromiumFirefoxObject(input);
+        return validateAndReturn(input);
+    }
+}
+const defaultLoader = new ManifestLoader();
+function resolveManifestInput(input, root, appDir) {
+    return defaultLoader.resolve(input, root, appDir);
+}
+function validateAndReturn(config) {
+    if (!config) return null;
+    validateManifestSchema(config);
+    return config;
+}
+function validateManifestSchema(config) {
+    if (isChromiumFirefoxObjectValue(config)) {
+        if (config.chromium) validateManifestRecord(config.chromium, "chromium");
+        if (config.firefox) validateManifestRecord(config.firefox, "firefox");
+        return;
+    }
+    validateManifestRecord(config);
+}
+function isChromiumFirefoxObjectValue(m) {
+    return "object" == typeof m && null !== m && ("chromium" in m || "firefox" in m);
+}
+function validateManifestRecord(manifest, target) {
+    const mv = getManifestVersion(manifest);
+    if (null == mv) throw new Error("manifest_version must be 2 or 3");
+    const errors = 2 === mv ? validateMv2(manifest) : validateMv3(manifest, target);
+    if (errors.length > 0) throw new Error(errors.join("; "));
+}
+function getManifestVersion(manifest) {
+    const mv = manifest.manifest_version;
+    if (2 === mv || 3 === mv) return mv;
+    return null;
+}
+function validateMv2(manifest) {
+    const errors = [];
+    if (null != manifest.action) errors.push('MV2 does not support "action"; use "browser_action" or "page_action"');
+    if (null != manifest.host_permissions) errors.push('MV2 does not support "host_permissions"; use "permissions"');
+    errors.push(...validateBackgroundMv2(manifest.background));
+    errors.push(...validatePermissionsList(manifest.permissions, "permissions"));
+    return errors;
+}
+function validateMv3(manifest, target) {
+    const errors = [];
+    if (null != manifest.browser_action || null != manifest.page_action) errors.push('MV3 does not support "browser_action" or "page_action"; use "action"');
+    const bgErrors = "firefox" === target ? validateBackgroundMv3Firefox(manifest.background) : validateBackgroundMv3Chrome(manifest.background);
+    errors.push(...bgErrors);
+    errors.push(...validatePermissionsList(manifest.permissions, "permissions"));
+    errors.push(...validatePermissionsList(manifest.host_permissions, "host_permissions"));
+    errors.push(...validateAction(manifest.action));
+    return errors;
+}
+function validateBackgroundMv2(background) {
+    const errors = [];
+    if (!background) return errors;
+    if ("object" != typeof background) {
+        errors.push('MV2 "background" must be an object');
+        return errors;
+    }
+    const bg = background;
+    if (null != bg.service_worker) errors.push('MV2 "background.service_worker" is not allowed');
+    if (null != bg.scripts && !isStringArray(bg.scripts)) errors.push('MV2 "background.scripts" must be string[]');
+    if (null != bg.page && "string" != typeof bg.page) errors.push('MV2 "background.page" must be a string');
+    return errors;
+}
+function validateBackgroundMv3Chrome(background) {
+    const errors = [];
+    if (!background) return errors;
+    if ("object" != typeof background) {
+        errors.push('MV3 (Chrome) "background" must be an object');
+        return errors;
+    }
+    const bg = background;
+    if (null != bg.scripts) errors.push('MV3 (Chrome) "background.scripts" is not allowed; use "service_worker"');
+    if (null != bg.page) errors.push('MV3 (Chrome) "background.page" is not allowed; use "service_worker"');
+    if (null != bg.service_worker && "string" != typeof bg.service_worker) errors.push('MV3 (Chrome) "background.service_worker" must be a string');
+    return errors;
+}
+function validateBackgroundMv3Firefox(background) {
+    const errors = [];
+    if (!background) return errors;
+    if ("object" != typeof background) {
+        errors.push('MV3 (Firefox) "background" must be an object');
+        return errors;
+    }
+    const bg = background;
+    const hasScripts = null != bg.scripts;
+    const hasPage = null != bg.page;
+    const hasServiceWorker = null != bg.service_worker;
+    if (!hasScripts && !hasPage && !hasServiceWorker) return errors;
+    if (hasScripts && !isStringArray(bg.scripts)) errors.push('MV3 (Firefox) "background.scripts" must be string[]');
+    if (hasPage && "string" != typeof bg.page) errors.push('MV3 (Firefox) "background.page" must be a string');
+    if (hasServiceWorker && "string" != typeof bg.service_worker) errors.push('MV3 (Firefox) "background.service_worker" must be a string when present');
+    if (hasPage && hasScripts) errors.push('MV3 (Firefox) "background" cannot have both "page" and "scripts"');
+    return errors;
+}
+function validateAction(action) {
+    if (null == action) return [];
+    if ("object" != typeof action) return [
+        '"action" must be an object'
+    ];
+    const act = action;
+    if (null != act.default_popup && "string" != typeof act.default_popup) return [
+        '"action.default_popup" must be a string'
+    ];
+    return [];
+}
+function validatePermissionsList(value, key) {
+    if (null == value) return [];
+    return isStringArray(value) ? [] : [
+        `"${key}" must be string[]`
+    ];
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item)=>"string" == typeof item);
+}
+const loader_require = (0, external_module_namespaceObject.createRequire)(__filename);
+function loadWithJiti(root, configPath) {
+    const isConfigRestart = "1" === process.env.ADDFOX_CONFIG_RESTART;
+    const jitiOptions = {
+        esmResolve: true
+    };
+    if (isConfigRestart) {
+        jitiOptions.moduleCache = false;
+        jitiOptions.requireCache = false;
+    }
+    const jitiFn = loader_require("jiti")(root, jitiOptions);
+    return jitiFn(configPath);
+}
+function loadNativeJs(configPath) {
+    const mod = loader_require(configPath);
+    return mod?.default ?? mod;
+}
+function unwrapConfig(mod) {
+    if (null == mod) return {};
+    if ("object" == typeof mod && "default" in mod && void 0 !== mod.default) return mod.default ?? {};
+    return mod ?? {};
+}
+function loadConfigModule(root, configPath, file) {
+    const isNativeJs = file.endsWith(".js") || file.endsWith(".mjs");
+    if (isNativeJs) try {
+        return unwrapConfig(loadNativeJs(configPath));
+    } catch  {}
+    return unwrapConfig(loadWithJiti(root, configPath));
+}
+function findConfigFile(root, configFiles) {
+    for (const file of configFiles){
+        const p = (0, external_path_namespaceObject.resolve)(root, file);
+        if ((0, external_fs_namespaceObject.existsSync)(p)) return p;
+    }
+    return null;
+}
+function loadConfigAtPath(root, configPath, file) {
+    try {
+        return loadConfigModule(root, configPath, file);
+    } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        throw new common_namespaceObject.AddfoxError({
+            code: common_namespaceObject.ADDFOX_ERROR_CODES.CONFIG_LOAD_FAILED,
+            message: "Failed to load config file",
+            details: `File: ${configPath}, error: ${message}`,
+            hint: "Check addfox.config syntax and dependencies",
+            cause: e instanceof Error ? e : void 0
+        });
+    }
+}
+function loadConfigFile(root, configFiles = CONFIG_FILES) {
+    for (const file of configFiles){
+        const p = (0, external_path_namespaceObject.resolve)(root, file);
+        if ((0, external_fs_namespaceObject.existsSync)(p)) return loadConfigAtPath(root, p, file);
+    }
+    return null;
+}
+function getResolvedConfigFilePath(root, configFiles = CONFIG_FILES) {
+    return findConfigFile(root, configFiles);
+}
+function resolveAppDir(root, userConfig) {
+    return (0, external_path_namespaceObject.resolve)(root, userConfig.appDir ?? "app");
+}
+function validateAppDir(appDir, entryDisabled) {
+    if (entryDisabled) return;
+    if (!(0, external_fs_namespaceObject.existsSync)(appDir) || !(0, external_fs_namespaceObject.statSync)(appDir).isDirectory()) throw new common_namespaceObject.AddfoxError({
+        code: common_namespaceObject.ADDFOX_ERROR_CODES.APP_DIR_MISSING,
+        message: "App directory not found",
+        details: `Missing appDir: ${appDir}`,
+        hint: "Create the directory or set appDir to an existing folder (default is app/)"
+    });
+}
+function createResolvedConfig(userConfig, root, appDir, manifest) {
+    return {
+        ...userConfig,
+        manifest,
+        appDir,
+        outDir: userConfig.outDir ?? DEFAULT_OUT_DIR,
+        envPrefix: userConfig.envPrefix ?? [
+            ...DEFAULT_ENV_PREFIXES
+        ],
+        outputRoot: ADDFOX_OUTPUT_ROOT,
+        root
+    };
+}
+function discoverAndResolveEntries(userConfig, root, appDir, manifest, entryDiscovererOptions, entryResolverOptions) {
+    const baseEntries = discoverEntries(appDir, entryDiscovererOptions);
+    const result = resolveEntries(userConfig, root, appDir, manifest ?? void 0, entryResolverOptions);
+    return {
+        baseEntries,
+        entries: result.entries
+    };
+}
+function resolveAddfoxConfig(root, options = {}) {
+    const t0 = performance.now();
+    const userConfig = loadConfigFile(root, options.configFiles);
+    if (!userConfig) throw new common_namespaceObject.AddfoxError({
+        code: common_namespaceObject.ADDFOX_ERROR_CODES.CONFIG_NOT_FOUND,
+        message: "Addfox config file not found",
+        details: `No addfox.config.ts, addfox.config.js or addfox.config.mjs found under ${root}`,
+        hint: "Run the command from project root or create addfox.config.ts / addfox.config.js"
+    });
+    const appDir = resolveAppDir(root, userConfig);
+    const entryDisabled = false === userConfig.entry;
+    validateAppDir(appDir, entryDisabled);
+    const manifest = resolveManifestInput(userConfig.manifest, root, appDir);
+    if (!manifest) throw new common_namespaceObject.AddfoxError({
+        code: common_namespaceObject.ADDFOX_ERROR_CODES.MANIFEST_MISSING,
+        message: "Manifest config or file not found",
+        details: "Configure manifest in addfox.config, or place manifest.json / manifest.chromium.json / manifest.firefox.json under appDir or appDir/manifest",
+        hint: "Option 1: manifest: { name, version, ... } in addfox.config; Option 2: manifest.json under appDir or appDir/manifest; Option 3: manifest: { chromium: 'path/to/manifest.json' } (path relative to appDir)"
+    });
+    const config = createResolvedConfig(userConfig, root, appDir, manifest);
+    const manifestForEntry = "object" == typeof manifest && null !== manifest ? manifest.chromium ?? manifest.firefox ?? manifest : null;
+    const { baseEntries, entries } = entryDisabled ? {
+        baseEntries: [],
+        entries: []
+    } : discoverAndResolveEntries(userConfig, root, appDir, manifestForEntry, options.entryDiscovererOptions, options.entryResolverOptions);
+    if (!entryDisabled && 0 === entries.length) throw new common_namespaceObject.AddfoxError({
+        code: common_namespaceObject.ADDFOX_ERROR_CODES.NO_ENTRIES,
+        message: "No entries discovered",
+        details: `No background, content, popup, options or sidepanel entry found under ${appDir}`,
+        hint: "At least one such directory with index.ts / index.js etc. is required"
+    });
+    (0, common_namespaceObject.logDoneTimed)("Parse config", Math.round(performance.now() - t0));
+    (0, common_namespaceObject.logEntriesTable)(entries, {
+        root
+    });
+    return {
+        config,
+        baseEntries,
+        entries
+    };
+}
+function clearConfigCache(configFilePath) {
+    try {
+        delete loader_require.cache[configFilePath];
+    } catch  {}
+    for (const key of Object.keys(loader_require.cache)){
+        const mod = loader_require.cache[key];
+        if (mod?.filename === configFilePath) try {
+            delete loader_require.cache[key];
+        } catch  {}
+    }
+}
+function getResolvedRstestConfigFilePath(root) {
+    for (const file of RSTEST_CONFIG_FILES){
+        const p = (0, external_path_namespaceObject.resolve)(root, file);
+        if ((0, external_fs_namespaceObject.existsSync)(p)) return p;
+    }
+    return null;
+}
+class Pipeline {
+    hooks;
+    constructor(hooks){
+        this.hooks = hooks;
+    }
+    async execute(root, argv) {
+        let context = {
+            root,
+            argv
+        };
+        try {
+            await this.runStage('init', context);
+            await this.runStage('options', context);
+            await this.runStage('parse', context);
+            await this.runStage('load', context);
+            await this.runStage('resolve', context);
+            await this.runStage('prepare', context);
+            await this.runStage('build', context);
+        } catch (error) {
+            await this.runStage('complete', context);
+            throw error;
+        }
+        await this.runStage('complete', context);
+        return context;
+    }
+    async runStage(stage, payload) {
+        await this.hooks.execute(stage, 'before', payload);
+        await this.hooks.execute(stage, 'after', payload);
+    }
+}
+const ADDFOX_PLACEHOLDER_REGEX = /\[addfox\.([a-z]+)\]/g;
+const CONTENT_PLACEHOLDER = "[addfox.content]";
+const CONTENT_PLACEHOLDER_LEGACY = "[addfox.content]";
+const SCRIPT_KEYS_SET = new Set(SCRIPT_ONLY_ENTRY_NAMES);
+function builder_isSourceFilePath(path) {
+    const lower = path.trim().toLowerCase();
+    return /\.(ts|tsx|js|jsx)$/.test(lower);
+}
+function isChromiumFirefoxManifest(m) {
+    return "object" == typeof m && null !== m && ("chromium" in m || "firefox" in m);
+}
+function isEntryFieldEmpty(value) {
+    if (null == value) return true;
+    if ("string" == typeof value) return "" === value.trim();
+    if (Array.isArray(value)) return 0 === value.length;
+    return false;
+}
+function hasNonEmptyStringArray(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+function isManifestRecord(value) {
+    return null !== value && "object" == typeof value && !Array.isArray(value);
+}
+function getManifestRecordForTarget(config, target) {
+    return pickManifestForTarget(config, target).manifest;
+}
+function pickManifestForTarget(config, target) {
+    if (!isChromiumFirefoxManifest(config)) return {
+        manifest: config
+    };
+    const hasChromium = null != config.chromium && "object" == typeof config.chromium;
+    const hasFirefox = null != config.firefox && "object" == typeof config.firefox;
+    if (hasChromium && hasFirefox) {
+        const match = config[target];
+        if (null != match && "object" == typeof match) return {
+            manifest: match
+        };
+        const fallback = "firefox" === target ? config.chromium : config.firefox;
+        return {
+            manifest: fallback,
+            warnMessage: `Build target is ${target} but manifest.${target} is missing; using ${"firefox" === target ? "chromium" : "firefox"} manifest.`
+        };
+    }
+    if (hasChromium) return {
+        manifest: config.chromium,
+        warnMessage: "firefox" === target ? "Build target is firefox but manifest only has chromium; using chromium manifest." : void 0
+    };
+    if (hasFirefox) return {
+        manifest: config.firefox,
+        warnMessage: "chromium" === target ? "Build target is chromium but manifest only has firefox; using firefox manifest." : void 0
+    };
+    return {
+        manifest: config.chromium ?? config.firefox ?? {},
+        warnMessage: "Manifest has no chromium or firefox object; using fallback."
+    };
+}
+function buildScriptOutputPath(entry) {
+    const scriptStem = (0, external_path_namespaceObject.basename)(entry.scriptPath, (0, external_path_namespaceObject.extname)(entry.scriptPath));
+    return scriptStem === entry.name ? `${entry.name}.js` : `${entry.name}/index.js`;
+}
+function buildHtmlOutputPath(entry, fallback) {
+    if (!entry.htmlPath) return fallback;
+    const htmlFile = (0, external_path_namespaceObject.basename)(entry.htmlPath).toLowerCase();
+    return htmlFile === `${entry.name}.html` ? `${entry.name}.html` : fallback;
+}
+function buildPlaceholderMap(entries) {
+    const map = {};
+    for (const key of MANIFEST_ENTRY_KEYS){
+        const entry = entries.find((e)=>e.name === key);
+        if (entry) map[key] = SCRIPT_KEYS_SET.has(key) ? buildScriptOutputPath(entry) : buildHtmlOutputPath(entry, MANIFEST_ENTRY_PATHS[key]);
+    }
+    return map;
+}
+function buildSourceToOutputMap(entries) {
+    const map = new Map();
+    const placeholderMap = buildPlaceholderMap(entries);
+    for (const key of MANIFEST_ENTRY_KEYS){
+        const entry = entries.find((e)=>e.name === key);
+        if (!entry) continue;
+        const sourcePath = entry.scriptPath;
+        const outputPath = placeholderMap[key];
+        if (sourcePath && outputPath) {
+            map.set(sourcePath, outputPath);
+            const basename = sourcePath.split(/[\\/]/).pop();
+            if (basename) {
+                map.set(basename, outputPath);
+                map.set(`./${basename}`, outputPath);
+            }
+            const entryDir = key;
+            const entryIndexPath = `${entryDir}/${basename}`;
+            map.set(entryIndexPath, outputPath);
+            map.set(`./${entryIndexPath}`, outputPath);
+        }
+    }
+    return map;
+}
+function shouldUseServiceWorker(mv, browser) {
+    return 3 === mv && "chromium" === browser;
+}
+function isChromiumOnlyAutofillKey(key) {
+    return "sidepanel" === key || "newtab" === key || "bookmarks" === key || "history" === key;
+}
+const fillers = {
+    background: (mv, browser)=>(out, path)=>{
+            const bg = out.background ?? {};
+            if (shouldUseServiceWorker(mv, browser)) {
+                if (isEntryFieldEmpty(bg.service_worker)) out.background = {
+                    ...bg,
+                    service_worker: path
+                };
+            } else {
+                const scripts = bg.scripts;
+                if (!Array.isArray(scripts) || 0 === scripts.length) out.background = {
+                    ...bg,
+                    scripts: [
+                        path
+                    ]
+                };
+            }
+        },
+    popup: (mv)=>(out, path)=>{
+            if (3 === mv) {
+                const action = out.action ?? {};
+                if (isEntryFieldEmpty(action.default_popup)) out.action = {
+                    ...action,
+                    default_popup: path
+                };
+            } else {
+                const ba = out.browser_action ?? {};
+                if (isEntryFieldEmpty(ba.default_popup)) out.browser_action = {
+                    ...ba,
+                    default_popup: path
+                };
+            }
+        },
+    options: (mv)=>(out, path)=>{
+            if (3 === mv) {
+                const opt = out.options_ui ?? {};
+                if (isEntryFieldEmpty(opt.page)) out.options_ui = {
+                    ...opt,
+                    page: path
+                };
+            } else if (isEntryFieldEmpty(out.options_page)) out.options_page = path;
+        },
+    devtools: ()=>(out, path)=>{
+            if (isEntryFieldEmpty(out.devtools_page)) out.devtools_page = path;
+        },
+    sandbox: ()=>(out, path)=>{
+            const sandbox = out.sandbox;
+            if (null === sandbox || "object" != typeof sandbox || Array.isArray(sandbox)) {
+                out.sandbox = {
+                    pages: [
+                        path
+                    ]
+                };
+                return;
+            }
+            const pages = sandbox.pages;
+            if (!Array.isArray(pages) || 0 === pages.length) out.sandbox = {
+                ...sandbox,
+                pages: [
+                    path
+                ]
+            };
+        },
+    content: ()=>(out, path)=>{
+            const cs = out.content_scripts;
+            if (!Array.isArray(cs) || 0 === cs.length) out.content_scripts = [
+                {
+                    matches: [
+                        "<all_urls>"
+                    ],
+                    js: [
+                        path
+                    ],
+                    run_at: "document_idle"
+                }
+            ];
+        },
+    newtab: ()=>(out, path)=>{
+            const overrides = out.chrome_url_overrides ?? {};
+            if (isEntryFieldEmpty(overrides.newtab)) out.chrome_url_overrides = {
+                ...overrides,
+                newtab: path
+            };
+        },
+    bookmarks: ()=>(out, path)=>{
+            const overrides = out.chrome_url_overrides ?? {};
+            if (isEntryFieldEmpty(overrides.bookmarks)) out.chrome_url_overrides = {
+                ...overrides,
+                bookmarks: path
+            };
+            ensurePermission(out, "bookmarks");
+        },
+    history: ()=>(out, path)=>{
+            const overrides = out.chrome_url_overrides ?? {};
+            if (isEntryFieldEmpty(overrides.history)) out.chrome_url_overrides = {
+                ...overrides,
+                history: path
+            };
+            ensurePermission(out, "history");
+        },
+    sidepanel: ()=>(out, path)=>{
+            const sp = out.side_panel ?? {};
+            if (isEntryFieldEmpty(sp.default_path)) out.side_panel = {
+                ...sp,
+                default_path: path
+            };
+        }
+};
+function ensurePermission(out, permission) {
+    const current = out.permissions;
+    if (!Array.isArray(current)) {
+        out.permissions = [
+            permission
+        ];
+        return;
+    }
+    if (!current.includes(permission)) out.permissions = [
+        ...current,
+        permission
+    ];
+}
+function buildAutoFillers(mv, browser) {
+    const result = {};
+    for (const [key, factory] of Object.entries(fillers))if ("sidepanel" !== key || 3 === mv) {
+        if (!("firefox" === browser && isChromiumOnlyAutofillKey(key))) result[key] = factory(mv, browser);
+    }
+    return result;
+}
+function needsSidePanelPermission(out, placeholderMap, browser) {
+    if ("chromium" !== browser) return false;
+    if (null != placeholderMap.sidepanel) return true;
+    const sp = out.side_panel;
+    if (null == sp || "object" != typeof sp || Array.isArray(sp)) return false;
+    const path = sp.default_path;
+    return "string" == typeof path && "" !== path.trim();
+}
+function autoFillEntryFields(manifest, placeholderMap, browser) {
+    const mv = 2 === manifest.manifest_version ? 2 : 3;
+    const out = {
+        ...manifest
+    };
+    const autoFillers = buildAutoFillers(mv, browser);
+    for (const [key, path] of Object.entries(placeholderMap))autoFillers[key]?.(out, path);
+    if (3 === mv && needsSidePanelPermission(out, placeholderMap, browser)) ensurePermission(out, "sidePanel");
+    return out;
+}
+function replacePlaceholderInString(str, placeholderMap) {
+    return str.replace(ADDFOX_PLACEHOLDER_REGEX, (_, key)=>key in placeholderMap ? placeholderMap[key] : `[addfox.${key}]`);
+}
+function replacePlaceholdersInValue(value, placeholderMap) {
+    if ("string" == typeof value) return replacePlaceholderInString(value, placeholderMap);
+    if (Array.isArray(value)) return value.map((item)=>replacePlaceholdersInValue(item, placeholderMap));
+    if (null !== value && "object" == typeof value) {
+        const out = {};
+        for (const [k, v] of Object.entries(value))out[k] = replacePlaceholdersInValue(v, placeholderMap);
+        return out;
+    }
+    return value;
+}
+function replaceSourcePathsWithOutput(value, sourceToOutputMap) {
+    if ("string" == typeof value) {
+        if (builder_isSourceFilePath(value)) {
+            const outputPath = sourceToOutputMap.get(value);
+            if (outputPath) return outputPath;
+            const basename = value.split(/[\\/]/).pop();
+            if (basename) {
+                const fromBasename = sourceToOutputMap.get(basename);
+                if (fromBasename) return fromBasename;
+                const fromDotSlash = sourceToOutputMap.get(`./${basename}`);
+                if (fromDotSlash) return fromDotSlash;
+            }
+        }
+        return value;
+    }
+    if (Array.isArray(value)) return value.map((item)=>replaceSourcePathsWithOutput(item, sourceToOutputMap));
+    if (null !== value && "object" == typeof value) {
+        const out = {};
+        for (const [k, v] of Object.entries(value))out[k] = replaceSourcePathsWithOutput(v, sourceToOutputMap);
+        return out;
+    }
+    return value;
+}
+function resolveContentScriptsPlaceholders(manifest, placeholderMap, contentScriptOutput) {
+    const contentScripts = manifest.content_scripts;
+    if (!Array.isArray(contentScripts)) return manifest;
+    const defaultContentJs = placeholderMap.content ? [
+        placeholderMap.content
+    ] : [];
+    const shouldAutoFillCss = contentScriptOutput?.autoFillCssInManifest !== false;
+    const resolved = contentScripts.map((item)=>{
+        if (null === item || "object" != typeof item || Array.isArray(item)) return item;
+        const obj = item;
+        const out = {
+            ...obj
+        };
+        if (Array.isArray(obj.js)) {
+            const jsReplacement = contentScriptOutput?.js ?? defaultContentJs;
+            out.js = obj.js.flatMap((el)=>el === CONTENT_PLACEHOLDER || el === CONTENT_PLACEHOLDER_LEGACY ? jsReplacement : [
+                    el
+                ]);
+        }
+        if (Array.isArray(obj.css)) {
+            const cssReplacement = contentScriptOutput?.css ?? [];
+            const resolvedCss = obj.css.flatMap((el)=>el === CONTENT_PLACEHOLDER || el === CONTENT_PLACEHOLDER_LEGACY ? cssReplacement : [
+                    el
+                ]);
+            if (resolvedCss.length > 0) out.css = resolvedCss;
+            else delete out.css;
+        }
+        const hadJs = hasNonEmptyStringArray(out.js);
+        const hadCss = hasNonEmptyStringArray(out.css);
+        if (!hadJs && !hadCss && placeholderMap.content) out.js = contentScriptOutput?.js ?? defaultContentJs;
+        const hasJs = hasNonEmptyStringArray(out.js);
+        const isContentItem = hasJs && null != placeholderMap.content && out.js.includes(placeholderMap.content);
+        if (shouldAutoFillCss && isContentItem && contentScriptOutput?.css?.length && !hasNonEmptyStringArray(out.css)) out.css = contentScriptOutput.css;
+        return out;
+    });
+    return {
+        ...manifest,
+        content_scripts: resolved
+    };
+}
+function replaceContentScriptSourcePaths(manifest, sourceToOutputMap) {
+    const contentScripts = manifest.content_scripts;
+    if (!Array.isArray(contentScripts)) return manifest;
+    const resolved = contentScripts.map((item)=>{
+        if (null === item || "object" != typeof item || Array.isArray(item)) return item;
+        const obj = item;
+        const out = {
+            ...obj
+        };
+        if (Array.isArray(obj.js)) out.js = obj.js.map((path)=>{
+            if ("string" == typeof path && builder_isSourceFilePath(path)) {
+                const outputPath = sourceToOutputMap.get(path);
+                if (outputPath) return outputPath;
+                const basename = path.split(/[\\/]/).pop();
+                if (basename) {
+                    const fromBasename = sourceToOutputMap.get(basename);
+                    if (fromBasename) return fromBasename;
+                }
+            }
+            return path;
+        });
+        return out;
+    });
+    return {
+        ...manifest,
+        content_scripts: resolved
+    };
+}
+function buildManifest(manifest, entries, browser, contentScriptOutput) {
+    const placeholderMap = buildPlaceholderMap(entries);
+    const sourceToOutputMap = buildSourceToOutputMap(entries);
+    const pipeline = [
+        (m)=>autoFillEntryFields(m, placeholderMap, browser),
+        (m)=>resolveContentScriptsPlaceholders(m, placeholderMap, contentScriptOutput),
+        (m)=>replaceSourcePathsWithOutput(m, sourceToOutputMap),
+        (m)=>replaceContentScriptSourcePaths(m, sourceToOutputMap),
+        (m)=>replacePlaceholdersInValue(m, placeholderMap)
+    ];
+    const result = pipeline.reduce((acc, fn)=>fn(acc), {
+        ...manifest
+    });
+    return isManifestRecord(result) ? result : manifest;
+}
+function buildForBrowser(config, entries, browser, onWarn, contentScriptOutput) {
+    const { manifest, warnMessage } = pickManifestForTarget(config, browser);
+    if (warnMessage) onWarn?.(warnMessage);
+    return buildManifest(manifest, entries, browser, contentScriptOutput);
+}
+function resolveManifestChromium(config, entries) {
+    return buildForBrowser(config, entries, "chromium");
+}
+function resolveManifestFirefox(config, entries) {
+    return buildForBrowser(config, entries, "firefox");
+}
+function resolveManifestForTarget(config, entries, target, onWarn, contentScriptOutput) {
+    return buildForBrowser(config, entries, target, onWarn, contentScriptOutput);
+}
+function toReloadManagerEntries(entries, root) {
+    return entries.filter((e)=>RELOAD_MANAGER_ENTRY_NAMES.has(e.name)).map((e)=>({
+            name: e.name,
+            path: (0, external_path_namespaceObject.resolve)(root, e.scriptPath)
+        }));
+}
+const external_node_module_namespaceObject = require("node:module");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_url_namespaceObject = require("node:url");
+const version_require = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+function findPackageJson() {
+    const __dirname = (0, external_node_path_namespaceObject.dirname)((0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__));
+    const distPath = (0, external_node_path_namespaceObject.resolve)(__dirname, "../../package.json");
+    if ((0, external_node_fs_namespaceObject.existsSync)(distPath)) return version_require(distPath);
+    const srcPath = (0, external_node_path_namespaceObject.resolve)(__dirname, "../package.json");
+    if ((0, external_node_fs_namespaceObject.existsSync)(srcPath)) return version_require(srcPath);
+    return {};
+}
+const version_pkg = findPackageJson();
+function getAddfoxVersion() {
+    return version_pkg?.version ?? "0.0.0";
+}
+const FRAMEWORK_KEYS = [
+    {
+        pkg: "solid-js",
+        name: "Solid"
+    },
+    {
+        pkg: "svelte",
+        name: "Svelte"
+    },
+    {
+        pkg: "vue",
+        name: "Vue"
+    },
+    {
+        pkg: "preact",
+        name: "Preact"
+    },
+    {
+        pkg: "react",
+        name: "React"
+    }
+];
+function readPackageJson(root) {
+    const path = (0, external_node_path_namespaceObject.join)(root, "package.json");
+    if (!(0, external_node_fs_namespaceObject.existsSync)(path)) return null;
+    try {
+        const raw = (0, external_node_fs_namespaceObject.readFileSync)(path, "utf-8");
+        return JSON.parse(raw);
+    } catch  {
+        return null;
+    }
+}
+function hasDep(pkg, key) {
+    const deps = pkg.dependencies;
+    const devDeps = pkg.devDependencies;
+    if (deps && "string" == typeof deps[key]) return true;
+    if (devDeps && "string" == typeof devDeps[key]) return true;
+    return false;
+}
+function detectFrontendFramework(root) {
+    if (!root || "string" != typeof root) return "Vanilla";
+    const pkg = readPackageJson(root);
+    if (!pkg) return "Vanilla";
+    for (const { pkg: key, name } of FRAMEWORK_KEYS)if (hasDep(pkg, key)) return name;
+    return "Vanilla";
+}
+exports.ADDFOX_OUTPUT_ROOT = __webpack_exports__.ADDFOX_OUTPUT_ROOT;
+exports.BROWSER_OUTPUT_PREFIX = __webpack_exports__.BROWSER_OUTPUT_PREFIX;
+exports.CLI_COMMANDS = __webpack_exports__.CLI_COMMANDS;
+exports.CONFIG_FILES = __webpack_exports__.CONFIG_FILES;
+exports.DEFAULT_APP_DIR = __webpack_exports__.DEFAULT_APP_DIR;
+exports.DEFAULT_BROWSER = __webpack_exports__.DEFAULT_BROWSER;
+exports.DEFAULT_ENV_PREFIXES = __webpack_exports__.DEFAULT_ENV_PREFIXES;
+exports.DEFAULT_OUT_DIR = __webpack_exports__.DEFAULT_OUT_DIR;
+exports.HMR_WS_PORT = __webpack_exports__.HMR_WS_PORT;
+exports.HTML_ENTRY_NAMES = __webpack_exports__.HTML_ENTRY_NAMES;
+exports.MANIFEST_DIR = __webpack_exports__.MANIFEST_DIR;
+exports.MANIFEST_ENTRY_KEYS = __webpack_exports__.MANIFEST_ENTRY_KEYS;
+exports.MANIFEST_ENTRY_PATHS = __webpack_exports__.MANIFEST_ENTRY_PATHS;
+exports.MANIFEST_FILE_NAMES = __webpack_exports__.MANIFEST_FILE_NAMES;
+exports.ManifestLoader = __webpack_exports__.ManifestLoader;
+exports.Pipeline = __webpack_exports__.Pipeline;
+exports.RELOAD_MANAGER_ENTRY_NAMES = __webpack_exports__.RELOAD_MANAGER_ENTRY_NAMES;
+exports.RESERVED_ENTRY_NAMES = __webpack_exports__.RESERVED_ENTRY_NAMES;
+exports.RSTEST_CONFIG_FILES = __webpack_exports__.RSTEST_CONFIG_FILES;
+exports.SCRIPT_EXTS = __webpack_exports__.SCRIPT_EXTS;
+exports.SCRIPT_ONLY_ENTRY_NAMES = __webpack_exports__.SCRIPT_ONLY_ENTRY_NAMES;
+exports.SUPPORTED_BROWSERS = __webpack_exports__.SUPPORTED_BROWSERS;
+exports.SUPPORTED_LAUNCH_TARGETS = __webpack_exports__.SUPPORTED_LAUNCH_TARGETS;
+exports.buildForBrowser = __webpack_exports__.buildForBrowser;
+exports.clearConfigCache = __webpack_exports__.clearConfigCache;
+exports.defineConfig = __webpack_exports__.defineConfig;
+exports.detectFrontendFramework = __webpack_exports__.detectFrontendFramework;
+exports.discoverEntries = __webpack_exports__.discoverEntries;
+exports.extractEntriesFromManifest = __webpack_exports__.extractEntriesFromManifest;
+exports.getAddfoxVersion = __webpack_exports__.getAddfoxVersion;
+exports.getAllEntryNames = __webpack_exports__.getAllEntryNames;
+exports.getBrowserOutputDir = __webpack_exports__.getBrowserOutputDir;
+exports.getHtmlEntryNames = __webpack_exports__.getHtmlEntryNames;
+exports.getManifestRecordForTarget = __webpack_exports__.getManifestRecordForTarget;
+exports.getResolvedConfigFilePath = __webpack_exports__.getResolvedConfigFilePath;
+exports.getResolvedRstestConfigFilePath = __webpack_exports__.getResolvedRstestConfigFilePath;
+exports.getScriptInjectIfMatches = __webpack_exports__.getScriptInjectIfMatches;
+exports.getScriptOnlyEntryNames = __webpack_exports__.getScriptOnlyEntryNames;
+exports.isScriptSrcRelative = __webpack_exports__.isScriptSrcRelative;
+exports.loadConfigFile = __webpack_exports__.loadConfigFile;
+exports.parseAddfoxEntryFromHtml = __webpack_exports__.parseAddfoxEntryFromHtml;
+exports.resolveAddfoxConfig = __webpack_exports__.resolveAddfoxConfig;
+exports.resolveEntries = __webpack_exports__.resolveEntries;
+exports.resolveManifestChromium = __webpack_exports__.resolveManifestChromium;
+exports.resolveManifestFirefox = __webpack_exports__.resolveManifestFirefox;
+exports.resolveManifestForTarget = __webpack_exports__.resolveManifestForTarget;
+exports.resolveManifestInput = __webpack_exports__.resolveManifestInput;
+exports.resolveScriptFromHtmlStrict = __webpack_exports__.resolveScriptFromHtmlStrict;
+exports.toReloadManagerEntries = __webpack_exports__.toReloadManagerEntries;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ADDFOX_OUTPUT_ROOT",
+    "BROWSER_OUTPUT_PREFIX",
+    "CLI_COMMANDS",
+    "CONFIG_FILES",
+    "DEFAULT_APP_DIR",
+    "DEFAULT_BROWSER",
+    "DEFAULT_ENV_PREFIXES",
+    "DEFAULT_OUT_DIR",
+    "HMR_WS_PORT",
+    "HTML_ENTRY_NAMES",
+    "MANIFEST_DIR",
+    "MANIFEST_ENTRY_KEYS",
+    "MANIFEST_ENTRY_PATHS",
+    "MANIFEST_FILE_NAMES",
+    "ManifestLoader",
+    "Pipeline",
+    "RELOAD_MANAGER_ENTRY_NAMES",
+    "RESERVED_ENTRY_NAMES",
+    "RSTEST_CONFIG_FILES",
+    "SCRIPT_EXTS",
+    "SCRIPT_ONLY_ENTRY_NAMES",
+    "SUPPORTED_BROWSERS",
+    "SUPPORTED_LAUNCH_TARGETS",
+    "buildForBrowser",
+    "clearConfigCache",
+    "defineConfig",
+    "detectFrontendFramework",
+    "discoverEntries",
+    "extractEntriesFromManifest",
+    "getAddfoxVersion",
+    "getAllEntryNames",
+    "getBrowserOutputDir",
+    "getHtmlEntryNames",
+    "getManifestRecordForTarget",
+    "getResolvedConfigFilePath",
+    "getResolvedRstestConfigFilePath",
+    "getScriptInjectIfMatches",
+    "getScriptOnlyEntryNames",
+    "isScriptSrcRelative",
+    "loadConfigFile",
+    "parseAddfoxEntryFromHtml",
+    "resolveAddfoxConfig",
+    "resolveEntries",
+    "resolveManifestChromium",
+    "resolveManifestFirefox",
+    "resolveManifestForTarget",
+    "resolveManifestInput",
+    "resolveScriptFromHtmlStrict",
+    "toReloadManagerEntries"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=index.cjs.map