@bleedingdev/modern-js-builder 3.2.0-ultramodern.0

package/dist/esm/shared/parseCommonConfig.mjs

@@ -0,0 +1,173 @@
+import { mergeRsbuildConfig } from "@rsbuild/core";
+import { pluginCssMinimizer } from "@rsbuild/plugin-css-minimizer";
+import { pluginLess } from "@rsbuild/plugin-less";
+import { pluginReact } from "@rsbuild/plugin-react";
+import { pluginSass } from "@rsbuild/plugin-sass";
+import { pluginDevtool } from "../plugins/devtools.mjs";
+import { pluginEmitRouteFile } from "../plugins/emitRouteFile.mjs";
+import { pluginEnvironmentDefaults } from "../plugins/environmentDefaults.mjs";
+import { pluginGlobalVars } from "../plugins/globalVars.mjs";
+import { pluginHtmlMinifierTerser } from "../plugins/htmlMinify.mjs";
+import { pluginRuntimeChunk } from "../plugins/runtimeChunk.mjs";
+import { transformToRsbuildServerOptions } from "./devServer.mjs";
+import { NODE_MODULES_REGEX } from "./utils.mjs";
+const CSS_MODULES_REGEX = /\.modules?\.\w+$/i;
+const GLOBAL_CSS_REGEX = /\.global\.\w+$/;
+const isLooseCssModules = (path)=>{
+    if (NODE_MODULES_REGEX.test(path)) return CSS_MODULES_REGEX.test(path);
+    return !GLOBAL_CSS_REGEX.test(path);
+};
+function removeUndefinedKey(obj) {
+    Object.keys(obj).forEach((key)=>{
+        if (void 0 === obj[key]) delete obj[key];
+    });
+    return obj;
+}
+async function parseCommonConfig(builderConfig, options) {
+    const frameworkConfigPath = options?.frameworkConfigPath;
+    const { plugins: [...plugins] = [], splitChunks, performance: { rsdoctor: rsdoctorConfig, ...performanceConfig } = {}, output: { module = false, enableCssModuleTSDeclaration, disableCssModuleExtension, disableTsChecker, disableSvgr, svgDefaultExport, assetsRetry, enableAssetManifest, sourceMap, convertToRem, polyfill, dataUriLimit = 10000, distPath = {}, ...outputConfig } = {}, html: { outputStructure, appIcon, ...htmlConfig } = {}, source: { alias, globalVars, transformImport, ...sourceConfig } = {}, dev = {}, server = {}, security: { checkSyntax, sri, ...securityConfig } = {}, tools: { devServer, tsChecker, minifyCss, less, sass, htmlPlugin, autoprefixer, ...toolsConfig } = {}, environments = {}, resolve = {} } = builderConfig;
+    let combinedAlias;
+    if (alias || resolve.alias) combinedAlias = [].concat(alias ?? []).concat(resolve.alias ?? []);
+    const rsbuildConfig = {
+        plugins,
+        splitChunks,
+        output: {
+            polyfill: 'ua' === polyfill ? 'off' : polyfill,
+            dataUriLimit,
+            sourceMap,
+            module,
+            ...outputConfig
+        },
+        resolve: {
+            ...resolve,
+            alias: combinedAlias
+        },
+        source: sourceConfig,
+        performance: performanceConfig,
+        html: htmlConfig,
+        tools: toolsConfig,
+        security: securityConfig,
+        environments
+    };
+    rsbuildConfig.tools.htmlPlugin = htmlPlugin;
+    rsbuildConfig.tools.lightningcssLoader ??= false;
+    const { html = {}, output = {}, source = {} } = rsbuildConfig;
+    source.transformImport = false === transformImport ? ()=>[] : transformImport;
+    if (!source.decorators) source.decorators = {
+        version: 'legacy'
+    };
+    output.charset ??= 'ascii';
+    if ('boolean' != typeof output.sourceMap) {
+        output.sourceMap ||= {};
+        output.sourceMap.css ??= 'production' !== process.env.NODE_ENV;
+    }
+    const { server: _server, worker, ...rsbuildDistPath } = distPath;
+    output.distPath = rsbuildDistPath;
+    output.distPath.html ??= 'html';
+    output.polyfill ??= 'entry';
+    if (disableCssModuleExtension) {
+        output.cssModules ||= {};
+        output.cssModules.auto ??= isLooseCssModules;
+    }
+    const extraConfig = {};
+    extraConfig.html ||= {};
+    extraConfig.html.outputStructure = outputStructure ?? 'nested';
+    html.title ??= '';
+    html.appIcon = appIcon;
+    extraConfig.tools ??= {};
+    if (false !== htmlPlugin) extraConfig.tools.htmlPlugin = (config)=>{
+        if ('function' == typeof config.templateParameters) {
+            const originFn = config.templateParameters;
+            config.templateParameters = (...args)=>{
+                const res = originFn(...args);
+                return {
+                    title: config.title,
+                    meta: void 0,
+                    ...res
+                };
+            };
+        }
+    };
+    if (!dev.lazyCompilation) dev.lazyCompilation = false;
+    const { rsbuildDev, rsbuildServer } = transformToRsbuildServerOptions(dev || {}, devServer || {}, server || {});
+    rsbuildConfig.server = removeUndefinedKey(rsbuildServer);
+    rsbuildConfig.dev = removeUndefinedKey(rsbuildDev);
+    rsbuildConfig.html = html;
+    rsbuildConfig.output = output;
+    const rsbuildPlugins = [
+        pluginGlobalVars(globalVars),
+        pluginDevtool({
+            sourceMap
+        }),
+        pluginEmitRouteFile(),
+        pluginSass({
+            sassLoaderOptions: sass
+        }),
+        pluginLess({
+            lessLoaderOptions: less
+        }),
+        pluginEnvironmentDefaults(distPath),
+        pluginHtmlMinifierTerser()
+    ];
+    if (checkSyntax) {
+        const { pluginCheckSyntax } = await import("@rsbuild/plugin-check-syntax");
+        rsbuildPlugins.push(pluginCheckSyntax('boolean' == typeof checkSyntax ? {} : checkSyntax));
+    }
+    if (!disableTsChecker) {
+        const { pluginTypeCheck } = await import("@rsbuild/plugin-type-check");
+        rsbuildPlugins.push(pluginTypeCheck({
+            tsCheckerOptions: tsChecker
+        }));
+    }
+    if (convertToRem) {
+        const { pluginRem } = await import("@rsbuild/plugin-rem");
+        rsbuildPlugins.push(pluginRem('boolean' == typeof convertToRem ? {} : convertToRem));
+    }
+    if (enableCssModuleTSDeclaration) {
+        const { pluginTypedCSSModules } = await import("@rsbuild/plugin-typed-css-modules");
+        rsbuildPlugins.push(pluginTypedCSSModules());
+    }
+    rsbuildPlugins.push(pluginRuntimeChunk(builderConfig.output?.disableInlineRuntimeChunk));
+    const { sourceBuild } = builderConfig.experiments || {};
+    if (sourceBuild) {
+        const { pluginSourceBuild } = await import("@rsbuild/plugin-source-build");
+        rsbuildPlugins.push(pluginSourceBuild(true === sourceBuild ? {} : sourceBuild));
+    }
+    rsbuildPlugins.push(pluginReact());
+    if (!disableSvgr) {
+        const { pluginSvgr } = await import("@rsbuild/plugin-svgr");
+        rsbuildPlugins.push(pluginSvgr({
+            mixedImport: true,
+            svgrOptions: {
+                exportType: 'component' === svgDefaultExport ? 'default' : 'named'
+            }
+        }));
+    }
+    if (assetsRetry) {
+        const { pluginAssetsRetry } = await import("@rsbuild/plugin-assets-retry");
+        rsbuildPlugins.push(pluginAssetsRetry(assetsRetry));
+    }
+    if (frameworkConfigPath && false !== performanceConfig.buildCache) {
+        const buildCache = 'object' == typeof performanceConfig.buildCache ? performanceConfig.buildCache : {};
+        rsbuildConfig.performance.buildCache = {
+            ...buildCache,
+            buildDependencies: [
+                frameworkConfigPath,
+                ...buildCache.buildDependencies || []
+            ]
+        };
+    }
+    rsbuildPlugins.push(pluginCssMinimizer({
+        pluginOptions: minifyCss
+    }));
+    if (enableAssetManifest) {
+        const { pluginManifest } = await import("../plugins/manifest.mjs");
+        rsbuildPlugins.push(pluginManifest());
+    }
+    return {
+        rsbuildConfig: mergeRsbuildConfig(rsbuildConfig, extraConfig),
+        rsbuildPlugins,
+        rsdoctorConfig
+    };
+}
+export { isLooseCssModules, parseCommonConfig };

