@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.0

package/dist/cjs/builder/shared/builderPlugins/adapterBasic.js

@@ -0,0 +1,133 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    builderPluginAdapterBasic: ()=>builderPluginAdapterBasic
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const builder_namespaceObject = require("@modern-js/builder");
+const builderPluginAdapterBasic = (options)=>({
+        name: 'builder-plugin-adapter-modern-basic',
+        setup (api) {
+            api.modifyBundlerChain((chain, { target, CHAIN_ID, environment })=>{
+                const isServiceWorker = environment.name === builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME;
+                if ('node' === target || isServiceWorker) applyNodeCompat(isServiceWorker, chain);
+                if ('web' === target) {
+                    const bareServerModuleReg = /\.(server|node)\.[tj]sx?$/;
+                    const depExt = 'js';
+                    chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(bareServerModuleReg);
+                    chain.module.rule('bare-server-module').test(bareServerModuleReg).use('server-module-loader').loader(external_node_path_default().join(__dirname, `../loaders/serverModuleLoader.${depExt}`));
+                }
+                const { appContext } = options;
+                const { metaName } = appContext;
+                chain.watchOptions({
+                    ignored: [
+                        `[\\\\/](?:node_modules(?![\\\\/]\\.${metaName})|.git)[\\\\/]`
+                    ]
+                });
+            });
+            api.modifyRspackConfig((config, { target, environment })=>{
+                const isServiceWorker = environment.name === builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME;
+                if ('node' === target || isServiceWorker) {
+                    const extensionAlias = {
+                        '.js': [
+                            '.node.js',
+                            '.server.js',
+                            '.js'
+                        ],
+                        '.jsx': [
+                            '.node.jsx',
+                            '.server.jsx',
+                            '.jsx'
+                        ],
+                        '.ts': [
+                            '.node.ts',
+                            '.server.ts',
+                            '.ts'
+                        ],
+                        '.tsx': [
+                            '.node.tsx',
+                            '.server.tsx',
+                            '.tsx'
+                        ],
+                        '.mjs': [
+                            '.node.mjs',
+                            '.server.mjs',
+                            '.mjs'
+                        ],
+                        '.json': [
+                            '.node.json',
+                            '.server.json',
+                            '.json'
+                        ]
+                    };
+                    config.resolve ??= {};
+                    config.resolve.extensionAlias = {
+                        ...config.resolve.extensionAlias,
+                        ...extensionAlias
+                    };
+                }
+            });
+        }
+    });
+function applyNodeCompat(isServiceWorker, chain) {
+    const nodeExts = [
+        '.node.js',
+        '.node.jsx',
+        '.node.ts',
+        '.node.tsx',
+        '.node.mjs',
+        '.server.js',
+        '.server.jsx',
+        '.server.ts',
+        '.server.tsx',
+        '.server.mjs'
+    ];
+    const webWorkerExts = [
+        '.worker.js',
+        '.worker.jsx',
+        '.worker.ts',
+        '.worker.tsx'
+    ];
+    for (const ext of nodeExts)chain.resolve.extensions.prepend(ext);
+    if (isServiceWorker) for (const ext of webWorkerExts)chain.resolve.extensions.prepend(ext);
+}
+exports.builderPluginAdapterBasic = __webpack_exports__.builderPluginAdapterBasic;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "builderPluginAdapterBasic"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/builderPlugins/adapterHtml.js

