extension-develop 3.0.0 → 3.1.0-next.11

package/dist/552.js

@@ -0,0 +1,54 @@
+"use strict";
+exports.ids = [
+    "552"
+];
+exports.modules = {
+    "./webpack/webpack-lib/branding.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            P: ()=>makeSanitizedConsole,
+            h: ()=>scrubBrand
+        });
+        function scrubBrand(txt, brand = 'Extension.js') {
+            if (!txt) return txt;
+            return txt.replace(/\bRspack\b/gi, brand).replace(/\bWebpack\b/gi, brand).replace(/\bwebpack-dev-server\b/gi, `${brand} dev server`).replace(/\bRspackDevServer\b/gi, `${brand} dev server`).replace(/ModuleBuildError:\s*/g, '').replace(/ModuleParseError:\s*/g, '').replace(/Error:\s*Module\s+build\s+failed.*?\n/gi, '').replace(/\n{3,}/g, '\n\n');
+        }
+        function makeSanitizedConsole(brand = 'Extension.js') {
+            const sanitize = (a)=>'string' == typeof a ? scrubBrand(a, brand) : a;
+            return {
+                log: (...args)=>console.log(...args.map(sanitize)),
+                info: (...args)=>console.info(...args.map(sanitize)),
+                warn: (...args)=>console.warn(...args.map(sanitize)),
+                error: (...args)=>console.error(...args.map(sanitize))
+            };
+        }
+    },
+    "./webpack/webpack-lib/stats-handler.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            handleStatsErrors: ()=>handleStatsErrors
+        });
+        var _branding__rspack_import_0 = __webpack_require__("./webpack/webpack-lib/branding.ts");
+        function handleStatsErrors(stats) {
+            try {
+                const verbose = '1' === String(process.env.EXTENSION_VERBOSE || '').trim();
+                const str = stats.toString({
+                    colors: true,
+                    all: false,
+                    errors: true,
+                    warnings: !!verbose
+                });
+                if (str) console.error((0, _branding__rspack_import_0.h)(str));
+            } catch  {
+                try {
+                    const str = stats.toString({
+                        colors: true,
+                        all: false,
+                        errors: true,
+                        warnings: true
+                    });
+                    if (str) console.error(str);
+                } catch  {}
+            }
+        }
+    }
+};

package/dist/928.js