package/dist/esm/shared/rsc/rsc-server-entry-loader.mjs

@@ -0,0 +1,7 @@
+function rscServerEntryLoader(source) {
+    this.cacheable(true);
+    const hasServerEntryDirective = source.includes("'use server-entry'") || source.includes('"use server-entry"') || source.includes('`use server-entry`');
+    if (hasServerEntryDirective) return source;
+    return `'use server-entry';\n${source}`;
+}
+export default rscServerEntryLoader;

package/dist/esm/shared/rsc/rscClientBrowserFallback.mjs

@@ -0,0 +1,20 @@
+import path from "path";
+function rscClientBrowserFallbackPlugin() {
+    return {
+        name: 'builder:rsc-client-browser-fallback',
+        setup (api) {
+            let emptyModulePath;
+            try {
+                emptyModulePath = require.resolve('./rscEmptyModule');
+            } catch  {
+                emptyModulePath = path.resolve(__dirname, 'rscEmptyModule');
+            }
+            api.modifyRspackConfig((config)=>{
+                config.resolve ??= {};
+                config.resolve.fallback ??= {};
+                config.resolve.fallback['react-server-dom-rspack/client.browser'] = emptyModulePath;
+            });
+        }
+    };
+}
+export { rscClientBrowserFallbackPlugin };

