extension-develop 3.1.0-next.5 → 3.1.0-next.7

package/dist/{329.js → 547.js}

@@ -3,7 +3,7 @@ const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
     return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
 }();
 exports.ids = [
-    "329"
+    "547"
 ];
 exports.modules = {
     "./webpack/webpack-config.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
@@ -461,196 +461,10 @@ exports.modules = {
             }
         }
         plugin_compilation_define_property(CompilationPlugin, "name", 'plugin-compilation');
-        function cssIntegrationsEnabled(integrations) {
-            const list = integrations.length > 0 ? integrations.map((n)=>external_pintor_default().yellow(n)).join(', ') : external_pintor_default().gray('none');
-            return `${external_pintor_default().gray('►►►')} CSS: Integrations enabled (${external_pintor_default().gray(String(integrations.length))}) ${list}`;
-        }
-        function cssConfigsDetected(postcssConfig, stylelintConfig, tailwindConfig, browserslistSource) {
-            const fmt = (v)=>v ? external_pintor_default().underline(v) : external_pintor_default().gray('none');
-            return `${external_pintor_default().gray('►►►')} CSS: Configs\n${external_pintor_default().gray('POSTCSS')} ${fmt(postcssConfig)}\n${external_pintor_default().gray('STYLELINT')} ${fmt(stylelintConfig)}\n${external_pintor_default().gray('TAILWIND')} ${fmt(tailwindConfig)}\n${external_pintor_default().gray('BROWSERSLIST')} ${fmt(browserslistSource)}`;
-        }
-        function isUsingIntegration(name) {
-            return `${external_pintor_default().gray('►►►')} Using ${external_pintor_default().brightBlue(name)}...`;
-        }
-        function youAreAllSet(name) {
-            return `${external_pintor_default().green('►►►')} ${name} installation completed. Run again to proceed.`;
-        }
-        function missingSassDependency() {
-            const prefix = external_pintor_default().red('►►►');
-            return [
-                `${prefix} SASS support requires the ${external_pintor_default().brightBlue('"sass"')} package to be installed in your project.`,
-                '',
-                "Add it to your devDependencies, for example:",
-                `  ${external_pintor_default().gray('npm install --save-dev sass')}`,
-                `  ${external_pintor_default().gray('pnpm add -D sass')}`,
-                '',
-                'Sample package.json:',
-                '  {',
-                '    "devDependencies": {',
-                `      "sass": ${external_pintor_default().yellow('"<version>"')}`,
-                '    }',
-                '  }'
-            ].join('\n');
-        }
+        var css_lib_messages = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
         var css_lib_integrations = __webpack_require__("./webpack/plugin-css/css-lib/integrations.ts");