@@ -0,0 +1,416 @@
+"use strict";
+exports.ids = [
+    "928"
+];
+exports.modules = {
+    "./webpack/dev-server/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            devServer: ()=>dev_server_devServer
+        });
+        var external_path_ = __webpack_require__("path");
+        var core_ = __webpack_require__("@rspack/core");
+        var dev_server_ = __webpack_require__("@rspack/dev-server");
+        var external_webpack_merge_ = __webpack_require__("webpack-merge");
+        var external_pintor_ = __webpack_require__("pintor");
+        var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_);
+        function getLoggingPrefix(type) {
+            const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+            if (isAuthor) {
+                const base = 'error' === type ? 'ERROR Author says' : '►►► Author says';
+                return external_pintor_default().brightMagenta(base);
+            }
+            if ('error' === type) return external_pintor_default().red('ERROR');
+            if ('warn' === type) return external_pintor_default().brightYellow('►►►');
+            if ('info' === type) return external_pintor_default().gray('►►►');
+            return external_pintor_default().green('►►►');
+        }
+        function ready(mode, browser) {
+            const extensionOutput = 'firefox' === browser || 'gecko-based' === browser || 'edge' === browser ? 'Add-on' : 'Extension';
+            const b = String(browser || '');
+            const cap = b.charAt(0).toUpperCase() + b.slice(1);
+            const pretty = external_pintor_default().green('ready for ' + mode);
+            return `${getLoggingPrefix('info')} ${cap} ${extensionOutput} ${pretty}.`;
+        }
+        function portInUse(requestedPort, newPort) {
+            return `Port: Requested port ${external_pintor_default().brightBlue(requestedPort.toString())} is in use; using ${external_pintor_default().brightBlue(newPort.toString())} instead.`;
+        }
+        function extensionJsRunnerError(error) {
+            return `Extension.js Runner Error:\n${external_pintor_default().red(String(error))}`;
+        }
+        function autoExitModeEnabled(ms) {
+            return `Auto-exit enabled. Will exit after ${external_pintor_default().brightBlue(ms.toString())} ms if idle.`;
+        }
+        function autoExitTriggered(ms) {
+            return `Auto-exit triggered after ${external_pintor_default().brightBlue(ms.toString())} ms. Cleaning up...`;
+        }
+        function autoExitForceKill(ms) {
+            return `Force-killing process after ${external_pintor_default().brightBlue(ms.toString())} ms to ensure exit.`;
+        }
+        function devServerStartTimeout(ms) {
+            return [
+                `Dev server startup is taking longer than expected (${external_pintor_default().brightBlue(ms.toString())} ms).`,
+                "The bundler may have encountered an error before emitting the first build.",
+                `If nothing else prints, try setting ${external_pintor_default().brightBlue('EXTENSION_VERBOSE=1')} for more logs.`
+            ].join('\n');
+        }
+        function bundlerFatalError(error) {
+            const text = error instanceof Error ? error.stack || error.message : String(error);
+            return `Build failed to start:\n${external_pintor_default().red(text)}`;
+        }
+        function bundlerRecompiling() {
+            return `Recompiling due to file changes…`;
+        }
+        function noEntrypointsDetected(port) {
+            return [
+                "No entrypoints or assets were produced by the initial compilation.",
+                `The dev server is running on 127.0.0.1:${external_pintor_default().brightBlue(port.toString())}, but nothing is being built.`,
+                "Possible causes:",
+                `  • Empty or missing entry configuration.`,
+                `  • Extension-related plugins are disabled (entries not derived from manifest).`,
+                `  • All sources are ignored or excluded.`,
+                `Try enabling verbose logs with ${external_pintor_default().brightBlue('EXTENSION_VERBOSE=1')} or review your extension config.`
+            ].join('\n');
+        }
+        var external_crypto_ = __webpack_require__("crypto");
+        var external_net_ = __webpack_require__("net");
+        var shared_utils = __webpack_require__("./webpack/plugin-browsers/browsers-lib/shared-utils.ts");
+        function _define_property(obj, key, value) {
+            if (key in obj) Object.defineProperty(obj, key, {
+                value: value,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+            else obj[key] = value;
+            return obj;
+        }
+        class PortManager {
+            async allocatePorts(_browser, _projectPath, requestedPort) {
+                try {
+                    const isValidRequested = 'number' == typeof requestedPort && requestedPort > 0 && requestedPort < 65536;
+                    const base = isValidRequested ? requestedPort : this.basePort;
+                    const port = await (0, shared_utils.aY)(base);
+                    const webSocketPort = await (0, shared_utils.aY)(port + 1);
+                    const instanceId = external_crypto_.randomBytes(8).toString('hex');
+                    this.currentInstance = {
+                        instanceId,
+                        port,
+                        webSocketPort
+                    };
+                    return {
+                        port,
+                        webSocketPort,
+                        instanceId
+                    };
+                } catch (error) {
+                    throw error;
+                }
+            }
+            getCurrentInstance() {
+                return this.currentInstance;
+            }
+            async updateExtensionId(extensionId) {
+                if (this.currentInstance) this.currentInstance.extensionId = extensionId;
+            }
+            async terminateCurrentInstance() {
+                this.currentInstance = null;
+            }
+            getPortInfo(allocation) {
+                return `Port: ${allocation.port}, WebSocket: ${allocation.webSocketPort}, Instance: ${allocation.instanceId.slice(0, 8)}`;
+            }
+            async isPortInUse(port) {
+                return new Promise((resolve)=>{
+                    const server = external_net_.createServer();
+                    server.once('error', ()=>resolve(true));
+                    server.once('listening', ()=>{
+                        server.close(()=>resolve(false));
+                    });
+                    server.listen(port, '127.0.0.1');
+                });
+            }
+            async getRunningInstances() {
+                return this.currentInstance ? [
+                    this.currentInstance
+                ] : [];
+            }
+            async getStats() {
+                return {
+                    total: this.currentInstance ? 1 : 0,
+                    running: this.currentInstance ? 1 : 0,
+                    terminated: 0,
+                    error: 0
+                };
+            }
+            constructor(_browser, _projectPath, basePort = 8080){
+                _define_property(this, "basePort", void 0);
+                _define_property(this, "currentInstance", null);
+                this.basePort = basePort;
+            }
+        }
+        var external_fs_ = __webpack_require__("fs");
+        function hasDependency(projectPath, dependency) {
+            const findNearestPackageJsonDirectory = (startPath)=>{
+                let currentDirectory = startPath;
+                const maxDepth = 4;
+                for(let i = 0; i < maxDepth; i++){
+                    const candidate = external_path_.join(currentDirectory, 'package.json');
+                    if (external_fs_.existsSync(candidate)) return currentDirectory;
+                    const parentDirectory = external_path_.dirname(currentDirectory);
+                    if (parentDirectory === currentDirectory) break;
+                    currentDirectory = parentDirectory;
+                }
+            };
+            const packageJsonDirectory = findNearestPackageJsonDirectory(projectPath);
+            if (!packageJsonDirectory) return false;
+            const packageJsonPath = external_path_.join(packageJsonDirectory, 'package.json');
+            if (!external_fs_.existsSync(packageJsonPath)) return false;
+            const packageJson = JSON.parse(external_fs_.readFileSync(packageJsonPath, 'utf8'));
+            const dependencies = packageJson.dependencies || {};
+            const devDependencies = packageJson.devDependencies || {};
+            return !!dependencies[dependency] || !!devDependencies[dependency];
+        }
+        function isUsingJSFramework(projectPath) {
+            const frameworks = [
+                'react',
+                'vue',
+                '@angular/core',
+                'svelte',
+                'solid-js',
+                'preact'
+            ];
+            return frameworks.some((fw)=>hasDependency(projectPath, fw));
+        }
+        var config_loader = __webpack_require__("./webpack/webpack-lib/config-loader.ts");
+        var sanitize = __webpack_require__("./webpack/webpack-lib/sanitize.ts");
+        var branding = __webpack_require__("./webpack/webpack-lib/branding.ts");
+        function setupCompilerHooks(compiler, port) {
+            const verbose = '1' === String(process.env.EXTENSION_VERBOSE || '').trim();
+            let reportedNoEntries = false;
+            compiler.hooks.invalid.tap('extension.js:invalid', ()=>{
+                if (verbose) console.log(bundlerRecompiling());
+            });
+            compiler.hooks.failed.tap('extension.js:failed', (error)=>{
+                console.error(bundlerFatalError(error));
+            });
+            compiler.hooks.done.tap('extension.js:done', (stats)=>{
+                try {
+                    if (stats?.hasErrors?.()) {
+                        const str = stats?.toString?.({
+                            colors: true,
+                            all: false,
+                            errors: true,
+                            warnings: true
+                        });
+                        if (str) console.error((0, branding.h)(str));
+                    } else if (stats?.hasWarnings?.()) {
+                        const str = stats?.toString?.({
+                            colors: true,
+                            all: false,
+                            errors: false,
+                            warnings: true
+                        });
+                        if (str) console.warn((0, branding.h)(str));
+                    }
+                    if (!reportedNoEntries) {
+                        const info = stats.toJson({
+                            all: false,
+                            assets: true,
+                            entrypoints: true
+                        });
+                        const hasAssets = Array.isArray(info?.assets) && info.assets.length > 0;
+                        const entrypoints = info?.entrypoints || {};
+                        const hasEntrypoints = entrypoints && Object.keys(entrypoints).length > 0;
+                        if (!hasAssets && !hasEntrypoints) {
+                            reportedNoEntries = true;
+                            console.warn(noEntrypointsDetected(port));
+                        }
+                    }
+                } catch (error) {
+                    const str = stats?.toString({
+                        colors: true,
+                        all: false,
+                        errors: true,
+                        warnings: true
+                    });
+                    if (str) console.error((0, branding.h)(str));
+                }
+            });
+        }
+        function parseMilliseconds(value) {
+            if ('number' == typeof value) return Number.isFinite(value) && value > 0 ? value : null;
+            if ('string' == typeof value) {
+                const parsed = parseInt(value, 10);
+                return !Number.isNaN(parsed) && parsed > 0 ? parsed : null;
+            }
+            return null;
+        }
+        function setupAutoExit(autoExitMsRaw, forceKillMsRaw, onCleanup) {
+            let autoExitTimer = null;
+            let forceKillTimer = null;
+            const autoExitMs = parseMilliseconds(autoExitMsRaw);
+            if (null === autoExitMs) return ()=>{};
+            try {
+                console.log(autoExitModeEnabled(autoExitMs));
+            } catch  {}
+            autoExitTimer = setTimeout(async ()=>{
+                try {
+                    console.log(autoExitTriggered(autoExitMs));
+                } catch  {}
+                await onCleanup();
+            }, autoExitMs);
+            const parsedForceKillMs = parseMilliseconds(forceKillMsRaw);
+            const forceKillMs = null !== parsedForceKillMs && parsedForceKillMs > 0 ? parsedForceKillMs : autoExitMs + 4000;
+            forceKillTimer = setTimeout(()=>{
+                try {
+                    console.log(autoExitForceKill(forceKillMs));
+                } catch  {}
+                process.exit(0);
+            }, forceKillMs);
+            function cancelAutoExitTimers() {
+                if (null !== autoExitTimer) {
+                    clearTimeout(autoExitTimer);
+                    autoExitTimer = null;
+                }
+                if (null !== forceKillTimer) {
+                    clearTimeout(forceKillTimer);
+                    forceKillTimer = null;
+                }
+            }
+            return cancelAutoExitTimers;
+        }
+        function closeAll(devServer, portManager) {
+            return devServer.stop().then(async ()=>{
+                await portManager.terminateCurrentInstance();
+                setTimeout(()=>process.exit(), 500);
+            }).catch(async (error)=>{
+                console.log(extensionJsRunnerError(error));
+                await portManager.terminateCurrentInstance();
+                setTimeout(()=>process.exit(1), 500);
+            });
+        }
+        function setupCleanupHandlers(devServer, portManager) {
+            const cleanup = async ()=>{
+                try {
+                    await closeAll(devServer, portManager);
+                } catch (error) {
+                    console.error('[Extension.js Runner] Error during cleanup.', error);
+                    process.exit(1);
+                }
+            };
+            process.on('uncaughtException', async (error)=>{
+                console.error('[Extension.js Runner] Uncaught exception.', error);
+                await cleanup();
+            });
+            process.on('unhandledRejection', async (reason, promise)=>{
+                console.error('[Extension.js Runner] Unhandled rejection.', promise, reason);
+                await cleanup();
+            });
+            const cancelAutoExit = setupAutoExit(process.env.EXTENSION_AUTO_EXIT_MS, process.env.EXTENSION_FORCE_KILL_MS, cleanup);
+            const cancelAndCleanup = async ()=>{
+                try {
+                    cancelAutoExit();
+                } catch  {}
+                await cleanup();
+            };
+            process.on('ERROR', cancelAndCleanup);
+            process.on('SIGINT', cancelAndCleanup);
+            process.on('SIGTERM', cancelAndCleanup);
+            process.on('SIGHUP', cancelAndCleanup);
+            return cancelAutoExit;
+        }
+        var webpack_config = __webpack_require__("./webpack/webpack-config.ts");
+        async function dev_server_devServer(projectStructure, devOptions) {
+            const { manifestPath, packageJsonPath } = projectStructure;
+            const manifestDir = external_path_.dirname(manifestPath);
+            const packageJsonDir = external_path_.dirname(packageJsonPath);
+            const commandConfig = await (0, config_loader.eY)(packageJsonDir, 'dev');
+            const browserConfig = await (0, config_loader.xY)(packageJsonDir, devOptions.browser);
+            const portManager = new PortManager(devOptions.browser, packageJsonDir, 8080);
+            const desiredPort = 'string' == typeof devOptions.port ? parseInt(devOptions.port, 10) : devOptions.port;
+            const portAllocation = await portManager.allocatePorts(devOptions.browser, packageJsonDir, desiredPort);
+            const currentInstance = portManager.getCurrentInstance();
+            if (!currentInstance) throw new Error('Failed to create instance');
+            const safeBrowserConfig = (0, sanitize.a)(browserConfig);
+            const safeCommandConfig = (0, sanitize.a)(commandConfig);
+            const safeDevOptions = (0, sanitize.a)(devOptions);
+            const baseConfig = (0, webpack_config["default"])(projectStructure, {
+                ...safeBrowserConfig,
+                ...safeCommandConfig,
+                ...safeDevOptions,
+                browser: devOptions.browser,
+                mode: 'development',
+                instanceId: currentInstance.instanceId,
+                port: portAllocation.port,
+                output: {
+                    clean: false,
+                    path: external_path_.join(packageJsonDir, 'dist', devOptions.browser)
+                }
+            });
+            const customWebpackConfig = await (0, config_loader.Tu)(manifestDir);
+            const finalConfig = customWebpackConfig(baseConfig);
+            const compilerConfig = (0, external_webpack_merge_.merge)(finalConfig, {});
+            const compiler = (0, core_.rspack)(compilerConfig);
+            setupCompilerHooks(compiler, portAllocation.port);
+            const port = portAllocation.port;
+            if (void 0 !== devOptions.port && devOptions.port !== port) console.log(portInUse(devOptions.port, port));
+            const serverConfig = {
+                host: '127.0.0.1',
+                allowedHosts: 'all',
+                static: {
+                    watch: {
+                        ignored: /\bnode_modules\b/
+                    }
+                },
+                compress: false,
+                devMiddleware: {
+                    writeToDisk: true,
+                    stats: false
+                },
+                watchFiles: {
+                    paths: [
+                        external_path_.join(packageJsonDir, 'public', '**/*'),
+                        ...isUsingJSFramework(packageJsonDir) ? [] : [
+                            external_path_.join(packageJsonDir, '**/*.html')
+                        ]
+                    ],
+                    options: {
+                        usePolling: true,
+                        interval: 1000
+                    }
+                },
+                client: {
+                    logging: 'none',
+                    progress: false,
+                    overlay: false,
+                    webSocketURL: {
+                        protocol: 'ws',
+                        hostname: '127.0.0.1',
+                        port
+                    }
+                },
+                headers: {
+                    'Access-Control-Allow-Origin': '*'
+                },
+                port,
+                hot: 'only',
+                liveReload: true
+            };
+            const devServer = new dev_server_.RspackDevServer(serverConfig, compiler);
+            const START_TIMEOUT_MS = parseInt(String(process.env.EXTENSION_START_TIMEOUT_MS || '30000'), 10);
+            let startTimeout;
+            try {
+                startTimeout = setTimeout(()=>{
+                    console.error(devServerStartTimeout(START_TIMEOUT_MS));
+                }, START_TIMEOUT_MS);
+                await devServer.start();
+                if (startTimeout) clearTimeout(startTimeout);
+                console.log(ready('development', devOptions.browser));
+            } catch (error) {
+                if (startTimeout) clearTimeout(startTimeout);
+                console.log(extensionJsRunnerError(error));
+                process.exit(1);
+            }
+            setupCleanupHandlers(devServer, portManager);
+        }
+    }
+};