package/dist/esm/shared/rsc/rscEmptyModule.mjs

@@ -0,0 +1,2 @@
+const rscEmptyModule = {};
+export default rscEmptyModule;

package/dist/esm/shared/utils.mjs

@@ -0,0 +1,53 @@
+import browserslist from "browserslist";
+const RUNTIME_CHUNK_NAME = 'builder-runtime';
+const RUNTIME_CHUNK_REGEX = new RegExp(`${RUNTIME_CHUNK_NAME}([.].+)?\\.js$`);
+const SERVICE_WORKER_ENVIRONMENT_NAME = 'workerSSR';
+const NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/;
+const castArray = (arr)=>{
+    if (void 0 === arr) return [];
+    return Array.isArray(arr) ? arr : [
+        arr
+    ];
+};
+const browsersListCache = new Map();
+async function getBrowserslist(path) {
+    const env = process.env.NODE_ENV;
+    const cacheKey = `${path}${env}`;
+    if (browsersListCache.has(cacheKey)) return browsersListCache.get(cacheKey);
+    const result = browserslist.loadConfig({
+        path,
+        env
+    });
+    if (result) {
+        browsersListCache.set(cacheKey, result);
+        return result;
+    }
+    return null;
+}
+const isHtmlDisabled = (config, target)=>{
+    const { htmlPlugin } = config.tools;
+    return false === htmlPlugin || Array.isArray(htmlPlugin) && htmlPlugin.includes(false) || 'web' !== target;
+};
+const DEFAULT_WEB_BROWSERSLIST = [
+    'chrome >= 87',
+    'edge >= 88',
+    'firefox >= 78',
+    'safari >= 14'
+];
+const DEFAULT_BROWSERSLIST = {
+    web: DEFAULT_WEB_BROWSERSLIST,
+    node: [
+        'node >= 16'
+    ],
+    'web-worker': DEFAULT_WEB_BROWSERSLIST
+};
+async function getBrowserslistWithDefault(path, config, target) {
+    const { overrideBrowserslist: overrides } = config?.output || {};
+    if ('web' === target || 'web-worker' === target) {
+        if (overrides) return overrides;
+        const browserslistrc = await getBrowserslist(path);
+        if (browserslistrc) return browserslistrc;
+    }
+    return DEFAULT_BROWSERSLIST[target];
+}
+export { NODE_MODULES_REGEX, RUNTIME_CHUNK_NAME, RUNTIME_CHUNK_REGEX, SERVICE_WORKER_ENVIRONMENT_NAME, castArray, getBrowserslistWithDefault, isHtmlDisabled };

