@lynx-js/rspeedy-canary 0.11.3-canary-20250919-f4528d19 → 0.11.3-canary-20250919-8c33d3e1

package/dist/0~src_plugins_api_plugin_ts.js

@@ -0,0 +1,33 @@
+export const __webpack_id__ = "src_plugins_api_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_api_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/api.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            pluginAPI: ()=>pluginAPI
+        });
+        var _rsbuild_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("@rsbuild/core");
+        var _debug_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./src/debug.ts");
+        var _version_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./src/version.ts");
+        const sAPI = Symbol.for('rspeedy.api');
+        function pluginAPI(config) {
+            return {
+                name: 'lynx:rsbuild:plugin-api',
+                setup (api) {
+                    api.expose(sAPI, {
+                        config,
+                        debug: _debug_js__WEBPACK_IMPORTED_MODULE_1__.Yz,
+                        async exit (code) {
+                            const { exit } = await __webpack_require__.e("src_cli_exit_ts").then(__webpack_require__.bind(__webpack_require__, "./src/cli/exit.ts"));
+                            return exit(code);
+                        },
+                        logger: _rsbuild_core__WEBPACK_IMPORTED_MODULE_0__.logger,
+                        version: _version_js__WEBPACK_IMPORTED_MODULE_2__.rE
+                    });
+                }
+            };
+        }
+    }
+};

package/dist/0~src_plugins_rsdoctor_plugin_ts.js

@@ -0,0 +1,54 @@
+export const __webpack_id__ = "src_plugins_rsdoctor_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_rsdoctor_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/rsdoctor.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            pluginRsdoctor: ()=>pluginRsdoctor
+        });
+        var core_ = __webpack_require__("@rsbuild/core");
+        function isCI() {
+            return !!process.env['CI'] && 'false' !== process.env['CI'];
+        }
+        function pluginRsdoctor(options) {
+            return {
+                name: 'lynx:rsbuild:rsdoctor',
+                remove: [
+                    'rsbuild:rsdoctor'
+                ],
+                setup (api) {
+                    if ('true' !== process.env['RSDOCTOR']) return;
+                    api.onBeforeCreateCompiler(async ({ bundlerConfigs })=>{
+                        const { RsdoctorRspackPlugin } = await import("@rsdoctor/rspack-plugin");
+                        for (const config of bundlerConfigs){
+                            const pluginName = 'RsdoctorRspackPlugin';
+                            const registered = config.plugins?.some((plugin)=>'object' == typeof plugin && plugin?.['isRsdoctorPlugin'] === true || plugin?.constructor?.name === pluginName);
+                            if (registered) continue;
+                            config.plugins ??= [];
+                            const defaultOptions = {
+                                disableClientServer: isCI(),
+                                supports: {
+                                    banner: true
+                                },
+                                linter: {
+                                    rules: {
+                                        'ecma-version-check': options?.linter?.rules?.['ecma-version-check'] ?? [
+                                            'Warn',
+                                            {
+                                                ecmaVersion: 2019
+                                            }
+                                        ]
+                                    }
+                                }
+                            };
+                            config.plugins.push(new RsdoctorRspackPlugin((0, core_.mergeRsbuildConfig)(defaultOptions, options)));
+                        }
+                        core_.logger.info("Rsdoctor is enabled.");
+                    });
+                }
+            };
+        }
+    }
+};

package/dist/1~src_plugins_chunkLoading_plugin_ts.js

@@ -0,0 +1,37 @@
+import { LynxCacheEventsPlugin } from "@lynx-js/cache-events-webpack-plugin";
+import { ChunkLoadingWebpackPlugin } from "@lynx-js/chunk-loading-webpack-plugin";
+export const __webpack_id__ = "src_plugins_chunkLoading_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_chunkLoading_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/chunkLoading.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            pluginChunkLoading: ()=>pluginChunkLoading
+        });
+        function isLynx(environment) {
+            return 'string' == typeof environment ? 'lynx' === environment : 'lynx' === environment.name;
+        }
+        var is_web = __webpack_require__("./src/utils/is-web.ts");
+        function pluginChunkLoading() {
+            return {
+                name: 'lynx:rsbuild:chunk-loading',
+                setup (api) {
+                    api.modifyBundlerChain((chain, { environment })=>{
+                        if ((0, is_web.H)(environment)) return void chain.output.chunkLoading("import-scripts").end();
+                        if (isLynx(environment)) chain.plugin('lynx:chunk-loading').use(ChunkLoadingWebpackPlugin).end().plugin('lynx:cache-events').use(LynxCacheEventsPlugin).end().output.chunkLoading('lynx').chunkFormat('commonjs').end();
+                    });
+                }
+            };
+        }
+    },
+    "./src/utils/is-web.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            H: ()=>isWeb
+        });
+        function isWeb(environment) {
+            return 'string' == typeof environment ? 'web' === environment : 'web' === environment.name;
+        }
+    }
+};