@@ -0,0 +1,89 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    builderPluginAdapterHtml: ()=>builderPluginAdapterHtml
+});
+const builder_namespaceObject = require("@modern-js/builder");
+const utils_namespaceObject = require("@modern-js/utils");
+const lodash_namespaceObject = require("@modern-js/utils/lodash");
+const index_js_namespaceObject = require("../bundlerPlugins/index.js");
+const createVirtualModule = (content)=>`data:text/javascript;charset=utf-8,${encodeURIComponent(content)}`;
+const builderPluginAdapterHtml = (options)=>({
+        name: 'builder-plugin-adapter-modern-html',
+        setup (api) {
+            api.modifyBundlerChain(async (chain, { CHAIN_ID, target, HtmlPlugin: HtmlBundlerPlugin, environment })=>{
+                const builderConfig = environment.config;
+                if (!(0, builder_namespaceObject.isHtmlDisabled)(builderConfig, target)) {
+                    applyBottomHtmlPlugin({
+                        options,
+                        chain,
+                        CHAIN_ID,
+                        HtmlBundlerPlugin,
+                        htmlPaths: environment.htmlPaths
+                    });
+                    await injectAssetPrefix({
+                        chain
+                    });
+                }
+            });
+        }
+    });
+async function injectAssetPrefix({ chain }) {
+    const entries = chain.entryPoints.entries() || {};
+    const entryNames = Object.keys(entries);
+    const assetPrefix = (0, utils_namespaceObject.removeTailSlash)(chain.output.get('publicPath') || '');
+    const code = `window.__assetPrefix__ = '${assetPrefix}';`;
+    entryNames.forEach((entryName)=>{
+        entries[entryName].prepend(createVirtualModule(code));
+    });
+}
+function applyBottomHtmlPlugin({ chain, options, CHAIN_ID, HtmlBundlerPlugin, htmlPaths }) {
+    const { normalizedConfig: modernConfig, appContext } = options;
+    for (const entryName of Object.keys(htmlPaths)){
+        const baseTemplateParams = {
+            entryName,
+            title: modernConfig.html.title,
+            mountId: modernConfig.html.templateParameters
+        };
+        chain.plugin(`${CHAIN_ID.PLUGIN.HTML}-${entryName}`).tap((args)=>[
+                {
+                    ...args[0] || {},
+                    __internal__: true,
+                    bottomTemplate: appContext.htmlTemplates[`__${entryName}-bottom__`] && (0, lodash_namespaceObject.template)(appContext.htmlTemplates[`__${entryName}-bottom__`])(baseTemplateParams)
+                }
+            ]);
+    }
+    chain.plugin('bottom-template').use(index_js_namespaceObject.BottomTemplatePlugin, [
+        HtmlBundlerPlugin
+    ]);
+}
+exports.builderPluginAdapterHtml = __webpack_exports__.builderPluginAdapterHtml;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "builderPluginAdapterHtml"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/builderPlugins/adapterPrecompress.js