package/dist/esm-node/createBuilder.mjs

@@ -0,0 +1,58 @@
+import "node:module";
+import { createRsbuild } from "@rsbuild/core";
+import { getRscPlugins } from "./plugins/rscConfig.mjs";
+import { pluginRsdoctor } from "./plugins/rsdoctor.mjs";
+import { parseCommonConfig } from "./shared/parseCommonConfig.mjs";
+import { rscClientBrowserFallbackPlugin } from "./shared/rsc/rscClientBrowserFallback.mjs";
+async function parseConfig(builderConfig, options) {
+    builderConfig.performance ??= {};
+    builderConfig.performance.buildCache ??= true;
+    const { rsbuildConfig, rsbuildPlugins, rsdoctorConfig } = await parseCommonConfig(builderConfig, options);
+    const { sri } = builderConfig.security || {};
+    if (sri) if (true === sri) rsbuildConfig.security.sri = {
+        enable: 'auto'
+    };
+    else {
+        const algorithm = Array.isArray(sri.hashFuncNames) ? sri.hashFuncNames[0] : void 0;
+        rsbuildConfig.security.sri = {
+            enable: sri.enabled,
+            algorithm
+        };
+    }
+    if (false === Boolean(rsbuildConfig.tools.lightningcssLoader)) {
+        const { pluginPostcss } = await import("./plugins/postcss.mjs");
+        rsbuildPlugins.push(pluginPostcss({
+            autoprefixer: builderConfig.tools?.autoprefixer
+        }));
+    }
+    const enableRsc = builderConfig.server?.rsc ?? false;
+    if (enableRsc) {
+        const rscPlugins = await getRscPlugins(enableRsc, options.internalDirectory);
+        rsbuildPlugins.push(...rscPlugins);
+    } else rsbuildPlugins.push(rscClientBrowserFallbackPlugin());
+    const rsdoctorPlugin = pluginRsdoctor(rsdoctorConfig);
+    if (rsdoctorPlugin) rsbuildPlugins.push(rsdoctorPlugin);
+    return {
+        rsbuildConfig,
+        rsbuildPlugins
+    };
+}
+async function createRspackBuilder(options) {
+    const { cwd = process.cwd(), config, ...rest } = options;
+    const { rsbuildConfig, rsbuildPlugins } = await parseConfig(config, {
+        ...rest,
+        cwd
+    });
+    rsbuildConfig.plugins = [
+        ...rsbuildPlugins,
+        ...rsbuildConfig.plugins || []
+    ];
+    const rsbuild = await createRsbuild({
+        cwd,
+        rsbuildConfig
+    });
+    return {
+        ...rsbuild
+    };
+}
+export { createRspackBuilder, parseConfig };

package/dist/esm-node/index.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+export { createRspackBuilder as createBuilder, parseConfig as parseRspackConfig } from "./createBuilder.mjs";
+export { logger } from "@rsbuild/core";
+export { RUNTIME_CHUNK_NAME, RUNTIME_CHUNK_REGEX, SERVICE_WORKER_ENVIRONMENT_NAME, castArray, isHtmlDisabled } from "./shared/utils.mjs";

package/dist/esm-node/plugins/devtools.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+const pluginDevtool = (options)=>({
+        name: 'builder:devtool',
+        setup (api) {
+            const devtoolJs = 'boolean' == typeof options.sourceMap || options.sourceMap?.js !== void 0;
+            if (devtoolJs) return;
+            api.modifyBundlerChain((chain, { isProd, isServer })=>{
+                const prodDevTool = isServer ? 'source-map' : 'hidden-source-map';
+                const devtool = isProd ? prodDevTool : 'cheap-module-source-map';
+                chain.devtool(devtool);
+            });
+        }
+    });
+export { pluginDevtool };

package/dist/esm-node/plugins/emitRouteFile.mjs

