extension-develop 4.1.11 → 4.1.13

package/dist/518.mjs

@@ -0,0 +1,434 @@
+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";
+function normalizeManifestOutputPath(originalPath) {
+    if (!originalPath) return originalPath;
+    const unixPath = originalPath.replace(/\\/g, '/');
+    if (/^\/public\//i.test(unixPath)) return unixPath.replace(/^\/public\//i, '');
+    if (/^(?:\.\/)?public\//i.test(unixPath)) return unixPath.replace(/^(?:\.\/)?public\//i, '');
+    if (/^\//.test(unixPath)) return unixPath.replace(/^\//, '');
+    return unixPath;
+}
+function manifestPageOutputTarget(raw, compiledTarget, manifestPath) {
+    const unixPath = raw.replace(/\\/g, '/');
+    if (/^(?:\/public\/|(?:\.\/)?public\/)/i.test(unixPath)) return normalizeManifestOutputPath(unixPath);
+    if (/^\//.test(unixPath)) {
+        const rest = unixPath.replace(/^\/+/, '');
+        if (manifestPath && rest) {
+            const manifestDir = __rspack_external_node_path_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));
+            if (inRoot && !inPublic) return compiledTarget;
+        }
+        return normalizeManifestOutputPath(unixPath);
+    }
+    return compiledTarget;
+}
+function manifestJsonOutputTarget(raw, compiledTarget, manifestPath, projectPath) {
+    const unixPath = raw.replace(/\\/g, '/');
+    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 { publicDir } = inspectPublicFolders(manifestPath, projectPath);
+    if (publicDir && __rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(publicDir, rest))) return rest;
+    return compiledTarget;
+}
+function pathEscapesExtensionRoot(normalized) {
+    return !normalized || normalized.split('/').includes('..') || /^[A-Za-z]:/.test(normalized);
+}
+function externalAssetOutputPath(normalized, root) {
+    const unix = normalized.replace(/\\/g, '/');
+    const noDrive = unix.replace(/^([A-Za-z]):(?:\/|$)/, '_drive_$1/');
+    const safe = noDrive.split('/').map((segment)=>{
+        if ('..' === segment) return '_';
+        if ('.' === segment || !segment) return '';
+        return segment.replace(/[<>:"|?*\x00-\x1F]/g, '_');
+    }).filter(Boolean).join('/');
+    return safe ? `${root}/${safe}` : `${root}/external`;
+}
+function iconOutputPath(raw) {
+    if (/^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw)) return normalizeManifestOutputPath(raw);
+    const normalized = normalizeManifestOutputPath(raw).replace(/^\.\//, '');
+    if (!pathEscapesExtensionRoot(normalized)) return normalized;
+    return externalAssetOutputPath(normalized, 'icons');
+}
+function themeIconOutputPath(raw, folder) {
+    return featureAssetOutputPath(raw, folder);
+}
+function themeImageOutputPath(raw) {
+    return featureAssetOutputPath(raw, 'theme/images');
+}
+function featureAssetOutputPath(raw, folder) {
+    if (/^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw)) return normalizeManifestOutputPath(raw);
+    const normalized = normalizeManifestOutputPath(raw).replace(/^\.\//, '');
+    if (!pathEscapesExtensionRoot(normalized)) return `${folder}/${normalized}`;
+    return externalAssetOutputPath(normalized, folder);
+}
+function isUrl(src) {
+    try {
+        new URL(src);
+        return true;
+    } catch (err) {
+        return false;
+    }
+}
+function emitSrcsetCandidates(srcset, node, assetType, attributeName, onResourceFound) {
+    for (const candidate of srcset.split(',')){
+        const url = candidate.trim().split(/\s+/)[0];
+        if (!url) continue;
+        const { cleanPath } = cleanAssetUrl(url);
+        if (cleanPath && !isUrl(cleanPath)) onResourceFound({
+            filePath: url,
+            childNode: node,
+            assetType,
+            attributeName
+        });
+    }
+}
+function parseHtml(node, onResourceFound) {
+    if ('#comment' === node.nodeName || '#text' === node.nodeName) return;
+    if ("script" === node.nodeName) {
+        const src = node.attrs?.find((attr)=>'src' === attr.name)?.value;
+        if (!src) return;
+        if (isUrl(src)) return;
+        onResourceFound({
+            filePath: src,
+            childNode: node,
+            assetType: "script"
+        });
+    } else if ('link' === node.nodeName) {
+        const href = node.attrs?.find((attr)=>'href' === attr.name)?.value;
+        const rel = node.attrs?.find((attr)=>'rel' === attr.name)?.value;
+        const imagesrcset = node.attrs?.find((attr)=>'imagesrcset' === attr.name)?.value;
+        if (imagesrcset) emitSrcsetCandidates(imagesrcset, node, 'staticHref', 'imagesrcset', onResourceFound);
+        if (!href) return;
+        if (isUrl(href)) return;
+        const nonStylesheetRelTokens = [
+            'dns-prefetch',
+            'icon',
+            'apple-touch-icon',
+            'apple-touch-icon-precomposed',
+            'mask-icon',
+            'manifest',
+            'modulepreload',
+            'preconnect',
+            'prefetch',
+            'preload',
+            'prerender'
+        ];
+        const relTokens = rel ? rel.toLowerCase().split(/\s+/) : [];
+        onResourceFound(relTokens.some((token)=>nonStylesheetRelTokens.includes(token)) ? {
+            filePath: href,
+            childNode: node,
+            assetType: 'staticHref',
+            attributeName: 'href'
+        } : {
+            filePath: href,
+            childNode: node,
+            assetType: 'css'
+        });
+    } else if ('audio' === node.nodeName || 'embed' === node.nodeName || 'iframe' === node.nodeName || 'img' === node.nodeName || 'input' === node.nodeName || 'source' === node.nodeName || 'track' === node.nodeName || 'video' === node.nodeName) {
+        const src = node.attrs?.find((attr)=>'src' === attr.name)?.value;
+        if (src && !isUrl(src)) onResourceFound({
+            filePath: src,
+            childNode: node,
+            assetType: 'staticSrc',
+            attributeName: 'src'
+        });
+        const srcset = node.attrs?.find((attr)=>'srcset' === attr.name)?.value;
+        if (srcset) emitSrcsetCandidates(srcset, node, 'staticSrc', 'srcset', onResourceFound);
+        if ('video' === node.nodeName) {
+            const poster = node.attrs?.find((attr)=>'poster' === attr.name)?.value;
+            if (poster && !isUrl(poster)) onResourceFound({
+                filePath: poster,
+                childNode: node,
+                assetType: 'staticSrc',
+                attributeName: 'poster'
+            });
+        }
+    }
+    const { childNodes = [] } = node;
+    for (const childNode of childNodes)if ('#comment' !== childNode.nodeName && '#text' !== childNode.nodeName) parseHtml(childNode, onResourceFound);
+}
+const cloneParsedHtmlAsset = (assets)=>({
+        css: [
+            ...assets.css || []
+        ],
+        js: [
+            ...assets.js || []
+        ],
+        moduleJs: [
+            ...assets.moduleJs || []
+        ],
+        static: [
+            ...assets.static || []
+        ]
+    });
+const assetsFromHtmlCache = new Map();
+function getAssetsFromHtml(htmlFilePath, htmlContent) {
+    const assets = {
+        css: [],
+        js: [],
+        moduleJs: [],
+        static: []
+    };
+    if (!htmlFilePath) return assets;
+    let cacheKey;
+    if (void 0 === htmlContent) try {
+        const stat = __rspack_external_node_fs_5ea92f0c.statSync(htmlFilePath);
+        cacheKey = `${stat.mtimeMs}:${stat.size}`;
+        const cached = assetsFromHtmlCache.get(htmlFilePath);
+        if (cached && cached.key === cacheKey) return cloneParsedHtmlAsset(cached.assets);
+    } catch  {
+        cacheKey = void 0;
+    }
+    try {
+        const htmlString = htmlContent || __rspack_external_node_fs_5ea92f0c.readFileSync(htmlFilePath, {
+            encoding: 'utf8'
+        });
+        if (!htmlString) return assets;
+        const htmlDocument = __rspack_external_parse5_utilities_78b19c6a.parse(htmlString);
+        const baseHref = getBaseHref(htmlDocument);
+        const getAbsolutePath = (htmlFilePath, filePathWithParts)=>{
+            const { cleanPath } = cleanAssetUrl(filePathWithParts);
+            return resolveHtmlRefPath(htmlFilePath, baseHref, cleanPath);
+        };
+        parseHtml(htmlDocument, ({ filePath, childNode, assetType })=>{
+            const fileAbsolutePath = getAbsolutePath(htmlFilePath, filePath);
+            switch(assetType){
+                case "script":
+                    {
+                        assets.js?.push(fileAbsolutePath);
+                        const scriptType = childNode?.attrs?.find((attr)=>'type' === attr.name)?.value;
+                        if ('module' === String(scriptType || '').toLowerCase()) assets.moduleJs?.push(fileAbsolutePath);
+                        break;
+                    }
+                case 'css':
+                    assets.css?.push(fileAbsolutePath);
+                    break;
+                case 'staticSrc':
+                case 'staticHref':
+                    if (filePath.startsWith('#')) break;
+                    assets.static?.push(fileAbsolutePath);
+                    break;
+                default:
+                    break;
+            }
+        });
+    } catch (error) {
+        const code = error?.code;
+        if (void 0 === htmlContent && 'ENOENT' === code) {
+            assetsFromHtmlCache.delete(htmlFilePath);
+            throw error;
+        }
+        return assets;
+    }
+    if (cacheKey) assetsFromHtmlCache.set(htmlFilePath, {
+        key: cacheKey,
+        assets: cloneParsedHtmlAsset(assets)
+    });
+    return assets;
+}
+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;
+        const assets = getAssetsFromHtml(includePath);
+        return Boolean(assets?.js?.includes(filePath) || assets?.css?.includes(filePath));
+    }) || '';
+    const extname = getExtname(filePath);
+    if (!entryname) return `${filePath.replace(extname, '')}${extension}`;
+    return `/${entryname.replace(extname, '')}${extension}`;
+}
+function getExtname(filePath) {
+    return __rspack_external_node_path_c5b9b54f.extname(filePath);
+}
+function getFilePath(filePath, extension, isPublic) {
+    if (isPublic) return `/${filePath}${extension}`;
+    return `${filePath}${extension}`;
+}
+function isFromIncludeList(filePath, includeList) {
+    return Object.values(includeList || {}).some((value)=>value === filePath);
+}
+function utils_isUrl(src) {
+    try {
+        new URL(src);
+        return true;
+    } catch (err) {
+        return false;
+    }
+}
+function resolveStaticAttributeName(assetType, attributeName) {
+    if (attributeName) return attributeName;
+    return 'staticSrc' === assetType ? 'src' : 'href';
+}
+function rewriteSrcsetCandidate(srcset, fromCleanPath, toUrl) {
+    return srcset.split(',').map((candidate)=>{
+        const match = candidate.match(/^(\s*)(\S+)(.*)$/);
+        if (!match) return candidate;
+        const [, lead, url, rest] = match;
+        const { cleanPath } = cleanAssetUrl(url);
+        if (cleanPath !== fromCleanPath && url !== fromCleanPath) return candidate;
+        return `${lead}${toUrl}${rest}`;
+    }).join(',');
+}
+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));
+    }
+    return __rspack_external_parse5_utilities_78b19c6a.setAttribute(node, attributeName, value);
+}
+function cleanAssetUrl(url) {
+    const hashIndex = url.indexOf('#');
+    const queryIndex = url.indexOf('?');
+    let endIndex = url.length;
+    if (-1 !== hashIndex && -1 !== queryIndex) endIndex = Math.min(hashIndex, queryIndex);
+    else if (-1 !== hashIndex) endIndex = hashIndex;
+    else if (-1 !== queryIndex) endIndex = queryIndex;
+    const cleanPath = url.slice(0, endIndex);
+    const hash = -1 !== hashIndex ? url.slice(hashIndex) : '';
+    const search = -1 !== queryIndex ? url.slice(queryIndex, -1 !== hashIndex ? hashIndex : void 0) : '';
+    return {
+        cleanPath,
+        hash,
+        search
+    };
+}
+function isHttpLike(inputUrl) {
+    return /^https?:\/\//i.test(inputUrl) || inputUrl.startsWith('//');
+}
+function isSpecialScheme(u) {
+    return /^(data:|blob:|chrome-extension:|javascript:|about:)/i.test(u);
+}
+function cleanLeading(s) {
+    return s.replace(/^\/+/, '').replace(/^\.\//, '').replace(/^\./, '');
+}
+function joinEmittedAssetName(prefix, rel) {
+    const parts = __rspack_external_node_path_c5b9b54f.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);
+}
+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 escapes = posix.split('/').includes('..');
+            return escapes ? externalAssetOutputPath(posix, 'assets') : joinEmittedAssetName('assets', posix);
+        }
+    }
+    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;
+    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 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('/');
+}
+function resolveAbsoluteFsPath(params) {
+    const { asset, projectRoot, publicRootForResource, outputRoot, manifestRoot } = params;
+    const looksLikeRootUrl = asset.startsWith('/') && !(asset.startsWith(projectRoot) || asset.startsWith(publicRootForResource) || asset.startsWith(outputRoot));
+    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)));
+    };
+    const isRootUrl = looksLikeRootUrl && (rootUrlIsClaimed(asset) || !__rspack_external_node_fs_5ea92f0c.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;
+        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);
+    return {
+        absoluteFsPath,
+        isUnderPublicRoot: Boolean(isUnderPublicRoot),
+        isRootUrl
+    };
+}
+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);
+    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;
+    return pageRelative;
+}
+function getBaseHref(htmlDocument) {
+    return getBaseNode(htmlDocument)?.attrs?.find((a)=>'href' === a.name)?.value;
+}
+function getBaseNode(htmlDocument) {
+    const htmlChildren = htmlDocument.childNodes || [];
+    for (const node of htmlChildren)if (node?.nodeName === 'html') {
+        for (const child of node.childNodes || [])if (child?.nodeName === 'head') {
+            for (const headChild of child.childNodes || [])if (headChild?.nodeName === 'base') {
+                const href = headChild.attrs?.find((a)=>'href' === a.name)?.value;
+                if (href) return headChild;
+            }
+        }
+    }
+}
+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 };