@@ -0,0 +1,112 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    builderPluginAdapterPrecompress: ()=>builderPluginAdapterPrecompress
+});
+const external_node_zlib_namespaceObject = require("node:zlib");
+const external_compression_webpack_plugin_namespaceObject = require("compression-webpack-plugin");
+var external_compression_webpack_plugin_default = /*#__PURE__*/ __webpack_require__.n(external_compression_webpack_plugin_namespaceObject);
+const DEFAULT_PRECOMPRESS_TEST = /\.(js|mjs|cjs|css|html|svg|json|map)$/i;
+const DEFAULT_PRECOMPRESS_THRESHOLD = 10240;
+const DEFAULT_PRECOMPRESS_MIN_RATIO = 0.8;
+const createDefaultGzipOptions = ()=>({
+        algorithm: 'gzip',
+        filename: '[path][base].gz',
+        test: DEFAULT_PRECOMPRESS_TEST,
+        threshold: DEFAULT_PRECOMPRESS_THRESHOLD,
+        minRatio: DEFAULT_PRECOMPRESS_MIN_RATIO,
+        compressionOptions: {
+            level: 6
+        }
+    });
+const createDefaultBrotliOptions = ()=>({
+        algorithm: 'brotliCompress',
+        filename: '[path][base].br',
+        test: DEFAULT_PRECOMPRESS_TEST,
+        threshold: DEFAULT_PRECOMPRESS_THRESHOLD,
+        minRatio: DEFAULT_PRECOMPRESS_MIN_RATIO,
+        compressionOptions: {
+            params: {
+                [external_node_zlib_namespaceObject.constants.BROTLI_PARAM_QUALITY]: 9
+            }
+        }
+    });
+const mergeCompressionOptions = (base, next)=>{
+    const merged = {
+        ...base,
+        ...next
+    };
+    if (base.compressionOptions || next.compressionOptions) merged.compressionOptions = {
+        ...base.compressionOptions,
+        ...next.compressionOptions
+    };
+    return merged;
+};
+const resolveCodecOptions = (codecConfig, createDefaultOptions)=>{
+    if (false === codecConfig) return null;
+    if (void 0 === codecConfig || true === codecConfig) return createDefaultOptions();
+    return mergeCompressionOptions(createDefaultOptions(), codecConfig);
+};
+const resolvePrecompressConfig = (normalizedConfig)=>{
+    const precompress = normalizedConfig.output.precompress;
+    if (false === precompress || void 0 === precompress) return false;
+    if (true === precompress) return {};
+    return precompress;
+};
+const builderPluginAdapterPrecompress = (options)=>({
+        name: 'builder-plugin-adapter-modern-precompress',
+        setup (api) {
+            api.modifyBundlerChain((chain, { isProd, target })=>{
+                if (!isProd || 'web' !== target) return;
+                const precompressConfig = resolvePrecompressConfig(options.normalizedConfig);
+                if (false === precompressConfig) return;
+                const gzipOptions = resolveCodecOptions(precompressConfig.gzip, createDefaultGzipOptions);
+                if (gzipOptions) chain.plugin('modern-precompress-gzip').use(external_compression_webpack_plugin_default(), [
+                    gzipOptions
+                ]);
+                const brotliOptions = resolveCodecOptions(precompressConfig.brotli, createDefaultBrotliOptions);
+                if (brotliOptions) chain.plugin('modern-precompress-brotli').use(external_compression_webpack_plugin_default(), [
+                    brotliOptions
+                ]);
+            });
+        }
+    });
+exports.builderPluginAdapterPrecompress = __webpack_exports__.builderPluginAdapterPrecompress;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "builderPluginAdapterPrecompress"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/builderPlugins/adapterSSR.js