@@ -0,0 +1,29 @@
+import "node:module";
+import node_fs from "node:fs";
+import { join } from "node:path";
+async function isFileExists(file) {
+    return node_fs.promises.access(file, node_fs.constants.F_OK).then(()=>true).catch(()=>false);
+}
+const pluginEmitRouteFile = ()=>({
+        name: 'builder:emit-route-file',
+        setup (api) {
+            api.onBeforeStartDevServer(async ({ environments })=>{
+                const { fs, ROUTE_SPEC_FILE } = await import("@modern-js/utils");
+                const routeFilePath = join(api.context.distPath, ROUTE_SPEC_FILE);
+                const htmlPaths = Object.values(environments).reduce((prev, curr)=>({
+                        ...prev,
+                        ...curr.htmlPaths
+                    }), {});
+                const routesInfo = Object.entries(htmlPaths).map(([entryName, filename], index)=>({
+                        urlPath: 0 === index ? '/' : `/${entryName}`,
+                        entryName,
+                        entryPath: filename,
+                        isSPA: true
+                    }));
+                if (!await isFileExists(routeFilePath) && routesInfo.length) await fs.outputFile(routeFilePath, JSON.stringify({
+                    routes: routesInfo
+                }, null, 2));
+            });
+        }
+    });
+export { isFileExists, pluginEmitRouteFile };

package/dist/esm-node/plugins/environmentDefaults.mjs

@@ -0,0 +1,67 @@
+import "node:module";
+import { join } from "node:path";
+import { SERVICE_WORKER_ENVIRONMENT_NAME, getBrowserslistWithDefault } from "../shared/utils.mjs";
+const pluginEnvironmentDefaults = (distPath = {})=>({
+        name: 'builder:environment-defaults-plugin',
+        setup (api) {
+            api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>{
+                const compatConfig = {};
+                if (config.environments?.[SERVICE_WORKER_ENVIRONMENT_NAME]) {
+                    compatConfig.environments ??= {};
+                    compatConfig.environments[SERVICE_WORKER_ENVIRONMENT_NAME] = {
+                        output: {
+                            polyfill: 'off',
+                            distPath: {
+                                root: join(distPath.root || 'dist', distPath.worker || 'worker'),
+                                js: '',
+                                css: '',
+                                jsAsync: '',
+                                cssAsync: ''
+                            },
+                            filename: {
+                                js: '[name].js'
+                            }
+                        }
+                    };
+                }
+                if (config.environments?.server) {
+                    compatConfig.environments ??= {};
+                    compatConfig.environments.server = {
+                        output: {
+                            emitAssets: false,
+                            distPath: {
+                                root: join(distPath.root || 'dist', distPath.server || 'bundles'),
+                                js: '',
+                                css: '',
+                                jsAsync: '',
+                                cssAsync: ''
+                            }
+                        }
+                    };
+                }
+                return compatConfig.environments ? mergeRsbuildConfig(compatConfig, config) : config;
+            });
+            api.modifyRsbuildConfig({
+                handler: (config)=>{
+                    const environmentNameOrder = [
+                        'client',
+                        'server',
+                        'workerSSR'
+                    ];
+                    config.environments = Object.fromEntries(Object.entries(config.environments).sort((a1, a2)=>environmentNameOrder.includes(a1[0]) ? environmentNameOrder.indexOf(a1[0]) - environmentNameOrder.indexOf(a2[0]) : 1));
+                },
+                order: 'post'
+            });
+            api.modifyEnvironmentConfig(async (config, { name })=>{
+                config.output.overrideBrowserslist ??= await getBrowserslistWithDefault(api.context.rootPath, config, name === SERVICE_WORKER_ENVIRONMENT_NAME ? 'node' : config.output.target);
+            });
+            api.modifyBundlerChain(async (chain, { environment })=>{
+                const isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+                if (isServiceWorker) chain.output.library({
+                    ...chain.output.get('library') || {},
+                    type: 'commonjs2'
+                });
+            });
+        }
+    });
+export { pluginEnvironmentDefaults };

package/dist/esm-node/plugins/globalVars.mjs

@@ -0,0 +1,22 @@
+import "node:module";
+import { applyOptionsChain } from "@modern-js/utils";
+const pluginGlobalVars = (options)=>({
+        name: 'builder:global-vars',
+        setup (api) {
+            api.modifyBundlerChain((chain, { env, target, bundler })=>{
+                if (!options) return;
+                const globalVars = applyOptionsChain({}, options, {
+                    env,
+                    target
+                });
+                const serializedVars = {};
+                Object.entries(globalVars).forEach(([key, value])=>{
+                    serializedVars[key] = JSON.stringify(value) ?? 'undefined';
+                });
+                chain.plugin('globalVars').use(bundler.DefinePlugin, [
+                    serializedVars
+                ]);
+            });
+        }
+    });
+export { pluginGlobalVars };

