extension-develop 4.1.11 → 4.1.13

package/dist/129.mjs

@@ -0,0 +1,89 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import { sources } from "@rspack/core";
+import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+const REGISTRY_KEY = '__extensionjs_verbatim_css_registry__';
+function registry() {
+    const holder = globalThis;
+    if (!holder[REGISTRY_KEY]) holder[REGISTRY_KEY] = new Map();
+    return holder[REGISTRY_KEY];
+}
+const VERBATIM_CSS_MARKER = /__extjs_verbatim_([a-z0-9]+)__/;
+function registerVerbatimCss(raw, resourcePath) {
+    const id = Math.abs(hash(`${resourcePath || ''}\n${raw}`)).toString(36);
+    registry().set(id, {
+        raw,
+        resourcePath
+    });
+    return id;
+}
+function verbatimCssPlaceholder(id) {
+    return `.__extjs_verbatim_${id}__{--extjs-verbatim:1}\n`;
+}
+function cssRelativeRefs(text) {
+    const scrubbed = text.replace(/\/\*[\s\S]*?\*\//g, ' ');
+    const refs = new Set();
+    const add = (value)=>{
+        const ref = String(value || '').trim();
+        if (!ref || /^(?:[a-z]+:|\/\/|#|data:)/i.test(ref)) return;
+        if (ref.startsWith('/')) return;
+        refs.add(ref.split(/[?#]/)[0]);
+    };
+    for (const match of scrubbed.matchAll(/@import\s+(?:url\()?\s*["']?([^"')\s;]+)["']?\)?/gi))add(match[1]);
+    for (const match of scrubbed.matchAll(/url\(\s*["']?([^"')]+)["']?\s*\)/gi))add(match[1]);
+    return [
+        ...refs
+    ];
+}
+function hash(text) {
+    let value = 0;
+    for(let i = 0; i < text.length; i++)value = 31 * value + text.charCodeAt(i) | 0;
+    return value;
+}
+function restoreVerbatimCssAssets(compilation) {
+    const restored = [];
+    for (const asset of compilation.getAssets()){
+        if (!asset.name.endsWith('.css')) continue;
+        const text = asset.source.source().toString();
+        const match = VERBATIM_CSS_MARKER.exec(text);
+        if (!match) continue;
+        const entry = registry().get(match[1]);
+        if (entry) {
+            compilation.updateAsset(asset.name, new sources.RawSource(entry.raw));
+            restored.push(asset.name);
+            if (entry.resourcePath) emitVerbatimCssClosure(compilation, asset.name, entry.raw, entry.resourcePath, new Set());
+        }
+    }
+    return restored;
+}
+function emitVerbatimCssClosure(compilation, assetName, text, resourcePath, seen) {
+    if ('function' != typeof compilation.emitAsset) return;
+    const sourceDir = __rspack_external_node_path_c5b9b54f.dirname(resourcePath);
+    const assetDir = __rspack_external_node_path_c5b9b54f.posix.dirname(assetName);
+    for (const ref of cssRelativeRefs(text)){
+        const sourceFile = __rspack_external_node_path_c5b9b54f.resolve(sourceDir, ref);
+        if (seen.has(sourceFile) || !__rspack_external_node_fs_5ea92f0c.existsSync(sourceFile)) continue;
+        seen.add(sourceFile);
+        const outName = __rspack_external_node_path_c5b9b54f.posix.normalize(__rspack_external_node_path_c5b9b54f.posix.join(assetDir, ref.split(__rspack_external_node_path_c5b9b54f.sep).join('/')));
+        if (outName.startsWith('..')) continue;
+        const bytes = __rspack_external_node_fs_5ea92f0c.readFileSync(sourceFile);
+        if ('function' != typeof compilation.getAsset || !compilation.getAsset(outName)) compilation.emitAsset(outName, new sources.RawSource(bytes));
+        if (sourceFile.endsWith('.css')) emitVerbatimCssClosure(compilation, outName, bytes.toString('utf8'), sourceFile, seen);
+    }
+}
+function cssSelectorTokens(text) {
+    const tokens = new Set();
+    const scrubbed = text.replace(/\/\*[\s\S]*?\*\//g, ' ').replace(/url\([^)]*\)/g, ' ').replace(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g, ' ');
+    for (const match of scrubbed.matchAll(/[.#][A-Za-z_-][\w-]*/g)){
+        const token = match[0];
+        if (!/^#[0-9a-fA-F]{3,8}$/.test(token)) tokens.add(token);
+    }
+    return tokens;
+}
+function minifierDroppedTokens(before, after) {
+    const kept = cssSelectorTokens(after);
+    return [
+        ...cssSelectorTokens(before)
+    ].filter((token)=>!kept.has(token));
+}
+export { minifierDroppedTokens, registerVerbatimCss, restoreVerbatimCssAssets, verbatimCssPlaceholder };

package/dist/278.mjs

@@ -0,0 +1,52 @@
+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";
+function isUsableDir(candidate) {
+    try {
+        if (!__rspack_external_node_fs_5ea92f0c.existsSync(candidate)) return false;
+        const stat = __rspack_external_node_fs_5ea92f0c.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 rootOk = isUsableDir(fromRoot);
+    const manifestOk = !sameLocation && isUsableDir(fromManifest);
+    return {
+        publicDir: rootOk ? fromRoot : manifestOk ? fromManifest : void 0,
+        fromRoot,
+        fromManifest,
+        usedFallback: !rootOk && manifestOk,
+        bothExist: rootOk && manifestOk
+    };
+}
+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');
+}
+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 roots = [
+        fromRoot,
+        manifestDir
+    ];
+    if (__rspack_external_node_path_c5b9b54f.resolve(fromManifest) !== __rspack_external_node_path_c5b9b54f.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)));
+}
+function publicRootsFor(compiler) {
+    if (!compiler) return [];
+    return publicRootsByCompiler.get(compiler) || [];
+}
+export { inspectPublicFolders, publicFolderOrDefault, publicResolveRoots, publicRootsFor, rememberPublicRoots };

package/dist/292.mjs

@@ -0,0 +1,61 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+function identityLineMap(resourcePath, source) {
+    const lineCount = source.split('\n').length;
+    const groups = [];
+    for(let line = 0; line < lineCount; line++)groups.push(0 === line ? 'AAAA' : 'AACA');
+    return {
+        version: 3,
+        file: '',
+        sources: [
+            resourcePath
+        ],
+        sourcesContent: [
+            source
+        ],
+        names: [],
+        mappings: groups.join(';')
+    };
+}
+function isLoaderSourceMap(value) {
+    return Boolean(value && 'object' == typeof value && 'string' == typeof value.mappings && Array.isArray(value.sources));
+}
+function inputOrIdentityMap(inputSourceMap, resourcePath, source) {
+    if (isLoaderSourceMap(inputSourceMap)) return {
+        ...inputSourceMap,
+        file: inputSourceMap.file || ''
+    };
+    if ('string' == typeof inputSourceMap) try {
+        const parsed = JSON.parse(inputSourceMap);
+        if (isLoaderSourceMap(parsed)) return {
+            ...parsed,
+            file: parsed.file || ''
+        };
+    } catch  {}
+    return identityLineMap(resourcePath, source);
+}
+function adjustLoaderSourceMap(map, options) {
+    let groups = map.mappings.split(';');
+    const beforeLines = options.before.split('\n');
+    const afterLines = options.after.split('\n');
+    const removed = beforeLines.length - afterLines.length;
+    if (removed > 0) {
+        let at = 0;
+        while(at < afterLines.length && at < beforeLines.length && beforeLines[at] === afterLines[at])at++;
+        groups.splice(at, removed);
+    }
+    const prefixLineCount = options.prefix ? options.prefix.split('\n').length - 1 : 0;
+    if (prefixLineCount > 0) groups = [
+        ...new Array(prefixLineCount).fill(''),
+        ...groups
+    ];
+    return {
+        ...map,
+        mappings: groups.join(';')
+    };
+}
+function returnWithMap(context, text, map) {
+    const callback = context?.callback;
+    if ('function' == typeof callback) return void callback.call(context, null, text, map);
+    return text;
+}
+export { adjustLoaderSourceMap, inputOrIdentityMap, returnWithMap };

package/dist/372.mjs

@@ -0,0 +1,87 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import { replaceCssUrlRefs, toPosixPath, htmlStaticAssetOutputName } from "./518.mjs";
+import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+const EXTENSION_ROOT_PLACEHOLDER = '__EXTENSIONJS_EXTENSION_ROOT__/';
+function isFile(candidate) {
+    try {
+        return __rspack_external_node_fs_5ea92f0c.statSync(candidate).isFile();
+    } catch  {
+        return false;
+    }
+}
+function resolveTarget(req, { resourcePath, manifestDir, publicRoot }) {
+    if (req.startsWith('/')) {
+        const rel = req.slice(1);
+        const fromPublic = __rspack_external_node_path_c5b9b54f.join(publicRoot, rel);
+        if (isFile(fromPublic)) return {
+            absolutePath: fromPublic,
+            outputName: toPosixPath(__rspack_external_node_path_c5b9b54f.normalize(rel)),
+            publicOwned: true
+        };
+        const fromManifest = __rspack_external_node_path_c5b9b54f.join(manifestDir, rel);
+        if (!isFile(fromManifest)) return;
+        return {
+            absolutePath: fromManifest,
+            outputName: htmlStaticAssetOutputName(manifestDir, resourcePath, fromManifest),
+            publicOwned: false
+        };
+    }
+    const absolutePath = __rspack_external_node_path_c5b9b54f.resolve(__rspack_external_node_path_c5b9b54f.dirname(resourcePath), req);
+    if (!isFile(absolutePath)) return;
+    return {
+        absolutePath,
+        outputName: htmlStaticAssetOutputName(manifestDir, resourcePath, absolutePath),
+        publicOwned: false
+    };
+}
+function rewriteInlinedCssUrls(source, context) {
+    const targets = [];
+    const seen = new Map();
+    const css = replaceCssUrlRefs(source, (request)=>{
+        const suffixAt = request.search(/[?#]/);
+        const req = -1 === suffixAt ? request : request.slice(0, suffixAt);
+        const suffix = -1 === suffixAt ? '' : request.slice(suffixAt);
+        if (!req || req.startsWith('//') || /^[a-z][a-z0-9+.-]*:/i.test(req)) return;
+        if (req.startsWith('~') || req.startsWith('@')) return;
+        if (req.startsWith(EXTENSION_ROOT_PLACEHOLDER)) return;
+        let outputName = seen.get(req);
+        if (!outputName) {
+            const target = resolveTarget(req, context);
+            if (!target) return;
+            outputName = target.outputName;
+            seen.set(req, outputName);
+            targets.push({
+                request: req,
+                ...target
+            });
+        }
+        return `${EXTENSION_ROOT_PLACEHOLDER}${outputName}${suffix}`;
+    });
+    return {
+        css,
+        targets
+    };
+}
+function toRuntimeStylesheetModule(css) {
+    return [
+        `var __extjsCssText = ${JSON.stringify(css)};`,
+        'function __extjsExtensionRoot() {',
+        '  try {',
+        '    if (typeof browser === "object" && browser && browser.runtime && typeof browser.runtime.getURL === "function") return String(browser.runtime.getURL("/"));',
+        '  } catch (error) {}',
+        '  try {',
+        '    if (typeof chrome === "object" && chrome && chrome.runtime && typeof chrome.runtime.getURL === "function") return String(chrome.runtime.getURL("/"));',
+        '  } catch (error) {}',
+        '  try {',
+        '    var base = (typeof globalThis === "object" && globalThis && globalThis.__EXTJS_EXTENSION_BASE__) ? String(globalThis.__EXTJS_EXTENSION_BASE__) : "";',
+        '    if (!base && typeof document === "object" && document && document.documentElement) base = String(document.documentElement.getAttribute("data-extjs-extension-base") || "");',
+        '    if (base) return base.replace(/\\/+$/, "") + "/";',
+        '  } catch (error) {}',
+        '  return "/";',
+        '}',
+        `module.exports = "data:text/css;charset=utf-8," + encodeURIComponent(__extjsCssText.split(${JSON.stringify(EXTENSION_ROOT_PLACEHOLDER)}).join(__extjsExtensionRoot()));`,
+        ''
+    ].join('\n');
+}
+export { EXTENSION_ROOT_PLACEHOLDER, rewriteInlinedCssUrls, toRuntimeStylesheetModule };