@@ -0,0 +1,151 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    builderPluginAdapterSSR: ()=>builderPluginAdapterSSR
+});
+const builder_namespaceObject = require("@modern-js/builder");
+const utils_namespaceObject = require("@modern-js/utils");
+const core_namespaceObject = require("@rsbuild/core");
+const external_path_namespaceObject = require("path");
+const utils_js_namespaceObject = require("../../../plugins/analyze/utils.js");
+const index_js_namespaceObject = require("../bundlerPlugins/index.js");
+const builderPluginAdapterSSR = (options)=>({
+        name: 'builder-plugin-adapter-modern-ssr',
+        setup (api) {
+            const { normalizedConfig } = options;
+            api.modifyRsbuildConfig((config)=>(0, core_namespaceObject.mergeRsbuildConfig)(config, {
+                    html: {
+                        inject: isStreamingSSR(normalizedConfig) ? 'head' : void 0
+                    },
+                    server: {
+                        compress: isStreamingSSR(normalizedConfig) || (0, utils_namespaceObject.isUseRsc)(normalizedConfig) ? false : void 0
+                    }
+                }));
+            api.modifyBundlerChain(async (chain, { target, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer, environment })=>{
+                const builderConfig = environment.config;
+                const { normalizedConfig } = options;
+                applyRouterPlugin(chain, 'route-plugin', options, HtmlBundlerPlugin);
+                const isServiceWorker = environment.name === builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME;
+                if ('node' === target || isServiceWorker) applyFilterEntriesBySSRConfig({
+                    isProd,
+                    chain,
+                    appNormalizedConfig: normalizedConfig
+                });
+                if ((0, utils_namespaceObject.isUseSSRBundle)(normalizedConfig) || (0, utils_namespaceObject.isUseRsc)(normalizedConfig)) {
+                    await applySSRLoaderEntry(chain, options, isServer);
+                    applySSRDataLoader(chain, options);
+                }
+                if (!(0, builder_namespaceObject.isHtmlDisabled)(builderConfig, target)) applyAsyncChunkHtmlPlugin({
+                    chain,
+                    modernConfig: options.normalizedConfig,
+                    HtmlBundlerPlugin
+                });
+            });
+        }
+    });
+const isStreamingSSR = (userConfig)=>{
+    const isStreaming = (ssr)=>{
+        if (!ssr) return false;
+        if ('boolean' == typeof ssr) return ssr;
+        return 'string' !== ssr.mode;
+    };
+    const { server } = userConfig;
+    if (isStreaming(server.ssr)) return true;
+    if (server?.ssrByEntries && 'object' == typeof server.ssrByEntries) {
+        for (const name of Object.keys(server.ssrByEntries))if (isStreaming(server.ssrByEntries[name])) return true;
+    }
+    return false;
+};
+function applyAsyncChunkHtmlPlugin({ chain, modernConfig, HtmlBundlerPlugin }) {
+    if (isStreamingSSR(modernConfig) || (0, utils_namespaceObject.isUseRsc)(modernConfig)) chain.plugin('html-async-chunk').use(index_js_namespaceObject.HtmlAsyncChunkPlugin, [
+        HtmlBundlerPlugin
+    ]);
+}
+function applyRouterPlugin(chain, pluginName, options, HtmlBundlerPlugin) {
+    const { appContext, normalizedConfig } = options;
+    const { entrypoints } = appContext;
+    const existNestedRoutes = entrypoints.some((entrypoint)=>entrypoint.nestedRoutesEntry);
+    const workerSSR = Boolean(normalizedConfig.deploy.worker?.ssr);
+    const { enableInlineRouteManifests, disableInlineRouteManifests } = normalizedConfig.output;
+    const inlineRouteManifests = disableInlineRouteManifests ? !disableInlineRouteManifests : enableInlineRouteManifests;
+    if (existNestedRoutes || workerSSR) chain.plugin(pluginName).use(index_js_namespaceObject.RouterPlugin, [
+        {
+            HtmlBundlerPlugin,
+            enableInlineRouteManifests: inlineRouteManifests,
+            staticJsDir: normalizedConfig.output?.distPath?.js,
+            disableFilenameHash: normalizedConfig.output?.filenameHash === false,
+            scriptLoading: normalizedConfig.html?.scriptLoading,
+            nonce: normalizedConfig.security?.nonce
+        }
+    ]);
+}
+function applyFilterEntriesBySSRConfig({ isProd, chain, appNormalizedConfig }) {
+    const { server: serverConfig, output: outputConfig } = appNormalizedConfig;
+    const entries = chain.entryPoints.entries();
+    if (isProd && (outputConfig?.ssg === true || 'function' == typeof outputConfig?.ssg)) return;
+    if (void 0 === entries) throw new Error('No entry found, one of src/routes/layout.tsx, src/App.tsx, src/index.tsx is required');
+    const entryNames = Object.keys(entries);
+    if (isProd && 1 === entryNames.length && outputConfig?.ssg) return;
+    const ssgEntries = [];
+    if (isProd && outputConfig?.ssgByEntries) {
+        const { ssgByEntries } = outputConfig;
+        entryNames.forEach((name)=>{
+            if (ssgByEntries[name]) ssgEntries.push(name);
+        });
+    }
+    const { ssr, ssrByEntries } = serverConfig || {};
+    entryNames.forEach((name)=>{
+        if (!serverConfig?.rsc && !ssgEntries.includes(name) && !name.includes('server-loaders') && (ssr && ssrByEntries?.[name] === false || !ssr && !ssrByEntries?.[name])) chain.entryPoints.delete(name);
+    });
+}
+async function applySSRLoaderEntry(chain, optinos, isServer) {
+    const { appContext } = optinos;
+    const { internalDirectory } = appContext;
+    const { entrypoints } = appContext;
+    await Promise.all(entrypoints.map(async (entrypoint)=>{
+        const { entryName } = entrypoint;
+        const serverLoadersFile = (0, utils_js_namespaceObject.getServerCombinedModuleFile)(internalDirectory, entryName);
+        if (isServer) try {
+            await utils_namespaceObject.fs.access(serverLoadersFile, utils_namespaceObject.fs.constants.F_OK);
+            chain.entry(`${entryName}-server-loaders`).add(serverLoadersFile);
+        } catch (err) {}
+    }));
+}
+function applySSRDataLoader(chain, options) {
+    const { normalizedConfig, appContext } = options;
+    const { appDirectory } = appContext;
+    const { entriesDir = './src' } = normalizedConfig.source;
+    const absolutePath = external_path_namespaceObject.resolve(appDirectory, entriesDir).split(external_path_namespaceObject.sep).join('(\\\\|/)');
+    const reg = new RegExp(`${absolutePath}.*\\.(loader|data|data.client)\\.[t|j]sx?$`);
+    chain.module.rule('ssr-data-loader').test(reg).use('data-loader').loader(require.resolve('@modern-js/plugin-data-loader/loader')).end();
+}
+exports.builderPluginAdapterSSR = __webpack_exports__.builderPluginAdapterSSR;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "builderPluginAdapterSSR"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/builderPlugins/builderHooks.js

