@rsbuild/core 1.4.1 → 1.4.2

package/dist/index.cjs

@@ -759,12 +759,6 @@ var __webpack_modules__ = {
             return module;
         });
     },
-    "../../compiled/open/index.js": function(module) {
-        "use strict";
-        module.exports = import("../compiled/open/index.js").then(function(module) {
-            return module;
-        });
-    },
     "../../compiled/postcss-load-config/index.js": function(module) {
         "use strict";
         module.exports = import("../compiled/postcss-load-config/index.js").then(function(module) {
@@ -902,7 +896,7 @@ __webpack_require__.n = (module)=>{
 var __webpack_exports__ = {};
 for(var __webpack_i__ in (()=>{
     "use strict";
-    let swcHelpersPath, pluginHelper_htmlPlugin, cssExtractPlugin;
+    let swcHelpersPath, pluginHelper_htmlPlugin, cssExtractPlugin, isDockerCached, cachedResult;
     __webpack_require__.r(__webpack_exports__), __webpack_require__.d(__webpack_exports__, {
         PLUGIN_CSS_NAME: ()=>PLUGIN_CSS_NAME,
         createRsbuild: ()=>createRsbuild,
@@ -2247,7 +2241,7 @@ ${section.body}` : section.body).join("\n\n"));
     async function createContext(options, userConfig) {
         let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = (0, external_node_path_namespaceObject.join)(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0, bundlerType = userConfig.provider ? 'webpack' : 'rspack';
         return {
-            version: "1.4.1",
+            version: "1.4.2",
             rootPath,
             distPath: '',
             cachePath,
@@ -3425,7 +3419,322 @@ ${section.body}` : section.body).join("\n\n"));
             scriptTests,
             styleTests
         };
-    }, normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1'), joinUrlSegments = (s1, s2)=>s1 && s2 ? addTrailingSlash(s1) + removeLeadingSlash(s2) : s1 || s2 || '', stripBase = (path, base)=>{
+    }, external_node_buffer_namespaceObject = require("node:buffer"), external_node_child_process_namespaceObject = require("node:child_process"), promises_namespaceObject = require("node:fs/promises");
+    function isInsideContainer() {
+        return void 0 === cachedResult && (cachedResult = (()=>{
+            try {
+                return external_node_fs_namespaceObject.statSync('/run/.containerenv'), !0;
+            } catch  {
+                return !1;
+            }
+        })() || (void 0 === isDockerCached && (isDockerCached = function() {
+            try {
+                return external_node_fs_namespaceObject.statSync('/.dockerenv'), !0;
+            } catch  {
+                return !1;
+            }
+        }() || function() {
+            try {
+                return external_node_fs_namespaceObject.readFileSync('/proc/self/cgroup', 'utf8').includes('docker');
+            } catch  {
+                return !1;
+            }
+        }()), isDockerCached)), cachedResult;
+    }
+    let isWsl = ()=>{
+        if ('linux' !== external_node_process_namespaceObject.platform) return !1;
+        if (external_node_os_namespaceObject.release().toLowerCase().includes('microsoft')) return !isInsideContainer();
+        try {
+            return !!external_node_fs_namespaceObject.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft') && !isInsideContainer();
+        } catch  {
+            return !1;
+        }
+    }, is_wsl = external_node_process_namespaceObject.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+    function defineLazyProperty(object, propertyName, valueGetter) {
+        let define = (value)=>Object.defineProperty(object, propertyName, {
+                value,
+                enumerable: !0,
+                writable: !0
+            });
+        return Object.defineProperty(object, propertyName, {
+            configurable: !0,
+            enumerable: !0,
+            get () {
+                let result = valueGetter();
+                return define(result), result;
+            },
+            set (value) {
+                define(value);
+            }
+        }), object;
+    }
+    let execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
+    async function defaultBrowserId() {
+        if ('darwin' !== external_node_process_namespaceObject.platform) throw Error('macOS only');
+        let { stdout } = await execFileAsync('defaults', [
+            'read',
+            'com.apple.LaunchServices/com.apple.launchservices.secure',
+            'LSHandlers'
+        ]), match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+        return match?.groups.id ?? 'com.apple.Safari';
+    }
+    let run_applescript_execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
+    async function runAppleScript(script, { humanReadableOutput = !0 } = {}) {
+        if ('darwin' !== external_node_process_namespaceObject.platform) throw Error('macOS only');
+        let { stdout } = await run_applescript_execFileAsync("osascript", [
+            '-e',
+            script,
+            humanReadableOutput ? [] : [
+                '-ss'
+            ]
+        ]);
+        return stdout.trim();
+    }
+    async function bundleName(bundleId) {
+        return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string\ntell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+    }
+    let windows_execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile), windowsBrowserProgIds = {
+        AppXq0fevzme2pys62n3e0fbqa7peapykr8v: {
+            name: 'Edge',
+            id: 'com.microsoft.edge.old'
+        },
+        MSEdgeDHTML: {
+            name: 'Edge',
+            id: 'com.microsoft.edge'
+        },
+        MSEdgeHTM: {
+            name: 'Edge',
+            id: 'com.microsoft.edge'
+        },
+        'IE.HTTP': {
+            name: 'Internet Explorer',
+            id: 'com.microsoft.ie'
+        },
+        FirefoxURL: {
+            name: 'Firefox',
+            id: 'org.mozilla.firefox'
+        },
+        ChromeHTML: {
+            name: 'Chrome',
+            id: 'com.google.chrome'
+        },
+        BraveHTML: {
+            name: 'Brave',
+            id: 'com.brave.Browser'
+        },
+        BraveBHTML: {
+            name: 'Brave Beta',
+            id: 'com.brave.Browser.beta'
+        },
+        BraveSSHTM: {
+            name: 'Brave Nightly',
+            id: 'com.brave.Browser.nightly'
+        }
+    };
+    class UnknownBrowserError extends Error {
+    }
+    async function defaultBrowser(_execFileAsync = windows_execFileAsync) {
+        let { stdout } = await _execFileAsync('reg', [
+            'QUERY',
+            ' HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice',
+            '/v',
+            'ProgId'
+        ]), match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+        if (!match) throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+        let { id } = match.groups, browser = windowsBrowserProgIds[id];
+        if (!browser) throw new UnknownBrowserError(`Unknown browser ID: ${id}`);
+        return browser;
+    }
+    let default_browser_execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
+    async function default_browser_defaultBrowser() {
+        if ('darwin' === external_node_process_namespaceObject.platform) {
+            let id = await defaultBrowserId();
+            return {
+                name: await bundleName(id),
+                id
+            };
+        }
+        if ('linux' === external_node_process_namespaceObject.platform) {
+            let { stdout } = await default_browser_execFileAsync('xdg-mime', [
+                'query',
+                'default',
+                'x-scheme-handler/http'
+            ]), id = stdout.trim();
+            return {
+                name: id.replace(/.desktop$/, '').replace('-', ' ').toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x)=>x.toUpperCase()),
+                id
+            };
+        }
+        if ('win32' === external_node_process_namespaceObject.platform) return defaultBrowser();
+        throw Error('Only macOS, Linux, and Windows are supported');
+    }
+    let execFile = external_node_util_namespaceObject.promisify(external_node_child_process_namespaceObject.execFile), open_dirname = external_node_path_namespaceObject.dirname((0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__)), localXdgOpenPath = external_node_path_namespaceObject.join(open_dirname, 'xdg-open'), { platform, arch } = external_node_process_namespaceObject, getWslDrivesMountPoint = (()=>{
+        let mountPoint, defaultMountPoint = '/mnt/';
+        return async function() {
+            if (mountPoint) return mountPoint;
+            let configFilePath = '/etc/wsl.conf', isConfigFileExists = !1;
+            try {
+                await promises_namespaceObject.access(configFilePath, promises_namespaceObject.constants.F_OK), isConfigFileExists = !0;
+            } catch  {}
+            if (!isConfigFileExists) return defaultMountPoint;
+            let configContent = await promises_namespaceObject.readFile(configFilePath, {
+                encoding: 'utf8'
+            }), configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+            return configMountPoint ? mountPoint = (mountPoint = configMountPoint.groups.mountPoint.trim()).endsWith('/') ? mountPoint : `${mountPoint}/` : defaultMountPoint;
+        };
+    })(), getPowershellPathFromWsl = async ()=>{
+        let mountPoint = await getWslDrivesMountPoint();
+        return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+    };
+    async function getWindowsDefaultBrowserFromWsl() {
+        let powershellPath = await getPowershellPathFromWsl(), encodedCommand = external_node_buffer_namespaceObject.Buffer.from('(Get-ItemProperty -Path "HKCU:\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice").ProgId', 'utf16le').toString('base64'), { stdout } = await execFile(powershellPath, [
+            '-NoProfile',
+            '-NonInteractive',
+            '-ExecutionPolicy',
+            'Bypass',
+            '-EncodedCommand',
+            encodedCommand
+        ], {
+            encoding: 'utf8'
+        }), progId = stdout.trim(), browserMap = {
+            ChromeHTML: 'com.google.chrome',
+            MSEdgeHTM: 'com.microsoft.edge',
+            FirefoxURL: 'org.mozilla.firefox'
+        };
+        return browserMap[progId] ? {
+            id: browserMap[progId]
+        } : {};
+    }
+    let pTryEach = async (array, mapper)=>{
+        let latestError;
+        for (let item of array)try {
+            return await mapper(item);
+        } catch (error) {
+            latestError = error;
+        }
+        throw latestError;
+    }, baseOpen = async (options)=>{
+        let command;
+        if (Array.isArray((options = {
+            wait: !1,
+            background: !1,
+            newInstance: !1,
+            allowNonzeroExitCode: !1,
+            ...options
+        }).app)) return pTryEach(options.app, (singleApp)=>baseOpen({
+                ...options,
+                app: singleApp
+            }));
+        let { name: app, arguments: appArguments = [] } = options.app ?? {};
+        if (appArguments = [
+            ...appArguments
+        ], Array.isArray(app)) return pTryEach(app, (appName)=>baseOpen({
+                ...options,
+                app: {
+                    name: appName,
+                    arguments: appArguments
+                }
+            }));
+        if ('browser' === app || 'browserPrivate' === app) {
+            let ids = {
+                'com.google.chrome': 'chrome',
+                'google-chrome.desktop': 'chrome',
+                'org.mozilla.firefox': 'firefox',
+                'firefox.desktop': 'firefox',
+                'com.microsoft.msedge': 'edge',
+                'com.microsoft.edge': 'edge',
+                'com.microsoft.edgemac': 'edge',
+                'microsoft-edge.desktop': 'edge'
+            }, browser = is_wsl ? await getWindowsDefaultBrowserFromWsl() : await default_browser_defaultBrowser();
+            if (browser.id in ids) {
+                let browserName = ids[browser.id];
+                return 'browserPrivate' === app && appArguments.push({
+                    chrome: '--incognito',
+                    firefox: '--private-window',
+                    edge: '--inPrivate'
+                }[browserName]), baseOpen({
+                    ...options,
+                    app: {
+                        name: apps[browserName],
+                        arguments: appArguments
+                    }
+                });
+            }
+            throw Error(`${browser.name} is not supported as a default browser`);
+        }
+        let cliArguments = [], childProcessOptions = {};
+        if ('darwin' === platform) command = 'open', options.wait && cliArguments.push('--wait-apps'), options.background && cliArguments.push('--background'), options.newInstance && cliArguments.push('--new'), app && cliArguments.push('-a', app);
+        else if ('win32' !== platform && (!is_wsl || isInsideContainer() || app)) {
+            if (app) command = app;
+            else {
+                let isBundled = !open_dirname || '/' === open_dirname, exeLocalXdgOpen = !1;
+                try {
+                    await promises_namespaceObject.access(localXdgOpenPath, promises_namespaceObject.constants.X_OK), exeLocalXdgOpen = !0;
+                } catch  {}
+                command = external_node_process_namespaceObject.versions.electron ?? ('android' === platform || isBundled || !exeLocalXdgOpen) ? 'xdg-open' : localXdgOpenPath;
+            }
+            appArguments.length > 0 && cliArguments.push(...appArguments), options.wait || (childProcessOptions.stdio = 'ignore', childProcessOptions.detached = !0);
+        } else {
+            command = is_wsl ? await getPowershellPathFromWsl() : `${external_node_process_namespaceObject.env.SYSTEMROOT || external_node_process_namespaceObject.env.windir || 'C:\\Windows'}\\System32\\WindowsPowerShell\\v1.0\\powershell`, cliArguments.push('-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand'), is_wsl || (childProcessOptions.windowsVerbatimArguments = !0);
+            let encodedArguments = [
+                'Start'
+            ];
+            options.wait && encodedArguments.push('-Wait'), app ? (encodedArguments.push(`"\`"${app}\`""`), options.target && appArguments.push(options.target)) : options.target && encodedArguments.push(`"${options.target}"`), appArguments.length > 0 && (appArguments = appArguments.map((argument)=>`"\`"${argument}\`""`), encodedArguments.push('-ArgumentList', appArguments.join(','))), options.target = external_node_buffer_namespaceObject.Buffer.from(encodedArguments.join(' '), 'utf16le').toString('base64');
+        }
+        'darwin' === platform && appArguments.length > 0 && cliArguments.push('--args', ...appArguments), options.target && cliArguments.push(options.target);
+        let subprocess = external_node_child_process_namespaceObject.spawn(command, cliArguments, childProcessOptions);
+        return options.wait ? new Promise((resolve, reject)=>{
+            subprocess.once('error', reject), subprocess.once('close', (exitCode)=>{
+                if (!options.allowNonzeroExitCode && exitCode > 0) return void reject(Error(`Exited with code ${exitCode}`));
+                resolve(subprocess);
+            });
+        }) : (subprocess.unref(), subprocess);
+    };
+    function detectArchBinary(binary) {
+        if ('string' == typeof binary || Array.isArray(binary)) return binary;
+        let { [arch]: archBinary } = binary;
+        if (!archBinary) throw Error(`${arch} is not supported`);
+        return archBinary;
+    }
+    function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+        if (wsl && is_wsl) return detectArchBinary(wsl);
+        if (!platformBinary) throw Error(`${platform} is not supported`);
+        return detectArchBinary(platformBinary);
+    }
+    let apps = {};
+    defineLazyProperty(apps, 'chrome', ()=>detectPlatformBinary({
+            darwin: 'google chrome',
+            win32: 'chrome',
+            linux: [
+                'google-chrome',
+                'google-chrome-stable',
+                'chromium'
+            ]
+        }, {
+            wsl: {
+                ia32: '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe',
+                x64: [
+                    '/mnt/c/Program Files/Google/Chrome/Application/chrome.exe',
+                    '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe'
+                ]
+            }
+        })), defineLazyProperty(apps, 'firefox', ()=>detectPlatformBinary({
+            darwin: 'firefox',
+            win32: 'C:\\Program Files\\Mozilla Firefox\\firefox.exe',
+            linux: 'firefox'
+        }, {
+            wsl: '/mnt/c/Program Files/Mozilla Firefox/firefox.exe'
+        })), defineLazyProperty(apps, 'edge', ()=>detectPlatformBinary({
+            darwin: 'microsoft edge',
+            win32: 'msedge',
+            linux: [
+                'microsoft-edge',
+                'microsoft-edge-dev'
+            ]
+        }, {
+            wsl: '/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe'
+        })), defineLazyProperty(apps, 'browser', ()=>'browser'), defineLazyProperty(apps, 'browserPrivate', ()=>'browserPrivate');
+    let normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1'), joinUrlSegments = (s1, s2)=>s1 && s2 ? addTrailingSlash(s1) + removeLeadingSlash(s2) : s1 || s2 || '', stripBase = (path, base)=>{
         if (path === base) return '/';
         let trailingSlashBase = addTrailingSlash(base);
         return path.startsWith(trailingSlashBase) ? path.slice(trailingSlashBase.length - 1) : path;