package/dist/esm-node/plugins/htmlMinify.mjs

@@ -0,0 +1,82 @@
+import "node:module";
+import { merge } from "ts-deepmerge";
+function applyRemoveConsole(options, config) {
+    const { removeConsole } = config.performance;
+    const compressOptions = 'boolean' == typeof options.compress ? {} : options.compress || {};
+    if (true === removeConsole) options.compress = {
+        ...compressOptions,
+        drop_console: true
+    };
+    else if (Array.isArray(removeConsole)) {
+        const pureFuncs = removeConsole.map((method)=>`console.${method}`);
+        options.compress = {
+            ...compressOptions,
+            pure_funcs: pureFuncs
+        };
+    }
+    return options;
+}
+function getTerserMinifyOptions(config) {
+    const options = {
+        mangle: {
+            safari10: true
+        },
+        format: {
+            ascii_only: 'ascii' === config.output.charset
+        }
+    };
+    if ('none' === config.output.legalComments) {
+        options.format ||= {};
+        options.format.comments = false;
+    }
+    const finalOptions = applyRemoveConsole(options, config);
+    return finalOptions;
+}
+function getMinifyOptions(config) {
+    const minifyJS = getTerserMinifyOptions(config);
+    return {
+        removeComments: false,
+        useShortDoctype: true,
+        keepClosingSlash: true,
+        collapseWhitespace: true,
+        removeRedundantAttributes: true,
+        removeScriptTypeAttributes: true,
+        removeStyleLinkTypeAttributes: true,
+        removeEmptyAttributes: true,
+        minifyJS,
+        minifyCSS: true,
+        minifyURLs: true
+    };
+}
+const pluginHtmlMinifierTerser = ()=>({
+        name: 'builder:plugin-html-minifier-terser',
+        setup (api) {
+            api.modifyBundlerChain(async (chain, { isProd, environment })=>{
+                const { output, tools: { htmlPlugin } } = environment.config;
+                const disableHtmlMinify = !isProd || false === output.minify || false === htmlPlugin;
+                const { minify } = await import("html-minifier-terser");
+                const pluginRecord = chain.plugins.entries();
+                const minifyOptions = getMinifyOptions(environment.config);
+                for (const id of Object.keys(pluginRecord)){
+                    if (!id.startsWith('html-')) continue;
+                    const values = pluginRecord[id].values();
+                    const isHtmlRspackPlugin = values.some((item)=>{
+                        const name = item?.name || item.constructor?.name;
+                        return 'HtmlRspackPlugin' === name;
+                    });
+                    if (isHtmlRspackPlugin && !disableHtmlMinify) {
+                        chain.plugin(id).tap((options)=>{
+                            if (!options.length) return options;
+                            const userMinifyOption = options[0].minify;
+                            if (false === userMinifyOption) return options;
+                            const minifyFn = (html)=>minify(html, userMinifyOption ? merge(minifyOptions, userMinifyOption) : minifyOptions);
+                            options[0].minify = minifyFn;
+                            return options;
+                        });
+                        continue;
+                    }
+                }
+            });
+        }
+    });
+export { pluginHtmlMinifierTerser };

package/dist/esm-node/plugins/manifest.mjs

@@ -0,0 +1,19 @@
+import "node:module";
+import { generateManifest } from "../shared/manifest.mjs";
+const pluginManifest = ()=>({
+        name: 'builder:manifest',
+        setup (api) {
+            api.modifyBundlerChain(async (chain, { target, CHAIN_ID })=>{
+                const { RspackManifestPlugin } = await import("rspack-manifest-plugin");
+                const publicPath = chain.output.get('publicPath');
+                chain.plugin(CHAIN_ID.PLUGIN.MANIFEST).use(RspackManifestPlugin, [
+                    {
+                        fileName: 'web' === target ? 'asset-manifest.json' : `asset-manifest-${target}.json`,
+                        publicPath,
+                        generate: generateManifest
+                    }
+                ]);
+            });
+        }
+    });
+export { pluginManifest };