extension-develop 4.1.16 → 4.1.17-canary.1789176231.b3d547b9

package/dist/{278.mjs → 105~0.mjs}

@@ -1,19 +1,19 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
-import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
+import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
+import * as __rspack_external_node_path_806ed179 from "node:path";
 function isUsableDir(candidate) {
     try {
-        if (!__rspack_external_node_fs_5ea92f0c.existsSync(candidate)) return false;
-        const stat = __rspack_external_node_fs_5ea92f0c.statSync(candidate);
+        if (!__rspack_external_node_fs_1b05aee1.existsSync(candidate)) return false;
+        const stat = __rspack_external_node_fs_1b05aee1.statSync(candidate);
         return 'function' == typeof stat?.isDirectory ? stat.isDirectory() : true;
     } catch  {
         return false;
     }
 }
 function inspectPublicFolders(manifestPath, projectRoot) {
-    const fromManifest = __rspack_external_node_path_c5b9b54f.join(__rspack_external_node_path_c5b9b54f.dirname(manifestPath), 'public');
-    const fromRoot = projectRoot ? __rspack_external_node_path_c5b9b54f.join(projectRoot, 'public') : fromManifest;
-    const sameLocation = __rspack_external_node_path_c5b9b54f.resolve(fromRoot) === __rspack_external_node_path_c5b9b54f.resolve(fromManifest);
+    const fromManifest = __rspack_external_node_path_806ed179.join(__rspack_external_node_path_806ed179.dirname(manifestPath), 'public');
+    const fromRoot = projectRoot ? __rspack_external_node_path_806ed179.join(projectRoot, 'public') : fromManifest;
+    const sameLocation = __rspack_external_node_path_806ed179.resolve(fromRoot) === __rspack_external_node_path_806ed179.resolve(fromManifest);
     const rootOk = isUsableDir(fromRoot);
     const manifestOk = !sameLocation && isUsableDir(fromManifest);
     return {
@@ -28,22 +28,22 @@ function resolvePublicFolder(manifestPath, projectRoot) {
     return inspectPublicFolders(manifestPath, projectRoot).publicDir;
 }
 function publicFolderOrDefault(manifestPath, projectRoot) {
-    return resolvePublicFolder(manifestPath, projectRoot) || __rspack_external_node_path_c5b9b54f.join(projectRoot, 'public');
+    return resolvePublicFolder(manifestPath, projectRoot) || __rspack_external_node_path_806ed179.join(projectRoot, 'public');
 }
 function publicResolveRoots(projectRoot, manifestPath) {
-    const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
-    const fromRoot = __rspack_external_node_path_c5b9b54f.join(projectRoot, 'public');
-    const fromManifest = __rspack_external_node_path_c5b9b54f.join(manifestDir, 'public');
+    const manifestDir = __rspack_external_node_path_806ed179.dirname(manifestPath);
+    const fromRoot = __rspack_external_node_path_806ed179.join(projectRoot, 'public');
+    const fromManifest = __rspack_external_node_path_806ed179.join(manifestDir, 'public');
     const roots = [
         fromRoot,
         manifestDir
     ];
-    if (__rspack_external_node_path_c5b9b54f.resolve(fromManifest) !== __rspack_external_node_path_c5b9b54f.resolve(fromRoot)) roots.push(fromManifest);
+    if (__rspack_external_node_path_806ed179.resolve(fromManifest) !== __rspack_external_node_path_806ed179.resolve(fromRoot)) roots.push(fromManifest);
     return roots;
 }
 const publicRootsByCompiler = new WeakMap();
 function rememberPublicRoots(compiler, roots) {
-    publicRootsByCompiler.set(compiler, roots.filter(Boolean).map((root)=>__rspack_external_node_path_c5b9b54f.resolve(root)));
+    publicRootsByCompiler.set(compiler, roots.filter(Boolean).map((root)=>__rspack_external_node_path_806ed179.resolve(root)));
 }
 function publicRootsFor(compiler) {
     if (!compiler) return [];

package/dist/177~0.mjs

@@ -0,0 +1,37 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import { publicFolderOrDefault } from "./105~0.mjs";
+import { replaceCssUrlRefs } from "./273~0.mjs";
+import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
+import * as __rspack_external_node_path_806ed179 from "node:path";
+const PUBLIC_ROOT_SCHEME = 'https://extensionjs-public.invalid';
+function isFile(candidate) {
+    try {
+        return __rspack_external_node_fs_1b05aee1.statSync(candidate).isFile();
+    } catch  {
+        return false;
+    }
+}
+function keepPublicRootRefs(source, publicRoot) {
+    return replaceCssUrlRefs(source, (request)=>{
+        if (!request.startsWith('/') || request.startsWith('//')) return;
+        const suffixAt = request.search(/[?#]/);
+        const rel = (-1 === suffixAt ? request : request.slice(0, suffixAt)).slice(1);
+        if (!rel || !isFile(__rspack_external_node_path_806ed179.join(publicRoot, rel))) return;
+        return `${PUBLIC_ROOT_SCHEME}${request}`;
+    });
+}
+function restorePublicRootRefs(source) {
+    return source.split(PUBLIC_ROOT_SCHEME).join('');
+}
+function publicCssUrlLoader(source) {
+    const { manifestPath, projectPath } = this.getOptions() || {};
+    if (!manifestPath || !projectPath) return source;
+    try {
+        const publicRoot = publicFolderOrDefault(manifestPath, projectPath);
+        return keepPublicRootRefs(source, publicRoot);
+    } catch  {
+        return source;
+    }
+}
+export default publicCssUrlLoader;
+export { PUBLIC_ROOT_SCHEME, keepPublicRootRefs, restorePublicRootRefs };

package/dist/{86.mjs → 273~0.mjs}

@@ -1,10 +1,10 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
-import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
+import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
+import * as __rspack_external_node_path_806ed179 from "node:path";
 const ASSET_EXT = /\.(png|jpe?g|gif|webp|svg|avif|ico|bmp|cur|woff2?|ttf|otf|eot|mp3|mp4|webm|ogg|wav)$/i;
 const URL_REF = /url\(\s*(?:"([^"\n]*)"|'([^'\n]*)'|([^)'"\s]*))\s*\)/g;
 function toPosixPath(value) {
-    return String(value).split(__rspack_external_node_path_c5b9b54f.sep).join('/');
+    return String(value).split(__rspack_external_node_path_806ed179.sep).join('/');
 }
 function isDeadCssUrlRef(rawRequest, { issuerDir, roots }) {
     const req = String(rawRequest).split('?')[0].split('#')[0];
@@ -14,11 +14,11 @@ function isDeadCssUrlRef(rawRequest, { issuerDir, roots }) {
     const isRelativeRef = req.startsWith('./') || req.startsWith('../');
     const isBareAssetRef = !isRootRef && !isRelativeRef && ASSET_EXT.test(req);
     if (!isRootRef && !isRelativeRef && !isBareAssetRef) return false;
-    const candidates = isRootRef ? roots.map((root)=>__rspack_external_node_path_c5b9b54f.join(root, req.slice(1))) : [
-        __rspack_external_node_path_c5b9b54f.resolve(issuerDir, req),
-        ...isBareAssetRef ? roots.map((root)=>__rspack_external_node_path_c5b9b54f.join(root, req)) : []
+    const candidates = isRootRef ? roots.map((root)=>__rspack_external_node_path_806ed179.join(root, req.slice(1))) : [
+        __rspack_external_node_path_806ed179.resolve(issuerDir, req),
+        ...isBareAssetRef ? roots.map((root)=>__rspack_external_node_path_806ed179.join(root, req)) : []
     ];
-    return !candidates.some((candidate)=>__rspack_external_node_fs_5ea92f0c.existsSync(candidate));
+    return !candidates.some((candidate)=>__rspack_external_node_fs_1b05aee1.existsSync(candidate));
 }
 function replaceCssUrlRefs(source, replacer) {
     return source.replace(URL_REF, (whole, dq, sq, bare)=>{

package/dist/331~0.mjs

@@ -0,0 +1,43 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import * as __rspack_external_node_path_806ed179 from "node:path";
+__rspack_external_node_path_806ed179.join(process.cwd(), 'node_modules/extension-develop/dist/certs');
+const CHROMIUM_BASED_BROWSERS = [
+    'chrome',
+    'edge',
+    'brave',
+    'opera',
+    'vivaldi',
+    'yandex'
+];
+const GECKO_BASED_BROWSERS = [
+    'firefox',
+    'waterfox',
+    'librewolf'
+];
+const WEBKIT_BASED_BROWSERS = [
+    'safari'
+];
+const CHROMIUM_FAMILY_ALIASES = [
+    'chromium',
+    'chrome',
+    'edge',
+    'chromium-based'
+];
+const GECKO_FAMILY_ALIASES = [
+    'firefox',
+    'gecko-based'
+];
+[
+    ...CHROMIUM_BASED_BROWSERS,
+    ...GECKO_BASED_BROWSERS
+];
+function isChromiumBasedBrowser(browser) {
+    return CHROMIUM_BASED_BROWSERS.includes(browser) || String(browser).includes('chromium');
+}
+function isGeckoBasedBrowser(browser) {
+    return GECKO_BASED_BROWSERS.includes(browser) || String(browser).includes('gecko') || String(browser).includes('firefox');
+}
+function isWebkitBasedBrowser(browser) {
+    return WEBKIT_BASED_BROWSERS.includes(browser) || String(browser).includes('webkit');
+}
+export { CHROMIUM_FAMILY_ALIASES, GECKO_FAMILY_ALIASES, isChromiumBasedBrowser, isGeckoBasedBrowser, isWebkitBasedBrowser };

package/dist/{845.mjs → 524~0.mjs}

@@ -1,6 +1,6 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
 import pintor from "pintor";
-import { prefix as messaging_prefix } from "./349.mjs";
+import { prefix as messaging_prefix } from "./852~0.mjs";
 function cssIntegrationsEnabled(integrations) {
     const names = integrations.length > 0 ? integrations.join(',') : 'none';
     return `${messaging_prefix('debug')} css      integrations=${integrations.length} names=${names}`;

package/dist/{887.mjs → 616~0.mjs}

@@ -1,8 +1,8 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
-import { controlTokenPath, legacyControlTokenPath } from "./77.mjs";
-import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
-import * as __rspack_external_node_crypto_9ba42079 from "node:crypto";
+import { controlTokenPath, legacyControlTokenPath } from "./950~0.mjs";
+import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
+import * as __rspack_external_node_path_806ed179 from "node:path";
+import * as __rspack_external_node_crypto_2e7c4b46 from "node:crypto";
 const REFUSAL_NEEDS_HEADED_WINDOW = 'needs_headed_window';
 const REFUSAL_NEEDS_USER_GESTURE = 'needs_user_gesture';
 const REFUSAL_SURFACE_NOT_OPEN = 'surface_not_open';
@@ -10,7 +10,7 @@ const REFUSAL_API_UNAVAILABLE = 'api_unavailable';
 const CONTROL_WS_PATH = '/extjs-control';
 function readPersistedControlPort(filePath) {
     try {
-        const port = parseInt(__rspack_external_node_fs_5ea92f0c.readFileSync(filePath, 'utf8').trim(), 10);
+        const port = parseInt(__rspack_external_node_fs_1b05aee1.readFileSync(filePath, 'utf8').trim(), 10);
         return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;
     } catch  {
         return null;
@@ -18,27 +18,27 @@ function readPersistedControlPort(filePath) {
 }
 function writePersistedControlPort(filePath, port) {
     try {
-        __rspack_external_node_fs_5ea92f0c.mkdirSync(__rspack_external_node_path_c5b9b54f.dirname(filePath), {
+        __rspack_external_node_fs_1b05aee1.mkdirSync(__rspack_external_node_path_806ed179.dirname(filePath), {
             recursive: true
         });
-        __rspack_external_node_fs_5ea92f0c.writeFileSync(filePath, `${port}\n`);
+        __rspack_external_node_fs_1b05aee1.writeFileSync(filePath, `${port}\n`);
     } catch  {}
 }
 function writeControlToken(projectPath, browser) {
-    const token = __rspack_external_node_crypto_9ba42079.randomBytes(32).toString('hex');
+    const token = __rspack_external_node_crypto_2e7c4b46.randomBytes(32).toString('hex');
     const file = controlTokenPath(projectPath, browser);
-    __rspack_external_node_fs_5ea92f0c.mkdirSync(__rspack_external_node_path_c5b9b54f.dirname(file), {
+    __rspack_external_node_fs_1b05aee1.mkdirSync(__rspack_external_node_path_806ed179.dirname(file), {
         recursive: true
     });
-    __rspack_external_node_fs_5ea92f0c.writeFileSync(file, token, {
+    __rspack_external_node_fs_1b05aee1.writeFileSync(file, token, {
         encoding: 'utf-8',
         mode: 384
     });
     try {
-        __rspack_external_node_fs_5ea92f0c.chmodSync(file, 384);
+        __rspack_external_node_fs_1b05aee1.chmodSync(file, 384);
     } catch  {}
     try {
-        __rspack_external_node_fs_5ea92f0c.writeFileSync(legacyControlTokenPath(projectPath), token, {
+        __rspack_external_node_fs_1b05aee1.writeFileSync(legacyControlTokenPath(projectPath), token, {
             encoding: 'utf-8',
             mode: 384
         });
@@ -50,7 +50,7 @@ function readControlToken(projectPath, browser) {
         controlTokenPath(projectPath, browser),
         legacyControlTokenPath(projectPath)
     ])try {
-        const token = __rspack_external_node_fs_5ea92f0c.readFileSync(file, 'utf-8').trim();
+        const token = __rspack_external_node_fs_1b05aee1.readFileSync(file, 'utf-8').trim();
         if (token.length) return token;
     } catch  {}
     return null;
@@ -59,16 +59,16 @@ function clearControlToken(projectPath, browser) {
     const file = controlTokenPath(projectPath, browser);
     let token = null;
     try {
-        token = __rspack_external_node_fs_5ea92f0c.readFileSync(file, 'utf-8').trim() || null;
+        token = __rspack_external_node_fs_1b05aee1.readFileSync(file, 'utf-8').trim() || null;
     } catch  {}
     try {
-        __rspack_external_node_fs_5ea92f0c.rmSync(file, {
+        __rspack_external_node_fs_1b05aee1.rmSync(file, {
             force: true
         });
     } catch  {}
     try {
         const legacy = legacyControlTokenPath(projectPath);
-        if (token && __rspack_external_node_fs_5ea92f0c.readFileSync(legacy, 'utf-8').trim() === token) __rspack_external_node_fs_5ea92f0c.rmSync(legacy, {
+        if (token && __rspack_external_node_fs_1b05aee1.readFileSync(legacy, 'utf-8').trim() === token) __rspack_external_node_fs_1b05aee1.rmSync(legacy, {
             force: true
         });
     } catch  {}

package/dist/{266.mjs → 672~0.mjs}

@@ -1,6 +1,88 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
 import pintor from "pintor";
-import { prefix } from "./349.mjs";
+import { isChromiumBasedBrowser, isGeckoBasedBrowser } from "./331~0.mjs";
+import { parseJsonSafe } from "./731~0.mjs";
+import { prefix as messaging_prefix } from "./852~0.mjs";
+import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
+function filterKeysForThisBrowser(manifest, browser) {
+    const isSafariTarget = 'safari' === browser || 'webkit-based' === browser || String(browser).includes('webkit');
+    const isChromiumTarget = isChromiumBasedBrowser(String(browser)) || isSafariTarget;
+    const isGeckoTarget = isGeckoBasedBrowser(String(browser));
+    const chromiumPrefixes = new Set([
+        'chromium',
+        'chrome',
+        'edge'
+    ]);
+    const geckoPrefixes = new Set([
+        'gecko',
+        'firefox'
+    ]);
+    const webkitPrefixes = new Set([
+        'safari',
+        'webkit'
+    ]);
+    const isFamilyPrefix = (prefix)=>isChromiumTarget && chromiumPrefixes.has(prefix) || isGeckoTarget && geckoPrefixes.has(prefix);
+    const isSpecificPrefix = (prefix)=>prefix === browser || isSafariTarget && webkitPrefixes.has(prefix);
+    const resolve = (node)=>{
+        if (Array.isArray(node)) return node.map((item)=>resolve(item));
+        if (node && 'object' == typeof node) {
+            const result = {};
+            const familyMatches = {};
+            const specificMatches = {};
+            for (const [key, value] of Object.entries(node)){
+                const indexOfColon = key.indexOf(':');
+                if (-1 === indexOfColon) {
+                    result[key] = resolve(value);
+                    continue;
+                }
+                const prefix = key.substring(0, indexOfColon);
+                const strippedKey = key.substring(indexOfColon + 1);
+                if (isSpecificPrefix(prefix)) specificMatches[strippedKey] = resolve(value);
+                else if (isFamilyPrefix(prefix)) familyMatches[strippedKey] = resolve(value);
+            }
+            for (const [strippedKey, value] of Object.entries(familyMatches))result[strippedKey] = value;
+            for (const [strippedKey, value] of Object.entries(specificMatches))result[strippedKey] = value;
+            return result;
+        }
+        return node;
+    };
+    return resolve(manifest);
+}
+const THEME_DISQUALIFYING_KEYS = [
+    'background',
+    "content_scripts",
+    'action',
+    'browser_action',
+    'page_action',
+    'sidebar_action',
+    'side_panel',
+    'options_page',
+    'options_ui',
+    'devtools_page',
+    'chrome_url_overrides',
+    'sandbox',
+    "user_scripts",
+    'declarative_net_request',
+    'web_accessible_resources'
+];
+function isStaticTheme(manifest) {
+    if (!manifest || 'object' != typeof manifest) return false;
+    const theme = manifest.theme;
+    if (!theme || 'object' != typeof theme) return false;
+    return !THEME_DISQUALIFYING_KEYS.some((key)=>{
+        const value = manifest[key];
+        return null != value;
+    });
+}
+function isStaticThemeSource(manifestPath, browser) {
+    if (!manifestPath) return false;
+    try {
+        const parsed = parseJsonSafe(__rspack_external_node_fs_1b05aee1.readFileSync(manifestPath, 'utf-8'));
+        return isStaticTheme(filterKeysForThisBrowser(parsed, browser));
+    } catch  {
+        return false;
+    }
+}
 function importScriptsDependencyMissing(workerPath, literal, expectedPath, sourceSibling) {
     const lines = [];
     lines.push(`The background service worker calls importScripts('${literal}'), but the file isn't in the output.`);
@@ -45,7 +127,7 @@ const SPLIT_ENTRY_SURFACES = {
         effect: "the content script never runs on the page"
     },
     script: {
-        loads: ()=>'the runtime injection loads only',
+        loads: ()=>'the browser injects only',
         effect: "the script never runs"
     }
 };
@@ -94,6 +176,6 @@ function staticImportDependencyMissing(assetName, literal, expectedPath) {
 }
 function reservedScriptsFolder(relPath, indicators) {
     const reasons = indicators.map((r)=>`- ${pintor.gray(r)}`).join('\n');
-    return `${prefix('error')} scripts/ is a reserved folder in Extension.js.\n${pintor.gray('PATH')} ${pintor.underline(relPath)}\nEvery file under ${pintor.blue("scripts/")} is wrapped with the browser content-script mount runtime, so Node.js-only files placed here fail to parse or run.\nThis file looks Node.js-only:\n${reasons}\nRename the folder at the project root (for example ${pintor.blue('bin/')}, ${pintor.blue('tools/')}, or ${pintor.blue('tasks/')}), or move the file out of scripts/.`;
+    return `${messaging_prefix('error')} scripts/ is a reserved folder in Extension.js.\n${pintor.gray('PATH')} ${pintor.underline(relPath)}\nEvery file under ${pintor.blue("scripts/")} is wrapped with the browser content-script mount runtime, so Node.js-only files placed here fail to parse or run.\nThis file looks Node.js-only:\n${reasons}\nRename the folder at the project root (for example ${pintor.blue('bin/')}, ${pintor.blue('tools/')}, or ${pintor.blue('tasks/')}), or move the file out of scripts/.`;
 }
-export { entrySplitAcrossInitialFiles, fetchedFileDependencyMissing, getURLDependencyMissing, importScriptsDependencyMissing, injectedCompiledSourceLiteral, injectedFileDependencyMissing, reservedScriptsFolder, runtimeSetSurfaceDependencyMissing, staticImportDependencyMissing };
+export { entrySplitAcrossInitialFiles, fetchedFileDependencyMissing, filterKeysForThisBrowser, getURLDependencyMissing, importScriptsDependencyMissing, injectedCompiledSourceLiteral, injectedFileDependencyMissing, isStaticTheme, isStaticThemeSource, reservedScriptsFolder, runtimeSetSurfaceDependencyMissing, staticImportDependencyMissing };

package/dist/{80.mjs → 731~0.mjs}

@@ -1,7 +1,14 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
-import { stripBom } from "./23.mjs";
-import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
+import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
+import * as __rspack_external_node_path_806ed179 from "node:path";
+function stripBom(text) {
+    const raw = 'string' == typeof text ? text : String(text || '');
+    return raw && 0xfeff === raw.charCodeAt(0) ? raw.slice(1) : raw;
+}
+function parseJsonSafe(text) {
+    const s = stripBom(text);
+    return JSON.parse(s || '{}');
+}
 const PROJECT_MANIFEST_FILENAMES = [
     'package.json',
     'deno.jsonc',
@@ -102,9 +109,9 @@ function parseNpmSpecifier(specifier) {
 }
 function findDenoConfigPath(projectDir) {
     for (const filename of DENO_CONFIG_FILENAMES){
-        const candidate = __rspack_external_node_path_c5b9b54f.join(projectDir, filename);
+        const candidate = __rspack_external_node_path_806ed179.join(projectDir, filename);
         try {
-            if (__rspack_external_node_fs_5ea92f0c.statSync(candidate).isFile()) return candidate;
+            if (__rspack_external_node_fs_1b05aee1.statSync(candidate).isFile()) return candidate;
         } catch  {}
     }
 }
@@ -112,7 +119,7 @@ function readDenoConfigDependencies(denoConfigPath) {
     const dependencies = {};
     let config;
     try {
-        config = parseJsoncSafe(__rspack_external_node_fs_5ea92f0c.readFileSync(denoConfigPath, 'utf8'));
+        config = parseJsoncSafe(__rspack_external_node_fs_1b05aee1.readFileSync(denoConfigPath, 'utf8'));
     } catch  {
         return dependencies;
     }
@@ -129,7 +136,7 @@ function readDenoConfigDependencies(denoConfigPath) {
 }
 function readPackageJsonDependencies(packageJsonPath) {
     try {
-        const pkg = JSON.parse(stripBom(__rspack_external_node_fs_5ea92f0c.readFileSync(packageJsonPath, 'utf8')) || '{}');
+        const pkg = JSON.parse(stripBom(__rspack_external_node_fs_1b05aee1.readFileSync(packageJsonPath, 'utf8')) || '{}');
         const sections = [
             pkg.dependencies,
             pkg.devDependencies,
@@ -148,7 +155,7 @@ function readPackageJsonDependencies(packageJsonPath) {
 function readProjectDependencies(projectDir) {
     const denoConfigPath = findDenoConfigPath(projectDir);
     const denoDependencies = denoConfigPath ? readDenoConfigDependencies(denoConfigPath) : {};
-    const packageJsonDependencies = readPackageJsonDependencies(__rspack_external_node_path_c5b9b54f.join(projectDir, 'package.json'));
+    const packageJsonDependencies = readPackageJsonDependencies(__rspack_external_node_path_806ed179.join(projectDir, 'package.json'));
     return {
         ...denoDependencies,
         ...packageJsonDependencies
@@ -160,45 +167,45 @@ function hasProjectDependency(projectDir, packageName) {
 function findNearestProjectManifestDirSync(startPath, maxDepth = 6) {
     let currentDirectory = startPath;
     for(let i = 0; i < maxDepth; i++){
-        if (PROJECT_MANIFEST_FILENAMES.some((filename)=>__rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(currentDirectory, filename)))) return currentDirectory;
-        const parentDirectory = __rspack_external_node_path_c5b9b54f.dirname(currentDirectory);
+        if (PROJECT_MANIFEST_FILENAMES.some((filename)=>__rspack_external_node_fs_1b05aee1.existsSync(__rspack_external_node_path_806ed179.join(currentDirectory, filename)))) return currentDirectory;
+        const parentDirectory = __rspack_external_node_path_806ed179.dirname(currentDirectory);
         if (parentDirectory === currentDirectory) break;
         currentDirectory = parentDirectory;
     }
 }
 function findNearestProjectManifestSync(manifestPath) {
-    const root = __rspack_external_node_path_c5b9b54f.parse(manifestPath).root;
-    let currentDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
+    const root = __rspack_external_node_path_806ed179.parse(manifestPath).root;
+    let currentDir = __rspack_external_node_path_806ed179.dirname(manifestPath);
     while(true){
         for (const filename of PROJECT_MANIFEST_FILENAMES){
-            const candidate = __rspack_external_node_path_c5b9b54f.join(currentDir, filename);
+            const candidate = __rspack_external_node_path_806ed179.join(currentDir, filename);
             try {
-                if (__rspack_external_node_fs_5ea92f0c.statSync(candidate).isFile()) return candidate;
+                if (__rspack_external_node_fs_1b05aee1.statSync(candidate).isFile()) return candidate;
             } catch  {}
         }
         if (currentDir === root) return null;
-        currentDir = __rspack_external_node_path_c5b9b54f.dirname(currentDir);
+        currentDir = __rspack_external_node_path_806ed179.dirname(currentDir);
     }
 }
 function findNearestDenoConfigSync(manifestPath) {
     if (/^(?:\.[\\/])?[a-z][a-z0-9+.-]+:[\\/]+/i.test(manifestPath)) return null;
-    const root = __rspack_external_node_path_c5b9b54f.parse(__rspack_external_node_path_c5b9b54f.resolve(manifestPath)).root;
-    let currentDir = __rspack_external_node_path_c5b9b54f.dirname(__rspack_external_node_path_c5b9b54f.resolve(manifestPath));
+    const root = __rspack_external_node_path_806ed179.parse(__rspack_external_node_path_806ed179.resolve(manifestPath)).root;
+    let currentDir = __rspack_external_node_path_806ed179.dirname(__rspack_external_node_path_806ed179.resolve(manifestPath));
     while(true){
         const found = findDenoConfigPath(currentDir);
         if (found) return found;
-        const parentDir = __rspack_external_node_path_c5b9b54f.dirname(currentDir);
+        const parentDir = __rspack_external_node_path_806ed179.dirname(currentDir);
         if (currentDir === root || parentDir === currentDir) return null;
         currentDir = parentDir;
     }
 }
 function validateDenoConfig(denoConfigPath) {
     try {
-        if (!__rspack_external_node_fs_5ea92f0c.existsSync(denoConfigPath)) return false;
-        parseJsoncSafe(__rspack_external_node_fs_5ea92f0c.readFileSync(denoConfigPath, 'utf8'));
+        if (!__rspack_external_node_fs_1b05aee1.existsSync(denoConfigPath)) return false;
+        parseJsoncSafe(__rspack_external_node_fs_1b05aee1.readFileSync(denoConfigPath, 'utf8'));
         return true;
     } catch  {
         return false;
     }
 }
-export { PROJECT_MANIFEST_FILENAMES, findNearestDenoConfigSync, findNearestProjectManifestDirSync, findNearestProjectManifestSync, hasProjectDependency, readProjectDependencies, validateDenoConfig };
+export { PROJECT_MANIFEST_FILENAMES, findNearestDenoConfigSync, findNearestProjectManifestDirSync, findNearestProjectManifestSync, hasProjectDependency, parseJsonSafe, readProjectDependencies, stripBom, validateDenoConfig };

package/dist/{372.mjs → 747~0.mjs}

@@ -1,12 +1,12 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
-import { htmlStaticAssetOutputName } from "./834.mjs";
-import { replaceCssUrlRefs, toPosixPath } from "./86.mjs";
-import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
+import { htmlStaticAssetOutputName } from "./938~0.mjs";
+import { replaceCssUrlRefs, toPosixPath } from "./273~0.mjs";
+import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
+import * as __rspack_external_node_path_806ed179 from "node:path";
 const EXTENSION_ROOT_PLACEHOLDER = '__EXTENSIONJS_EXTENSION_ROOT__/';
 function isFile(candidate) {
     try {
-        return __rspack_external_node_fs_5ea92f0c.statSync(candidate).isFile();
+        return __rspack_external_node_fs_1b05aee1.statSync(candidate).isFile();
     } catch  {
         return false;
     }
@@ -14,13 +14,13 @@ function isFile(candidate) {
 function resolveTarget(req, { resourcePath, manifestDir, publicRoot }) {
     if (req.startsWith('/')) {
         const rel = req.slice(1);
-        const fromPublic = __rspack_external_node_path_c5b9b54f.join(publicRoot, rel);
+        const fromPublic = __rspack_external_node_path_806ed179.join(publicRoot, rel);
         if (isFile(fromPublic)) return {
             absolutePath: fromPublic,
-            outputName: toPosixPath(__rspack_external_node_path_c5b9b54f.normalize(rel)),
+            outputName: toPosixPath(__rspack_external_node_path_806ed179.normalize(rel)),
             publicOwned: true
         };
-        const fromManifest = __rspack_external_node_path_c5b9b54f.join(manifestDir, rel);
+        const fromManifest = __rspack_external_node_path_806ed179.join(manifestDir, rel);
         if (!isFile(fromManifest)) return;
         return {
             absolutePath: fromManifest,
@@ -28,7 +28,7 @@ function resolveTarget(req, { resourcePath, manifestDir, publicRoot }) {
             publicOwned: false
         };
     }
-    const absolutePath = __rspack_external_node_path_c5b9b54f.resolve(__rspack_external_node_path_c5b9b54f.dirname(resourcePath), req);
+    const absolutePath = __rspack_external_node_path_806ed179.resolve(__rspack_external_node_path_806ed179.dirname(resourcePath), req);
     if (!isFile(absolutePath)) return;
     return {
         absolutePath,