package/dist/1~src_plugins_dev_plugin_ts.js

@@ -0,0 +1,144 @@
+import { createRequire } from "node:module";
+export const __webpack_id__ = "src_plugins_dev_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_dev_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/dev.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            pluginDev: ()=>pluginDev,
+            findIp: ()=>findIp
+        });
+        var external_node_path_ = __webpack_require__("node:path");
+        var core_ = __webpack_require__("@rsbuild/core");
+        var picocolors = __webpack_require__("../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+        var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+        var debug = __webpack_require__("./src/debug.ts");
+        class ProvidePlugin_ProvidePlugin {
+            definitions;
+            constructor(definitions){
+                this.definitions = definitions;
+            }
+            apply(compiler) {
+                const { ProvidePlugin } = compiler.webpack;
+                new ProvidePlugin(this.definitions).apply(compiler);
+            }
+        }
+        function pluginDev(options, server) {
+            return {
+                name: 'lynx:rsbuild:dev',
+                apply (config, { action }) {
+                    return 'dev' === action || 'development' === config.mode;
+                },
+                async setup (api) {
+                    const hostname = server?.host ?? await findIp('v4');
+                    let assetPrefix = options?.assetPrefix;
+                    switch(typeof assetPrefix){
+                        case 'string':
+                            if (server?.port !== void 0) {
+                                const hasPortPlaceholder = assetPrefix.includes('<port>');
+                                if (!hasPortPlaceholder) {
+                                    const assetPrefixURL = new URL(assetPrefix);
+                                    if (assetPrefixURL.port !== String(server.port)) {
+                                        core_.logger.warn(`Setting different port values in ${picocolors_default().cyan('server.port')} and ${picocolors_default().cyan('dev.assetPrefix')}. Using server.port(${picocolors_default().cyan(server.port)}) to make HMR work.`);
+                                        assetPrefixURL.port = String(server.port);
+                                        assetPrefix = assetPrefixURL.toString();
+                                    }
+                                }
+                            }
+                            break;
+                        case 'undefined':
+                        case 'boolean':
+                            if (options?.assetPrefix !== false) assetPrefix = `http://${hostname}:<port>/`;
+                            break;
+                    }
+                    if (server?.base) {
+                        if (assetPrefix.endsWith('/')) assetPrefix = assetPrefix.slice(0, -1);
+                        assetPrefix = `${assetPrefix}${server.base}/`;
+                    }
+                    (0, debug.Yz)(`dev.assetPrefix is normalized to ${assetPrefix}`);
+                    api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>mergeRsbuildConfig(config, {
+                            dev: {
+                                assetPrefix,
+                                client: {
+                                    host: hostname,
+                                    port: '<port>'
+                                }
+                            },
+                            output: {
+                                assetPrefix
+                            }
+                        }));
+                    const require = createRequire(import.meta.url);
+                    api.modifyBundlerChain((chain, { isDev, environment })=>{
+                        const { action } = api.context;
+                        if ('dev' !== action && !isDev) return;
+                        const rsbuildPath = require.resolve('@rsbuild/core');
+                        const rspeedyDir = external_node_path_["default"].dirname(require.resolve('@lynx-js/rspeedy/package.json'));
+                        const searchParams = new URLSearchParams({
+                            hostname,
+                            port: api.context.devServer?.port?.toString() ?? '',
+                            pathname: '/rsbuild-hmr',
+                            hot: options?.hmr ?? true ? 'true' : 'false',
+                            'live-reload': options?.liveReload ?? true ? 'true' : 'false',
+                            protocol: 'ws'
+                        });
+                        if (environment.webSocketToken) searchParams.set('token', environment.webSocketToken);
+                        chain.resolve.alias.set('webpack/hot/log.js', require.resolve('@rspack/core/hot/log', {
+                            paths: [
+                                rsbuildPath
+                            ]
+                        })).set('webpack/hot/emitter.js', require.resolve('@rspack/core/hot/emitter', {
+                            paths: [
+                                rsbuildPath
+                            ]
+                        })).set('@lynx-js/webpack-dev-transport/client', `${require.resolve('@lynx-js/webpack-dev-transport/client')}?${searchParams.toString()}`).set('@rspack/core/hot/dev-server', require.resolve('@rspack/core/hot/dev-server', {
+                            paths: [
+                                rsbuildPath
+                            ]
+                        })).end().end().plugin('lynx.hmr.provide').use(ProvidePlugin_ProvidePlugin, [
+                            {
+                                WebSocket: [
+                                    options?.client?.websocketTransport ?? require.resolve('@lynx-js/websocket'),
+                                    'default'
+                                ],
+                                __webpack_dev_server_client__: [
+                                    require.resolve('./client/hmr/WebSocketClient.js', {
+                                        paths: [
+                                            rspeedyDir
+                                        ]
+                                    }),
+                                    'default'
+                                ]
+                            }
+                        ]).end();
+                    });
+                }
+            };
+        }
+        async function findIp(family, isInternal = false) {
+            const [{ default: ipaddr }, os] = await Promise.all([
+                __webpack_require__.e("vendors-node_modules_pnpm_ipaddr_js_2_2_0_node_modules_ipaddr_js_lib_ipaddr_js").then(__webpack_require__.t.bind(__webpack_require__, "../../../node_modules/.pnpm/ipaddr.js@2.2.0/node_modules/ipaddr.js/lib/ipaddr.js", 23)),
+                import("node:os")
+            ]);
+            let host;
+            const networks = Object.values(os.networkInterfaces()).flatMap((networks)=>networks ?? []).filter((network)=>{
+                if (!network || !network.address) return false;
+                if (network.family !== `IP${family}`) return false;
+                if (network.internal !== isInternal) return false;
+                if ('v6' === family) {
+                    const range = ipaddr.parse(network.address).range();
+                    if ('ipv4Mapped' !== range && 'uniqueLocal' !== range) return false;
+                }
+                return network.address;
+            });
+            if (networks.length > 0) {
+                host = networks[0].address;
+                if (host.includes(':')) host = `[${host}]`;
+            }
+            if (!host) throw new Error("No valid IP found");
+            return host;
+        }
+    }
+};

package/dist/1~src_plugins_emitOnErrors_plugin_ts.js

@@ -0,0 +1,22 @@
+export const __webpack_id__ = "src_plugins_emitOnErrors_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_emitOnErrors_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/emitOnErrors.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            pluginEmitOnErrors: ()=>pluginEmitOnErrors
+        });
+        function pluginEmitOnErrors() {
+            return {
+                name: 'lynx:rsbuild:emit-on-errors',
+                setup (api) {
+                    api.modifyBundlerChain((chain)=>{
+                        chain.optimization.emitOnErrors(true);
+                    });
+                }
+            };
+        }
+    }
+};

package/dist/1~src_plugins_index_ts.js

@@ -0,0 +1,52 @@
+export const __webpack_id__ = "src_plugins_index_ts";
+export const __webpack_ids__ = [
+    "src_plugins_index_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            applyDefaultPlugins: ()=>applyDefaultPlugins
+        });
+        var _debug_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/debug.ts");
+        async function applyDebugPlugins(rsbuildInstance, config) {
+            const debugPlugins = Object.freeze([
+                __webpack_require__.e("src_plugins_emitOnErrors_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/emitOnErrors.plugin.ts")).then(({ pluginEmitOnErrors })=>pluginEmitOnErrors()),
+                Promise.all([
+                    __webpack_require__.e("vendors-node_modules_pnpm_javascript-stringify_2_1_0_node_modules_javascript-stringify_dist_i-562fbc"),
+                    __webpack_require__.e("src_plugins_inspect_plugin_ts")
+                ]).then(__webpack_require__.bind(__webpack_require__, "./src/plugins/inspect.plugin.ts")).then(({ pluginInspect })=>pluginInspect(config))
+            ]);
+            rsbuildInstance.addPlugins(await Promise.all(debugPlugins));
+        }
+        async function applyDefaultPlugins(rsbuildInstance, config) {
+            const defaultPlugins = Object.freeze([
+                __webpack_require__.e("src_plugins_api_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/api.plugin.ts")).then(({ pluginAPI })=>pluginAPI(config)),
+                __webpack_require__.e("src_plugins_chunkLoading_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/chunkLoading.plugin.ts")).then(({ pluginChunkLoading })=>pluginChunkLoading()),
+                __webpack_require__.e("src_plugins_dev_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/dev.plugin.ts")).then(({ pluginDev })=>pluginDev(config.dev, config.server)),
+                __webpack_require__.e("src_plugins_minify_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/minify.plugin.ts")).then(({ pluginMinify })=>pluginMinify(config.output?.minify)),
+                __webpack_require__.e("src_plugins_optimization_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/optimization.plugin.ts")).then(({ pluginOptimization })=>pluginOptimization()),
+                __webpack_require__.e("src_plugins_output_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/output.plugin.ts")).then(({ pluginOutput })=>pluginOutput(config.output)),
+                __webpack_require__.e("src_plugins_resolve_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/resolve.plugin.ts")).then(({ pluginResolve })=>pluginResolve()),
+                __webpack_require__.e("src_plugins_rsdoctor_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/rsdoctor.plugin.ts")).then(({ pluginRsdoctor })=>pluginRsdoctor(config.tools?.rsdoctor)),
+                __webpack_require__.e("src_plugins_sourcemap_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/sourcemap.plugin.ts")).then(({ pluginSourcemap })=>pluginSourcemap()),
+                __webpack_require__.e("src_plugins_swc_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/swc.plugin.ts")).then(({ pluginSwc })=>pluginSwc()),
+                __webpack_require__.e("src_plugins_target_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/target.plugin.ts")).then(({ pluginTarget })=>pluginTarget())
+            ]);
+            const promises = [
+                Promise.all(defaultPlugins).then((plugins)=>{
+                    rsbuildInstance.addPlugins(plugins);
+                })
+            ];
+            if ((0, _debug_js__WEBPACK_IMPORTED_MODULE_0__._o)()) {
+                (0, _debug_js__WEBPACK_IMPORTED_MODULE_0__.Yz)('apply Rspeedy default debug plugins');
+                promises.push(applyDebugPlugins(rsbuildInstance, config));
+            }
+            await Promise.all(promises);
+            const { pluginCssMinimizer, PLUGIN_CSS_MINIMIZER_NAME } = await import("@rsbuild/plugin-css-minimizer");
+            if (!rsbuildInstance.isPluginExists(PLUGIN_CSS_MINIMIZER_NAME)) rsbuildInstance.addPlugins([
+                pluginCssMinimizer()
+            ]);
+        }
+    }
+};

package/dist/1~src_plugins_inspect_plugin_ts.js

@@ -0,0 +1,49 @@
+import { mkdir, writeFile } from "node:fs/promises";
+export const __webpack_id__ = "src_plugins_inspect_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_inspect_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/config/output/dist-path.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            z: ()=>DEFAULT_DIST_PATH_INTERMEDIATE
+        });
+        const DEFAULT_DIST_PATH_INTERMEDIATE = '.rspeedy';
+    },
+    "./src/plugins/inspect.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            inspectRspeedyConfig: ()=>inspectRspeedyConfig,
+            pluginInspect: ()=>pluginInspect
+        });
+        var external_node_path_ = __webpack_require__("node:path");
+        var core_ = __webpack_require__("@rsbuild/core");
+        var dist = __webpack_require__("../../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/index.js");
+        var picocolors = __webpack_require__("../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+        var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+        var dist_path = __webpack_require__("./src/config/output/dist-path.ts");
+        var debug = __webpack_require__("./src/debug.ts");
+        function pluginInspect(config) {
+            return {
+                name: 'lynx:rsbuild:inspect',
+                setup (api) {
+                    api.onBeforeBuild(async ()=>{
+                        await inspectRspeedyConfig(config, external_node_path_["default"].join(api.context.distPath, dist_path.z, 'rspeedy.config.js'), false);
+                    });
+                }
+            };
+        }
+        async function inspectRspeedyConfig(config, path, verbose) {
+            const stringifiedConfig = (0, dist.stringify)(config, (value, _, stringify)=>{
+                if ('function' == typeof value && !verbose && value.toString().length > 100) return "function () { /* omitted long function */ }";
+                return stringify(value);
+            }, 2);
+            if (!stringifiedConfig) return void (0, debug.Yz)('No Rspeedy config found, skip inspect config.');
+            await mkdir((0, external_node_path_.dirname)(path), {
+                recursive: true
+            });
+            await writeFile(path, `export default ${stringifiedConfig}`);
+            core_.logger.success(`Inspect Rspeedy config succeed, open following files to view the content: \n\n  - ${picocolors_default().bold(picocolors_default().yellow('Rspeedy'))}: ${picocolors_default().underline(path)}\n`);
+        }
+    }
+};

package/dist/1~src_plugins_minify_plugin_ts.js

