extension-develop 3.8.2 → 3.8.3

package/dist/module.cjs

@@ -131823,7 +131823,6 @@ var __webpack_modules__ = {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
             DX: ()=>optionalInstallFailed,
-            Jv: ()=>youAreAllSet,
             Se: ()=>missingSassDependency,
             Vo: ()=>optionalInstallManagerMissing,
             _j: ()=>optionalToolingSetup,
@@ -131847,9 +131846,6 @@ var __webpack_modules__ = {
         function isUsingIntegration(name) {
             return `${pintor__rspack_import_0_default().gray('►►►')} Using ${pintor__rspack_import_0_default().brightBlue(name)}...`;
         }
-        function youAreAllSet(name) {
-            return `${pintor__rspack_import_0_default().green('►►►')} ${name} installation completed.`;
-        }
         function optionalToolingSetup(integrations, fallback, isAuthor) {
             const list = integrations && integrations.length > 0 ? integrations : [
                 fallback
@@ -131913,57 +131909,39 @@ var __webpack_modules__ = {
             V: ()=>maybeUseLess
         });
         var path__rspack_import_0 = __webpack_require__("path");
-        var module__rspack_import_1 = __webpack_require__("module");
-        var pintor__rspack_import_2 = __webpack_require__("pintor");
-        var pintor__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_2);
-        var _css_lib_messages__rspack_import_3 = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
-        var _css_lib_integrations__rspack_import_4 = __webpack_require__("./webpack/plugin-css/css-lib/integrations.ts");
-        var _css_lib_is_content_script__rspack_import_5 = __webpack_require__("./webpack/plugin-css/css-lib/is-content-script.ts");
+        var pintor__rspack_import_1 = __webpack_require__("pintor");
+        var pintor__rspack_import_1_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_1);
+        var _css_lib_messages__rspack_import_2 = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
+        var _css_lib_integrations__rspack_import_3 = __webpack_require__("./webpack/plugin-css/css-lib/integrations.ts");
+        var _css_lib_is_content_script__rspack_import_4 = __webpack_require__("./webpack/plugin-css/css-lib/is-content-script.ts");
+        var _webpack_lib_optional_deps_resolver__rspack_import_5 = __webpack_require__("./webpack/webpack-lib/optional-deps-resolver.ts");
         let userMessageDelivered = false;
         function isUsingLess(projectPath) {
-            if ((0, _css_lib_integrations__rspack_import_4.ws)(projectPath, 'less')) {
+            if ((0, _css_lib_integrations__rspack_import_3.ws)(projectPath, 'less')) {
                 if (!userMessageDelivered) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor__rspack_import_2_default().brightMagenta('►►► Author says')} ${_css_lib_messages__rspack_import_3.zA('LESS')}`);
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor__rspack_import_1_default().brightMagenta('►►► Author says')} ${_css_lib_messages__rspack_import_2.zA('LESS')}`);
                     userMessageDelivered = true;
                 }
                 return true;
             }
             return false;
         }
-        function resolveLessLoader(projectPath) {
-            const extensionRoot = (0, _css_lib_integrations__rspack_import_4.He)();
-            const bases = [
-                projectPath,
-                extensionRoot || void 0,
-                process.cwd()
-            ].filter(Boolean);
-            for (const base of bases)try {
-                const req = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(base, 'package.json'));
-                return req.resolve('less-loader');
-            } catch  {}
-            try {
-                return require.resolve('less-loader', {
-                    paths: bases
-                });
-            } catch  {
-                return;
-            }
-        }
         async function maybeUseLess(projectPath, manifestPath) {
             const resolvedManifestPath = manifestPath || path__rspack_import_0.join(projectPath, 'manifest.json');
             if (!isUsingLess(projectPath)) return [];
-            let lessLoaderPath = resolveLessLoader(projectPath);
-            if (!lessLoaderPath) {
-                const lessDependencies = [
+            const lessLoaderPath = await (0, _webpack_lib_optional_deps_resolver__rspack_import_5.f)({
+                integration: 'LESS',
+                projectPath,
+                dependencyId: 'less-loader',
+                installDependencies: [
                     'less',
                     'less-loader'
-                ];
-                const didInstall = await (0, _css_lib_integrations__rspack_import_4.tm)('LESS', lessDependencies);
-                if (!didInstall) throw new Error('[LESS] Optional dependencies failed to install.');
-                lessLoaderPath = resolveLessLoader(projectPath);
-                if (!lessLoaderPath) throw new Error('[LESS] less-loader could not be resolved after optional dependency installation.');
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_css_lib_messages__rspack_import_3.Jv('LESS'));
-            }
+                ],
+                verifyPackageIds: [
+                    'less',
+                    'less-loader'
+                ]
+            });
             return [
                 {
                     test: /\.less$/,
@@ -131995,7 +131973,7 @@ var __webpack_modules__ = {
                     generator: {
                         filename: "content_scripts/[name].[contenthash:8].css"
                     },
-                    issuer: (issuer)=>(0, _css_lib_is_content_script__rspack_import_5.z)(issuer, resolvedManifestPath, projectPath)
+                    issuer: (issuer)=>(0, _css_lib_is_content_script__rspack_import_4.z)(issuer, resolvedManifestPath, projectPath)
                 }
             ];
         }