package/dist/add-centralized-logger-script-background.js

@@ -22,7 +22,7 @@ var __webpack_require__ = {};
 })();
 (()=>{
     __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
             value: 'Module'
         });
         Object.defineProperty(exports1, '__esModule', {
@@ -212,9 +212,9 @@ function logger_background(source) {
     return source;
 }
 exports["default"] = __webpack_exports__["default"];
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+for(var __rspack_i in __webpack_exports__)if (-1 === [
     "default"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

package/dist/add-centralized-logger-script-content.js

@@ -22,7 +22,7 @@ var __webpack_require__ = {};
 })();
 (()=>{
     __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
             value: 'Module'
         });
         Object.defineProperty(exports1, '__esModule', {
@@ -153,7 +153,7 @@ function logger_script(source) {
     const declaredContentJsAbsPaths = [];
     const contentScripts = Array.isArray(manifest.content_scripts) ? manifest.content_scripts : [];
     for (const cs of contentScripts){
-        const jsList = Array.isArray(null == cs ? void 0 : cs.js) ? cs.js : [];
+        const jsList = Array.isArray(cs?.js) ? cs.js : [];
         for (const js of jsList){
             const abs = external_path_default().resolve(projectPath, js);
             declaredContentJsAbsPaths.push(abs);
@@ -164,9 +164,9 @@ function logger_script(source) {
     return source;
 }
 exports["default"] = __webpack_exports__["default"];
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+for(var __rspack_i in __webpack_exports__)if (-1 === [
     "default"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

package/dist/add-centralized-logger-script.js

@@ -13,7 +13,7 @@ var __webpack_require__ = {};
 })();
 (()=>{
     __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
             value: 'Module'
         });
         Object.defineProperty(exports1, '__esModule', {
@@ -41,8 +41,7 @@ function isUrl(src) {
 function parseHtml(node, onResourceFound) {
     if ('#comment' === node.nodeName || '#text' === node.nodeName) return;
     if ("script" === node.nodeName) {
-        var _node_attrs_find, _node_attrs;
-        const src = null == (_node_attrs = node.attrs) ? void 0 : null == (_node_attrs_find = _node_attrs.find((attr)=>'src' === attr.name)) ? void 0 : _node_attrs_find.value;
+        const src = node.attrs?.find((attr)=>'src' === attr.name)?.value;
         if (!src) return;
         if (isUrl(src)) return;
         onResourceFound({
@@ -51,9 +50,8 @@ function parseHtml(node, onResourceFound) {
             assetType: "script"
         });
     } else if ('link' === node.nodeName) {
-        var _node_attrs_find1, _node_attrs1, _node_attrs_find2, _node_attrs2;
-        const href = null == (_node_attrs1 = node.attrs) ? void 0 : null == (_node_attrs_find1 = _node_attrs1.find((attr)=>'href' === attr.name)) ? void 0 : _node_attrs_find1.value;
-        const rel = null == (_node_attrs2 = node.attrs) ? void 0 : null == (_node_attrs_find2 = _node_attrs2.find((attr)=>'rel' === attr.name)) ? void 0 : _node_attrs_find2.value;
+        const href = node.attrs?.find((attr)=>'href' === attr.name)?.value;
+        const rel = node.attrs?.find((attr)=>'rel' === attr.name)?.value;
         if (!href) return;
         if (isUrl(href)) return;
         onResourceFound('dns-prefetch' === rel || 'icon' === rel || 'manifest' === rel || 'modulepreload' === rel || 'preconnect' === rel || 'prefetch' === rel || 'preload' === rel || 'prerender' === rel ? {
@@ -66,8 +64,7 @@ function parseHtml(node, onResourceFound) {
             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) {
-        var _node_attrs_find3, _node_attrs3, _node_attrs_find4, _node_attrs4;
-        const src = null == (_node_attrs3 = node.attrs) ? void 0 : null == (_node_attrs_find3 = _node_attrs3.find((attr)=>'src' === attr.name)) ? void 0 : _node_attrs_find3.value;
+        const src = node.attrs?.find((attr)=>'src' === attr.name)?.value;
         if (!src) return;
         if (isUrl(src)) return;
         onResourceFound({
@@ -75,7 +72,7 @@ function parseHtml(node, onResourceFound) {
             childNode: node,
             assetType: 'staticSrc'
         });
-        const srcset = null == (_node_attrs4 = node.attrs) ? void 0 : null == (_node_attrs_find4 = _node_attrs4.find((attr)=>'srcset' === attr.name)) ? void 0 : _node_attrs_find4.value;
+        const srcset = node.attrs?.find((attr)=>'srcset' === attr.name)?.value;
         if (srcset) {
             const candidates = srcset.split(',');
             for (const candidate of candidates){
@@ -91,8 +88,7 @@ function parseHtml(node, onResourceFound) {
             }
         }
         if ('video' === node.nodeName) {
-            var _node_attrs_find5, _node_attrs5;
-            const poster = null == (_node_attrs5 = node.attrs) ? void 0 : null == (_node_attrs_find5 = _node_attrs5.find((attr)=>'poster' === attr.name)) ? void 0 : _node_attrs_find5.value;
+            const poster = node.attrs?.find((attr)=>'poster' === attr.name)?.value;
             if (poster && !isUrl(poster)) {
                 const { cleanPath } = cleanAssetUrl(poster);
                 if (cleanPath) onResourceFound({
@@ -103,8 +99,7 @@ function parseHtml(node, onResourceFound) {
             }
         }
     } else if ('link' === node.nodeName) {
-        var _node_attrs_find6, _node_attrs6;
-        const imagesrcset = null == (_node_attrs6 = node.attrs) ? void 0 : null == (_node_attrs_find6 = _node_attrs6.find((attr)=>'imagesrcset' === attr.name)) ? void 0 : _node_attrs_find6.value;
+        const imagesrcset = node.attrs?.find((attr)=>'imagesrcset' === attr.name)?.value;
         if (imagesrcset) {
             const candidates = imagesrcset.split(',');
             for (const candidate of candidates){
@@ -149,18 +144,15 @@ function getAssetsFromHtml(htmlFilePath, htmlContent, publicPath = 'public') {
             const fileAbsolutePath = getAbsolutePath(htmlFilePath, filePath);
             switch(assetType){
                 case "script":
-                    var _assets_js;
-                    null == (_assets_js = assets.js) || _assets_js.push(fileAbsolutePath);
+                    assets.js?.push(fileAbsolutePath);
                     break;
                 case 'css':
-                    var _assets_css;
-                    null == (_assets_css = assets.css) || _assets_css.push(fileAbsolutePath);
+                    assets.css?.push(fileAbsolutePath);
                     break;
                 case 'staticSrc':
                 case 'staticHref':
-                    var _assets_static;
                     if (filePath.startsWith('#')) break;
-                    null == (_assets_static = assets.static) || _assets_static.push(fileAbsolutePath);
+                    assets.static?.push(fileAbsolutePath);
                     break;
                 default:
                     break;
@@ -195,11 +187,10 @@ function cleanAssetUrl(url) {
 }
 function getBaseHref(htmlDocument) {
     const htmlChildren = htmlDocument.childNodes || [];
-    for (const node of htmlChildren)if ((null == node ? void 0 : node.nodeName) === 'html') {
-        for (const child of node.childNodes || [])if ((null == child ? void 0 : child.nodeName) === 'head') {
-            for (const headChild of child.childNodes || [])if ((null == headChild ? void 0 : headChild.nodeName) === 'base') {
-                var _headChild_attrs_find, _headChild_attrs;
-                const href = null == (_headChild_attrs = headChild.attrs) ? void 0 : null == (_headChild_attrs_find = _headChild_attrs.find((a)=>'href' === a.name)) ? void 0 : _headChild_attrs_find.value;
+    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 href;
             }
         }
@@ -254,7 +245,7 @@ if (import.meta.webpackHot) { import.meta.webpackHot.accept() }
         if (!htmlPath) continue;
         if (!external_fs_namespaceObject.existsSync(htmlPath)) continue;
         const assets = getAssetsFromHtml(htmlPath);
-        const jsAssets = (null == assets ? void 0 : assets.js) || [];
+        const jsAssets = assets?.js || [];
         const absAssets = jsAssets.map((p)=>{
             if (p.startsWith('/')) return external_path_namespaceObject.normalize(external_path_namespaceObject.join(projectPath, 'public', p.slice(1)));
             return external_path_namespaceObject.normalize(p);
@@ -324,9 +315,9 @@ if (import.meta.webpackHot) { import.meta.webpackHot.accept() }
     return `${loggerPrelude}${source}`;
 }
 exports["default"] = __webpack_exports__["default"];
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+for(var __rspack_i in __webpack_exports__)if (-1 === [
     "default"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });