@upupming/react-rsbuild-plugin 0.0.0-stage → 0.22.2-genui.20261113.2

package/dist/index.js

@@ -0,0 +1,1589 @@
+import { createRequire } from "node:module";
+import { pluginReactAlias } from "@lynx-js/react-alias-rsbuild-plugin";
+import { LAYERS, ReactWebpackPlugin } from "@lynx-js/react-webpack-plugin";
+import { isPluginLynxRegistered, pluginLynx } from "@lynx-js/rsbuild-plugin";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+import { RuntimeConfigWebpackPlugin } from "@lynx-js/runtime-config-webpack-plugin";
+import { RuntimeWrapperWebpackPlugin } from "@lynx-js/runtime-wrapper-webpack-plugin";
+import { LynxEncodePlugin, WebEncodePlugin } from "@lynx-js/template-webpack-plugin";
+import { ReactRefreshRspackPlugin } from "@lynx-js/react-refresh-webpack-plugin";
+function pluginAutoLynx() {
+    return {
+        name: 'lynx:react:auto-lynx',
+        async setup (api) {
+            if ('rstest' === api.context.callerName) return;
+            const { environments } = api.getRsbuildConfig('original');
+            if (isPluginLynxRegistered(api, Object.keys(environments ?? {}))) return;
+            const original = api.getRsbuildConfig('original');
+            for (const plugin of pluginLynx()){
+                const { action } = api.context;
+                if ('function' != typeof plugin.apply || plugin.apply(original, {
+                    action
+                })) await plugin.setup(api);
+            }
+        }
+    };
+}
+const DETECT_IMPORT_ERROR = 'react:detect-import-error';
+const ALIAS_BACKGROUND_ONLY_MAIN = 'react:alias-background-only-main';
+const ALIAS_BACKGROUND_ONLY_BACKGROUND = 'react:alias-background-only-background';
+function applyBackgroundOnly(api) {
+    api.modifyBundlerChain(async (chain, { rspack })=>{
+        const __dirname = node_path.dirname(fileURLToPath(import.meta.url));
+        const { getImportResolver, getMainThreadResolver } = await import("./resolve.js");
+        const resolve = getImportResolver(rspack);
+        const resolveMainThread = getMainThreadResolver(rspack);
+        const [backgroundOnly, backgroundOnlyMainThread] = await Promise.all([
+            resolve('background-only'),
+            resolveMainThread('background-only')
+        ]);
+        chain.module.rule(ALIAS_BACKGROUND_ONLY_MAIN).issuerLayer(LAYERS.MAIN_THREAD).resolve.alias.set('background-only$', backgroundOnlyMainThread);
+        chain.module.rule(ALIAS_BACKGROUND_ONLY_BACKGROUND).issuerLayer(LAYERS.BACKGROUND).resolve.alias.set('background-only$', backgroundOnly);
+        chain.module.rule(DETECT_IMPORT_ERROR).test(backgroundOnlyMainThread).issuerLayer(LAYERS.MAIN_THREAD).use(DETECT_IMPORT_ERROR).loader(node_path.resolve(__dirname, 'loaders/invalid-import-error-loader')).options({
+            message: '\'background-only\' cannot be imported from a main-thread module.'
+        });
+    });
+}
+const REACT_COMPILATION_RESULT = Symbol.for('@lynx-js/react/internal:compilation-result');
+const REACT_COMPILE_RESULT_EXPOSURE = Symbol.for('@lynx-js/react/internal:compile-result');
+function isReactCompileResult(value) {
+    if ('object' != typeof value || null === value) return false;
+    if (1 !== value.version) return false;
+    const runtimeRequirements = value.runtimeRequirements;
+    return 'object' == typeof runtimeRequirements && null !== runtimeRequirements && 'boolean' == typeof runtimeRequirements.mainThreadProgrammability;
+}
+function getCompilationResult(stats) {
+    const compilation = stats.compilation;
+    const result = compilation[REACT_COMPILATION_RESULT];
+    return isReactCompileResult(result) ? result : void 0;
+}
+const reactCompileResultExposure = {
+    version: 1,
+    getCompileResult (stats) {
+        const childStats = 'stats' in stats ? stats.stats : [
+            stats
+        ];
+        if (0 === childStats.length) return;
+        let mainThreadProgrammability = false;
+        for (const childStatsItem of childStats){
+            const result = getCompilationResult(childStatsItem);
+            if (void 0 === result) return;
+            mainThreadProgrammability ||= result.runtimeRequirements.mainThreadProgrammability;
+        }
+        return {
+            version: 1,
+            runtimeRequirements: {
+                mainThreadProgrammability
+            }
+        };
+    }
+};
+function applyCSS(api, options) {
+    const { enableRemoveCSSScope, enableCSSSelector, enableCSSInvalidation, targetSdkVersion } = options;
+    api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>mergeRsbuildConfig(config, {
+            output: {
+                injectStyles: false
+            }
+        }));
+    const __dirname = node_path.dirname(fileURLToPath(import.meta.url));
+    api.modifyBundlerChain(async (chain, { CHAIN_ID })=>{
+        const { CssExtractRspackPlugin } = await import("@lynx-js/css-extract-webpack-plugin");
+        const cssRules = [
+            CHAIN_ID.RULE.CSS,
+            CHAIN_ID.RULE.SASS,
+            CHAIN_ID.RULE.LESS,
+            CHAIN_ID.RULE.STYLUS
+        ];
+        cssRules.filter((rule)=>chain.module.rules.has(rule)).forEach((ruleName)=>{
+            const rule = chain.module.rule(ruleName);
+            const mainRuleName = ruleName === CHAIN_ID.RULE.CSS ? CHAIN_ID.ONE_OF.CSS_MAIN : ruleName;
+            const mainRule = rule.oneOf(mainRuleName);
+            const parentRuleEntries = rule.entries();
+            removeLightningCSS(mainRule);
+            mainRule.issuerLayer(LAYERS.BACKGROUND).use(CHAIN_ID.USE.MINI_CSS_EXTRACT).loader(CssExtractRspackPlugin.loader).end();
+            const uses = mainRule.uses.entries() ?? {};
+            const ruleEntries = mainRule.entries();
+            const cssLoader = uses[CHAIN_ID.USE.CSS];
+            if (!cssLoader) return;
+            const cssLoaderRule = cssLoader.entries();
+            const mainThreadLayerRule = chain.module.rule(`${ruleName}:${LAYERS.MAIN_THREAD}`).test(parentRuleEntries.test).merge(ruleEntries).issuerLayer(LAYERS.MAIN_THREAD);
+            if (void 0 !== parentRuleEntries.dependency) mainThreadLayerRule.merge({
+                dependency: parentRuleEntries.dependency
+            });
+            mainThreadLayerRule.use(CHAIN_ID.USE.IGNORE_CSS).loader(node_path.resolve(__dirname, './loaders/ignore-css-loader')).end().uses.merge(uses).delete(CHAIN_ID.USE.MINI_CSS_EXTRACT).delete(CHAIN_ID.USE.LIGHTNINGCSS).delete(CHAIN_ID.USE.CSS).end().use(CHAIN_ID.USE.CSS).after(CHAIN_ID.USE.IGNORE_CSS).merge(cssLoaderRule).options(normalizeCssLoaderOptions(cssLoaderRule.options, true)).end();
+        });
+        cssRules.filter((rule)=>rule && chain.module.rules.has(rule)).forEach((ruleName)=>{
+            const inlineRuleName = ruleName === CHAIN_ID.RULE.CSS ? CHAIN_ID.ONE_OF.CSS_INLINE : `${ruleName}-inline`;
+            const inlineRule = chain.module.rule(ruleName).oneOf(inlineRuleName);
+            removeLightningCSS(inlineRule);
+        });
+        function removeLightningCSS(rule) {
+            if (rule.uses.has(CHAIN_ID.USE.LIGHTNINGCSS)) rule.uses.delete(CHAIN_ID.USE.LIGHTNINGCSS);
+        }
+        chain.plugin(CHAIN_ID.PLUGIN.MINI_CSS_EXTRACT).tap(([options])=>[
+                {
+                    ...options,
+                    enableRemoveCSSScope: enableRemoveCSSScope ?? true,
+                    enableCSSSelector,
+                    enableCSSInvalidation,
+                    targetSdkVersion,
+                    cssPlugins: []
+                }
+            ]).init((_, args)=>new CssExtractRspackPlugin(...args)).end().end();
+        chain.module.when(void 0 === enableRemoveCSSScope, (module)=>module.rule('lynx.css.scoped').test(/\.css$/).resourceQuery({
+                and: [
+                    /cssId/
+                ]
+            }).sideEffects(false));
+    });
+}
+const normalizeCssLoaderOptions = (options, exportOnlyLocals)=>{
+    if (options.modules && exportOnlyLocals) {
+        let { modules } = options;
+        modules = true === modules ? {
+            exportOnlyLocals: true
+        } : 'string' == typeof modules ? {
+            mode: modules,
+            exportOnlyLocals: true
+        } : {
+            ...modules,
+            exportOnlyLocals: true
+        };
+        return {
+            ...options,
+            modules
+        };
+    }
+    return options;
+};
+const FETCH_BUNDLE_MIN_ENGINE_VERSION = '3.9';
+function resolveLazyBundleFetcher(engineVersion) {
+    const meets = meetsMinEngineVersion(engineVersion, FETCH_BUNDLE_MIN_ENGINE_VERSION);
+    const envOverride = process.env['REACT_LAZY_BUNDLE_FETCHER'];
+    if ('FetchBundle' === envOverride && !meets) throw new Error(`[pluginReactLynx] REACT_LAZY_BUNDLE_FETCHER=FetchBundle requires engineVersion >= ${FETCH_BUNDLE_MIN_ENGINE_VERSION}, but got ${engineVersion ? `'${engineVersion}'` : '<unset>'}. Older hosts do not expose 'lynx.fetchBundle' / 'lynx.loadScript'. Either bump 'engineVersion' to '${FETCH_BUNDLE_MIN_ENGINE_VERSION}' or higher, or unset REACT_LAZY_BUNDLE_FETCHER (the default falls back to 'QueryComponent' on older hosts).`);
+    if ('FetchBundle' === envOverride || 'QueryComponent' === envOverride) return envOverride;
+    return meets ? 'FetchBundle' : 'QueryComponent';
+}
+function meetsMinEngineVersion(actual, min) {
+    if (!actual) return false;
+    const actualParts = actual.split('.').map(Number);
+    const minParts = min.split('.').map(Number);
+    const len = Math.max(actualParts.length, minParts.length);
+    for(let i = 0; i < len; i++){
+        const a = actualParts[i] ?? 0;
+        const m = minParts[i] ?? 0;
+        if (Number.isNaN(a) || Number.isNaN(m)) return false;
+        if (a > m) break;
+        if (a < m) return false;
+    }
+    return true;
+}
+const isPlainObject = (obj)=>null !== obj && 'object' == typeof obj && '[object Object]' === Object.prototype.toString.call(obj);
+function getUserSplitChunks(config, environment) {
+    const scoped = config.environments?.[environment];
+    return {
+        splitChunks: scoped?.splitChunks ?? config.splitChunks,
+        chunkSplitStrategy: scoped?.performance?.chunkSplit?.strategy ?? config.performance?.chunkSplit?.strategy
+    };
+}
+const applySplitChunksRule = (api)=>{
+    api.modifyEnvironmentConfig((config, { name, mergeEnvironmentConfig })=>{
+        const { splitChunks, chunkSplitStrategy } = getUserSplitChunks(api.getRsbuildConfig('original'), name);
+        if (void 0 === splitChunks && ('all-in-one' === chunkSplitStrategy || !chunkSplitStrategy)) return mergeEnvironmentConfig(config, {
+            splitChunks: false
+        });
+        return config;
+    });
+    api.modifyBundlerChain((chain, { environment })=>{
+        const { config } = environment;
+        const { splitChunks, chunkSplitStrategy } = getUserSplitChunks(api.getRsbuildConfig('original'), environment.name);
+        const isSplitByExperience = void 0 === splitChunks ? 'split-by-experience' === chunkSplitStrategy : isPlainObject(config.splitChunks) && 'default' === config.splitChunks.preset;
+        if (!isSplitByExperience) return;
+        const currentConfig = chain.optimization.splitChunks.values();
+        if (!isPlainObject(currentConfig)) return;
+        const extraGroups = {};
+        extraGroups['preact'] = {
+            name: 'lib-preact',
+            test: /node_modules[\\/](.*?[\\/])?(?:(?:internal-)?preact|(?:internal-)?preact[\\/]compat|(?:internal-)?preact[\\/]hooks|(?:internal-)?preact[\\/]jsx-runtime)[\\/]/,
+            priority: 0
+        };
+        chain.optimization.splitChunks({
+            ...currentConfig,
+            cacheGroups: {
+                ...currentConfig.cacheGroups,
+                ...extraGroups
+            }
+        });
+    });
+    api.modifyRspackConfig((rspackConfig)=>{
+        if (!rspackConfig.optimization) return rspackConfig;
+        if (!rspackConfig.optimization.splitChunks) return rspackConfig;
+        rspackConfig.optimization.splitChunks.chunks = function(chunk) {
+            return !Array.from(chunk.runtime).every((runtime)=>runtime.endsWith('__main-thread'));
+        };
+        return rspackConfig;
+    });
+};
+const S_LYNX_CONFIG = Symbol.for('@lynx-js/rsbuild-plugin:config');
+const PLUGIN_NAME_REACT = 'lynx:react';
+const PLUGIN_NAME_RUNTIME_CONFIG = 'lynx:runtime-config';
+const PLUGIN_NAME_TEMPLATE = 'lynx:template';
+const PLUGIN_NAME_RUNTIME_WRAPPER = 'lynx:runtime-wrapper';
+const PLUGIN_NAME_WEB = 'lynx:web';
+const DEFAULT_FILENAME_HASH = '.[contenthash:8]';
+const EMPTY_HASH = '';
+function applyEntry(api, options) {
+    const { compat, customCSSInheritanceList, debugInfoOutside, defaultDisplayLinear, enableAccessibilityElement, enableCSSInheritance, enableCSSInvalidation, enableCSSSelector, enableNewGesture, enableRemoveCSSScope, firstScreenSyncTiming, globalPropsMode, enableSSR, removeDescendantSelectorScope, targetSdkVersion, extractStr: originalExtractStr, experimental_isLazyBundle, experimental_transformBuiltinAttributeNames, experimental_reEvalJSOnReload } = options;
+    const lazyBundleFetcher = resolveLazyBundleFetcher(targetSdkVersion);
+    const runtimeConfig = {};
+    runtimeConfig['globalPropsMode'] = globalPropsMode ?? 'reactive';
+    if (experimental_transformBuiltinAttributeNames) runtimeConfig['transformBuiltinAttributeNames'] = experimental_transformBuiltinAttributeNames;
+    api.modifyBundlerChain(async (chain, { environment, isDev, isProd })=>{
+        const { LynxTemplatePlugin } = 'rstest' === api.context.callerName ? ReactWebpackPlugin.defaultOptions : api.useExposed(Symbol.for('LynxTemplatePlugin'));
+        const mainThreadChunks = [];
+        const entryPairs = [];
+        const { splitChunks, chunkSplitStrategy } = getUserSplitChunks(api.getRsbuildConfig('original'), environment.name);
+        const enableChunkSplitting = void 0 === splitChunks ? chunkSplitStrategy ? 'all-in-one' !== chunkSplitStrategy : false !== environment.config.splitChunks : false !== environment.config.splitChunks;
+        const rspeedyConfig = 'rspeedy' === api.context.callerName ? api.useExposed(Symbol.for('rspeedy.api'))?.config : void 0;
+        const lynxConfig = api.useExposed(S_LYNX_CONFIG);
+        const isLynx = 'lynx' === environment.name || environment.name.startsWith('lynx-');
+        const isWeb = 'web' === environment.name || environment.name.startsWith('web-');
+        const isApplication = 'rslib' !== api.context.callerName && 'rstest' !== api.context.callerName;
+        if (isApplication) {
+            if (!lynxConfig) throw new Error('No Lynx config exposed. `pluginLynx` has to be applied for the Lynx build engine to be configured.');
+            const entries = chain.entryPoints.entries() ?? {};
+            const { hmr, liveReload } = environment.config.dev ?? {};
+            const enabledHMR = isDev && false !== hmr;
+            const enabledLiveReload = isDev && false !== liveReload;
+            chain.entryPoints.clear();
+            Object.entries(entries).forEach(([entryName, entryPoint])=>{
+                const { imports } = getChunks(entryName, entryPoint.values());
+                const templateFilename = lynxConfig.resolveBundleFilename({
+                    entryName,
+                    platform: environment.name
+                });
+                const lazyBundleFilename = lynxConfig.resolveLazyBundleFilename({
+                    platform: environment.name
+                });
+                const mainThreadEntry = `${entryName}__main-thread`;
+                const mainThreadName = node_path.posix.join(isLynx ? lynxConfig.resolveIntermediateDir() : '', `${entryName}/main-thread.js`);
+                const backgroundName = node_path.posix.join(isLynx ? lynxConfig.resolveIntermediateDir() : '', getBackgroundFilename(entryName, environment.config, isProd, experimental_isLazyBundle));
+                const backgroundEntry = entryName;
+                mainThreadChunks.push(mainThreadName);
+                entryPairs.push({
+                    mainThread: mainThreadEntry,
+                    background: backgroundEntry
+                });
+                chain.entry(mainThreadEntry).add({
+                    layer: LAYERS.MAIN_THREAD,
+                    import: imports,
+                    filename: mainThreadName
+                }).when(enabledHMR, (entry)=>{
+                    const require = createRequire(import.meta.url);
+                    entry.prepend({
+                        layer: LAYERS.MAIN_THREAD,
+                        import: require.resolve('@lynx-js/css-extract-webpack-plugin/runtime/hotModuleReplacement.lepus.cjs')
+                    });
+                }).end().entry(backgroundEntry).add({
+                    layer: LAYERS.BACKGROUND,
+                    import: imports,
+                    filename: backgroundName
+                }).when(enabledHMR, (entry)=>{
+                    entry.prepend({
+                        layer: LAYERS.BACKGROUND,
+                        import: '@rspack/core/hot/dev-server'
+                    }).prepend({
+                        layer: LAYERS.BACKGROUND,
+                        import: '@lynx-js/react/refresh'
+                    });
+                }).when(enabledHMR || enabledLiveReload, (entry)=>{
+                    entry.prepend({
+                        layer: LAYERS.BACKGROUND,
+                        import: '@lynx-js/webpack-dev-transport/client'
+                    });
+                }).end().plugin(`${PLUGIN_NAME_TEMPLATE}-${entryName}`).use(LynxTemplatePlugin, [
+                    {
+                        dsl: 'react_nodiff',
+                        chunks: [
+                            mainThreadEntry,
+                            backgroundEntry
+                        ],
+                        filename: templateFilename,
+                        ...lazyBundleFilename ? {
+                            lazyBundleFilename
+                        } : {},
+                        intermediate: lynxConfig.resolveIntermediateDir({
+                            entryName
+                        }),
+                        customCSSInheritanceList,
+                        debugInfoOutside,
+                        defaultDisplayLinear,
+                        enableA11y: true,
+                        enableAccessibilityElement,
+                        enableCSSInheritance,
+                        enableCSSInvalidation,
+                        enableCSSSelector,
+                        enableNewGesture,
+                        enableRemoveCSSScope: enableRemoveCSSScope ?? true,
+                        removeDescendantSelectorScope,
+                        targetSdkVersion,
+                        experimental_isLazyBundle,
+                        lazyBundleFetcher,
+                        cssPlugins: [],
+                        enableReuseLoadScriptExports: experimental_reEvalJSOnReload
+                    }
+                ]).end();
+            });
+        }
+        if (isLynx) {
+            let inlineScripts;
+            inlineScripts = experimental_isLazyBundle ? true : environment.config.output?.inlineScripts ?? !enableChunkSplitting;
+            chain.plugin(PLUGIN_NAME_RUNTIME_WRAPPER).use(RuntimeWrapperWebpackPlugin, [
+                {
+                    injectVars (vars) {
+                        const UNUSED_VARS = new Set([
+                            'Card',
+                            'Component',
+                            'ReactLynx',
+                            'Behavior'
+                        ]);
+                        return vars.map((name)=>{
+                            if (UNUSED_VARS.has(name)) return `__${name}`;
+                            return name;
+                        });
+                    },
+                    targetSdkVersion,
+                    experimental_isLazyBundle,
+                    experimental_reEvalJSOnReload: experimental_reEvalJSOnReload && isApplication
+                }
+            ]).end().plugin(`${LynxEncodePlugin.name}`).use(LynxEncodePlugin, [
+                {
+                    inlineScripts
+                }
+            ]).end();
+        }
+        if (isWeb) chain.plugin(PLUGIN_NAME_WEB).use(WebEncodePlugin, []).end();
+        let extractStr = originalExtractStr;
+        if (enableChunkSplitting && originalExtractStr) {
+            (api.logger ?? console).warn('`extractStr` is changed to `false` because it is only supported when chunk splitting is disabled, please set `splitChunks` to `false` to use `extractStr.`');
+            extractStr = false;
+        }
+        const { version: runtimeVersion } = api.useExposed(Symbol.for('@lynx-js/react/internal:resolve'));
+        chain.plugin(PLUGIN_NAME_REACT).after(PLUGIN_NAME_TEMPLATE).use(ReactWebpackPlugin, [
+            {
+                LynxTemplatePlugin,
+                disableCreateSelectorQueryIncompatibleWarning: compat?.disableCreateSelectorQueryIncompatibleWarning ?? false,
+                firstScreenSyncTiming,
+                globalPropsMode,
+                enableSSR,
+                mainThreadChunks,
+                entryPairs,
+                extractStr,
+                experimental_isLazyBundle,
+                experimental_useElementTemplate: options.experimental_useElementTemplate,
+                profile: getDefaultProfile(),
+                lazyBundleFetcher,
+                runtimeVersion,
+                experimental_reEvalJSOnReload
+            }
+        ]);
+        const isHostEnvironment = isApplication && !experimental_isLazyBundle;
+        if (isHostEnvironment && Object.keys(runtimeConfig).length > 0) chain.plugin(PLUGIN_NAME_RUNTIME_CONFIG).after(PLUGIN_NAME_REACT).use(RuntimeConfigWebpackPlugin, [
+            runtimeConfig
+        ]);
+        function getDefaultProfile() {
+            const environmentProfile = rspeedyConfig?.environments?.[environment.name]?.performance?.profile;
+            if (void 0 !== environmentProfile) return environmentProfile;
+            return lynxConfig?.performance.profile;
+        }
+    });
+}
+function getChunks(entryName, entryValue) {
+    const chunks = [
+        entryName
+    ];
+    const imports = [];
+    for (const item of entryValue){
+        if ('string' == typeof item) {
+            imports.push(item);
+            continue;
+        }
+        if (Array.isArray(item)) {
+            imports.push(...imports);
+            continue;
+        }
+        const { dependOn } = item;
+        if (Array.isArray(item.import)) imports.push(...item.import);
+        else imports.push(item.import);
+        if (dependOn) if ('string' == typeof dependOn) chunks.unshift(dependOn);
+        else chunks.unshift(...dependOn);
+    }
+    return {
+        chunks,
+        imports
+    };
+}
+function getBackgroundFilename(entryName, config, isProd, experimental_isLazyBundle) {
+    const { filename } = config.output;
+    if ('string' == typeof filename.js) return filename.js.replaceAll('[name]', entryName).replaceAll('.js', '/background.js');
+    else return `${entryName}/background${getHash(config, isProd, experimental_isLazyBundle)}.js`;
+}
+function getHash(config, isProd, experimental_isLazyBundle) {
+    if ('string' == typeof config.output?.filenameHash) return config.output.filenameHash ? `.[${config.output.filenameHash}]` : EMPTY_HASH;
+    else if (config.output?.filenameHash === false) return EMPTY_HASH;
+    else if (isProd || experimental_isLazyBundle) return DEFAULT_FILENAME_HASH;
+    else return EMPTY_HASH;
+}
+function applyGenerator(api, options) {
+    api.modifyBundlerChain({
+        order: 'pre',
+        handler: (chain)=>{
+            const rule = chain.module.rule("react:json-parse").test(/\.json$/).type('json').generator({
+                JSONParse: false
+            });
+            if (!options.extractStr) rule.issuerLayer(LAYERS.MAIN_THREAD);
+        }
+    });
+}
+function applyLazy(api) {
+    api.modifyBundlerChain((chain)=>{
+        chain.output.library({
+            type: 'commonjs'
+        });
+    });
+}
+const MAIN_THREAD_ENV_INCLUDE = [
+    'transform-nullish-coalescing-operator',
+    'transform-optional-chaining',
+    'transform-export-namespace-from',
+    'transform-logical-assignment-operators',
+    'transform-numeric-separator',
+    'transform-class-properties',
+    'transform-class-static-block',
+    'transform-private-methods',
+    'transform-private-property-in-object'
+];
+const MAIN_THREAD_ENV_TARGETS = {
+    chrome: '120'
+};
+function getLoaderOptions(output, options, isMainThread = false) {
+    const inlineSourcesContent = output?.sourceMap === true || !(output?.sourceMap === false || output?.sourceMap?.js === false || output?.sourceMap?.js?.includes('nosources'));
+    const { compat, enableRemoveCSSScope, shake, defineDCE, engineVersion, enableUiSourceMap, experimental_transformBuiltinAttributeNames, experimental_isLazyBundle, experimental_useElementTemplate } = options;
+    return {
+        compat,
+        enableRemoveCSSScope,
+        isDynamicComponent: experimental_isLazyBundle,
+        inlineSourcesContent,
+        defineDCE,
+        engineVersion,
+        experimental_transformBuiltinAttributeNames,
+        experimental_useElementTemplate,
+        ...isMainThread ? {
+            enableUiSourceMap,
+            shake
+        } : {}
+    };
+}
+const TESTING_RULE_NAME = 'react:testing';
+function applyTestingLoaders(api, options) {
+    api.modifyBundlerChain((chain, { CHAIN_ID, environment })=>{
+        const rule = chain.module.rule(CHAIN_ID.RULE.JS).oneOf(CHAIN_ID.ONE_OF.JS_MAIN);
+        rule.use(TESTING_RULE_NAME).loader(ReactWebpackPlugin.loaders.TESTING).options(getLoaderOptions(environment.config.output, options)).end();
+    });
+}
+function applyLoaders(api, options) {
+    api.modifyEnvironmentConfig({
+        order: 'post',
+        handler (config) {
+            const coreJs = /[\\/]node_modules[\\/]core-js[\\/]/;
+            if ('off' !== config.output.polyfill && !config.source.exclude?.some((rule)=>rule instanceof RegExp && rule.source === coreJs.source)) config.source.exclude = [
+                ...config.source.exclude ?? [],
+                coreJs
+            ];
+        }
+    });
+    api.modifyBundlerChain((chain, { CHAIN_ID, environment })=>{
+        const rule = chain.module.rule(CHAIN_ID.RULE.JS);
+        const jsMainRule = rule.oneOf(CHAIN_ID.ONE_OF.JS_MAIN);
+        const type = jsMainRule.get('type');
+        const uses = jsMainRule.uses.entries() ?? {};
+        jsMainRule.uses.clear();
+        const backgroundRule = jsMainRule.oneOf(LAYERS.BACKGROUND);
+        backgroundRule.issuerLayer(LAYERS.BACKGROUND).when(void 0 !== type, (rule)=>{
+            rule.type(type);
+        }).uses.merge(uses).end().use(LAYERS.BACKGROUND).loader(ReactWebpackPlugin.loaders.BACKGROUND).options(getLoaderOptions(environment.config.output, options)).end();
+        const mainThreadRule = jsMainRule.oneOf(LAYERS.MAIN_THREAD);
+        mainThreadRule.issuerLayer(LAYERS.MAIN_THREAD).when(void 0 !== type, (rule)=>{
+            rule.type(type);
+        }).uses.merge(uses).end().when(void 0 !== uses[CHAIN_ID.USE.SWC], (rule)=>{
+            rule.uses.delete(CHAIN_ID.USE.SWC);
+            const swcLoaderRule = uses[CHAIN_ID.USE.SWC].entries();
+            const swcLoaderOptions = swcLoaderRule.options;
+            const jsc = {
+                ...swcLoaderOptions.jsc
+            };
+            delete jsc['target'];
+            rule.use(CHAIN_ID.USE.SWC).merge(swcLoaderRule).options({
+                ...swcLoaderOptions,
+                jsc,
+                env: {
+                    ...swcLoaderOptions.env,
+                    targets: 'off' === environment.config.output.polyfill ? MAIN_THREAD_ENV_TARGETS : {
+                        chrome: '92'
+                    },
+                    include: [
+                        'transform-block-scoping',
+                        ...MAIN_THREAD_ENV_INCLUDE
+                    ]
+                }
+            });
+        }).use(LAYERS.MAIN_THREAD).loader(ReactWebpackPlugin.loaders.MAIN_THREAD).options(getLoaderOptions(environment.config.output, options, true)).end();
+    });
+}
+function applyNodeEnv(api) {
+    api.modifyEnvironmentConfig((userConfig, { mergeEnvironmentConfig })=>mergeEnvironmentConfig(userConfig, {
+            tools: {
+                rspack: {
+                    optimization: {
+                        nodeEnv: process.env['NODE_ENV'] ?? false
+                    }
+                }
+            }
+        }));
+}
+function applyOptimizeBundleSize(api, options) {
+    api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>{
+        const optimizeBundleSize = options.optimizeBundleSize;
+        const optimizeBackground = 'boolean' == typeof optimizeBundleSize ? optimizeBundleSize : optimizeBundleSize?.background;
+        const optimizeMainThread = 'boolean' == typeof optimizeBundleSize ? optimizeBundleSize : optimizeBundleSize?.mainThread;
+        if (optimizeBackground || optimizeMainThread) {
+            const minifyConfig = {};
+            if (optimizeBackground) minifyConfig['backgroundOptions'] = {
+                minimizerOptions: {
+                    compress: {
+                        pure_funcs: [
+                            'lynx.registerDataProcessors'
+                        ]
+                    }
+                }
+            };
+            if (optimizeMainThread) minifyConfig['mainThreadOptions'] = {
+                minimizerOptions: {
+                    compress: {
+                        pure_funcs: [
+                            'NativeModules.call',
+                            'lynx.getJSModule'
+                        ]
+                    }
+                }
+            };
+            return mergeRsbuildConfig(config, {
+                output: {
+                    minify: minifyConfig
+                }
+            });
+        }
+        return config;
+    });
+}
+const PLUGIN_NAME_REACT_REFRESH = 'lynx:react:refresh';
+function applyRefresh(api) {
+    api.modifyBundlerChain(async (chain, { isProd, CHAIN_ID, environment })=>{
+        if (!isProd && environment.config.dev?.hmr !== false) await Promise.all([
+            applyRefreshRules(api, chain, CHAIN_ID, ReactRefreshRspackPlugin)
+        ]);
+    });
+}
+async function applyRefreshRules(api, chain, CHAIN_ID, ReactRefreshPlugin) {
+    const { resolve } = api.useExposed(Symbol.for('@lynx-js/react/internal:resolve'));
+    const [reactRuntime, refresh, workletRuntime] = await Promise.all([
+        resolve('@lynx-js/react/package.json'),
+        resolve('@lynx-js/react/refresh'),
+        resolve('@lynx-js/react/worklet-runtime/init')
+    ]);
+    chain.resolve.alias.set('@lynx-js/react/refresh$', refresh);
+    chain.plugin(PLUGIN_NAME_REACT_REFRESH).before(CHAIN_ID.PLUGIN.HMR).use(ReactRefreshPlugin).end().module.rule('react:refresh').issuerLayer(LAYERS.BACKGROUND).before(CHAIN_ID.RULE.JS).test(/\.[jt]sx$/).exclude.add(/node_modules/).add(node_path.dirname(reactRuntime)).add(node_path.dirname(refresh)).add(node_path.dirname(workletRuntime)).add(ReactRefreshPlugin.loader).end().use('ReactRefresh').loader(ReactRefreshPlugin.loader).options({}).end().end().end().end();
+}
+function applySWC(api) {
+    api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>mergeRsbuildConfig({
+            tools: {
+                swc: {
+                    jsc: {
+                        transform: {
+                            useDefineForClassFields: false,
+                            optimizer: {
+                                simplify: true
+                            }
+                        },
+                        parser: {
+                            syntax: "typescript",
+                            tsx: false,
+                            decorators: true
+                        }
+                    }
+                }
+            }
+        }, config));
+}
+function applyUseSyncExternalStore(api) {
+    api.modifyBundlerChain(async (chain, { rspack })=>{
+        const { getImportResolver } = await import("./resolve.js");
+        const resolve = getImportResolver(rspack);
+        const useSyncExternalStoreEntries = [
+            'use-sync-external-store',
+            'use-sync-external-store/with-selector',
+            'use-sync-external-store/with-selector.js',
+            'use-sync-external-store/shim',
+            'use-sync-external-store/shim/with-selector',
+            'use-sync-external-store/shim/with-selector.js'
+        ];
+        await Promise.all(useSyncExternalStoreEntries.map((key)=>{
+            const entry = key.endsWith('.js') ? key.replace('.js', '') : key;
+            return resolve(`@lynx-js/${entry}`).then((value)=>{
+                chain.resolve.alias.set(`${key}$`, value);
+            });
+        }));
+    });
+}
+const _accessExpressionAsString = (str)=>variable(str) ? `.${str}` : `[${JSON.stringify(str)}]`;
+const variable = (str)=>false === reserved(str) && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
+const reserved = (str)=>RESERVED.has(str);
+const RESERVED = new Set([
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "null",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with"
+]);
+class TypeGuardError extends Error {
+    method;
+    path;
+    expected;
+    value;
+    description;
+    fake_expected_typed_value_;
+    constructor(props){
+        super(props.message || `Error on ${props.method}(): invalid type${props.path ? ` on ${props.path}` : ""}, expect to be ${props.expected}`);
+        const proto = new.target.prototype;
+        if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
+        else this.__proto__ = proto;
+        this.method = props.method;
+        this.path = props.path;
+        this.expected = props.expected;
+        this.value = props.value;
+        if (props.description || void 0 === props.value) this.description = props.description ?? [
+            "The value at this path is `undefined`.",
+            "",
+            `Please fill the \`${props.expected}\` typed value next time.`
+        ].join("\n");
+    }
+}
+const _assertGuard = (exceptionable, props, factory)=>{
+    if (true === exceptionable) if (factory) throw factory(props);
+    else throw new TypeGuardError(props);
+    return false;
+};
+const validateConfig = (()=>{
+    const _io0 = (input, _exceptionable = true)=>(void 0 === input.enableUiSourceMap || "boolean" == typeof input.enableUiSourceMap) && (void 0 === input.compat || "object" == typeof input.compat && null !== input.compat && false === Array.isArray(input.compat) && _io1(input.compat, _exceptionable)) && (void 0 === input.customCSSInheritanceList || Array.isArray(input.customCSSInheritanceList) && input.customCSSInheritanceList.every((elem, _index1)=>"string" == typeof elem)) && (void 0 === input.debugInfoOutside || "boolean" == typeof input.debugInfoOutside) && (void 0 === input.defaultDisplayLinear || "boolean" == typeof input.defaultDisplayLinear) && (void 0 === input.enableAccessibilityElement || "boolean" == typeof input.enableAccessibilityElement) && null !== input.experimental_transformBuiltinAttributeNames && (void 0 === input.experimental_transformBuiltinAttributeNames || "boolean" == typeof input.experimental_transformBuiltinAttributeNames || "object" == typeof input.experimental_transformBuiltinAttributeNames && null !== input.experimental_transformBuiltinAttributeNames && false === Array.isArray(input.experimental_transformBuiltinAttributeNames) && _io4(input.experimental_transformBuiltinAttributeNames, _exceptionable)) && (void 0 === input.enableCSSInheritance || "boolean" == typeof input.enableCSSInheritance) && (void 0 === input.enableCSSInvalidation || "boolean" == typeof input.enableCSSInvalidation) && (void 0 === input.enableCSSSelector || "boolean" == typeof input.enableCSSSelector) && (void 0 === input.enableNewGesture || "boolean" == typeof input.enableNewGesture) && (void 0 === input.enableRemoveCSSScope || "boolean" == typeof input.enableRemoveCSSScope) && (void 0 === input.firstScreenSyncTiming || "immediately" === input.firstScreenSyncTiming || "jsReady" === input.firstScreenSyncTiming || "manual" === input.firstScreenSyncTiming) && (void 0 === input.enableSSR || "boolean" == typeof input.enableSSR) && (void 0 === input.removeDescendantSelectorScope || "boolean" == typeof input.removeDescendantSelectorScope) && (void 0 === input.shake || "object" == typeof input.shake && null !== input.shake && false === Array.isArray(input.shake) && _io6(input.shake, _exceptionable)) && (void 0 === input.defineDCE || "object" == typeof input.defineDCE && null !== input.defineDCE && false === Array.isArray(input.defineDCE) && _io7(input.defineDCE, _exceptionable)) && (void 0 === input.engineVersion || "string" == typeof input.engineVersion) && (void 0 === input.targetSdkVersion || "string" == typeof input.targetSdkVersion) && (void 0 === input.globalPropsMode || "reactive" === input.globalPropsMode || "event" === input.globalPropsMode) && null !== input.extractStr && (void 0 === input.extractStr || "boolean" == typeof input.extractStr || "object" == typeof input.extractStr && null !== input.extractStr && false === Array.isArray(input.extractStr) && _io9(input.extractStr, _exceptionable)) && (void 0 === input.experimental_isLazyBundle || "boolean" == typeof input.experimental_isLazyBundle) && (void 0 === input.experimental_useElementTemplate || "boolean" == typeof input.experimental_useElementTemplate) && null !== input.optimizeBundleSize && (void 0 === input.optimizeBundleSize || "boolean" == typeof input.optimizeBundleSize || "object" == typeof input.optimizeBundleSize && null !== input.optimizeBundleSize && false === Array.isArray(input.optimizeBundleSize) && _io10(input.optimizeBundleSize, _exceptionable)) && (void 0 === input.experimental_reEvalJSOnReload || "boolean" == typeof input.experimental_reEvalJSOnReload) && (0 === Object.keys(input).length || Object.keys(input).every((key)=>{
+            if ([
+                "enableUiSourceMap",
+                "compat",
+                "customCSSInheritanceList",
+                "debugInfoOutside",
+                "defaultDisplayLinear",
+                "enableAccessibilityElement",
+                "experimental_transformBuiltinAttributeNames",
+                "enableCSSInheritance",
+                "enableCSSInvalidation",
+                "enableCSSSelector",
+                "enableNewGesture",
+                "enableRemoveCSSScope",
+                "firstScreenSyncTiming",
+                "enableSSR",
+                "removeDescendantSelectorScope",
+                "shake",
+                "defineDCE",
+                "engineVersion",
+                "targetSdkVersion",
+                "globalPropsMode",
+                "extractStr",
+                "experimental_isLazyBundle",
+                "experimental_useElementTemplate",
+                "optimizeBundleSize",
+                "experimental_reEvalJSOnReload"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return false;
+        }));
+    const _io1 = (input, _exceptionable = true)=>(void 0 === input.componentsPkg || Array.isArray(input.componentsPkg) && input.componentsPkg.every((elem, _index2)=>"string" == typeof elem)) && (void 0 === input.oldRuntimePkg || Array.isArray(input.oldRuntimePkg) && input.oldRuntimePkg.every((elem, _index3)=>"string" == typeof elem)) && (void 0 === input.newRuntimePkg || "string" == typeof input.newRuntimePkg) && (void 0 === input.additionalComponentAttributes || Array.isArray(input.additionalComponentAttributes) && input.additionalComponentAttributes.every((elem, _index4)=>"string" == typeof elem)) && null !== input.addComponentElement && (void 0 === input.addComponentElement || "boolean" == typeof input.addComponentElement || "object" == typeof input.addComponentElement && null !== input.addComponentElement && _io2(input.addComponentElement, _exceptionable)) && (void 0 === input.simplifyCtorLikeReactLynx2 || "boolean" == typeof input.simplifyCtorLikeReactLynx2) && (void 0 === input.transformLegacyEventAttributeNames || "boolean" == typeof input.transformLegacyEventAttributeNames) && (void 0 === input.removeComponentAttrRegex || "string" == typeof input.removeComponentAttrRegex) && (void 0 === input.disableDeprecatedWarning || "boolean" == typeof input.disableDeprecatedWarning) && null !== input.darkMode && (void 0 === input.darkMode || "boolean" == typeof input.darkMode || "object" == typeof input.darkMode && null !== input.darkMode && _io3(input.darkMode, _exceptionable)) && (void 0 === input.legacySlot || "boolean" == typeof input.legacySlot) && (void 0 === input.disableCreateSelectorQueryIncompatibleWarning || "boolean" == typeof input.disableCreateSelectorQueryIncompatibleWarning) && (0 === Object.keys(input).length || Object.keys(input).every((key)=>{
+            if ([
+                "componentsPkg",
+                "oldRuntimePkg",
+                "newRuntimePkg",
+                "additionalComponentAttributes",
+                "addComponentElement",
+                "simplifyCtorLikeReactLynx2",
+                "transformLegacyEventAttributeNames",
+                "removeComponentAttrRegex",
+                "disableDeprecatedWarning",
+                "darkMode",
+                "legacySlot",
+                "disableCreateSelectorQueryIncompatibleWarning"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return false;
+        }));
+    const _io2 = (input, _exceptionable = true)=>"boolean" == typeof input.compilerOnly && (1 === Object.keys(input).length || Object.keys(input).every((key)=>{
+            if ([
+                "compilerOnly"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return false;
+        }));
+    const _io3 = (input, _exceptionable = true)=>"string" == typeof input.themeExpr && (1 === Object.keys(input).length || Object.keys(input).every((key)=>{
+            if ([
+                "themeExpr"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return false;
+        }));
+    const _io4 = (input, _exceptionable = true)=>(void 0 === input.mode || "dash-case" === input.mode || "mapping-only" === input.mode) && (void 0 === input.preserve || Array.isArray(input.preserve) && input.preserve.every((elem, _index5)=>"string" == typeof elem)) && (void 0 === input.rename || "object" == typeof input.rename && null !== input.rename && false === Array.isArray(input.rename) && _io5(input.rename, _exceptionable)) && (0 === Object.keys(input).length || Object.keys(input).every((key)=>{
+            if ([
+                "mode",
+                "preserve",
+                "rename"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return false;
+        }));
+    const _io5 = (input, _exceptionable = true)=>Object.keys(input).every((key)=>{
+            const value = input[key];
+            if (void 0 === value) return true;
+            return "string" == typeof value;
+        });
+    const _io6 = (input, _exceptionable = true)=>(void 0 === input.pkgName || Array.isArray(input.pkgName) && input.pkgName.every((elem, _index6)=>"string" == typeof elem)) && (void 0 === input.retainProp || Array.isArray(input.retainProp) && input.retainProp.every((elem, _index7)=>"string" == typeof elem)) && (void 0 === input.removeCall || Array.isArray(input.removeCall) && input.removeCall.every((elem, _index8)=>"string" == typeof elem)) && (void 0 === input.removeCallParams || Array.isArray(input.removeCallParams) && input.removeCallParams.every((elem, _index9)=>"string" == typeof elem)) && (0 === Object.keys(input).length || Object.keys(input).every((key)=>{
+            if ([
+                "pkgName",
+                "retainProp",
+                "removeCall",
+                "removeCallParams"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return false;
+        }));
+    const _io7 = (input, _exceptionable = true)=>(void 0 === input.define || "object" == typeof input.define && null !== input.define && false === Array.isArray(input.define) && _io8(input.define, _exceptionable)) && (0 === Object.keys(input).length || Object.keys(input).every((key)=>{
+            if ([
+                "define"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return false;
+        }));
+    const _io8 = (input, _exceptionable = true)=>Object.keys(input).every((key)=>{
+            const value = input[key];
+            if (void 0 === value) return true;
+            return "string" == typeof value;
+        });
+    const _io9 = (input, _exceptionable = true)=>(void 0 === input.strLength || "number" == typeof input.strLength) && (0 === Object.keys(input).length || Object.keys(input).every((key)=>{
+            if ([
+                "strLength"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return false;
+        }));
+    const _io10 = (input, _exceptionable = true)=>(void 0 === input.mainThread || "boolean" == typeof input.mainThread) && (void 0 === input.background || "boolean" == typeof input.background) && (0 === Object.keys(input).length || Object.keys(input).every((key)=>{
+            if ([
+                "mainThread",
+                "background"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return false;
+        }));
+    const _ao0 = (input, _path, _exceptionable = true)=>(void 0 === input.enableUiSourceMap || "boolean" == typeof input.enableUiSourceMap || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".enableUiSourceMap",
+            expected: "(boolean | undefined)",
+            value: input.enableUiSourceMap
+        }, _errorFactory)) && (void 0 === input.compat || ("object" == typeof input.compat && null !== input.compat && false === Array.isArray(input.compat) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".compat",
+            expected: "(Partial<CompatVisitorConfig> & { disableCreateSelectorQueryIncompatibleWarning?: boolean; } | undefined)",
+            value: input.compat
+        }, _errorFactory)) && _ao1(input.compat, _path + ".compat", _exceptionable) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".compat",
+            expected: "(Partial<CompatVisitorConfig> & { disableCreateSelectorQueryIncompatibleWarning?: boolean; } | undefined)",
+            value: input.compat
+        }, _errorFactory)) && (void 0 === input.customCSSInheritanceList || (Array.isArray(input.customCSSInheritanceList) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".customCSSInheritanceList",
+            expected: "(Array<string> | undefined)",
+            value: input.customCSSInheritanceList
+        }, _errorFactory)) && input.customCSSInheritanceList.every((elem, _index10)=>"string" == typeof elem || _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + ".customCSSInheritanceList[" + _index10 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".customCSSInheritanceList",
+            expected: "(Array<string> | undefined)",
+            value: input.customCSSInheritanceList
+        }, _errorFactory)) && (void 0 === input.debugInfoOutside || "boolean" == typeof input.debugInfoOutside || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".debugInfoOutside",
+            expected: "(boolean | undefined)",
+            value: input.debugInfoOutside
+        }, _errorFactory)) && (void 0 === input.defaultDisplayLinear || "boolean" == typeof input.defaultDisplayLinear || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".defaultDisplayLinear",
+            expected: "(boolean | undefined)",
+            value: input.defaultDisplayLinear
+        }, _errorFactory)) && (void 0 === input.enableAccessibilityElement || "boolean" == typeof input.enableAccessibilityElement || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".enableAccessibilityElement",
+            expected: "(boolean | undefined)",
+            value: input.enableAccessibilityElement
+        }, _errorFactory)) && (null !== input.experimental_transformBuiltinAttributeNames || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".experimental_transformBuiltinAttributeNames",
+            expected: "(TransformBuiltinAttributeNamesOptions | boolean | undefined)",
+            value: input.experimental_transformBuiltinAttributeNames
+        }, _errorFactory)) && (void 0 === input.experimental_transformBuiltinAttributeNames || "boolean" == typeof input.experimental_transformBuiltinAttributeNames || ("object" == typeof input.experimental_transformBuiltinAttributeNames && null !== input.experimental_transformBuiltinAttributeNames && false === Array.isArray(input.experimental_transformBuiltinAttributeNames) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".experimental_transformBuiltinAttributeNames",
+            expected: "(TransformBuiltinAttributeNamesOptions | boolean | undefined)",
+            value: input.experimental_transformBuiltinAttributeNames
+        }, _errorFactory)) && _ao4(input.experimental_transformBuiltinAttributeNames, _path + ".experimental_transformBuiltinAttributeNames", _exceptionable) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".experimental_transformBuiltinAttributeNames",
+            expected: "(TransformBuiltinAttributeNamesOptions | boolean | undefined)",
+            value: input.experimental_transformBuiltinAttributeNames
+        }, _errorFactory)) && (void 0 === input.enableCSSInheritance || "boolean" == typeof input.enableCSSInheritance || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".enableCSSInheritance",
+            expected: "(boolean | undefined)",
+            value: input.enableCSSInheritance
+        }, _errorFactory)) && (void 0 === input.enableCSSInvalidation || "boolean" == typeof input.enableCSSInvalidation || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".enableCSSInvalidation",
+            expected: "(boolean | undefined)",
+            value: input.enableCSSInvalidation
+        }, _errorFactory)) && (void 0 === input.enableCSSSelector || "boolean" == typeof input.enableCSSSelector || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".enableCSSSelector",
+            expected: "(boolean | undefined)",
+            value: input.enableCSSSelector
+        }, _errorFactory)) && (void 0 === input.enableNewGesture || "boolean" == typeof input.enableNewGesture || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".enableNewGesture",
+            expected: "(boolean | undefined)",
+            value: input.enableNewGesture
+        }, _errorFactory)) && (void 0 === input.enableRemoveCSSScope || "boolean" == typeof input.enableRemoveCSSScope || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".enableRemoveCSSScope",
+            expected: "(boolean | undefined)",
+            value: input.enableRemoveCSSScope
+        }, _errorFactory)) && (void 0 === input.firstScreenSyncTiming || "immediately" === input.firstScreenSyncTiming || "jsReady" === input.firstScreenSyncTiming || "manual" === input.firstScreenSyncTiming || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".firstScreenSyncTiming",
+            expected: "(\"immediately\" | \"jsReady\" | \"manual\" | undefined)",
+            value: input.firstScreenSyncTiming
+        }, _errorFactory)) && (void 0 === input.enableSSR || "boolean" == typeof input.enableSSR || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".enableSSR",
+            expected: "(boolean | undefined)",
+            value: input.enableSSR
+        }, _errorFactory)) && (void 0 === input.removeDescendantSelectorScope || "boolean" == typeof input.removeDescendantSelectorScope || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".removeDescendantSelectorScope",
+            expected: "(boolean | undefined)",
+            value: input.removeDescendantSelectorScope
+        }, _errorFactory)) && (void 0 === input.shake || ("object" == typeof input.shake && null !== input.shake && false === Array.isArray(input.shake) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".shake",
+            expected: "(Partial<ShakeVisitorConfig> | undefined)",
+            value: input.shake
+        }, _errorFactory)) && _ao6(input.shake, _path + ".shake", _exceptionable) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".shake",
+            expected: "(Partial<ShakeVisitorConfig> | undefined)",
+            value: input.shake
+        }, _errorFactory)) && (void 0 === input.defineDCE || ("object" == typeof input.defineDCE && null !== input.defineDCE && false === Array.isArray(input.defineDCE) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".defineDCE",
+            expected: "(Partial<DefineDceVisitorConfig> | undefined)",
+            value: input.defineDCE
+        }, _errorFactory)) && _ao7(input.defineDCE, _path + ".defineDCE", _exceptionable) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".defineDCE",
+            expected: "(Partial<DefineDceVisitorConfig> | undefined)",
+            value: input.defineDCE
+        }, _errorFactory)) && (void 0 === input.engineVersion || "string" == typeof input.engineVersion || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".engineVersion",
+            expected: "(string | undefined)",
+            value: input.engineVersion
+        }, _errorFactory)) && (void 0 === input.targetSdkVersion || "string" == typeof input.targetSdkVersion || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".targetSdkVersion",
+            expected: "(string | undefined)",
+            value: input.targetSdkVersion
+        }, _errorFactory)) && (void 0 === input.globalPropsMode || "reactive" === input.globalPropsMode || "event" === input.globalPropsMode || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".globalPropsMode",
+            expected: "(\"event\" | \"reactive\" | undefined)",
+            value: input.globalPropsMode
+        }, _errorFactory)) && (null !== input.extractStr || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".extractStr",
+            expected: "(Partial<ExtractStrConfig> | boolean | undefined)",
+            value: input.extractStr
+        }, _errorFactory)) && (void 0 === input.extractStr || "boolean" == typeof input.extractStr || ("object" == typeof input.extractStr && null !== input.extractStr && false === Array.isArray(input.extractStr) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".extractStr",
+            expected: "(Partial<ExtractStrConfig> | boolean | undefined)",
+            value: input.extractStr
+        }, _errorFactory)) && _ao9(input.extractStr, _path + ".extractStr", _exceptionable) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".extractStr",
+            expected: "(Partial<ExtractStrConfig> | boolean | undefined)",
+            value: input.extractStr
+        }, _errorFactory)) && (void 0 === input.experimental_isLazyBundle || "boolean" == typeof input.experimental_isLazyBundle || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".experimental_isLazyBundle",
+            expected: "(boolean | undefined)",
+            value: input.experimental_isLazyBundle
+        }, _errorFactory)) && (void 0 === input.experimental_useElementTemplate || "boolean" == typeof input.experimental_useElementTemplate || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".experimental_useElementTemplate",
+            expected: "(boolean | undefined)",
+            value: input.experimental_useElementTemplate
+        }, _errorFactory)) && (null !== input.optimizeBundleSize || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".optimizeBundleSize",
+            expected: "(__type | boolean | undefined)",
+            value: input.optimizeBundleSize
+        }, _errorFactory)) && (void 0 === input.optimizeBundleSize || "boolean" == typeof input.optimizeBundleSize || ("object" == typeof input.optimizeBundleSize && null !== input.optimizeBundleSize && false === Array.isArray(input.optimizeBundleSize) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".optimizeBundleSize",
+            expected: "(__type | boolean | undefined)",
+            value: input.optimizeBundleSize
+        }, _errorFactory)) && _ao10(input.optimizeBundleSize, _path + ".optimizeBundleSize", _exceptionable) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".optimizeBundleSize",
+            expected: "(__type | boolean | undefined)",
+            value: input.optimizeBundleSize
+        }, _errorFactory)) && (void 0 === input.experimental_reEvalJSOnReload || "boolean" == typeof input.experimental_reEvalJSOnReload || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".experimental_reEvalJSOnReload",
+            expected: "(boolean | undefined)",
+            value: input.experimental_reEvalJSOnReload
+        }, _errorFactory)) && (0 === Object.keys(input).length || false === _exceptionable || Object.keys(input).every((key)=>{
+            if ([
+                "enableUiSourceMap",
+                "compat",
+                "customCSSInheritanceList",
+                "debugInfoOutside",
+                "defaultDisplayLinear",
+                "enableAccessibilityElement",
+                "experimental_transformBuiltinAttributeNames",
+                "enableCSSInheritance",
+                "enableCSSInvalidation",
+                "enableCSSSelector",
+                "enableNewGesture",
+                "enableRemoveCSSScope",
+                "firstScreenSyncTiming",
+                "enableSSR",
+                "removeDescendantSelectorScope",
+                "shake",
+                "defineDCE",
+                "engineVersion",
+                "targetSdkVersion",
+                "globalPropsMode",
+                "extractStr",
+                "experimental_isLazyBundle",
+                "experimental_useElementTemplate",
+                "optimizeBundleSize",
+                "experimental_reEvalJSOnReload"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + _accessExpressionAsString(key),
+                expected: "undefined",
+                value: value
+            }, _errorFactory);
+        }));
+    const _ao1 = (input, _path, _exceptionable = true)=>(void 0 === input.componentsPkg || (Array.isArray(input.componentsPkg) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".componentsPkg",
+            expected: "(Array<string> | undefined)",
+            value: input.componentsPkg
+        }, _errorFactory)) && input.componentsPkg.every((elem, _index11)=>"string" == typeof elem || _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + ".componentsPkg[" + _index11 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".componentsPkg",
+            expected: "(Array<string> | undefined)",
+            value: input.componentsPkg
+        }, _errorFactory)) && (void 0 === input.oldRuntimePkg || (Array.isArray(input.oldRuntimePkg) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".oldRuntimePkg",
+            expected: "(Array<string> | undefined)",
+            value: input.oldRuntimePkg
+        }, _errorFactory)) && input.oldRuntimePkg.every((elem, _index12)=>"string" == typeof elem || _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + ".oldRuntimePkg[" + _index12 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".oldRuntimePkg",
+            expected: "(Array<string> | undefined)",
+            value: input.oldRuntimePkg
+        }, _errorFactory)) && (void 0 === input.newRuntimePkg || "string" == typeof input.newRuntimePkg || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".newRuntimePkg",
+            expected: "(string | undefined)",
+            value: input.newRuntimePkg
+        }, _errorFactory)) && (void 0 === input.additionalComponentAttributes || (Array.isArray(input.additionalComponentAttributes) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".additionalComponentAttributes",
+            expected: "(Array<string> | undefined)",
+            value: input.additionalComponentAttributes
+        }, _errorFactory)) && input.additionalComponentAttributes.every((elem, _index13)=>"string" == typeof elem || _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + ".additionalComponentAttributes[" + _index13 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".additionalComponentAttributes",
+            expected: "(Array<string> | undefined)",
+            value: input.additionalComponentAttributes
+        }, _errorFactory)) && (null !== input.addComponentElement || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".addComponentElement",
+            expected: "(AddComponentElementConfig | boolean | undefined)",
+            value: input.addComponentElement
+        }, _errorFactory)) && (void 0 === input.addComponentElement || "boolean" == typeof input.addComponentElement || ("object" == typeof input.addComponentElement && null !== input.addComponentElement || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".addComponentElement",
+            expected: "(AddComponentElementConfig | boolean | undefined)",
+            value: input.addComponentElement
+        }, _errorFactory)) && _ao2(input.addComponentElement, _path + ".addComponentElement", _exceptionable) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".addComponentElement",
+            expected: "(AddComponentElementConfig | boolean | undefined)",
+            value: input.addComponentElement
+        }, _errorFactory)) && (void 0 === input.simplifyCtorLikeReactLynx2 || "boolean" == typeof input.simplifyCtorLikeReactLynx2 || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".simplifyCtorLikeReactLynx2",
+            expected: "(boolean | undefined)",
+            value: input.simplifyCtorLikeReactLynx2
+        }, _errorFactory)) && (void 0 === input.transformLegacyEventAttributeNames || "boolean" == typeof input.transformLegacyEventAttributeNames || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".transformLegacyEventAttributeNames",
+            expected: "(boolean | undefined)",
+            value: input.transformLegacyEventAttributeNames
+        }, _errorFactory)) && (void 0 === input.removeComponentAttrRegex || "string" == typeof input.removeComponentAttrRegex || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".removeComponentAttrRegex",
+            expected: "(string | undefined)",
+            value: input.removeComponentAttrRegex
+        }, _errorFactory)) && (void 0 === input.disableDeprecatedWarning || "boolean" == typeof input.disableDeprecatedWarning || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".disableDeprecatedWarning",
+            expected: "(boolean | undefined)",
+            value: input.disableDeprecatedWarning
+        }, _errorFactory)) && (null !== input.darkMode || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".darkMode",
+            expected: "(DarkModeConfig | boolean | undefined)",
+            value: input.darkMode
+        }, _errorFactory)) && (void 0 === input.darkMode || "boolean" == typeof input.darkMode || ("object" == typeof input.darkMode && null !== input.darkMode || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".darkMode",
+            expected: "(DarkModeConfig | boolean | undefined)",
+            value: input.darkMode
+        }, _errorFactory)) && _ao3(input.darkMode, _path + ".darkMode", _exceptionable) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".darkMode",
+            expected: "(DarkModeConfig | boolean | undefined)",
+            value: input.darkMode
+        }, _errorFactory)) && (void 0 === input.legacySlot || "boolean" == typeof input.legacySlot || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".legacySlot",
+            expected: "(boolean | undefined)",
+            value: input.legacySlot
+        }, _errorFactory)) && (void 0 === input.disableCreateSelectorQueryIncompatibleWarning || "boolean" == typeof input.disableCreateSelectorQueryIncompatibleWarning || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".disableCreateSelectorQueryIncompatibleWarning",
+            expected: "(boolean | undefined)",
+            value: input.disableCreateSelectorQueryIncompatibleWarning
+        }, _errorFactory)) && (0 === Object.keys(input).length || false === _exceptionable || Object.keys(input).every((key)=>{
+            if ([
+                "componentsPkg",
+                "oldRuntimePkg",
+                "newRuntimePkg",
+                "additionalComponentAttributes",
+                "addComponentElement",
+                "simplifyCtorLikeReactLynx2",
+                "transformLegacyEventAttributeNames",
+                "removeComponentAttrRegex",
+                "disableDeprecatedWarning",
+                "darkMode",
+                "legacySlot",
+                "disableCreateSelectorQueryIncompatibleWarning"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + _accessExpressionAsString(key),
+                expected: "undefined",
+                value: value
+            }, _errorFactory);
+        }));
+    const _ao2 = (input, _path, _exceptionable = true)=>("boolean" == typeof input.compilerOnly || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".compilerOnly",
+            expected: "boolean",
+            value: input.compilerOnly
+        }, _errorFactory)) && (1 === Object.keys(input).length || false === _exceptionable || Object.keys(input).every((key)=>{
+            if ([
+                "compilerOnly"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + _accessExpressionAsString(key),
+                expected: "undefined",
+                value: value
+            }, _errorFactory);
+        }));
+    const _ao3 = (input, _path, _exceptionable = true)=>("string" == typeof input.themeExpr || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".themeExpr",
+            expected: "string",
+            value: input.themeExpr
+        }, _errorFactory)) && (1 === Object.keys(input).length || false === _exceptionable || Object.keys(input).every((key)=>{
+            if ([
+                "themeExpr"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + _accessExpressionAsString(key),
+                expected: "undefined",
+                value: value
+            }, _errorFactory);
+        }));
+    const _ao4 = (input, _path, _exceptionable = true)=>(void 0 === input.mode || "dash-case" === input.mode || "mapping-only" === input.mode || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".mode",
+            expected: "(\"dash-case\" | \"mapping-only\" | undefined)",
+            value: input.mode
+        }, _errorFactory)) && (void 0 === input.preserve || (Array.isArray(input.preserve) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".preserve",
+            expected: "(ReadonlyArray<string> | undefined)",
+            value: input.preserve
+        }, _errorFactory)) && input.preserve.every((elem, _index14)=>"string" == typeof elem || _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + ".preserve[" + _index14 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".preserve",
+            expected: "(ReadonlyArray<string> | undefined)",
+            value: input.preserve
+        }, _errorFactory)) && (void 0 === input.rename || ("object" == typeof input.rename && null !== input.rename && false === Array.isArray(input.rename) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".rename",
+            expected: "(Readonly<Record<string, string>> | undefined)",
+            value: input.rename
+        }, _errorFactory)) && _ao5(input.rename, _path + ".rename", _exceptionable) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".rename",
+            expected: "(Readonly<Record<string, string>> | undefined)",
+            value: input.rename
+        }, _errorFactory)) && (0 === Object.keys(input).length || false === _exceptionable || Object.keys(input).every((key)=>{
+            if ([
+                "mode",
+                "preserve",
+                "rename"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + _accessExpressionAsString(key),
+                expected: "undefined",
+                value: value
+            }, _errorFactory);
+        }));
+    const _ao5 = (input, _path, _exceptionable = true)=>false === _exceptionable || Object.keys(input).every((key)=>{
+            const value = input[key];
+            if (void 0 === value) return true;
+            return "string" == typeof value || _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + _accessExpressionAsString(key),
+                expected: "string",
+                value: value
+            }, _errorFactory);
+        });
+    const _ao6 = (input, _path, _exceptionable = true)=>(void 0 === input.pkgName || (Array.isArray(input.pkgName) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".pkgName",
+            expected: "(Array<string> | undefined)",
+            value: input.pkgName
+        }, _errorFactory)) && input.pkgName.every((elem, _index15)=>"string" == typeof elem || _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + ".pkgName[" + _index15 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".pkgName",
+            expected: "(Array<string> | undefined)",
+            value: input.pkgName
+        }, _errorFactory)) && (void 0 === input.retainProp || (Array.isArray(input.retainProp) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".retainProp",
+            expected: "(Array<string> | undefined)",
+            value: input.retainProp
+        }, _errorFactory)) && input.retainProp.every((elem, _index16)=>"string" == typeof elem || _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + ".retainProp[" + _index16 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".retainProp",
+            expected: "(Array<string> | undefined)",
+            value: input.retainProp
+        }, _errorFactory)) && (void 0 === input.removeCall || (Array.isArray(input.removeCall) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".removeCall",
+            expected: "(Array<string> | undefined)",
+            value: input.removeCall
+        }, _errorFactory)) && input.removeCall.every((elem, _index17)=>"string" == typeof elem || _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + ".removeCall[" + _index17 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".removeCall",
+            expected: "(Array<string> | undefined)",
+            value: input.removeCall
+        }, _errorFactory)) && (void 0 === input.removeCallParams || (Array.isArray(input.removeCallParams) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".removeCallParams",
+            expected: "(Array<string> | undefined)",
+            value: input.removeCallParams
+        }, _errorFactory)) && input.removeCallParams.every((elem, _index18)=>"string" == typeof elem || _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + ".removeCallParams[" + _index18 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".removeCallParams",
+            expected: "(Array<string> | undefined)",
+            value: input.removeCallParams
+        }, _errorFactory)) && (0 === Object.keys(input).length || false === _exceptionable || Object.keys(input).every((key)=>{
+            if ([
+                "pkgName",
+                "retainProp",
+                "removeCall",
+                "removeCallParams"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + _accessExpressionAsString(key),
+                expected: "undefined",
+                value: value
+            }, _errorFactory);
+        }));
+    const _ao7 = (input, _path, _exceptionable = true)=>(void 0 === input.define || ("object" == typeof input.define && null !== input.define && false === Array.isArray(input.define) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".define",
+            expected: "(Record<string, string> | undefined)",
+            value: input.define
+        }, _errorFactory)) && _ao8(input.define, _path + ".define", _exceptionable) || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".define",
+            expected: "(Record<string, string> | undefined)",
+            value: input.define
+        }, _errorFactory)) && (0 === Object.keys(input).length || false === _exceptionable || Object.keys(input).every((key)=>{
+            if ([
+                "define"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + _accessExpressionAsString(key),
+                expected: "undefined",
+                value: value
+            }, _errorFactory);
+        }));
+    const _ao8 = (input, _path, _exceptionable = true)=>false === _exceptionable || Object.keys(input).every((key)=>{
+            const value = input[key];
+            if (void 0 === value) return true;
+            return "string" == typeof value || _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + _accessExpressionAsString(key),
+                expected: "string",
+                value: value
+            }, _errorFactory);
+        });
+    const _ao9 = (input, _path, _exceptionable = true)=>(void 0 === input.strLength || "number" == typeof input.strLength || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".strLength",
+            expected: "(number | undefined)",
+            value: input.strLength
+        }, _errorFactory)) && (0 === Object.keys(input).length || false === _exceptionable || Object.keys(input).every((key)=>{
+            if ([
+                "strLength"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + _accessExpressionAsString(key),
+                expected: "undefined",
+                value: value
+            }, _errorFactory);
+        }));
+    const _ao10 = (input, _path, _exceptionable = true)=>(void 0 === input.mainThread || "boolean" == typeof input.mainThread || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".mainThread",
+            expected: "(boolean | undefined)",
+            value: input.mainThread
+        }, _errorFactory)) && (void 0 === input.background || "boolean" == typeof input.background || _assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + ".background",
+            expected: "(boolean | undefined)",
+            value: input.background
+        }, _errorFactory)) && (0 === Object.keys(input).length || false === _exceptionable || Object.keys(input).every((key)=>{
+            if ([
+                "mainThread",
+                "background"
+            ].some((prop)=>key === prop)) return true;
+            const value = input[key];
+            if (void 0 === value) return true;
+            return _assertGuard(_exceptionable, {
+                method: "typia.createAssertEquals",
+                path: _path + _accessExpressionAsString(key),
+                expected: "undefined",
+                value: value
+            }, _errorFactory);
+        }));
+    const __is = (input, _exceptionable = true)=>void 0 === input || "object" == typeof input && null !== input && false === Array.isArray(input) && _io0(input, true);
+    let _errorFactory;
+    return (input, errorFactory = ({ path, expected, value })=>{
+        if ('undefined' === expected) {
+            const errorMessage = `Unknown property: \`${path}\` in the configuration of pluginReactLynx. If you are trying to set a Lynx config, use \`pluginLynxConfig\` (the Lynx Config rsbuild plugin) instead.`;
+            return new Error(errorMessage);
+        }
+        return new Error([
+            `Invalid config on pluginReactLynx: \`${path}\`.`,
+            `  - Expect to be ${expected}`,
+            `  - Got: ${whatIs(value)}`,
+            ''
+        ].join('\n'));
+    })=>{
+        if (false === __is(input)) {
+            _errorFactory = errorFactory;
+            ((input, _path, _exceptionable = true)=>void 0 === input || ("object" == typeof input && null !== input && false === Array.isArray(input) || _assertGuard(true, {
+                    method: "typia.createAssertEquals",
+                    path: _path + "",
+                    expected: "(PluginReactLynxOptions | undefined)",
+                    value: input
+                }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard(true, {
+                    method: "typia.createAssertEquals",
+                    path: _path + "",
+                    expected: "(PluginReactLynxOptions | undefined)",
+                    value: input
+                }, _errorFactory))(input, "$input", true);
+        }
+        return input;
+    };
+})();
+function whatIs(value) {
+    return Object.prototype.toString.call(value).replace(/^\[object\s+([a-z]+)\]$/i, '$1').toLowerCase();
+}
+function pluginReactLynx(userOptions) {
+    validateConfig(userOptions);
+    const engineVersion = userOptions?.engineVersion ?? userOptions?.targetSdkVersion ?? '3.2';
+    const defaultOptions = {
+        compat: void 0,
+        customCSSInheritanceList: void 0,
+        debugInfoOutside: true,
+        defaultDisplayLinear: true,
+        enableAccessibilityElement: false,
+        enableCSSInheritance: false,
+        enableCSSInvalidation: true,
+        enableCSSSelector: true,
+        enableNewGesture: false,
+        enableRemoveCSSScope: true,
+        firstScreenSyncTiming: 'immediately',
+        enableSSR: false,
+        removeDescendantSelectorScope: true,
+        shake: void 0,
+        defineDCE: void 0,
+        targetSdkVersion: '',
+        engineVersion: '',
+        extractStr: false,
+        globalPropsMode: 'reactive',
+        experimental_isLazyBundle: false,
+        experimental_transformBuiltinAttributeNames: false,
+        experimental_useElementTemplate: false,
+        optimizeBundleSize: false,
+        enableUiSourceMap: false,
+        experimental_reEvalJSOnReload: false
+    };
+    const resolvedOptions = Object.assign(defaultOptions, userOptions, {
+        targetSdkVersion: engineVersion,
+        engineVersion
+    });
+    return [
+        pluginAutoLynx(),
+        pluginReactAlias({
+            lazy: resolvedOptions.experimental_isLazyBundle,
+            elementTemplate: resolvedOptions.experimental_useElementTemplate,
+            LAYERS: LAYERS
+        }),
+        {
+            name: 'lynx:react',
+            pre: [
+                'lynx:rsbuild:plugin-api',
+                'lynx:config'
+            ],
+            setup (api) {
+                api.expose(REACT_COMPILE_RESULT_EXPOSURE, reactCompileResultExposure);
+                const isRslib = 'rslib' === api.context.callerName;
+                const isRstest = 'rstest' === api.context.callerName;
+                const exposedConfig = api.useExposed(Symbol.for('lynx.config'));
+                if (exposedConfig) Object.keys(defaultOptions).forEach((key)=>{
+                    if (Object.hasOwn(exposedConfig.config, key)) Object.assign(resolvedOptions, {
+                        [key]: exposedConfig.config[key]
+                    });
+                });
+                if (!isRstest) applyCSS(api, resolvedOptions);
+                applyEntry(api, resolvedOptions);
+                applyBackgroundOnly(api);
+                applyGenerator(api, resolvedOptions);
+                if (isRstest) applyTestingLoaders(api, resolvedOptions);
+                else applyLoaders(api, resolvedOptions);
+                applyRefresh(api);
+                applySplitChunksRule(api);
+                applySWC(api);
+                applyUseSyncExternalStore(api);
+                if (isRslib) applyNodeEnv(api);
+                api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>{
+                    const userConfig = api.getRsbuildConfig('original');
+                    if (void 0 === userConfig.source?.include) config = mergeRsbuildConfig(config, {
+                        source: {
+                            include: [
+                                /\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)$/
+                            ]
+                        }
+                    });
+                    config = mergeRsbuildConfig({
+                        tools: {
+                            rspack: {
+                                output: {
+                                    iife: false
+                                }
+                            }
+                        }
+                    }, config);
+                    config = mergeRsbuildConfig({
+                        resolve: {
+                            dedupe: [
+                                'react-compiler-runtime'
+                            ]
+                        }
+                    }, config);
+                    return config;
+                });
+                if (resolvedOptions.optimizeBundleSize) applyOptimizeBundleSize(api, resolvedOptions);
+                if (resolvedOptions.experimental_isLazyBundle) applyLazy(api);
+                api.expose(Symbol.for('LAYERS'), LAYERS);
+                const require = createRequire(import.meta.url);
+                const { version } = require('../package.json');
+                const webpackPluginPath = require.resolve('@lynx-js/react-webpack-plugin');
+                api.logger?.debug(`Using @lynx-js/react-webpack-plugin v${version} at ${webpackPluginPath}`);
+            }
+        },
+        {
+            name: 'lynx:react:css-minify-guard',
+            enforce: 'post',
+            setup (api) {
+                if (false !== resolvedOptions.enableRemoveCSSScope) return;
+                api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>mergeRsbuildConfig(config, {
+                        output: {
+                            minify: {
+                                css: false
+                            }
+                        }
+                    }));
+            }
+        }
+    ];
+}
+export { LAYERS, pluginReactLynx };