@@ -132014,8 +131992,7 @@ var __webpack_modules__ = {
         var _css_lib_messages__rspack_import_4 = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
         var _css_lib_integrations__rspack_import_5 = __webpack_require__("./webpack/plugin-css/css-lib/integrations.ts");
         var _tailwind__rspack_import_6 = __webpack_require__("./webpack/plugin-css/css-tools/tailwind.ts");
-        var _sass__rspack_import_7 = __webpack_require__("./webpack/plugin-css/css-tools/sass.ts");
-        var _less__rspack_import_8 = __webpack_require__("./webpack/plugin-css/css-tools/less.ts");
+        var _webpack_lib_optional_deps_resolver__rspack_import_7 = __webpack_require__("./webpack/webpack-lib/optional-deps-resolver.ts");
         let userMessageDelivered = false;
         const postCssConfigFiles = [
             '.postcssrc',
@@ -132186,33 +132163,6 @@ var __webpack_modules__ = {
             return false;
         }
         async function maybeUsePostCss(projectPath, opts) {
-            const getResolutionPaths = ()=>{
-                const extensionRoot = (0, _css_lib_integrations__rspack_import_5.He)();
-                const paths = [
-                    projectPath,
-                    extensionRoot || void 0,
-                    process.cwd()
-                ].filter(Boolean);
-                return Array.from(new Set(paths));
-            };
-            const resolveWithCreateRequire = (id)=>{
-                const bases = getResolutionPaths();
-                for (const base of bases)try {
-                    const req = (0, module__rspack_import_2.createRequire)(path__rspack_import_0.join(base, 'package.json'));
-                    return req.resolve(id);
-                } catch  {}
-            };
-            const resolvePostCssLoader = ()=>{
-                const fromRuntimeRequire = resolveWithCreateRequire('postcss-loader');
-                if (fromRuntimeRequire) return fromRuntimeRequire;
-                try {
-                    return require.resolve('postcss-loader', {
-                        paths: getResolutionPaths()
-                    });
-                } catch  {
-                    return;
-                }
-            };
             const userPostCssConfig = findPostCssConfig(projectPath);
             const userConfigMentionsTailwind = userConfigMentionsTailwindPlugin(userPostCssConfig);
             const userConfigUsesDirectTailwindReference = userConfigUsesDirectTailwindPluginReference(userPostCssConfig);
@@ -132235,20 +132185,19 @@ var __webpack_modules__ = {
             const tailwindPresent = (0, _tailwind__rspack_import_6.F)(projectPath);
             const tailwindConfigured = tailwindPresent || userConfigMentionsTailwind;
             if (!userPostCssConfig && !pkgHasPostCss && !tailwindPresent) return {};
-            let resolvedPostCssLoader = resolvePostCssLoader();
-            if (!resolvedPostCssLoader) {
-                if (!(0, _sass__rspack_import_7.fZ)(projectPath) && !(0, _less__rspack_import_8.K)(projectPath)) {
-                    const postCssDependencies = [
-                        'postcss',
-                        'postcss-loader'
-                    ];
-                    const didInstall = await (0, _css_lib_integrations__rspack_import_5.tm)('PostCSS', postCssDependencies);
-                    if (!didInstall) throw new Error('[PostCSS] Optional dependencies failed to install.');
-                }
-                resolvedPostCssLoader = resolvePostCssLoader();
-                if (!resolvedPostCssLoader) throw new Error('[PostCSS] postcss-loader could not be resolved after optional dependency installation.');
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_css_lib_messages__rspack_import_4.Jv('PostCSS'));
-            }
+            const resolvedPostCssLoader = await (0, _webpack_lib_optional_deps_resolver__rspack_import_7.f)({
+                integration: 'PostCSS',
+                projectPath,
+                dependencyId: 'postcss-loader',
+                installDependencies: [
+                    'postcss',
+                    'postcss-loader'
+                ],
+                verifyPackageIds: [
+                    'postcss',
+                    'postcss-loader'
+                ]
+            });
             let pluginsFromOptions;
             const shouldInjectTailwindPlugin = tailwindConfigured && !pkgHasPostCss && (!userPostCssConfig || userConfigIsCjsInEsm || userConfigMentionsTailwind);
             const declaredTailwindMajor = getDeclaredTailwindMajor(projectPath);
@@ -132377,6 +132326,7 @@ var __webpack_modules__ = {
         var pintor__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_2);
         var _css_lib_messages__rspack_import_3 = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
         var _css_lib_integrations__rspack_import_4 = __webpack_require__("./webpack/plugin-css/css-lib/integrations.ts");
+        var _webpack_lib_optional_deps_resolver__rspack_import_5 = __webpack_require__("./webpack/webpack-lib/optional-deps-resolver.ts");
         let userMessageDelivered = false;
         function isUsingSass(projectPath) {
             if ((0, _css_lib_integrations__rspack_import_4.ws)(projectPath, 'sass')) {
@@ -132388,25 +132338,6 @@ var __webpack_modules__ = {
             }
             return false;
         }
-        function resolveSassLoader(projectPath) {
-            const extensionRoot = (0, _css_lib_integrations__rspack_import_4.He)();
-            const bases = [
-                projectPath,
-                extensionRoot || void 0,
-                process.cwd()
-            ].filter(Boolean);
-            for (const base of bases)try {
-                const req = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(base, 'package.json'));
-                return req.resolve('sass-loader');
-            } catch  {}
-            try {
-                return require.resolve('sass-loader', {
-                    paths: bases
-                });
-            } catch  {
-                return;
-            }
-        }
         function resolveSassImplementation(projectPath) {
             const extensionRoot = (0, _css_lib_integrations__rspack_import_4.He)();
             const bases = [
@@ -132443,24 +132374,23 @@ var __webpack_modules__ = {
         }
         async function maybeUseSass(projectPath) {
             if (!isUsingSass(projectPath)) return [];
-            let sassLoaderPath = resolveSassLoader(projectPath);
-            if (!sassLoaderPath) {
-                const postCssDependencies = [
+            const sassLoaderPath = await (0, _webpack_lib_optional_deps_resolver__rspack_import_5.f)({
+                integration: 'SASS',
+                projectPath,
+                dependencyId: 'sass-loader',
+                installDependencies: [
                     'postcss-loader',
                     'postcss-scss',
-                    'postcss-preset-env'
-                ];
-                const didInstallPostCss = await (0, _css_lib_integrations__rspack_import_4.tm)('PostCSS', postCssDependencies);
-                if (!didInstallPostCss) throw new Error('[PostCSS] Optional dependencies failed to install.');
-                const sassDependencies = [
+                    'postcss-preset-env',
                     'sass-loader'
-                ];
-                const didInstallSass = await (0, _css_lib_integrations__rspack_import_4.tm)('SASS', sassDependencies);
-                if (!didInstallSass) throw new Error('[SASS] Optional dependencies failed to install.');
-                sassLoaderPath = resolveSassLoader(projectPath);
-                if (!sassLoaderPath) throw new Error('[SASS] sass-loader could not be resolved after optional dependency installation.');
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_css_lib_messages__rspack_import_3.Jv('SASS'));
-            }
+                ],
+                verifyPackageIds: [
+                    'postcss-loader',
+                    'postcss-scss',
+                    'postcss-preset-env',
+                    'sass-loader'
+                ]
+            });
             return [
                 {
                     test: /\.(sass|scss)$/,
@@ -132520,9 +132450,7 @@ var __webpack_modules__ = {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
             Dy: ()=>_plugin_css_css_lib_integrations__rspack_import_0.Dy,
-            He: ()=>_plugin_css_css_lib_integrations__rspack_import_0.He,
             qQ: ()=>isUsingJSFramework,
-            tm: ()=>_plugin_css_css_lib_integrations__rspack_import_0.tm,
             ws: ()=>_plugin_css_css_lib_integrations__rspack_import_0.ws
         });
         var _plugin_css_css_lib_integrations__rspack_import_0 = __webpack_require__("./webpack/plugin-css/css-lib/integrations.ts");
@@ -132585,7 +132513,6 @@ var __webpack_modules__ = {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
             Ei: ()=>jsFrameworksHmrSummary,
-            Jv: ()=>youAreAllSet,
             LR: ()=>creatingTSConfig,
             MH: ()=>jsFrameworksConfigsDetected,
             Q2: ()=>optionalDepsReady,
@@ -132598,9 +132525,6 @@ var __webpack_modules__ = {
         function isUsingIntegration(name) {
             return `${pintor__rspack_import_0_default().gray('►►►')} Using ${pintor__rspack_import_0_default().brightBlue(name)}...`;
         }
-        function youAreAllSet(name) {
-            return `${pintor__rspack_import_0_default().green('►►►')} ${name} installation completed.`;
-        }
         function optionalDepsReady(integrations) {
             const list = integrations.length > 0 ? integrations.map((name)=>pintor__rspack_import_0_default().yellow(name)).join(', ') : pintor__rspack_import_0_default().gray('optional');
             return `${pintor__rspack_import_0_default().green('►►►')} All set — ${list} tooling is ready.`;
@@ -132637,40 +132561,8 @@ var __webpack_modules__ = {
         var pintor__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_2);
         var _js_frameworks_lib_messages__rspack_import_3 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
         var _frameworks_lib_integrations__rspack_import_4 = __webpack_require__("./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts");
+        var _webpack_lib_optional_deps_resolver__rspack_import_5 = __webpack_require__("./webpack/webpack-lib/optional-deps-resolver.ts");
         let userMessageDelivered = false;
-        function resolveWithRuntimePaths(id, projectPath) {
-            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_4.He)();
-            const bases = [
-                projectPath,
-                extensionRoot || void 0,
-                process.cwd()
-            ].filter(Boolean);
-            for (const base of bases)try {
-                const req = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(base, 'package.json'));
-                return req.resolve(id);
-            } catch  {}
-            try {
-                return require.resolve(id, {
-                    paths: bases
-                });
-            } catch  {
-                return;
-            }
-        }
-        function getPreactRefreshPlugin(projectPath) {
-            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_4.He)();
-            const bases = [
-                projectPath,
-                extensionRoot || void 0,
-                process.cwd()
-            ].filter(Boolean);
-            for (const base of bases)try {
-                const req = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(base, 'package.json'));
-                const mod = req('@rspack/plugin-preact-refresh');
-                const plugin = mod && mod.default || mod;
-                if (plugin) return plugin;
-            } catch  {}
-        }
         function isUsingPreact(projectPath) {
             if ((0, _frameworks_lib_integrations__rspack_import_4.ws)(projectPath, 'preact')) {
                 if (!userMessageDelivered) {
@@ -132683,22 +132575,27 @@ var __webpack_modules__ = {
         }
         async function maybeUsePreact(projectPath) {
             if (!isUsingPreact(projectPath)) return;
-            let preactRefreshPath = resolveWithRuntimePaths('@rspack/plugin-preact-refresh', projectPath);
-            if (!preactRefreshPath) {
-                const preactDependencies = [
-                    '@prefresh/core',
-                    '@prefresh/utils',
-                    '@rspack/plugin-preact-refresh',
-                    'preact'
-                ];
-                const didInstall = await (0, _frameworks_lib_integrations__rspack_import_4.tm)('Preact', preactDependencies);
-                if (!didInstall) throw new Error('[Preact] Optional dependencies failed to install.');
-                preactRefreshPath = resolveWithRuntimePaths('@rspack/plugin-preact-refresh', projectPath);
-                if (!preactRefreshPath) throw new Error('[Preact] @rspack/plugin-preact-refresh could not be resolved after optional dependency installation.');
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_js_frameworks_lib_messages__rspack_import_3.Jv('Preact'));
-            }
-            const PreactRefreshPlugin = getPreactRefreshPlugin(projectPath);
-            if (!PreactRefreshPlugin) throw new Error('[Preact] @rspack/plugin-preact-refresh is installed but its plugin could not be resolved.');
+            const preactDependencies = [
+                '@prefresh/core',
+                '@prefresh/utils',
+                '@rspack/plugin-preact-refresh',
+                'preact'
+            ];
+            await (0, _webpack_lib_optional_deps_resolver__rspack_import_5.f)({
+                integration: 'Preact',
+                projectPath,
+                dependencyId: '@rspack/plugin-preact-refresh',
+                installDependencies: preactDependencies,
+                verifyPackageIds: preactDependencies
+            });
+            const PreactRefreshPlugin = await (0, _webpack_lib_optional_deps_resolver__rspack_import_5.C)({
+                integration: 'Preact',
+                projectPath,
+                dependencyId: '@rspack/plugin-preact-refresh',
+                installDependencies: preactDependencies,
+                verifyPackageIds: preactDependencies,
+                moduleAdapter: (mod)=>mod && mod.default || mod
+            });
             const preactPlugins = [
                 new PreactRefreshPlugin({})
             ];
@@ -132741,40 +132638,8 @@ var __webpack_modules__ = {
         var pintor__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_2);
         var _js_frameworks_lib_messages__rspack_import_3 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
         var _frameworks_lib_integrations__rspack_import_4 = __webpack_require__("./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts");
+        var _webpack_lib_optional_deps_resolver__rspack_import_5 = __webpack_require__("./webpack/webpack-lib/optional-deps-resolver.ts");
         let userMessageDelivered = false;
-        function resolveWithRuntimePaths(id, projectPath) {
-            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_4.He)();
-            const bases = [
-                projectPath,
-                extensionRoot || void 0,
-                process.cwd()
-            ].filter(Boolean);
-            for (const base of bases)try {
-                const req = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(base, 'package.json'));
-                return req.resolve(id);
-            } catch  {}
-            try {
-                return require.resolve(id, {
-                    paths: bases
-                });
-            } catch  {
-                return;
-            }
-        }
-        function getReactRefreshPlugin(projectPath) {
-            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_4.He)();
-            const bases = [
-                projectPath,
-                extensionRoot || void 0,
-                process.cwd()
-            ].filter(Boolean);
-            for (const base of bases)try {
-                const req = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(base, 'package.json'));
-                const mod = req('@rspack/plugin-react-refresh');
-                const plugin = mod && mod.default || mod;
-                if (plugin) return plugin;
-            } catch  {}
-        }
         function isUsingReact(projectPath) {
             if ((0, _frameworks_lib_integrations__rspack_import_4.ws)(projectPath, 'react')) {
                 if (!userMessageDelivered) {
@@ -132787,20 +132652,25 @@ var __webpack_modules__ = {
         }
         async function maybeUseReact(projectPath) {
             if (!isUsingReact(projectPath)) return;
-            let reactRefreshPath = resolveWithRuntimePaths('react-refresh', projectPath);
-            if (!reactRefreshPath) {
-                const reactDependencies = [
-                    'react-refresh',
-                    '@rspack/plugin-react-refresh'
-                ];
-                const didInstall = await (0, _frameworks_lib_integrations__rspack_import_4.tm)('React', reactDependencies);
-                if (!didInstall) throw new Error('[React] Optional dependencies failed to install.');
-                reactRefreshPath = resolveWithRuntimePaths('react-refresh', projectPath);
-                if (!reactRefreshPath) throw new Error('[React] react-refresh could not be resolved after optional dependency installation.');
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_js_frameworks_lib_messages__rspack_import_3.Jv('React'));
-            }
-            const ReactRefreshPlugin = getReactRefreshPlugin(projectPath);
-            if (!ReactRefreshPlugin) throw new Error('[React] @rspack/plugin-react-refresh is installed but its plugin could not be resolved.');
+            const reactDependencies = [
+                'react-refresh',
+                '@rspack/plugin-react-refresh'
+            ];
+            await (0, _webpack_lib_optional_deps_resolver__rspack_import_5.f)({
+                integration: 'React',
+                projectPath,
+                dependencyId: 'react-refresh',
+                installDependencies: reactDependencies,
+                verifyPackageIds: reactDependencies
+            });
+            const ReactRefreshPlugin = await (0, _webpack_lib_optional_deps_resolver__rspack_import_5.C)({
+                integration: 'React',
+                projectPath,
+                dependencyId: '@rspack/plugin-react-refresh',
+                installDependencies: reactDependencies,
+                verifyPackageIds: reactDependencies,
+                moduleAdapter: (mod)=>mod && mod.default || mod
+            });
             const reactPlugins = [
                 new ReactRefreshPlugin({
                     overlay: false
@@ -132852,26 +132722,8 @@ var __webpack_modules__ = {
         var _js_frameworks_lib_messages__rspack_import_3 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
         var _frameworks_lib_integrations__rspack_import_4 = __webpack_require__("./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts");
         var _js_frameworks_lib_load_loader_options__rspack_import_5 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/load-loader-options.ts");
+        var _webpack_lib_optional_deps_resolver__rspack_import_6 = __webpack_require__("./webpack/webpack-lib/optional-deps-resolver.ts");
         let userMessageDelivered = false;
-        function resolveWithRuntimePaths(id, projectPath) {
-            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_4.He)();
-            const bases = [
-                projectPath,
-                extensionRoot || void 0,
-                process.cwd()
-            ].filter(Boolean);
-            for (const base of bases)try {
-                const req = (0, module__rspack_import_2.createRequire)(path__rspack_import_0.join(base, 'package.json'));
-                return req.resolve(id);
-            } catch  {}
-            try {
-                return require.resolve(id, {
-                    paths: bases
-                });
-            } catch  {
-                return;
-            }
-        }
         function resolveFromProject(id, projectPath) {
             for (const base of [
                 projectPath,
@@ -132901,33 +132753,30 @@ var __webpack_modules__ = {
         }
         async function maybeUseSvelte(projectPath, mode) {
             if (!isUsingSvelte(projectPath)) return;
-            let svelteLoaderPath = resolveFromProject('svelte-loader', projectPath) || resolveWithRuntimePaths('svelte-loader', projectPath);
-            if (!svelteLoaderPath) {
-                const typeScriptDependencies = [
-                    "typescript"
-                ];
-                const didInstallTs = await (0, _frameworks_lib_integrations__rspack_import_4.tm)('TypeScript', typeScriptDependencies);
-                if (!didInstallTs) throw new Error('[TypeScript] Optional dependencies failed to install.');
-                const svelteDependencies = [
+            const svelteLoaderPath = await (0, _webpack_lib_optional_deps_resolver__rspack_import_6.f)({
+                integration: 'Svelte',
+                projectPath,
+                dependencyId: 'svelte-loader',
+                installDependencies: [
+                    "typescript",
                     'svelte-loader'
-                ];
-                const didInstallSvelte = await (0, _frameworks_lib_integrations__rspack_import_4.tm)('Svelte', svelteDependencies);
-                if (!didInstallSvelte) throw new Error('[Svelte] Optional dependencies failed to install.');
-                svelteLoaderPath = resolveFromProject('svelte-loader', projectPath) || resolveWithRuntimePaths('svelte-loader', projectPath);
-                if (!svelteLoaderPath) throw new Error('[Svelte] svelte-loader could not be resolved after optional dependency installation.');
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_js_frameworks_lib_messages__rspack_import_3.Jv('Svelte'));
-            }
-            const resolvedTypescript = resolveFromProject("typescript", projectPath) || resolveWithRuntimePaths("typescript", projectPath);
-            if (!resolvedTypescript) {
-                const typeScriptDependencies = [
+                ],
+                verifyPackageIds: [
+                    "typescript",
+                    'svelte-loader'
+                ]
+            });
+            await (0, _webpack_lib_optional_deps_resolver__rspack_import_6.f)({
+                integration: 'TypeScript',
+                projectPath,
+                dependencyId: "typescript",
+                installDependencies: [
                     "typescript"
-                ];
-                const didInstallTs = await (0, _frameworks_lib_integrations__rspack_import_4.tm)('TypeScript', typeScriptDependencies);
-                if (!didInstallTs) throw new Error('[TypeScript] Optional dependencies failed to install.');
-                const reResolvedTypescript = resolveFromProject("typescript", projectPath) || resolveWithRuntimePaths("typescript", projectPath);
-                if (!reResolvedTypescript) throw new Error('[TypeScript] TypeScript could not be resolved after optional dependency installation.');
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_js_frameworks_lib_messages__rspack_import_3.Jv('TypeScript'));
-            }
+                ],
+                verifyPackageIds: [
+                    "typescript"
+                ]
+            });
             const customOptions = await (0, _js_frameworks_lib_load_loader_options__rspack_import_5.g)(projectPath, 'svelte');
             const defaultLoaders = [
                 {
@@ -133018,11 +132867,11 @@ var __webpack_modules__ = {
         });
         var path__rspack_import_0 = __webpack_require__("path");
         var fs__rspack_import_1 = __webpack_require__("fs");
-        __webpack_require__("module");
-        var pintor__rspack_import_3 = __webpack_require__("pintor");
-        var pintor__rspack_import_3_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_3);
-        var _js_frameworks_lib_messages__rspack_import_4 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
-        var _frameworks_lib_integrations__rspack_import_5 = __webpack_require__("./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts");
+        var pintor__rspack_import_2 = __webpack_require__("pintor");
+        var pintor__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_2);
+        var _js_frameworks_lib_messages__rspack_import_3 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
+        var _frameworks_lib_integrations__rspack_import_4 = __webpack_require__("./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts");
+        __webpack_require__("./webpack/webpack-lib/optional-deps-resolver.ts");
         let hasShownUserMessage = false;
         function findNearestPackageJsonDirectory(startPath) {
             let currentDirectory = startPath;
@@ -133077,12 +132926,12 @@ var __webpack_modules__ = {
             const hasTsFiles = hasTypeScriptSourceFiles(projectPath);
             if (!hasShownUserMessage) {
                 if (TypeScriptAsDevDep || TypeScriptAsDep || hasTsFiles) if (tsConfigFilePath) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor__rspack_import_3_default().brightMagenta('►►► Author says')} ${_js_frameworks_lib_messages__rspack_import_4.zA('TypeScript')}`);
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor__rspack_import_2_default().brightMagenta('►►► Author says')} ${_js_frameworks_lib_messages__rspack_import_3.zA('TypeScript')}`);
                 } else if (hasTsFiles) {
                     const errorMessage = '[Extension.js] Missing tsconfig.json next to package.json. Create one to use TypeScript.';
                     throw new Error(errorMessage);
                 } else {
-                    console.log(_js_frameworks_lib_messages__rspack_import_4.LR());
+                    console.log(_js_frameworks_lib_messages__rspack_import_3.LR());
                     writeTsConfig(projectPath);
                 }
                 hasShownUserMessage = true;
@@ -133096,7 +132945,7 @@ var __webpack_modules__ = {
                     allowSyntheticDefaultImports: true,
                     esModuleInterop: true,
                     forceConsistentCasingInFileNames: true,
-                    jsx: (0, _frameworks_lib_integrations__rspack_import_5.qQ)(projectPath) ? 'react-jsx' : 'preserve',
+                    jsx: (0, _frameworks_lib_integrations__rspack_import_4.qQ)(projectPath) ? 'react-jsx' : 'preserve',
                     lib: [
                         'dom',
                         'dom.iterable',
@@ -133143,40 +132992,8 @@ var __webpack_modules__ = {
         var _js_frameworks_lib_messages__rspack_import_4 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
         var _frameworks_lib_integrations__rspack_import_5 = __webpack_require__("./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts");
         var _js_frameworks_lib_load_loader_options__rspack_import_6 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/load-loader-options.ts");
+        var _webpack_lib_optional_deps_resolver__rspack_import_7 = __webpack_require__("./webpack/webpack-lib/optional-deps-resolver.ts");
         let userMessageDelivered = false;
-        function resolveWithRuntimePaths(id, projectPath) {
-            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_5.He)();
-            const bases = [
-                projectPath,
-                extensionRoot || void 0,
-                process.cwd()
-            ].filter(Boolean);
-            for (const base of bases)try {
-                const req = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(base, 'package.json'));
-                return req.resolve(id);
-            } catch  {}
-            try {
-                return require.resolve(id, {
-                    paths: bases
-                });
-            } catch  {
-                return;
-            }
-        }
-        function getVueLoaderPlugin(projectPath) {
-            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_5.He)();
-            const bases = [
-                projectPath,
-                extensionRoot || void 0,
-                process.cwd()
-            ].filter(Boolean);
-            for (const base of bases)try {
-                const req = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(base, 'package.json'));
-                const mod = req('vue-loader');
-                const plugin = mod && mod.VueLoaderPlugin || mod && mod.default && mod.default.VueLoaderPlugin;
-                if (plugin) return plugin;
-            } catch  {}
-        }
         function isUsingVue(projectPath) {
             const using = (0, _frameworks_lib_integrations__rspack_import_5.ws)(projectPath, 'vue');
             if (using && !userMessageDelivered) {
@@ -133187,20 +133004,25 @@ var __webpack_modules__ = {
         }
         async function maybeUseVue(projectPath, mode = 'development') {
             if (!isUsingVue(projectPath)) return;
-            let vueLoaderPath = resolveWithRuntimePaths('vue-loader', projectPath);
-            if (!vueLoaderPath) {
-                const vueDependencies = [
-                    'vue-loader',
-                    '@vue/compiler-sfc'
-                ];
-                const didInstall = await (0, _frameworks_lib_integrations__rspack_import_5.tm)('Vue', vueDependencies);
-                if (!didInstall) throw new Error('[Vue] Optional dependencies failed to install.');
-                vueLoaderPath = resolveWithRuntimePaths('vue-loader', projectPath);
-                if (!vueLoaderPath) throw new Error('[Vue] vue-loader could not be resolved after optional dependency installation.');
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_js_frameworks_lib_messages__rspack_import_4.Jv('Vue'));
-            }
-            const VueLoaderPlugin = getVueLoaderPlugin(projectPath);
-            if (!VueLoaderPlugin) throw new Error('[Vue] vue-loader is installed but VueLoaderPlugin could not be resolved.');
+            const vueDependencies = [
+                'vue-loader',
+                '@vue/compiler-sfc'
+            ];
+            const vueLoaderPath = await (0, _webpack_lib_optional_deps_resolver__rspack_import_7.f)({
+                integration: 'Vue',
+                projectPath,
+                dependencyId: 'vue-loader',
+                installDependencies: vueDependencies,
+                verifyPackageIds: vueDependencies
+            });
+            const VueLoaderPlugin = await (0, _webpack_lib_optional_deps_resolver__rspack_import_7.C)({
+                integration: 'Vue',
+                projectPath,
+                dependencyId: 'vue-loader',
+                installDependencies: vueDependencies,
+                verifyPackageIds: vueDependencies,
+                moduleAdapter: (mod)=>mod && mod.VueLoaderPlugin || mod && mod.default && mod.default.VueLoaderPlugin
+            });
             const customOptions = await (0, _js_frameworks_lib_load_loader_options__rspack_import_6.g)(projectPath, 'vue');
             const defaultLoaders = [
                 {
@@ -134038,6 +133860,266 @@ var __webpack_modules__ = {
             return `${getLoggingPrefix('error')} Your project declares dependencies that are managed by ${pintor__rspack_import_2_default().blue('Extension.js')} and referenced in ${pintor__rspack_import_2_default().underline('extension.config.js')}\n${pintor__rspack_import_2_default().red('This can cause version conflicts and break the development/build process.')}\n\n${pintor__rspack_import_2_default().gray('Managed dependencies (remove these from your package.json):')}\n${list}\n\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(userPackageJsonPath)}\nIf you need a different version, open an issue so we can consider bundling it safely.\nOperation aborted.`;
         }
     },
+    "./webpack/webpack-lib/optional-deps-resolver.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            C: ()=>ensureOptionalModuleLoaded,
+            f: ()=>ensureOptionalPackageResolved
+        });
+        var fs__rspack_import_0 = __webpack_require__("fs");
+        var path__rspack_import_1 = __webpack_require__("path");
+        var module__rspack_import_2 = __webpack_require__("module");
+        var _plugin_css_css_lib_integrations__rspack_import_3 = __webpack_require__("./webpack/plugin-css/css-lib/integrations.ts");
+        const installSingleFlight = new Map();
+        function getResolutionBases(projectPath) {
+            const extensionRoot = (0, _plugin_css_css_lib_integrations__rspack_import_3.He)();
+            const bases = [
+                projectPath,
+                extensionRoot || void 0,
+                process.cwd()
+            ].filter(Boolean);
+            return Array.from(new Set(bases));
+        }
+        function packageJsonPath(basePath) {
+            return path__rspack_import_1.join(basePath, 'package.json');
+        }
+        function tryResolveWithBase(dependencyId, basePath) {
+            try {
+                const req = (0, module__rspack_import_2.createRequire)(packageJsonPath(basePath));
+                return req.resolve(dependencyId);
+            } catch  {
+                return;
+            }
+        }
+        function resolveDependency(dependencyId, projectPath) {
+            const bases = getResolutionBases(projectPath);
+            for (const basePath of bases){
+                const resolvedPath = tryResolveWithBase(dependencyId, basePath);
+                if (resolvedPath) return {
+                    resolvedPath,
+                    basePath
+                };
+            }
+            try {
+                const resolvedPath = require.resolve(dependencyId, {
+                    paths: bases
+                });
+                return {
+                    resolvedPath,
+                    basePath: projectPath
+                };
+            } catch  {
+                return;
+            }
+        }
+        function resolveFromKnownLocations(dependencyId, projectPath, installRoot) {
+            const resolved = resolveDependency(dependencyId, projectPath);
+            if (resolved) return resolved.resolvedPath;
+            if (!installRoot) return;
+            return resolveFromInstallRootPackageDir(dependencyId, installRoot);
+        }
+        function getPackageDirFromInstallRoot(dependencyId, installRoot) {
+            return path__rspack_import_1.join(installRoot, 'node_modules', ...dependencyId.split('/'));
+        }
+        function readPackageJsonFromDir(packageDir) {
+            const manifestPath = path__rspack_import_1.join(packageDir, 'package.json');
+            if (!fs__rspack_import_0.existsSync(manifestPath)) return;
+            try {
+                const raw = fs__rspack_import_0.readFileSync(manifestPath, 'utf8');
+                return JSON.parse(raw || '{}');
+            } catch  {
+                return;
+            }
+        }
+        function getPackageEntryCandidates(pkg) {
+            const candidateEntries = [];
+            if ('string' == typeof pkg?.main) candidateEntries.push(pkg.main);
+            if ('string' == typeof pkg?.module) candidateEntries.push(pkg.module);
+            if ('string' == typeof pkg?.exports) candidateEntries.push(pkg.exports);
+            const dotExport = pkg?.exports?.['.'];
+            if ('string' == typeof dotExport) candidateEntries.push(dotExport);
+            if (dotExport && 'object' == typeof dotExport) {
+                if ('string' == typeof dotExport.require) candidateEntries.push(dotExport.require);
+                if ('string' == typeof dotExport.default) candidateEntries.push(dotExport.default);
+                if ('string' == typeof dotExport.import) candidateEntries.push(dotExport.import);
+            }
+            candidateEntries.push('index.js', 'index.cjs', 'index.mjs');
+            return candidateEntries;
+        }
+        function resolveFirstExistingEntry(packageDir, candidateEntries) {
+            for (const relativeEntry of candidateEntries){
+                const absoluteEntry = path__rspack_import_1.resolve(packageDir, relativeEntry);
+                if (fs__rspack_import_0.existsSync(absoluteEntry)) return absoluteEntry;
+            }
+        }
+        function resolveFromInstallRootPackageDir(dependencyId, installRoot) {
+            const packageDir = getPackageDirFromInstallRoot(dependencyId, installRoot);
+            if (!fs__rspack_import_0.existsSync(packageDir)) return;
+            try {
+                return require.resolve(packageDir);
+            } catch  {}
+            const pkg = readPackageJsonFromDir(packageDir);
+            if (!pkg) return;
+            const candidateEntries = getPackageEntryCandidates(pkg);
+            return resolveFirstExistingEntry(packageDir, candidateEntries);
+        }
+        function verifyPackageInInstallRoot(packageId, installRoot) {
+            const packageJson = path__rspack_import_1.join(getPackageDirFromInstallRoot(packageId, installRoot), 'package.json');
+            return fs__rspack_import_0.existsSync(packageJson);
+        }
+        function buildDiagnostics(input) {
+            const bases = getResolutionBases(input.projectPath);
+            const verifyState = input.verifyPackageIds.map((id)=>({
+                    dependency: id,
+                    existsAtInstallRoot: input.installRoot ? verifyPackageInInstallRoot(id, input.installRoot) : false
+                }));
+            return {
+                integration: input.integration,
+                dependencyId: input.dependencyId,
+                projectPath: input.projectPath,
+                installRoot: input.installRoot || null,
+                installDependencies: input.installDependencies,
+                verifyPackageIds: input.verifyPackageIds,
+                resolutionBases: bases,
+                verifyState
+            };
+        }
+        async function runInstallAndVerify(input) {
+            const didInstall = await (0, _plugin_css_css_lib_integrations__rspack_import_3.tm)(input.integration, input.installDependencies);
+            if (!didInstall) {
+                const diagnostics = buildDiagnostics({
+                    integration: input.integration,
+                    dependencyId: input.dependencyId,
+                    projectPath: input.projectPath,
+                    installRoot: input.installRoot,
+                    installDependencies: input.installDependencies,
+                    verifyPackageIds: input.verifyPackageIds
+                });
+                throw new Error(`[${input.integration}] Optional dependencies failed to install.\n` + JSON.stringify(diagnostics, null, 2));
+            }
+            if (!input.installRoot) {
+                const diagnostics = buildDiagnostics({
+                    integration: input.integration,
+                    dependencyId: input.dependencyId,
+                    projectPath: input.projectPath,
+                    installRoot: input.installRoot,
+                    installDependencies: input.installDependencies,
+                    verifyPackageIds: input.verifyPackageIds
+                });
+                throw new Error(`[${input.integration}] Optional dependency install root is unavailable.\n` + JSON.stringify(diagnostics, null, 2));
+            }
+            const missingAfterInstall = input.verifyPackageIds.filter((id)=>!verifyPackageInInstallRoot(id, input.installRoot));
+            if (missingAfterInstall.length > 0) {
+                const diagnostics = buildDiagnostics({
+                    integration: input.integration,
+                    dependencyId: input.dependencyId,
+                    projectPath: input.projectPath,
+                    installRoot: input.installRoot,
+                    installDependencies: input.installDependencies,
+                    verifyPackageIds: input.verifyPackageIds
+                });
+                throw new Error(`[${input.integration}] Optional dependency install reported success but packages are missing: ${missingAfterInstall.join(', ')}.\n` + JSON.stringify(diagnostics, null, 2));
+            }
+        }
+        async function ensureInstalledAndVerified(input) {
+            const installRoot = (0, _plugin_css_css_lib_integrations__rspack_import_3.He)();
+            const key = [
+                installRoot || 'missing-install-root',
+                ...input.installDependencies.slice().sort()
+            ].join('::');
+            const existing = installSingleFlight.get(key);
+            if (existing) return void await existing;
+            const installPromise = runInstallAndVerify({
+                integration: input.integration,
+                installDependencies: input.installDependencies,
+                verifyPackageIds: input.verifyPackageIds,
+                projectPath: input.projectPath,
+                dependencyId: input.dependencyId,
+                installRoot
+            });
+            installSingleFlight.set(key, installPromise);
+            try {
+                await installPromise;
+            } finally{
+                installSingleFlight.delete(key);
+            }
+        }
+        async function ensureOptionalPackageResolved(input) {
+            const installRoot = (0, _plugin_css_css_lib_integrations__rspack_import_3.He)();
+            const resolvedBeforeInstall = resolveFromKnownLocations(input.dependencyId, input.projectPath, installRoot);
+            if (resolvedBeforeInstall) return resolvedBeforeInstall;
+            const installDependencies = input.installDependencies || [
+                input.dependencyId
+            ];
+            const verifyPackageIds = input.verifyPackageIds || installDependencies;
+            await ensureInstalledAndVerified({
+                integration: input.integration,
+                installDependencies,
+                verifyPackageIds,
+                projectPath: input.projectPath,
+                dependencyId: input.dependencyId
+            });
+            const resolvedAfterInstall = resolveFromKnownLocations(input.dependencyId, input.projectPath, installRoot);
+            if (resolvedAfterInstall) return resolvedAfterInstall;
+            const diagnostics = buildDiagnostics({
+                integration: input.integration,
+                dependencyId: input.dependencyId,
+                projectPath: input.projectPath,
+                installRoot,
+                installDependencies,
+                verifyPackageIds
+            });
+            throw new Error(`[${input.integration}] ${input.dependencyId} could not be resolved after optional dependency installation.\n` + JSON.stringify(diagnostics, null, 2));
+        }
+        async function ensureOptionalModuleLoaded(input) {
+            const resolvedPath = await ensureOptionalPackageResolved(input);
+            const candidateBases = getResolutionBases(input.projectPath);
+            let loaded;
+            let didLoad = false;
+            let lastLoadError;
+            for (const basePath of candidateBases){
+                const req = (0, module__rspack_import_2.createRequire)(packageJsonPath(basePath));
+                const candidateModuleIds = [
+                    input.dependencyId,
+                    resolvedPath
+                ];
+                for (const candidateModuleId of candidateModuleIds)try {
+                    loaded = req(candidateModuleId);
+                    didLoad = true;
+                    break;
+                } catch (error) {
+                    lastLoadError = error;
+                }
+                if (didLoad) break;
+            }
+            if (!didLoad) try {
+                loaded = require(resolvedPath);
+                didLoad = true;
+            } catch (directRequireError) {
+                lastLoadError = directRequireError;
+            }
+            if (!didLoad) {
+                const diagnostics = {
+                    ...buildDiagnostics({
+                        integration: input.integration,
+                        dependencyId: input.dependencyId,
+                        projectPath: input.projectPath,
+                        installRoot: (0, _plugin_css_css_lib_integrations__rspack_import_3.He)(),
+                        installDependencies: input.installDependencies || [
+                            input.dependencyId
+                        ],
+                        verifyPackageIds: input.verifyPackageIds || input.installDependencies || [
+                            input.dependencyId
+                        ]
+                    }),
+                    resolvedPath,
+                    loadError: lastLoadError instanceof Error ? lastLoadError.message : String(lastLoadError)
+                };
+                throw new Error(`[${input.integration}] ${input.dependencyId} could not be loaded after it resolved.\n` + JSON.stringify(diagnostics, null, 2));
+            }
+            return input.moduleAdapter ? input.moduleAdapter(loaded) : loaded;
+        }
+    },
     "./webpack/webpack-lib/package-json.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -134706,7 +134788,7 @@ var __webpack_modules__ = {
     },
     "./package.json" (module) {
         "use strict";
-        module.exports = JSON.parse('{"rE":"3.8.2","El":{"@rspack/core":"^1.7.5","@rspack/dev-server":"^1.1.5","@swc/core":"^1.15.8","@swc/helpers":"^0.5.18","adm-zip":"^0.5.16","browser-extension-manifest-fields":"^2.2.1","case-sensitive-paths-webpack-plugin":"^2.4.0","chrome-location2":"4.0.0","chromium-location":"2.0.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","edge-location":"2.2.0","extension-from-store":"^0.1.1","firefox-location2":"3.0.0","go-git-it":"^5.1.1","ignore":"^7.0.5","loader-utils":"^3.3.1","magic-string":"^0.30.21","parse5":"^8.0.0","parse5-utilities":"^1.0.0","pintor":"0.3.0","schema-utils":"^4.3.3","tiny-glob":"^0.2.9","unique-names-generator":"^4.7.1","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3","ws":"^8.19.0"}}');
+        module.exports = JSON.parse('{"rE":"3.8.3","El":{"@rspack/core":"^1.7.5","@rspack/dev-server":"^1.1.5","@swc/core":"^1.15.8","@swc/helpers":"^0.5.18","adm-zip":"^0.5.16","browser-extension-manifest-fields":"^2.2.1","case-sensitive-paths-webpack-plugin":"^2.4.0","chrome-location2":"4.0.0","chromium-location":"2.0.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","edge-location":"2.2.0","extension-from-store":"^0.1.1","firefox-location2":"3.0.0","go-git-it":"^5.1.1","ignore":"^7.0.5","loader-utils":"^3.3.1","magic-string":"^0.30.21","parse5":"^8.0.0","parse5-utilities":"^1.0.0","pintor":"0.3.0","schema-utils":"^4.3.3","tiny-glob":"^0.2.9","unique-names-generator":"^4.7.1","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3","ws":"^8.19.0"}}');
     }
 };
 var __webpack_module_cache__ = {};

package/package.json

@@ -24,7 +24,7 @@
     "webpack/webpack-lib/build-dependencies.json"
   ],
   "name": "extension-develop",
-  "version": "3.8.2",
+  "version": "3.8.3",
   "description": "Develop, build, preview, and package Extension.js projects.",
   "author": {
     "name": "Cezar Augusto",