@@ -0,0 +1,51 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    builderPluginAdapterHooks: ()=>builderPluginAdapterHooks
+});
+const builderPluginAdapterHooks = (options)=>({
+        name: 'builder-plugin-support-modern-hooks',
+        setup (api) {
+            const _internalContext = options.appContext._internalContext;
+            const hooks = _internalContext.pluginAPI?.getHooks();
+            api.modifyBundlerChain(async (chain, utils)=>{
+                await hooks?.modifyBundlerChain.call(chain, utils);
+            });
+            api.modifyRsbuildConfig(async (config, utils)=>{
+                await hooks?.modifyRsbuildConfig.call(config, utils);
+            });
+            api.modifyRspackConfig(async (config, utils)=>{
+                await hooks?.modifyRspackConfig.call(config, utils);
+            });
+        }
+    });
+exports.builderPluginAdapterHooks = __webpack_exports__.builderPluginAdapterHooks;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "builderPluginAdapterHooks"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/builderPlugins/index.js

@@ -0,0 +1,86 @@
+"use strict";
+var __webpack_modules__ = {
+    "./adapterBasic" (module) {
+        module.exports = require("./adapterBasic.js");
+    },
+    "./adapterHtml" (module) {
+        module.exports = require("./adapterHtml.js");
+    },
+    "./adapterPrecompress" (module) {
+        module.exports = require("./adapterPrecompress.js");
+    },
+    "./adapterSSR" (module) {
+        module.exports = require("./adapterSSR.js");
+    },
+    "./builderHooks" (module) {
+        module.exports = require("./builderHooks.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _adapterBasic__rspack_import_0 = __webpack_require__("./adapterBasic");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _adapterBasic__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_adapterBasic__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _adapterHtml__rspack_import_1 = __webpack_require__("./adapterHtml");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _adapterHtml__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_adapterHtml__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _adapterPrecompress__rspack_import_2 = __webpack_require__("./adapterPrecompress");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _adapterPrecompress__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_adapterPrecompress__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _adapterSSR__rspack_import_3 = __webpack_require__("./adapterSSR");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _adapterSSR__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_adapterSSR__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _builderHooks__rspack_import_4 = __webpack_require__("./builderHooks");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _builderHooks__rspack_import_4)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_builderHooks__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});