@@ -0,0 +1,86 @@
+export const __webpack_id__ = "src_plugins_minify_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_minify_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/minify.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            pluginMinify: ()=>pluginMinify
+        });
+        var _debug_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/debug.ts");
+        function pluginMinify(options) {
+            const defaultConfig = Object.freeze({
+                output: {
+                    minify: {
+                        js: true,
+                        jsOptions: {
+                            minimizerOptions: {
+                                compress: {
+                                    negate_iife: false,
+                                    join_vars: false,
+                                    ecma: 2015,
+                                    inline: 2,
+                                    comparisons: false,
+                                    toplevel: true,
+                                    side_effects: false
+                                },
+                                format: {
+                                    keep_quoted_props: true,
+                                    comments: false
+                                },
+                                mangle: {
+                                    toplevel: true
+                                }
+                            }
+                        },
+                        css: true,
+                        cssOptions: {
+                            minimizerOptions: {
+                                targets: '',
+                                include: {
+                                    nesting: true,
+                                    doublePositionGradients: true,
+                                    spaceSeparatedColorNotation: true
+                                },
+                                exclude: {
+                                    vendorPrefixes: true,
+                                    logicalProperties: true,
+                                    hexAlphaColors: true
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            return {
+                name: 'lynx:rsbuild:minify',
+                setup (api) {
+                    api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>{
+                        if (false === options) {
+                            (0, _debug_js__WEBPACK_IMPORTED_MODULE_0__.Yz)("minification disabled");
+                            return mergeRsbuildConfig(config, {
+                                output: {
+                                    minify: false
+                                }
+                            });
+                        }
+                        const configs = [
+                            config,
+                            defaultConfig
+                        ];
+                        if (true !== options && void 0 !== options) {
+                            (0, _debug_js__WEBPACK_IMPORTED_MODULE_0__.Yz)("merging minification options");
+                            configs.push({
+                                output: {
+                                    minify: options
+                                }
+                            });
+                        }
+                        return mergeRsbuildConfig(...configs);
+                    });
+                }
+            };
+        }
+    }
+};

package/dist/1~src_plugins_optimization_plugin_ts.js

@@ -0,0 +1,26 @@
+export const __webpack_id__ = "src_plugins_optimization_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_optimization_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/optimization.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            pluginOptimization: ()=>pluginOptimization
+        });
+        function pluginOptimization() {
+            return {
+                name: 'lynx:rsbuild:optimization',
+                setup (api) {
+                    api.modifyBundlerChain((chain, { CHAIN_ID, isProd })=>{
+                        const rule = chain.module.rules.get(CHAIN_ID.RULE.JS);
+                        chain.module.rule('js-override-strict').type(rule.get('type')).test(rule.get('test')).parser({
+                            overrideStrict: 'strict'
+                        }).end();
+                        if (isProd) chain.optimization.avoidEntryIife(true);
+                    });
+                }
+            };
+        }
+    }
+};

package/dist/1~src_plugins_output_plugin_ts.js

@@ -0,0 +1,47 @@
+export const __webpack_id__ = "src_plugins_output_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_output_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/config/output/dist-path.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            z: ()=>DEFAULT_DIST_PATH_INTERMEDIATE
+        });
+        const DEFAULT_DIST_PATH_INTERMEDIATE = '.rspeedy';
+    },
+    "./src/plugins/output.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            pluginOutput: ()=>pluginOutput
+        });
+        var _config_output_dist_path_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/config/output/dist-path.ts");
+        const defaultFilenameOptions = Object.freeze({
+            css: '[name]/[name].css'
+        });
+        const defaultDistPathOptions = Object.freeze({
+            css: _config_output_dist_path_js__WEBPACK_IMPORTED_MODULE_0__.z
+        });
+        function pluginOutput(options) {
+            return {
+                name: 'lynx:rsbuild:output',
+                setup (api) {
+                    api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>{
+                        if (!options) return mergeRsbuildConfig({
+                            output: {
+                                filename: {
+                                    css: defaultFilenameOptions.css
+                                }
+                            }
+                        }, config);
+                        return mergeRsbuildConfig(config, {
+                            output: {
+                                distPath: Object.assign({}, defaultDistPathOptions, options.distPath),
+                                filename: Object.assign({}, defaultFilenameOptions, options.filename)
+                            }
+                        });
+                    });
+                }
+            };
+        }
+    }
+};

package/dist/1~src_plugins_resolve_plugin_ts.js

@@ -0,0 +1,22 @@
+export const __webpack_id__ = "src_plugins_resolve_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_resolve_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/resolve.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            pluginResolve: ()=>pluginResolve
+        });
+        function pluginResolve() {
+            return {
+                name: 'lynx:rsbuild:resolve',
+                setup (api) {
+                    api.modifyBundlerChain((chain)=>{
+                        chain.resolve.aliasFields.add('browser').end().conditionNames.add('lynx').add('import').add('require').add('browser').end().extensions.add('.cjs').end().mainFields.add('lynx').add('module').add('main').end().mainFiles.add('index.lynx').add('index').end().end().end();
+                    });
+                }
+            };
+        }
+    }
+};