-        var external_module_ = __webpack_require__("module");
-        let userMessageDelivered = false;
-        function isUsingSass(projectPath) {
-            if ((0, css_lib_integrations.w)(projectPath, 'sass')) {
-                if (!userMessageDelivered) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${external_pintor_default().brightMagenta('►►► Author says')} ${isUsingIntegration('SASS')}`);
-                    userMessageDelivered = true;
-                }
-                return true;
-            }
-            return false;
-        }
-        function resolveSassImplementation(projectPath) {
-            const bases = [
-                projectPath,
-                process.cwd()
-            ];
-            for (const base of bases)try {
-                const req = (0, external_module_.createRequire)(external_path_.join(base, 'package.json'));
-                let mod = req('sass');
-                if (mod && 'object' == typeof mod && 'default' in mod) mod = mod.default;
-                return mod;
-            } catch  {}
-            try {
-                let mod = __webpack_require__("../../node_modules/.pnpm/sass@1.97.2/node_modules/sass/sass.node.js");
-                if (mod && 'object' == typeof mod && 'default' in mod) mod = mod.default;
-                return mod;
-            } catch  {
-                return;
-            }
-        }
-        function createSassLoaderOptions(projectPath, mode) {
-            const implementation = resolveSassImplementation(projectPath);
-            const usingSass = isUsingSass(projectPath);
-            if (usingSass && !implementation) throw new Error(missingSassDependency());
-            const base = {
-                sourceMap: 'development' === mode,
-                sassOptions: {
-                    outputStyle: 'expanded'
-                }
-            };
-            if (implementation) base.implementation = implementation;
-            return base;
-        }
-        async function maybeUseSass(projectPath) {
-            if (!isUsingSass(projectPath)) return [];
-            try {
-                require.resolve('sass-loader');
-            } catch (e) {
-                const postCssDependencies = [
-                    'postcss-loader',
-                    'postcss-scss',
-                    'postcss-preset-env'
-                ];
-                await (0, css_lib_integrations.t)('PostCSS', postCssDependencies);
-                const sassDependencies = [
-                    'sass-loader'
-                ];
-                await (0, css_lib_integrations.t)('SASS', sassDependencies);
-                console.log(youAreAllSet('SASS'));
-                process.exit(0);
-            }
-            return [
-                {
-                    test: /\.(sass|scss)$/,
-                    exclude: /\.module\.(sass|scss)$/,
-                    use: [
-                        {
-                            loader: require.resolve('sass-loader'),
-                            options: createSassLoaderOptions(projectPath, 'development')
-                        }
-                    ]
-                },
-                {
-                    test: /\.module\.(sass|scss)$/,
-                    use: [
-                        {
-                            loader: require.resolve('sass-loader'),
-                            options: createSassLoaderOptions(projectPath, 'development')
-                        }
-                    ]
-                }
-            ];
-        }
-        function is_content_script_parseJsonSafe(text) {
-            const s = text && 0xfeff === text.charCodeAt(0) ? text.slice(1) : text;
-            return JSON.parse(s || '{}');
-        }
-        function isContentScriptEntry(absolutePath, manifestPath) {
-            if (!absolutePath || !manifestPath) return false;
-            if (!external_fs_.existsSync(manifestPath)) return false;
-            const manifest = is_content_script_parseJsonSafe(external_fs_.readFileSync(manifestPath, 'utf8'));
-            for (const content of manifest.content_scripts || [])if (content.js?.length) for (const js of content.js){
-                const contentPath = external_path_.resolve(external_path_.dirname(manifestPath), js);
-                if (contentPath === absolutePath) return true;
-            }
-            return false;
-        }
-        let less_userMessageDelivered = false;
-        function isUsingLess(projectPath) {
-            if ((0, css_lib_integrations.w)(projectPath, 'less')) {
-                if (!less_userMessageDelivered) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${external_pintor_default().brightMagenta('►►► Author says')} ${isUsingIntegration('LESS')}`);
-                    less_userMessageDelivered = true;
-                }
-                return true;
-            }
-            return false;
-        }
-        async function maybeUseLess(projectPath, manifestPath) {
-            const resolvedManifestPath = manifestPath || external_path_.join(projectPath, 'manifest.json');
-            if (!isUsingLess(projectPath)) return [];
-            try {
-                require.resolve('less-loader');
-            } catch (e) {
-                const lessDependencies = [
-                    'less',
-                    'less-loader'
-                ];
-                await (0, css_lib_integrations.t)('LESS', lessDependencies);
-                console.log(youAreAllSet('LESS'));
-                process.exit(0);
-            }
-            return [
-                {
-                    test: /\.less$/,
-                    exclude: /\.module\.less$/,
-                    use: [
-                        {
-                            loader: require.resolve('less-loader'),
-                            options: {
-                                sourceMap: true
-                            }
-                        }
-                    ]
-                },
-                {
-                    test: /\.module\.less$/,
-                    use: [
-                        {
-                            loader: require.resolve('less-loader'),
-                            options: {
-                                sourceMap: true
-                            }
-                        }
-                    ]
-                },
-                {
-                    test: /\.less$/,
-                    exclude: /\.module\.less$/,
-                    type: 'asset/resource',
-                    generator: {
-                        filename: "content_scripts/[name].[contenthash:8].css"
-                    },
-                    issuer: (issuer)=>isContentScriptEntry(issuer, resolvedManifestPath)
-                }
-            ];
-        }
+        var sass = __webpack_require__("./webpack/plugin-css/css-tools/sass.ts");
+        var less = __webpack_require__("./webpack/plugin-css/css-tools/less.ts");
         function getStylelintConfigFile(projectPath) {
             const stylelintConfigJs = external_path_.join(projectPath, 'stylelint.config.js');
             const stylelintConfigDotJs = external_path_.join(projectPath, '.stylelintrc.js');
@@ -673,16 +487,16 @@ exports.modules = {
             if (external_fs_.existsSync(stylelintConfigYml)) return stylelintConfigYml;
             if (external_fs_.existsSync(stylelintConfigDotYml)) return stylelintConfigDotYml;
         }
-        let stylelint_userMessageDelivered = false;
+        let userMessageDelivered = false;
         function stylelint_isUsingStylelint(projectPath) {
             const packageJsonPath = external_path_.join(projectPath, 'package.json');
             if (!external_fs_.existsSync(packageJsonPath)) return false;
             const configFile = getStylelintConfigFile(projectPath);
             const isUsingStylelint = !!configFile;
             if (isUsingStylelint) {
-                if (!stylelint_userMessageDelivered) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${external_pintor_default().brightMagenta('►►► Author says')} ${isUsingIntegration('Stylelint')}`);
-                    stylelint_userMessageDelivered = true;
+                if (!userMessageDelivered) {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${external_pintor_default().brightMagenta('►►► Author says')} ${css_lib_messages.zA('Stylelint')}`);
+                    userMessageDelivered = true;
                 }
             }
             return isUsingStylelint;
@@ -691,154 +505,12 @@ exports.modules = {
             stylelint_isUsingStylelint(projectPath);
             return [];
         }