@@ -3611,19 +3920,27 @@ ${section.body}` : section.body).join("\n\n"));
             }
         }
         try {
-            let { default: open } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/open/index.js")), { apps } = open, options = browser1 ? {
+            let options = browser1 ? {
                 app: {
                     name: apps[browser1] ?? browser1,
                     arguments: null == browserArgs1 ? void 0 : browserArgs1.split(' ')
                 }
             } : {};
-            return await open(url, options), !0;
+            return (await ((target, options)=>{
+                if ('string' != typeof target) throw TypeError('Expected a `target`');
+                return baseOpen({
+                    ...options,
+                    target
+                });
+            })(url, options)).on('error', (err)=>{
+                index_js_namespaceObject.logger.error('Failed to launch browser in child process', err);
+            }), !0;
         } catch (err) {
-            return index_js_namespaceObject.logger.error('Failed to open start URL.'), index_js_namespaceObject.logger.error(err), !1;
+            return index_js_namespaceObject.logger.error('Failed to launch browser.'), index_js_namespaceObject.logger.error(err), !1;
         }
     }
     let openedURLs = [], replacePortPlaceholder = (url, port)=>url.replace(/<port>/g, String(port));
-    async function open_open({ https, port, routes, config, clearCache }) {
+    async function server_open_open({ https, port, routes, config, clearCache }) {
         let { targets, before } = ((config)=>{
             let { open } = config.server;
             return 'boolean' == typeof open ? {
@@ -3639,7 +3956,6 @@ ${section.body}` : section.body).join("\n\n"));
                 before: open.before
             };
         })(config);
