extension-develop 4.1.14 → 4.1.16-canary.387.3c3b02c

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/273~0.mjs

@@ -0,0 +1,45 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+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_806ed179.sep).join('/');
+}
+function isDeadCssUrlRef(rawRequest, { issuerDir, roots }) {
+    const req = String(rawRequest).split('?')[0].split('#')[0];
+    if (!req || req.startsWith('//') || /^[a-z][a-z0-9+.-]*:/i.test(req)) return false;
+    if (req.startsWith('~') || req.startsWith('@')) return false;
+    const isRootRef = req.startsWith('/');
+    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_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_1b05aee1.existsSync(candidate));
+}
+function replaceCssUrlRefs(source, replacer) {
+    return source.replace(URL_REF, (whole, dq, sq, bare)=>{
+        const request = dq ?? sq ?? bare ?? '';
+        if (!request) return whole;
+        const next = replacer(request);
+        if (void 0 === next) return whole;
+        return `url("${next.replace(/["\\]/g, '\\$&')}")`;
+    });
+}
+function extractCssUrlRefs(source) {
+    const found = [];
+    const seen = new Set();
+    URL_REF.lastIndex = 0;
+    let match;
+    while(null !== (match = URL_REF.exec(source))){
+        const request = match[1] ?? match[2] ?? match[3] ?? '';
+        if (!request || seen.has(request)) continue;
+        seen.add(request);
+        found.push(request);
+    }
+    return found;
+}
+export { extractCssUrlRefs, isDeadCssUrlRef, replaceCssUrlRefs, toPosixPath };

package/dist/{518.mjs → 300~0.mjs}

@@ -1,8 +1,8 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
-import { inspectPublicFolders } from "./278.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_parse5_utilities_78b19c6a from "parse5-utilities";
+import { inspectPublicFolders } from "./105~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_parse5_utilities_4a00fdd6 from "parse5-utilities";
 function normalizeManifestOutputPath(originalPath) {
     if (!originalPath) return originalPath;
     const unixPath = originalPath.replace(/\\/g, '/');
@@ -17,9 +17,9 @@ function manifestPageOutputTarget(raw, compiledTarget, manifestPath) {
     if (/^\//.test(unixPath)) {
         const rest = unixPath.replace(/^\/+/, '');
         if (manifestPath && rest) {
-            const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
-            const inPublic = __rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(manifestDir, 'public', rest));
-            const inRoot = __rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(manifestDir, rest));
+            const manifestDir = __rspack_external_node_path_806ed179.dirname(manifestPath);
+            const inPublic = __rspack_external_node_fs_1b05aee1.existsSync(__rspack_external_node_path_806ed179.join(manifestDir, 'public', rest));
+            const inRoot = __rspack_external_node_fs_1b05aee1.existsSync(__rspack_external_node_path_806ed179.join(manifestDir, rest));
             if (inRoot && !inPublic) return compiledTarget;
         }
         return normalizeManifestOutputPath(unixPath);
@@ -31,10 +31,10 @@ function manifestJsonOutputTarget(raw, compiledTarget, manifestPath, projectPath
     if (/^(?:\/public\/|(?:\.\/)?public\/|\/)/i.test(unixPath) || !manifestPath) return manifestPageOutputTarget(unixPath, compiledTarget, manifestPath);
     const rest = unixPath.replace(/^\.\//, '');
     if (!rest || rest.split('/').includes('..')) return compiledTarget;
-    const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
-    if (__rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(manifestDir, rest))) return compiledTarget;
+    const manifestDir = __rspack_external_node_path_806ed179.dirname(manifestPath);
+    if (__rspack_external_node_fs_1b05aee1.existsSync(__rspack_external_node_path_806ed179.join(manifestDir, rest))) return compiledTarget;
     const { publicDir } = inspectPublicFolders(manifestPath, projectPath);
-    if (publicDir && __rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(publicDir, rest))) return rest;
+    if (publicDir && __rspack_external_node_fs_1b05aee1.existsSync(__rspack_external_node_path_806ed179.join(publicDir, rest))) return rest;
     return compiledTarget;
 }
 function pathEscapesExtensionRoot(normalized) {
@@ -179,7 +179,7 @@ function getAssetsFromHtml(htmlFilePath, htmlContent) {
     if (!htmlFilePath) return assets;
     let cacheKey;
     if (void 0 === htmlContent) try {
-        const stat = __rspack_external_node_fs_5ea92f0c.statSync(htmlFilePath);
+        const stat = __rspack_external_node_fs_1b05aee1.statSync(htmlFilePath);
         cacheKey = `${stat.mtimeMs}:${stat.size}`;
         const cached = assetsFromHtmlCache.get(htmlFilePath);
         if (cached && cached.key === cacheKey) return cloneParsedHtmlAsset(cached.assets);
@@ -187,11 +187,11 @@ function getAssetsFromHtml(htmlFilePath, htmlContent) {
         cacheKey = void 0;
     }
     try {
-        const htmlString = htmlContent || __rspack_external_node_fs_5ea92f0c.readFileSync(htmlFilePath, {
+        const htmlString = htmlContent || __rspack_external_node_fs_1b05aee1.readFileSync(htmlFilePath, {
             encoding: 'utf8'
         });
         if (!htmlString) return assets;
-        const htmlDocument = __rspack_external_parse5_utilities_78b19c6a.parse(htmlString);
+        const htmlDocument = __rspack_external_parse5_utilities_4a00fdd6.parse(htmlString);
         const baseHref = getBaseHref(htmlDocument);
         const getAbsolutePath = (htmlFilePath, filePathWithParts)=>{
             const { cleanPath } = cleanAssetUrl(filePathWithParts);
@@ -237,7 +237,7 @@ function getHtmlPageDeclaredAssetPath(filepathList, filePath, extension) {
     const entryname = Object.keys(filepathList).find((key)=>{
         const includePath = filepathList[key];
         if (includePath === filePath) return true;
-        if (!includePath || !__rspack_external_node_fs_5ea92f0c.existsSync(includePath)) return false;
+        if (!includePath || !__rspack_external_node_fs_1b05aee1.existsSync(includePath)) return false;
         const assets = getAssetsFromHtml(includePath);
         return Boolean(assets?.js?.includes(filePath) || assets?.css?.includes(filePath));
     }) || '';
@@ -246,7 +246,7 @@ function getHtmlPageDeclaredAssetPath(filepathList, filePath, extension) {
     return `/${entryname.replace(extname, '')}${extension}`;
 }
 function getExtname(filePath) {
-    return __rspack_external_node_path_c5b9b54f.extname(filePath);
+    return __rspack_external_node_path_806ed179.extname(filePath);
 }
 function getFilePath(filePath, extension, isPublic) {
     if (isPublic) return `/${filePath}${extension}`;
@@ -279,10 +279,10 @@ function rewriteSrcsetCandidate(srcset, fromCleanPath, toUrl) {
 }
 function applyRewrittenStaticUrl(node, attributeName, cleanPath, value) {
     if ('srcset' === attributeName || 'imagesrcset' === attributeName) {
-        const current = __rspack_external_parse5_utilities_78b19c6a.getAttribute(node, attributeName) || '';
-        return __rspack_external_parse5_utilities_78b19c6a.setAttribute(node, attributeName, rewriteSrcsetCandidate(current, cleanPath, value));
+        const current = __rspack_external_parse5_utilities_4a00fdd6.getAttribute(node, attributeName) || '';
+        return __rspack_external_parse5_utilities_4a00fdd6.setAttribute(node, attributeName, rewriteSrcsetCandidate(current, cleanPath, value));
     }
-    return __rspack_external_parse5_utilities_78b19c6a.setAttribute(node, attributeName, value);
+    return __rspack_external_parse5_utilities_4a00fdd6.setAttribute(node, attributeName, value);
 }
 function cleanAssetUrl(url) {
     const hashIndex = url.indexOf('#');
@@ -310,16 +310,16 @@ function cleanLeading(s) {
     return s.replace(/^\/+/, '').replace(/^\.\//, '').replace(/^\./, '');
 }
 function joinEmittedAssetName(prefix, rel) {
-    const parts = __rspack_external_node_path_c5b9b54f.posix.join(prefix, rel).split('/');
+    const parts = __rspack_external_node_path_806ed179.posix.join(prefix, rel).split('/');
     let i = 0;
     while(i < parts.length && ('..' === parts[i] || '.' === parts[i]))i++;
-    return parts.slice(i).join('/') || __rspack_external_node_path_c5b9b54f.posix.basename(rel);
+    return parts.slice(i).join('/') || __rspack_external_node_path_806ed179.posix.basename(rel);
 }
 function htmlStaticAssetOutputName(manifestDir, htmlEntry, absolutePath) {
     if ('string' == typeof manifestDir && manifestDir) {
-        const rel = __rspack_external_node_path_c5b9b54f.relative(manifestDir, absolutePath);
-        if (rel && !__rspack_external_node_path_c5b9b54f.isAbsolute(rel)) {
-            const posix = rel.split(__rspack_external_node_path_c5b9b54f.sep).join('/');
+        const rel = __rspack_external_node_path_806ed179.relative(manifestDir, absolutePath);
+        if (rel && !__rspack_external_node_path_806ed179.isAbsolute(rel)) {
+            const posix = rel.split(__rspack_external_node_path_806ed179.sep).join('/');
             const escapes = posix.split('/').includes('..');
             return escapes ? externalAssetOutputPath(posix, 'assets') : joinEmittedAssetName('assets', posix);
         }
@@ -327,14 +327,14 @@ function htmlStaticAssetOutputName(manifestDir, htmlEntry, absolutePath) {
     return joinEmittedAssetName('assets', computePosixRelative(htmlEntry, absolutePath));
 }
 function computePosixRelative(fromPath, toPath) {
-    const fromRoot = __rspack_external_node_path_c5b9b54f.parse(fromPath).root;
-    const toRoot = __rspack_external_node_path_c5b9b54f.parse(toPath).root;
+    const fromRoot = __rspack_external_node_path_806ed179.parse(fromPath).root;
+    const toRoot = __rspack_external_node_path_806ed179.parse(toPath).root;
     if (fromRoot && toRoot && String(fromRoot).toLowerCase() !== String(toRoot).toLowerCase()) {
-        const base = __rspack_external_node_path_c5b9b54f.basename(toPath);
-        return base.split(__rspack_external_node_path_c5b9b54f.sep).join('/');
+        const base = __rspack_external_node_path_806ed179.basename(toPath);
+        return base.split(__rspack_external_node_path_806ed179.sep).join('/');
     }
-    const rel = __rspack_external_node_path_c5b9b54f.relative(__rspack_external_node_path_c5b9b54f.dirname(fromPath), toPath) || toPath;
-    return rel.split(__rspack_external_node_path_c5b9b54f.sep).join('/');
+    const rel = __rspack_external_node_path_806ed179.relative(__rspack_external_node_path_806ed179.dirname(fromPath), toPath) || toPath;
+    return rel.split(__rspack_external_node_path_806ed179.sep).join('/');
 }
 function resolveAbsoluteFsPath(params) {
     const { asset, projectRoot, publicRootForResource, outputRoot, manifestRoot } = params;
@@ -342,24 +342,24 @@ function resolveAbsoluteFsPath(params) {
     const rootUrlIsClaimed = (value)=>{
         const normalized = cleanLeading(value.slice(1));
         const withoutPublicPrefix = normalized.replace(/^public\//, '');
-        if (__rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(publicRootForResource, withoutPublicPrefix))) return true;
-        return Boolean(manifestRoot && __rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(manifestRoot, normalized)));
+        if (__rspack_external_node_fs_1b05aee1.existsSync(__rspack_external_node_path_806ed179.join(publicRootForResource, withoutPublicPrefix))) return true;
+        return Boolean(manifestRoot && __rspack_external_node_fs_1b05aee1.existsSync(__rspack_external_node_path_806ed179.join(manifestRoot, normalized)));
     };
-    const isRootUrl = looksLikeRootUrl && (rootUrlIsClaimed(asset) || !__rspack_external_node_fs_5ea92f0c.existsSync(asset));
+    const isRootUrl = looksLikeRootUrl && (rootUrlIsClaimed(asset) || !__rspack_external_node_fs_1b05aee1.existsSync(asset));
     const isDotPublic = asset.startsWith('./public/');
     const isPlainPublic = asset.startsWith('public/');
     const absoluteFsPath = isRootUrl ? (()=>{
         const rootRelative = asset.slice(1);
         const normalized = cleanLeading(rootRelative);
         const withoutPublicPrefix = normalized.replace(/^public\//, '');
-        const candidate = __rspack_external_node_path_c5b9b54f.join(publicRootForResource, withoutPublicPrefix);
-        if (__rspack_external_node_fs_5ea92f0c.existsSync(candidate)) return candidate;
-        const manifestCandidate = manifestRoot ? __rspack_external_node_path_c5b9b54f.join(manifestRoot, normalized) : '';
-        if (manifestCandidate && __rspack_external_node_fs_5ea92f0c.existsSync(manifestCandidate)) return manifestCandidate;
+        const candidate = __rspack_external_node_path_806ed179.join(publicRootForResource, withoutPublicPrefix);
+        if (__rspack_external_node_fs_1b05aee1.existsSync(candidate)) return candidate;
+        const manifestCandidate = manifestRoot ? __rspack_external_node_path_806ed179.join(manifestRoot, normalized) : '';
+        if (manifestCandidate && __rspack_external_node_fs_1b05aee1.existsSync(manifestCandidate)) return manifestCandidate;
         return manifestCandidate || candidate;
-    })() : isDotPublic ? __rspack_external_node_path_c5b9b54f.join(projectRoot, cleanLeading(asset)) : isPlainPublic ? __rspack_external_node_path_c5b9b54f.join(projectRoot, asset.replace(/^\./, '')) : __rspack_external_node_path_c5b9b54f.isAbsolute(asset) ? asset : __rspack_external_node_path_c5b9b54f.join(projectRoot, asset);
-    const relToPublic = __rspack_external_node_path_c5b9b54f.relative(publicRootForResource, absoluteFsPath);
-    const isUnderPublicRoot = relToPublic && !relToPublic.startsWith('..') && !__rspack_external_node_path_c5b9b54f.isAbsolute(relToPublic);
+    })() : isDotPublic ? __rspack_external_node_path_806ed179.join(projectRoot, cleanLeading(asset)) : isPlainPublic ? __rspack_external_node_path_806ed179.join(projectRoot, asset.replace(/^\./, '')) : __rspack_external_node_path_806ed179.isAbsolute(asset) ? asset : __rspack_external_node_path_806ed179.join(projectRoot, asset);
+    const relToPublic = __rspack_external_node_path_806ed179.relative(publicRootForResource, absoluteFsPath);
+    const isUnderPublicRoot = relToPublic && !relToPublic.startsWith('..') && !__rspack_external_node_path_806ed179.isAbsolute(relToPublic);
     return {
         absoluteFsPath,
         isUnderPublicRoot: Boolean(isUnderPublicRoot),
@@ -369,11 +369,11 @@ function resolveAbsoluteFsPath(params) {
 function resolveHtmlRefPath(htmlFilePath, baseHref, cleanPath) {
     if (utils_isUrl(cleanPath)) return cleanPath;
     if (cleanPath.startsWith('/')) return cleanPath;
-    const htmlDir = __rspack_external_node_path_c5b9b54f.dirname(htmlFilePath);
-    const pageRelative = __rspack_external_node_path_c5b9b54f.join(htmlDir, cleanPath);
+    const htmlDir = __rspack_external_node_path_806ed179.dirname(htmlFilePath);
+    const pageRelative = __rspack_external_node_path_806ed179.join(htmlDir, cleanPath);
     if (!baseHref || utils_isUrl(baseHref)) return pageRelative;
-    const throughBase = __rspack_external_node_path_c5b9b54f.join(htmlDir, baseHref, cleanPath);
-    if (__rspack_external_node_fs_5ea92f0c.existsSync(throughBase) || !__rspack_external_node_fs_5ea92f0c.existsSync(pageRelative)) return throughBase;
+    const throughBase = __rspack_external_node_path_806ed179.join(htmlDir, baseHref, cleanPath);
+    if (__rspack_external_node_fs_1b05aee1.existsSync(throughBase) || !__rspack_external_node_fs_1b05aee1.existsSync(pageRelative)) return throughBase;
     return pageRelative;
 }
 function getBaseHref(htmlDocument) {
@@ -390,45 +390,4 @@ function getBaseNode(htmlDocument) {
         }
     }
 }
-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('/');
-}
-function isDeadCssUrlRef(rawRequest, { issuerDir, roots }) {
-    const req = String(rawRequest).split('?')[0].split('#')[0];
-    if (!req || req.startsWith('//') || /^[a-z][a-z0-9+.-]*:/i.test(req)) return false;
-    if (req.startsWith('~') || req.startsWith('@')) return false;
-    const isRootRef = req.startsWith('/');
-    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)) : []
-    ];
-    return !candidates.some((candidate)=>__rspack_external_node_fs_5ea92f0c.existsSync(candidate));
-}
-function replaceCssUrlRefs(source, replacer) {
-    return source.replace(URL_REF, (whole, dq, sq, bare)=>{
-        const request = dq ?? sq ?? bare ?? '';
-        if (!request) return whole;
-        const next = replacer(request);
-        if (void 0 === next) return whole;
-        return `url("${next.replace(/["\\]/g, '\\$&')}")`;
-    });
-}
-function extractCssUrlRefs(source) {
-    const found = [];
-    const seen = new Set();
-    URL_REF.lastIndex = 0;
-    let match;
-    while(null !== (match = URL_REF.exec(source))){
-        const request = match[1] ?? match[2] ?? match[3] ?? '';
-        if (!request || seen.has(request)) continue;
-        seen.add(request);
-        found.push(request);
-    }
-    return found;
-}
-export { applyRewrittenStaticUrl, cleanAssetUrl, cleanLeading, extractCssUrlRefs, getAssetsFromHtml, getBaseHref, getBaseNode, getExtname, getFilePath, getHtmlPageDeclaredAssetPath, htmlStaticAssetOutputName, iconOutputPath, isDeadCssUrlRef, isFromIncludeList, isHttpLike, isSpecialScheme, manifestJsonOutputTarget, manifestPageOutputTarget, normalizeManifestOutputPath, parseHtml, replaceCssUrlRefs, resolveAbsoluteFsPath, resolveHtmlRefPath, resolveStaticAttributeName, themeIconOutputPath, themeImageOutputPath, toPosixPath, utils_isUrl };
+export { applyRewrittenStaticUrl, cleanAssetUrl, cleanLeading, getAssetsFromHtml, getBaseHref, getBaseNode, getExtname, getFilePath, getHtmlPageDeclaredAssetPath, htmlStaticAssetOutputName, iconOutputPath, isFromIncludeList, isHttpLike, isSpecialScheme, manifestJsonOutputTarget, manifestPageOutputTarget, normalizeManifestOutputPath, parseHtml, resolveAbsoluteFsPath, resolveHtmlRefPath, resolveStaticAttributeName, themeIconOutputPath, themeImageOutputPath, utils_isUrl };

package/dist/{266.mjs → 519~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 } from "./349.mjs";
+import { prefix } from "./852~0.mjs";
 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.`);
@@ -21,6 +21,45 @@ function injectedFileDependencyMissing(assetName, literal, expectedPath, sourceS
     lines.push(`Move the file to ${pintor.blue(expectedPath)} or ${pintor.blue('public/')} so it ships with the extension.`);
     return lines.join('\n');
 }
+function injectedCompiledSourceLiteral(assetName, literal, emittedPath) {
+    const lines = [];
+    lines.push(`${assetName} injects '${literal}', but ${literal} is compiled to ${emittedPath}.`);
+    lines.push(`${pintor.gray('REQUESTED')} ${pintor.underline(literal)}`);
+    lines.push(`${pintor.gray('EMITTED')} ${pintor.underline(emittedPath)}`);
+    lines.push("The browser asks for the source path, which the output does not contain, so the injection fails at runtime.");
+    lines.push(`Inject the emitted path: ${pintor.blue(emittedPath)}.`);
+    return lines.join('\n');
+}
+const SPLIT_ENTRY_RECIPE_URL = 'https://extension.js.org/docs/features/rspack-configuration#share-a-module-between-entries';
+const SPLIT_ENTRY_SURFACES = {
+    page: {
+        loads: (entryName)=>`${entryName}.html references only`,
+        effect: 'the page renders blank'
+    },
+    background: {
+        loads: ()=>'the background registration loads only',
+        effect: "the background script never starts"
+    },
+    content_script: {
+        loads: ()=>"the content_scripts declaration injects only",
+        effect: "the content script never runs on the page"
+    },
+    script: {
+        loads: ()=>'the runtime injection loads only',
+        effect: "the script never runs"
+    }
+};
+function entrySplitAcrossInitialFiles(entryName, surface, ownFile, extraFiles) {
+    const shape = SPLIT_ENTRY_SURFACES[surface];
+    const count = extraFiles.length + 1;
+    const lines = [];
+    lines.push(`${entryName} is split into ${count} initial files, but ${shape.loads(entryName)} ${ownFile}.`);
+    lines.push(`${pintor.gray('LOADED')} ${pintor.underline(ownFile)}`);
+    lines.push(`${pintor.gray('NOT LOADED')} ${extraFiles.map((file)=>pintor.underline(file)).join(', ')}`);
+    lines.push(`The entry waits for the other files at runtime and never runs, so ${shape.effect}.`);
+    lines.push(`Only a user-set optimization.splitChunks cache group does this. Use chunks: 'async' and import() the shared module: ${pintor.blue(SPLIT_ENTRY_RECIPE_URL)}`);
+    return lines.join('\n');
+}
 function fetchedFileDependencyMissing(assetName, literal, expectedPath) {
     const lines = [];
     lines.push(`${assetName} loads '${literal}' at runtime (fetch/XMLHttpRequest/new URL), but the file isn't in the output.`);
@@ -57,4 +96,4 @@ 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/.`;
 }
-export { fetchedFileDependencyMissing, getURLDependencyMissing, importScriptsDependencyMissing, injectedFileDependencyMissing, reservedScriptsFolder, runtimeSetSurfaceDependencyMissing, staticImportDependencyMissing };
+export { entrySplitAcrossInitialFiles, fetchedFileDependencyMissing, getURLDependencyMissing, importScriptsDependencyMissing, injectedCompiledSourceLiteral, injectedFileDependencyMissing, reservedScriptsFolder, runtimeSetSurfaceDependencyMissing, staticImportDependencyMissing };

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/{93.mjs → 712~0.mjs}

@@ -1,12 +1,12 @@
 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 canonicalizeDir(dir) {
     try {
-        return __rspack_external_node_fs_5ea92f0c.realpathSync.native(dir);
+        return __rspack_external_node_fs_1b05aee1.realpathSync.native(dir);
     } catch  {
         try {
-            return __rspack_external_node_fs_5ea92f0c.realpathSync(dir);
+            return __rspack_external_node_fs_1b05aee1.realpathSync(dir);
         } catch  {
             return dir;
         }
@@ -15,14 +15,14 @@ function canonicalizeDir(dir) {
 function canonicalizeResourcePath(resourcePath) {
     if ('string' != typeof resourcePath || 0 === resourcePath.length) return resourcePath;
     try {
-        return __rspack_external_node_path_c5b9b54f.normalize(__rspack_external_node_path_c5b9b54f.join(canonicalizeDir(__rspack_external_node_path_c5b9b54f.dirname(resourcePath)), __rspack_external_node_path_c5b9b54f.basename(resourcePath)));
+        return __rspack_external_node_path_806ed179.normalize(__rspack_external_node_path_806ed179.join(canonicalizeDir(__rspack_external_node_path_806ed179.dirname(resourcePath)), __rspack_external_node_path_806ed179.basename(resourcePath)));
     } catch  {
-        return __rspack_external_node_path_c5b9b54f.normalize(resourcePath);
+        return __rspack_external_node_path_806ed179.normalize(resourcePath);
     }
 }
 function toResourceKey(resourcePath) {
     if ('string' != typeof resourcePath || 0 === resourcePath.length) return resourcePath;
-    const key = canonicalizeResourcePath(__rspack_external_node_path_c5b9b54f.resolve(resourcePath));
+    const key = canonicalizeResourcePath(__rspack_external_node_path_806ed179.resolve(resourcePath));
     if ('win32' === process.platform && /^[a-zA-Z]:/.test(key)) return key[0].toUpperCase() + key.slice(1);
     return key;
 }
@@ -31,8 +31,8 @@ function isResourceUnderDirs(resource, dirs) {
     const candidate = canonicalizeResourcePath(resource);
     return dirs.some((dir)=>{
         if (candidate === dir) return true;
-        const rel = __rspack_external_node_path_c5b9b54f.relative(dir, candidate);
-        return rel.length > 0 && !rel.startsWith('..') && !__rspack_external_node_path_c5b9b54f.isAbsolute(rel);
+        const rel = __rspack_external_node_path_806ed179.relative(dir, candidate);
+        return rel.length > 0 && !rel.startsWith('..') && !__rspack_external_node_path_806ed179.isAbsolute(rel);
     });
 }
 export { canonicalizeDir, canonicalizeResourcePath, isResourceUnderDirs, toResourceKey };