-        let tailwind_userMessageDelivered = false;
-        function tailwind_isUsingTailwind(projectPath) {
-            const isUsingTailwind = (0, css_lib_integrations.w)(projectPath, 'tailwindcss') || (0, css_lib_integrations.w)(projectPath, '@tailwindcss/postcss');
-            if (isUsingTailwind) {
-                if (!tailwind_userMessageDelivered) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${external_pintor_default().brightMagenta('►►► Author says')} ${isUsingIntegration('Tailwind')}`);
-                    tailwind_userMessageDelivered = true;
-                }
-            }
-            return isUsingTailwind;
-        }
-        function getTailwindConfigFile(projectPath) {
-            const configFileMjs = external_path_.join(projectPath, 'tailwind.config.mjs');
-            const configFileCjs = external_path_.join(projectPath, 'tailwind.config.cjs');
-            const configFileJs = external_path_.join(projectPath, 'tailwind.config.js');
-            if (external_fs_.existsSync(configFileMjs)) return configFileMjs;
-            if (external_fs_.existsSync(configFileCjs)) return configFileCjs;
-            if (external_fs_.existsSync(configFileJs)) return configFileJs;
-        }
-        let postcss_userMessageDelivered = false;
-        const postCssConfigFiles = [
-            '.postcssrc',
-            '.postcssrc.json',
-            '.postcssrc.yaml',
-            '.postcssrc.yml',
-            'postcss.config.mjs',
-            '.postcssrc.js',
-            '.postcssrc.cjs',
-            'postcss.config.js',
-            'postcss.config.cjs'
-        ];
-        function findPostCssConfig(projectPath) {
-            for (const configFile of postCssConfigFiles){
-                const configPath = external_path_.join(projectPath, configFile);
-                if (external_fs_.existsSync(configPath)) return configPath;
-            }
-        }
-        function isUsingPostCss(projectPath) {
-            if ((0, css_lib_integrations.w)(projectPath, 'postcss')) {
-                if (!postcss_userMessageDelivered) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${external_pintor_default().brightMagenta('►►► Author says')} ${isUsingIntegration('PostCSS')}`);
-                    postcss_userMessageDelivered = true;
-                }
-                return true;
-            }
-            if (findPostCssConfig(projectPath)) {
-                if (!postcss_userMessageDelivered) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${external_pintor_default().brightMagenta('►►► Author says')} ${isUsingIntegration('PostCSS')}`);
-                    postcss_userMessageDelivered = true;
-                }
-                return true;
-            }
-            if (tailwind_isUsingTailwind(projectPath)) {
-                if (!postcss_userMessageDelivered) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${external_pintor_default().brightMagenta('►►► Author says')} ${isUsingIntegration('PostCSS')}`);
-                    postcss_userMessageDelivered = true;
-                }
-                return true;
-            }
-            return false;
-        }
-        async function maybeUsePostCss(projectPath, opts) {
-            const userPostCssConfig = findPostCssConfig(projectPath);
-            function getPackageJsonConfig(p) {
-                try {
-                    const raw = external_fs_.readFileSync(external_path_.join(p, 'package.json'), 'utf8');
-                    const pkg = JSON.parse(raw || '{}');
-                    return {
-                        hasPostCss: !!pkg?.postcss,
-                        config: pkg?.postcss
-                    };
-                } catch  {
-                    return {
-                        hasPostCss: false
-                    };
-                }
-            }
-            const { hasPostCss: pkgHasPostCss, config: pkgPostCssConfig } = getPackageJsonConfig(projectPath);
-            const tailwindPresent = tailwind_isUsingTailwind(projectPath);
-            if (!userPostCssConfig && !pkgHasPostCss && !tailwindPresent) return {};
-            try {
-                require.resolve('postcss-loader');
-            } catch (e) {
-                if (!isUsingSass(projectPath) && !isUsingLess(projectPath)) {
-                    const postCssDependencies = [
-                        'postcss',
-                        'postcss-loader'
-                    ];
-                    await (0, css_lib_integrations.t)('PostCSS', postCssDependencies);
-                }
-                console.log(youAreAllSet('PostCSS'));
-                process.exit(0);
-            }
-            let pluginsFromOptions;
-            if (tailwindPresent) try {
-                const bases = [
-                    projectPath,
-                    process.cwd()
-                ];
-                let tailwindMod;
-                for (const base of bases)try {
-                    const req = (0, external_module_.createRequire)(external_path_.join(base, 'package.json'));
-                    tailwindMod = req('@tailwindcss/postcss');
-                    break;
-                } catch (e) {}
-                if (tailwindMod) {
-                    if (tailwindMod && 'object' == typeof tailwindMod && 'default' in tailwindMod) tailwindMod = tailwindMod.default;
-                    if ('function' == typeof tailwindMod) {
-                        const instance = tailwindMod();
-                        pluginsFromOptions = [
-                            {
-                                '@tailwindcss/postcss': false
-                            },
-                            instance
-                        ];
-                    } else if (tailwindMod && 'object' == typeof tailwindMod && 'postcssPlugin' in tailwindMod) pluginsFromOptions = [
-                        {
-                            '@tailwindcss/postcss': false
-                        },
-                        tailwindMod
-                    ];
-                }
-            } catch  {}
-            const postcssOptions = {
-                ident: 'postcss',
-                cwd: projectPath,
-                config: projectPath
-            };
-            if (pluginsFromOptions) postcssOptions.plugins = pluginsFromOptions;
-            if ('true' === process.env.EXTENSION_AUTHOR_MODE) try {
-                console.log(`${external_pintor_default().brightMagenta('►►► Author says')} [extension.js:postcss] projectPath=%s userPostCssConfig=%s pkgHasPostCss=%s tailwindPresent=%s`, projectPath, userPostCssConfig || 'none', pkgHasPostCss, tailwindPresent);
-                const resolvedPluginsCount = Array.isArray(postcssOptions.plugins) ? postcssOptions.plugins.length : 0;
-                console.log(`${external_pintor_default().brightMagenta('►►► Author says')} [extension.js:postcss] resolvedPlugins=%d config=%s cwd=%s`, resolvedPluginsCount, String(postcssOptions.config), String(postcssOptions.cwd));
-            } catch  {}
-            return {
-                test: /\.css$/,
-                type: 'css',
-                loader: require.resolve('postcss-loader'),
-                options: {
-                    postcssOptions,
-                    sourceMap: 'development' === opts.mode
-                }
-            };
-        }
+        var tailwind = __webpack_require__("./webpack/plugin-css/css-tools/tailwind.ts");
+        var postcss = __webpack_require__("./webpack/plugin-css/css-tools/postcss.ts");
         async function commonStyleLoaders(projectPath, opts) {
             const styleLoaders = [];
-            if (isUsingPostCss(projectPath) || tailwind_isUsingTailwind(projectPath) || isUsingSass(projectPath) || isUsingLess(projectPath)) {
-                const maybeInstallPostCss = await maybeUsePostCss(projectPath, opts);
+            if ((0, postcss.A)(projectPath) || (0, tailwind.F)(projectPath) || (0, sass.fZ)(projectPath) || (0, less.K)(projectPath)) {
+                const maybeInstallPostCss = await (0, postcss.t)(projectPath, opts);
                 if (maybeInstallPostCss.loader) styleLoaders.push(maybeInstallPostCss);
             }
             if (opts.loader) styleLoaders.push({
@@ -850,31 +522,37 @@ exports.modules = {
             });
             return styleLoaders.filter(Boolean);
         }
-        async function cssInContentScriptLoader(projectPath, manifestPath, mode) {
-            const isContentScript = (issuer)=>isContentScriptEntry(issuer, manifestPath);
+        var is_content_script = __webpack_require__("./webpack/plugin-css/css-lib/is-content-script.ts");
+        async function cssInContentScriptLoader(projectPath, manifestPath, mode, usage = {}) {
+            const { useSass = true, useLess = true } = usage;
+            const isContentScript = (issuer)=>(0, is_content_script.z)(issuer, manifestPath);
             const fileTypes = [
                 {
                     test: /\.css$/,
                     loader: null
                 },
-                {
-                    test: /\.(sass|scss)$/,
-                    exclude: /\.module\.(sass|scss)$/,
-                    loader: 'sass-loader'
-                },
-                {
-                    test: /\.module\.(sass|scss)$/,
-                    loader: 'sass-loader'
-                },
-                {
-                    test: /\.less$/,
-                    exclude: /\.module\.less$/,
-                    loader: 'less-loader'
-                },
-                {
-                    test: /\.module\.less$/,
-                    loader: 'less-loader'
-                }
+                ...useSass ? [
+                    {
+                        test: /\.(sass|scss)$/,
+                        exclude: /\.module\.(sass|scss)$/,
+                        loader: 'sass-loader'
+                    },
+                    {
+                        test: /\.module\.(sass|scss)$/,
+                        loader: 'sass-loader'
+                    }
+                ] : [],
+                ...useLess ? [
+                    {
+                        test: /\.less$/,
+                        exclude: /\.module\.less$/,
+                        loader: 'less-loader'
+                    },
+                    {
+                        test: /\.module\.less$/,
+                        loader: 'less-loader'
+                    }
+                ] : []
             ];
             const rules = await Promise.all(fileTypes.map(async ({ test, exclude, loader })=>{
                 const baseConfig = {
@@ -892,7 +570,7 @@ exports.modules = {
                         mode: mode
                     })
                 };
-                const loaderOptions = 'sass-loader' === loader ? createSassLoaderOptions(projectPath, mode) : {
+                const loaderOptions = 'sass-loader' === loader ? (0, sass.mF)(projectPath, mode) : {
                     sourceMap: true
                 };
                 return {
@@ -906,36 +584,41 @@ exports.modules = {
             }));
             return rules;
         }
-        async function cssInHtmlLoader(projectPath, mode, manifestPath) {
-            const isNotContentScript = (issuer)=>!isContentScriptEntry(issuer, manifestPath);
+        async function cssInHtmlLoader(projectPath, mode, manifestPath, usage = {}) {
+            const { useSass = true, useLess = true } = usage;
+            const isNotContentScript = (issuer)=>!(0, is_content_script.z)(issuer, manifestPath);
             const fileTypes = [
                 {
                     test: /\.css$/,
                     type: 'css',
                     loader: null
                 },
-                {
-                    test: /\.(sass|scss)$/,
-                    exclude: /\.module\.(sass|scss)$/,
-                    type: 'css',
-                    loader: 'sass-loader'
-                },
-                {
-                    test: /\.module\.(sass|scss)$/,
-                    type: 'css/module',
-                    loader: 'sass-loader'
-                },
-                {
-                    test: /\.less$/,
-                    exclude: /\.module\.less$/,
-                    type: 'css',
-                    loader: 'less-loader'
-                },
-                {
-                    test: /\.module\.less$/,
-                    type: 'css/module',
-                    loader: 'less-loader'
-                }
+                ...useSass ? [
+                    {
+                        test: /\.(sass|scss)$/,
+                        exclude: /\.module\.(sass|scss)$/,
+                        type: 'css',
+                        loader: 'sass-loader'
+                    },
+                    {
+                        test: /\.module\.(sass|scss)$/,
+                        type: 'css/module',
+                        loader: 'sass-loader'
+                    }
+                ] : [],
+                ...useLess ? [
+                    {
+                        test: /\.less$/,
+                        exclude: /\.module\.less$/,
+                        type: 'css',
+                        loader: 'less-loader'
+                    },
+                    {
+                        test: /\.module\.less$/,
+                        type: 'css/module',
+                        loader: 'less-loader'
+                    }
+                ] : []
             ];
             const rules = await Promise.all(fileTypes.map(async ({ test, exclude, type, loader })=>{
                 const baseConfig = {
@@ -950,7 +633,7 @@ exports.modules = {
                         mode: mode
                     })
                 };
-                const loaderOptions = 'sass-loader' === loader ? createSassLoaderOptions(projectPath, mode) : {
+                const loaderOptions = 'sass-loader' === loader ? (0, sass.mF)(projectPath, mode) : {
                     sourceMap: true
                 };
                 return {
@@ -977,17 +660,25 @@ exports.modules = {
         class CssPlugin {
             async configureOptions(compiler) {
                 const mode = compiler.options.mode || 'development';
-                const projectPath = compiler.options.context;
+                const projectPath = compiler.options.context || process.cwd();
                 const plugins = [];
                 const manifestPath = this.manifestPath;
+                const usingSass = (0, css_lib_integrations.w)(projectPath, 'sass');
+                const usingLess = (0, css_lib_integrations.w)(projectPath, 'less');
                 const maybeInstallStylelint = await maybeUseStylelint(projectPath);
                 plugins.push(...maybeInstallStylelint);
+                const maybeInstallSass = await (0, sass.IZ)(projectPath);
+                const maybeInstallLess = await (0, less.V)(projectPath, manifestPath);
                 const loaders = [
-                    ...await cssInContentScriptLoader(projectPath, manifestPath, mode),
-                    ...await cssInHtmlLoader(projectPath, mode, manifestPath)
+                    ...await cssInContentScriptLoader(projectPath, manifestPath, mode, {
+                        useSass: usingSass,
+                        useLess: usingLess
+                    }),
+                    ...await cssInHtmlLoader(projectPath, mode, manifestPath, {
+                        useSass: usingSass,
+                        useLess: usingLess
+                    })
                 ];
-                const maybeInstallSass = await maybeUseSass(projectPath);
-                const maybeInstallLess = await maybeUseLess(projectPath, manifestPath);
                 if (maybeInstallSass.length) loaders.push({
                     test: /\.(sass|scss)$/,
                     exclude: /\.module\.(sass|scss)$/,
@@ -995,7 +686,7 @@ exports.modules = {
                     generator: {
                         filename: "content_scripts/[name].[contenthash:8].css"
                     },
-                    issuer: (issuer)=>isContentScriptEntry(issuer, manifestPath)
+                    issuer: (issuer)=>(0, is_content_script.z)(issuer, manifestPath)
                 });
                 if (maybeInstallLess.length) loaders.push({
                     test: /\.less$/,
@@ -1004,7 +695,7 @@ exports.modules = {
                     generator: {
                         filename: "content_scripts/[name].[contenthash:8].css"
                     },
-                    issuer: (issuer)=>isContentScriptEntry(issuer, manifestPath)
+                    issuer: (issuer)=>(0, is_content_script.z)(issuer, manifestPath)
                 });
                 compiler.options.plugins = [
                     ...compiler.options.plugins,
@@ -1016,20 +707,18 @@ exports.modules = {
                 ].filter(Boolean);
                 if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
                     const integrations = [];
-                    const usingSass = (0, css_lib_integrations.w)(projectPath, 'sass');
-                    const usingLess = (0, css_lib_integrations.w)(projectPath, 'less');
                     const usingTailwind = (0, css_lib_integrations.w)(projectPath, 'tailwindcss');
-                    const usingPostcss = (0, css_lib_integrations.w)(projectPath, 'postcss') || void 0 !== plugin_css_findPostCssConfig(projectPath) || usingSass || usingLess || usingTailwind;
+                    const usingPostcss = (0, css_lib_integrations.w)(projectPath, 'postcss') || void 0 !== findPostCssConfig(projectPath) || usingSass || usingLess || usingTailwind;
                     if (usingPostcss) integrations.push('PostCSS');
                     if (usingSass) integrations.push('Sass');
                     if (usingLess) integrations.push('Less');
                     if (usingTailwind) integrations.push('Tailwind');
-                    console.log(cssIntegrationsEnabled(integrations));
-                    const postcssConfig = plugin_css_findPostCssConfig(projectPath);
+                    console.log(css_lib_messages.uo(integrations));
+                    const postcssConfig = findPostCssConfig(projectPath);
                     const stylelintConfig = getStylelintConfigFile(projectPath);
-                    const tailwindConfig = getTailwindConfigFile(projectPath);
+                    const tailwindConfig = (0, tailwind.r)(projectPath);
                     const browserslistSource = findBrowserslistSource(projectPath);
-                    console.log(cssConfigsDetected(postcssConfig, stylelintConfig, tailwindConfig, browserslistSource));
+                    console.log(css_lib_messages.fD(postcssConfig, stylelintConfig, tailwindConfig, browserslistSource));
                 }
             }
             async apply(compiler) {
@@ -1043,7 +732,7 @@ exports.modules = {
             }
         }
         plugin_css_define_property(CssPlugin, "name", 'plugin-css');
-        const plugin_css_postCssConfigFiles = [
+        const postCssConfigFiles = [
             '.postcssrc',
             '.postcssrc.json',
             '.postcssrc.yaml',
@@ -1053,8 +742,8 @@ exports.modules = {
             'postcss.config.js',
             'postcss.config.cjs'
         ];
-        function plugin_css_findPostCssConfig(projectPath) {
-            for (const configFile of plugin_css_postCssConfigFiles){
+        function findPostCssConfig(projectPath) {
+            for (const configFile of postCssConfigFiles){
                 const configPath = external_path_.join(projectPath, configFile);
                 if (external_fs_.existsSync(configPath)) return configPath;
             }
@@ -1198,351 +887,12 @@ exports.modules = {
             }
         }
         plugin_static_assets_define_property(StaticAssetsPlugin, "name", 'plugin-static-assets');
-        var js_frameworks_lib_messages = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
-        var frameworks_lib_integrations = __webpack_require__("./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts");
-        let preact_userMessageDelivered = false;
-        let cachedPreactRefreshPlugin;
-        function getPreactRefreshPlugin() {
-            if (cachedPreactRefreshPlugin) return cachedPreactRefreshPlugin;
-            try {
-                const mod = __webpack_require__("@rspack/plugin-preact-refresh");
-                const plugin = mod && mod.default || mod;
-                cachedPreactRefreshPlugin = plugin;
-                return cachedPreactRefreshPlugin;
-            } catch  {}
-        }
-        function isUsingPreact(projectPath) {
-            if ((0, frameworks_lib_integrations.ws)(projectPath, 'preact')) {
-                if (!preact_userMessageDelivered) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${external_pintor_default().brightMagenta('►►► Author says')} ${js_frameworks_lib_messages.zA('Preact')}`);
-                    preact_userMessageDelivered = true;
-                }
-                return true;
-            }
-            return false;
-        }
-        async function maybeUsePreact(projectPath) {
-            if (!isUsingPreact(projectPath)) return;
-            try {
-                require.resolve('@rspack/plugin-preact-refresh');
-            } catch (e) {
-                const preactDependencies = [
-                    '@prefresh/core',
-                    '@prefresh/utils',
-                    '@rspack/plugin-preact-refresh',
-                    'preact'
-                ];
-                await (0, frameworks_lib_integrations.tm)('Preact', preactDependencies);
-                console.log(js_frameworks_lib_messages.Jv('Preact'));
-                process.exit(0);
-            }
-            const PreactRefreshPlugin = getPreactRefreshPlugin();
-            if (!PreactRefreshPlugin) throw new Error('[Preact] @rspack/plugin-preact-refresh is installed but its plugin could not be resolved.');
-            const preactPlugins = [
-                new PreactRefreshPlugin({})
-            ];
-            return {
-                plugins: preactPlugins,
-                loaders: void 0,
-                alias: {
-                    react: 'preact/compat',
-                    'react-dom/test-utils': 'preact/test-utils',
-                    'react-dom': 'preact/compat',
-                    'react/jsx-runtime': 'preact/jsx-runtime'
-                }
-            };
-        }
-        let react_userMessageDelivered = false;
-        let cachedReactRefreshPlugin;
-        function getReactRefreshPlugin() {
-            if (cachedReactRefreshPlugin) return cachedReactRefreshPlugin;
-            try {
-                const mod = __webpack_require__("@rspack/plugin-react-refresh");
-                const plugin = mod && mod.default || mod;
-                cachedReactRefreshPlugin = plugin;
-                return cachedReactRefreshPlugin;
-            } catch  {}
-        }
-        function isUsingReact(projectPath) {
-            if ((0, frameworks_lib_integrations.ws)(projectPath, 'react')) {
-                if (!react_userMessageDelivered) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${external_pintor_default().brightMagenta('►►► Author says')} ${js_frameworks_lib_messages.zA('React')}`);
-                    react_userMessageDelivered = true;
-                }
-                return true;
-            }
-            return false;
-        }
-        async function maybeUseReact(projectPath) {
-            if (!isUsingReact(projectPath)) return;
-            try {
-                require.resolve('react-refresh');
-            } catch (e) {
-                const reactDependencies = [
-                    'react-refresh',
-                    '@rspack/plugin-react-refresh'
-                ];
-                await (0, frameworks_lib_integrations.tm)('React', reactDependencies);
-                console.log(js_frameworks_lib_messages.Jv('React'));
-                process.exit(0);
-            }
-            const ReactRefreshPlugin = getReactRefreshPlugin();
-            if (!ReactRefreshPlugin) throw new Error('[React] @rspack/plugin-react-refresh is installed but its plugin could not be resolved.');
-            const reactPlugins = [
-                new ReactRefreshPlugin({
-                    overlay: false
-                })
-            ];
-            const requireFromProject = (0, external_module_.createRequire)(external_path_.join(projectPath, 'package.json'));
-            let reactPath;
-            let reactDomPath;
-            let reactDomClientPath;
-            let jsxRuntimePath;
-            try {
-                reactPath = requireFromProject.resolve('react');
-            } catch  {}
-            try {
-                reactDomPath = requireFromProject.resolve('react-dom');
-            } catch  {}
-            try {
-                reactDomClientPath = requireFromProject.resolve('react-dom/client');
-            } catch  {}
-            try {
-                jsxRuntimePath = requireFromProject.resolve('react/jsx-runtime');
-            } catch  {}
-            const alias = {};
-            if (reactPath) alias['react$'] = reactPath;
-            if (reactDomPath) alias['react-dom$'] = reactDomPath;
-            if (reactDomClientPath) alias['react-dom/client'] = reactDomClientPath;
-            if (jsxRuntimePath) alias['react/jsx-runtime'] = jsxRuntimePath;
-            return {
-                plugins: reactPlugins,
-                loaders: void 0,
-                alias
-            };
-        }
-        var external_url_ = __webpack_require__("url");
-        let load_loader_options_userMessageDelivered = false;
-        function isAuthorMode() {
-            const v = String(process.env.EXTENSION_AUTHOR_MODE || '').trim().toLowerCase();
-            return 'true' === v || '1' === v || 'development' === v || 'dev' === v;
-        }
-        function resolveLoaderConfigPath(projectPath, framework) {
-            const candidates = [
-                external_path_.join(projectPath, `${framework}.loader.ts`),
-                external_path_.join(projectPath, `${framework}.loader.mts`),
-                external_path_.join(projectPath, `${framework}.loader.js`),
-                external_path_.join(projectPath, `${framework}.loader.mjs`)
-            ];
-            return candidates.find((p)=>external_fs_.existsSync(p)) || null;
-        }
-        async function loadLoaderOptions(projectPath, framework) {
-            const configPath = resolveLoaderConfigPath(projectPath, framework);
-            if (configPath) {
-                if (!load_loader_options_userMessageDelivered && isAuthorMode()) {
-                    const display = external_path_.basename(configPath);
-                    console.log(js_frameworks_lib_messages.Ty(display));
-                    load_loader_options_userMessageDelivered = true;
-                }
-                try {
-                    const module = await import((0, external_url_.pathToFileURL)(configPath).href);
-                    return module.default || module;
-                } catch (err) {
-                    const error = err;
-                    console.error(`Error loading ${framework} loader options: ${error.message}`);
-                    throw err;
-                }
-            }
-            return null;
-        }
-        let vue_userMessageDelivered = false;
-        let cachedVueLoaderPlugin;
-        function getVueLoaderPlugin() {
-            if (cachedVueLoaderPlugin) return cachedVueLoaderPlugin;
-            try {
-                const mod = __webpack_require__("vue-loader");
-                const plugin = mod && mod.VueLoaderPlugin || mod && mod.default && mod.default.VueLoaderPlugin;
-                if (plugin) {
-                    cachedVueLoaderPlugin = plugin;
-                    return cachedVueLoaderPlugin;
-                }
-            } catch  {}
-        }
-        function isUsingVue(projectPath) {
-            const using = (0, frameworks_lib_integrations.ws)(projectPath, 'vue');
-            if (using && !vue_userMessageDelivered) {
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${external_pintor_default().brightMagenta('►►► Author says')} ${js_frameworks_lib_messages.zA('Vue')}`);
-                vue_userMessageDelivered = true;
-            }
-            return using;
-        }
-        async function maybeUseVue(projectPath) {
-            if (!isUsingVue(projectPath)) return;
-            try {
-                require.resolve('vue-loader');
-            } catch (e) {
-                const vueDependencies = [
-                    'vue-loader',
-                    '@vue/compiler-sfc'
-                ];
-                await (0, frameworks_lib_integrations.tm)('Vue', vueDependencies);
-                console.log(js_frameworks_lib_messages.Jv('Vue'));
-                process.exit(0);
-            }
-            const VueLoaderPlugin = getVueLoaderPlugin();
-            if (!VueLoaderPlugin) throw new Error('[Vue] vue-loader is installed but VueLoaderPlugin could not be resolved.');
-            const customOptions = await loadLoaderOptions(projectPath, 'vue');
-            const defaultLoaders = [
-                {
-                    test: /\.vue$/,
-                    loader: require.resolve('vue-loader'),
-                    options: {
-                        experimentalInlineMatchResource: true,
-                        ...customOptions || {}
-                    },
-                    include: projectPath,
-                    exclude: /node_modules/
-                }
-            ];
-            const defaultPlugins = [
-                new VueLoaderPlugin()
-            ];
-            return {
-                plugins: defaultPlugins,
-                loaders: defaultLoaders,
-                alias: void 0
-            };
-        }
+        var preact = __webpack_require__("./webpack/plugin-js-frameworks/js-tools/preact.ts");
+        var react = __webpack_require__("./webpack/plugin-js-frameworks/js-tools/react.ts");
+        var vue = __webpack_require__("./webpack/plugin-js-frameworks/js-tools/vue.ts");
         var typescript = __webpack_require__("./webpack/plugin-js-frameworks/js-tools/typescript.ts");
-        let svelte_userMessageDelivered = false;
-        function resolveFromProject(id, projectPath) {
-            try {
-                return require.resolve(id, {
-                    paths: [
-                        projectPath,
-                        process.cwd()
-                    ]
-                });
-            } catch  {
-                return;
-            }
-        }
-        function isUsingSvelte(projectPath) {
-            const using = (0, frameworks_lib_integrations.ws)(projectPath, 'svelte');
-            if (using && !svelte_userMessageDelivered) {
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(js_frameworks_lib_messages.zA('Svelte'));
-                svelte_userMessageDelivered = true;
-            }
-            return using;
-        }
-        async function maybeUseSvelte(projectPath, mode) {
-            if (!isUsingSvelte(projectPath)) return;
-            try {
-                resolveFromProject('svelte-loader', projectPath) || require.resolve('svelte-loader');
-            } catch (e) {
-                const typeScriptDependencies = [
-                    "typescript"
-                ];
-                await (0, frameworks_lib_integrations.tm)('TypeScript', typeScriptDependencies);
-                const svelteDependencies = [
-                    'svelte-loader'
-                ];
-                await (0, frameworks_lib_integrations.tm)('Svelte', svelteDependencies);
-                console.log(js_frameworks_lib_messages.Jv('Svelte'));
-                process.exit(0);
-            }
-            try {
-                require.resolve("typescript", {
-                    paths: [
-                        projectPath,
-                        process.cwd()
-                    ]
-                });
-            } catch (e) {
-                const typeScriptDependencies = [
-                    "typescript"
-                ];
-                await (0, frameworks_lib_integrations.tm)('TypeScript', typeScriptDependencies);
-                console.log(js_frameworks_lib_messages.Jv('TypeScript'));
-                process.exit(0);
-            }
-            const customOptions = await loadLoaderOptions(projectPath, 'svelte');
-            const svelteLoaderPath = resolveFromProject('svelte-loader', projectPath) || require.resolve('svelte-loader');
-            const defaultLoaders = [
-                {
-                    test: /\.svelte\.ts$/,
-                    use: [
-                        svelteLoaderPath
-                    ],
-                    include: projectPath,
-                    exclude: /node_modules/
-                },
-                {
-                    test: /\.(svelte|svelte\.js)$/,
-                    use: {
-                        loader: svelteLoaderPath,
-                        options: {
-                            emitCss: true,
-                            compilerOptions: {
-                                dev: 'development' === mode
-                            },
-                            hotReload: 'development' === mode,
-                            ...customOptions || {}
-                        }
-                    },
-                    include: projectPath,
-                    exclude: /node_modules/
-                },
-                {
-                    test: /[\\/]node_modules[\\/]svelte[\\/].*\.mjs$/,
-                    resolve: {
-                        fullySpecified: false
-                    }
-                }
-            ];
-            const alias = void 0;
-            const resolverPlugin = {
-                apply (compiler) {
-                    const existingMainFields = compiler.options.resolve && compiler.options.resolve.mainFields || [];
-                    const existingConditionNames = compiler.options.resolve && (compiler.options.resolve.conditionNames || compiler.options.resolve.conditions) || [];
-                    const existingExtensions = compiler.options.resolve && compiler.options.resolve.extensions || [];
-                    const existingAlias = compiler.options.resolve && compiler.options.resolve.alias || {};
-                    const existingModules = compiler.options.resolve && compiler.options.resolve.modules || [];
-                    const nextMainFields = [
-                        'svelte',
-                        'browser',
-                        'module',
-                        'main',
-                        ...existingMainFields
-                    ];
-                    const dedupe = (arr)=>Array.from(new Set(arr));
-                    compiler.options.resolve = {
-                        ...compiler.options.resolve,
-                        mainFields: dedupe(nextMainFields),
-                        conditionNames: dedupe([
-                            'svelte',
-                            ...existingConditionNames
-                        ]),
-                        extensions: dedupe([
-                            '.svelte',
-                            ...existingExtensions
-                        ]),
-                        alias: existingAlias,
-                        modules: dedupe([
-                            external_path_.join(projectPath, 'node_modules'),
-                            ...existingModules
-                        ])
-                    };
-                }
-            };
-            return {
-                plugins: [
-                    resolverPlugin
-                ],
-                loaders: defaultLoaders,
-                alias
-            };
-        }
+        var svelte = __webpack_require__("./webpack/plugin-js-frameworks/js-tools/svelte.ts");
+        var js_frameworks_lib_messages = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
         function plugin_js_frameworks_define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
                 value: value,
@@ -1557,10 +907,10 @@ exports.modules = {
             async configureOptions(compiler) {
                 const mode = compiler.options.mode || 'development';
                 const projectPath = compiler.options.context;
-                const maybeInstallReact = await maybeUseReact(projectPath);
-                const maybeInstallPreact = await maybeUsePreact(projectPath);
-                const maybeInstallVue = await maybeUseVue(projectPath);
-                const maybeInstallSvelte = await maybeUseSvelte(projectPath, mode);
+                const maybeInstallReact = await (0, react.b)(projectPath);
+                const maybeInstallPreact = await (0, preact.b)(projectPath);
+                const maybeInstallVue = await (0, vue.K)(projectPath);
+                const maybeInstallSvelte = await (0, svelte.X)(projectPath, mode);
                 const tsConfigPath = (0, typescript.hB)(projectPath);
                 const manifestDir = external_path_.dirname(this.manifestPath);
                 const tsRoot = tsConfigPath ? external_path_.dirname(tsConfigPath) : manifestDir;
@@ -1616,8 +966,8 @@ exports.modules = {
                                 jsc: {
                                     parser: {
                                         syntax: preferTypeScript ? "typescript" : "ecmascript",
-                                        tsx: preferTypeScript ? true : (0, typescript.eE)(projectPath) && (isUsingReact(projectPath) || isUsingPreact(projectPath)),
-                                        jsx: !preferTypeScript && (isUsingReact(projectPath) || isUsingPreact(projectPath)),
+                                        tsx: preferTypeScript ? true : (0, typescript.eE)(projectPath) && ((0, react.S)(projectPath) || (0, preact.K)(projectPath)),
+                                        jsx: !preferTypeScript && ((0, react.S)(projectPath) || (0, preact.K)(projectPath)),
                                         dynamicImport: true
                                     },
                                     transform: {
@@ -1626,7 +976,7 @@ exports.modules = {
                                             refresh: 'development' === mode,
                                             runtime: 'automatic',
                                             importSource: 'react',
-                                            ...isUsingPreact(projectPath) ? {
+                                            ...(0, preact.K)(projectPath) ? {
                                                 pragma: 'h',
                                                 pragmaFrag: 'Fragment',
                                                 throwIfNamespace: true,