-        if ('true' === process.env.CSB) return;
         clearCache && (openedURLs = []);
         let urls = [], host = await getHostInUrl(config.server.host), baseUrl = `${https ? 'https' : 'http'}://${host}:${port}`;
         for (let url of (targets.length ? urls.push(...targets.map((target)=>(function(str, base) {
@@ -5172,7 +5488,7 @@ ${section.body}` : section.body).join("\n\n"));
                 protocol,
                 printUrls: config.server.printUrls,
                 trailingLineBreak: !cliShortcutsEnabled
-            }), openPage = async ()=>open_open({
+            }), openPage = async ()=>server_open_open({
                 https,
                 port: port1,
                 routes,
@@ -5451,7 +5767,7 @@ ${section.body}` : section.body).join("\n\n"));
                         protocol,
                         printUrls: serverConfig.printUrls,
                         trailingLineBreak: !cliShortcutsEnabled
-                    }), openPage = async ()=>open_open({
+                    }), openPage = async ()=>server_open_open({
                         https,
                         port,
                         routes,
@@ -5510,7 +5826,7 @@ ${section.body}` : section.body).join("\n\n"));
                             ...chain.get('experiments'),
                             rspackFuture: {
                                 bundlerInfo: {
-                                    force: !!config.security.sri.enable
+                                    force: !1
                                 }
                             }
                         }), process.env.RSPACK_CONFIG_VALIDATE ||= 'loose-silent';
@@ -6349,7 +6665,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                             let { config, browserslist } = environment, cacheRoot = external_node_path_default().join(api.context.cachePath, '.swc'), rule = chain.module.rule(CHAIN_ID.RULE.JS).test(SCRIPT_REGEX).type("javascript/auto").dependency({
                                 not: 'url'
                             }).resourceQuery({
-                                not: /raw|inline/
+                                not: /raw/
                             });
                             chain.module.rule(CHAIN_ID.RULE.JS_RAW).test(SCRIPT_REGEX).type('asset/source').resourceQuery(/raw/);
                             let dataUriRule = chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).mimetype({
@@ -6716,7 +7032,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         let config = api.getNormalizedConfig();
                         if (config.server.open) {
                             var _api_context_devServer;
-                            open_open({
+                            server_open_open({
                                 https: null == (_api_context_devServer = api.context.devServer) ? void 0 : _api_context_devServer.https,
                                 port,
                                 routes,
@@ -7528,11 +7844,11 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             ].includes(level) && (index_js_namespaceObject.logger.level = level);
         }
         let { npm_execpath } = process.env;
-        (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && index_js_namespaceObject.logger.log(), index_js_namespaceObject.logger.greet(`  Rsbuild v1.4.1\n`);
+        (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && index_js_namespaceObject.logger.log(), index_js_namespaceObject.logger.greet(`  Rsbuild v1.4.2\n`);
         try {
             !function() {
                 let cli = ((name = "")=>new CAC(name))('rsbuild');
-                cli.help(), cli.version("1.4.1"), cli.option('--base <base>', 'specify the base path of the server').option('-c, --config <config>', 'specify the configuration file, can be a relative or absolute path').option('--config-loader <loader>', 'specify the loader to load the config file, can be `jiti` or `native`', {
+                cli.help(), cli.version("1.4.2"), cli.option('--base <base>', 'specify the base path of the server').option('-c, --config <config>', 'specify the configuration file, can be a relative or absolute path').option('--config-loader <loader>', 'specify the loader to load the config file, can be `jiti` or `native`', {
                     default: 'jiti'
                 }).option('-r, --root <root>', 'specify the project root directory, can be an absolute path or a path relative to cwd').option('-m, --mode <mode>', 'specify the build mode, can be `development`, `production` or `none`').option('--log-level <level>', 'specify the log level, can be `info`, `warn`, `error` or `silent`').option('--env-mode <mode>', 'specify the env mode to load the `.env.[mode]` file').option('--environment <name>', 'specify the name of environment to build', {
                     type: [
@@ -7590,7 +7906,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             index_js_namespaceObject.logger.error('Failed to start Rsbuild CLI.'), index_js_namespaceObject.logger.error(err);
         }
     }
-    let src_version = "1.4.1";
+    let src_version = "1.4.2";
 })(), exports.PLUGIN_CSS_NAME = __webpack_exports__.PLUGIN_CSS_NAME, exports.PLUGIN_SWC_NAME = __webpack_exports__.PLUGIN_SWC_NAME, exports.createRsbuild = __webpack_exports__.createRsbuild, exports.defaultAllowedOrigins = __webpack_exports__.defaultAllowedOrigins, exports.defineConfig = __webpack_exports__.defineConfig, exports.ensureAssetPrefix = __webpack_exports__.ensureAssetPrefix, exports.loadConfig = __webpack_exports__.loadConfig, exports.loadEnv = __webpack_exports__.loadEnv, exports.logger = __webpack_exports__.logger, exports.mergeRsbuildConfig = __webpack_exports__.mergeRsbuildConfig, exports.rspack = __webpack_exports__.rspack, exports.runCLI = __webpack_exports__.runCLI, exports.version = __webpack_exports__.version, __webpack_exports__)-1 === [
     "PLUGIN_CSS_NAME",
     "PLUGIN_SWC_NAME",