@modern-js/builder 3.0.0-alpha.0 → 3.0.0-alpha.2

package/dist/esm/rsc/plugins/rspack-rsc-client-plugin.mjs

@@ -0,0 +1,143 @@
+import path from "path";
+import { sharedData } from "../common.mjs";
+const hasExtension = (filePath)=>'' !== path.extname(filePath);
+class RspackRscClientPlugin {
+    apply(compiler) {
+        const { EntryPlugin, RuntimeGlobals, WebpackError, sources: { RawSource } } = compiler.rspack;
+        const ssrManifest = {
+            moduleMap: {},
+            moduleLoading: null,
+            styles: []
+        };
+        const getEntryModule = (compilation)=>{
+            const entryModules = [];
+            for (const [, entryValue] of compilation.entries.entries()){
+                const entryDependency = entryValue.dependencies[0];
+                if (!entryDependency) {
+                    compilation.errors.push(new WebpackError("Could not find an entry dependency."));
+                    continue;
+                }
+                const resolvedModule = compilation.moduleGraph.getModule(entryDependency);
+                if (resolvedModule) entryModules.push(resolvedModule);
+            }
+            if (0 === entryModules.length) {
+                compilation.errors.push(new WebpackError("Could not find any entries in the compilation."));
+                return [];
+            }
+            return entryModules;
+        };
+        const addClientReferencesChunks = (compilation, callback)=>{
+            const promises = [];
+            [
+                ...this.clientReferencesMap.keys()
+            ].forEach((resourcePath)=>{
+                const entries = compilation.entries.entries();
+                for (const [entryName, entry] of entries){
+                    const runtimeName = entry.options.runtime || entryName;
+                    if (hasExtension(entryName)) continue;
+                    const dependency = EntryPlugin.createDependency(resourcePath);
+                    promises.push(new Promise((resolve, reject)=>{
+                        compilation.addInclude(compiler.context, dependency, {
+                            name: entryName
+                        }, (error, module)=>{
+                            if (error) reject(error);
+                            else {
+                                compilation.moduleGraph.getExportsInfo(module).setUsedInUnknownWay(runtimeName);
+                                this.dependencies.push(dependency);
+                                resolve(void 0);
+                            }
+                        });
+                    }));
+                }
+            });
+            if (this.styles && this.styles.size > 0) for (const style of this.styles){
+                const dependency = EntryPlugin.createDependency(style);
+                promises.push(new Promise((resolve, reject)=>{
+                    compilation.addInclude(compiler.context, dependency, {
+                        name: void 0
+                    }, (error, module)=>{
+                        if (error) reject(error);
+                        else {
+                            compilation.moduleGraph.getExportsInfo(module).setUsedInUnknownWay(void 0);
+                            this.dependencies.push(dependency);
+                            resolve(void 0);
+                        }
+                    });
+                }));
+            }
+            Promise.all(promises).then(()=>callback(null)).catch((error)=>callback(error));
+        };
+        compiler.hooks.finishMake.tapAsync(RspackRscClientPlugin.name, (compilation, callback)=>{
+            const entryModules = getEntryModule(compilation);
+            for (const entryModule of entryModules)if (entryModule) addClientReferencesChunks(compilation, callback);
+        });
+        compiler.hooks.thisCompilation.tap(RspackRscClientPlugin.name, (compilation)=>{
+            this.styles = sharedData.get('styles');
+            this.clientReferencesMap = sharedData.get('clientReferencesMap');
+            compilation.hooks.additionalTreeRuntimeRequirements.tap(RspackRscClientPlugin.name, (_chunk, runtimeRequirements)=>{
+                runtimeRequirements.add(RuntimeGlobals.ensureChunkHandlers);
+                runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+                runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
+            });
+            compilation.hooks.processAssets.tap(RspackRscClientPlugin.name, ()=>{
+                const clientManifest = {};
+                const { chunkGraph, moduleGraph } = compilation;
+                for (const dependency of this.dependencies){
+                    const module = moduleGraph.getModule(dependency);
+                    if (!module) continue;
+                    const resourcePath = module.nameForCondition();
+                    const clientReferences = resourcePath ? this.clientReferencesMap.get(resourcePath) : void 0;
+                    if (clientReferences) {
+                        const moduleId = chunkGraph.getModuleId(module);
+                        const ssrModuleMetaData = {};
+                        for (const { id, exportName, ssrId } of clientReferences){
+                            const clientExportName = exportName;
+                            const ssrExportName = exportName;
+                            const chunksSet = new Set();
+                            for (const chunk of chunkGraph.getModuleChunksIterable(module))chunksSet.add(chunk);
+                            for (const connection of moduleGraph.getOutgoingConnections(module))for (const chunk of chunkGraph.getModuleChunksIterable(connection.module))chunksSet.add(chunk);
+                            const chunks = [];
+                            const styles = [];
+                            for (const chunk of chunksSet)if (chunk.id) {
+                                for (const file of chunk.files)if (file.endsWith('.js')) chunks.push(chunk.id, file);
+                            }
+                            clientManifest[id] = {
+                                id: moduleId,
+                                name: clientExportName,
+                                chunks,
+                                styles
+                            };
+                            if (ssrId) ssrModuleMetaData[clientExportName] = {
+                                id: ssrId,
+                                name: ssrExportName,
+                                chunks: []
+                            };
+                        }
+                        ssrManifest.moduleMap[moduleId] = ssrModuleMetaData;
+                    }
+                }
+                compilation.emitAsset(this.clientManifestFilename, new RawSource(JSON.stringify(clientManifest, null, 2), false));
+                const { crossOriginLoading, publicPath = "" } = compilation.outputOptions;
+                ssrManifest.moduleLoading = {
+                    prefix: compilation.getPath(publicPath, {
+                        hash: compilation.hash ?? "XXXX"
+                    }),
+                    crossOrigin: crossOriginLoading ? "use-credentials" === crossOriginLoading ? crossOriginLoading : "" : void 0
+                };
+                if (this.styles && this.styles.size > 0) {
+                    const assets = compilation.getAssets();
+                    const cssAsset = assets.find((asset)=>asset.name.endsWith('.css'));
+                    if (cssAsset) ssrManifest.styles.push(cssAsset.name);
+                }
+                compilation.emitAsset(this.ssrManifestFilename, new RawSource(JSON.stringify(ssrManifest, null, 2), false));
+            });
+        });
+    }
+    constructor(options){
+        this.clientReferencesMap = new Map();
+        this.dependencies = [];
+        this.clientManifestFilename = options?.clientManifestFilename || "react-client-manifest.json";
+        this.ssrManifestFilename = options?.ssrManifestFilename || "react-ssr-manifest.json";
+    }
+}
+export { RspackRscClientPlugin };

package/dist/esm/rsc/plugins/rspack-rsc-server-plugin.mjs

@@ -0,0 +1,211 @@
+import { findRootIssuer, getRscBuildInfo, isCssModule, rspackRscLayerName, setRscBuildInfo, sharedData } from "../common.mjs";
+const rspack_rsc_server_plugin_resourcePath2Entries = new Map();
+class RscServerPlugin {
+    isValidModule(module) {
+        return Boolean(module?.resource);
+    }
+    hasValidEntries(entries) {
+        return Boolean(entries && entries.length > 0);
+    }
+    getEntryNameFromIssuer(issuer) {
+        return issuer.resource ? this.entryPath2Name.get(issuer.resource) : void 0;
+    }
+    createEntryFromIssuer(issuer, entryName) {
+        return {
+            entryName,
+            entryPath: issuer.resource
+        };
+    }
+    buildModuleToEntriesMapping(compilation) {
+        this.moduleToEntries.clear();
+        for (const [entryName, entryDependency] of compilation.entries.entries()){
+            const entryModule = compilation.moduleGraph.getModule(entryDependency.dependencies[0]);
+            if (entryModule) this.traverseModulesFromEntry(entryModule, entryName, compilation.moduleGraph, new Set());
+        }
+    }
+    traverseModulesFromEntry(module, entryName, moduleGraph, visited) {
+        if (!module?.resource || visited.has(module.resource)) return;
+        visited.add(module.resource);
+        if (!this.moduleToEntries.has(module.resource)) this.moduleToEntries.set(module.resource, new Set());
+        this.moduleToEntries.get(module.resource).add(entryName);
+        for (const connection of moduleGraph.getOutgoingConnections(module))if (connection.module && 'resource' in connection.module) this.traverseModulesFromEntry(connection.module, entryName, moduleGraph, visited);
+    }
+    findModuleEntries(module, compilation, resourcePath2Entries, visited = new Set()) {
+        if (!this.isValidModule(module) || visited.has(module.resource)) return [];
+        visited.add(module.resource);
+        const currentEntries = resourcePath2Entries.get(module.resource);
+        if (this.hasValidEntries(currentEntries)) return currentEntries;
+        const entryNames = this.moduleToEntries.get(module.resource);
+        if (entryNames && entryNames.size > 0) {
+            const entries = [];
+            for (const entryName of entryNames){
+                const entryPath = this.getEntryPathByName(entryName, compilation);
+                if (entryPath) entries.push({
+                    entryName,
+                    entryPath
+                });
+            }
+            return entries;
+        }
+        const issuer = findRootIssuer(compilation.moduleGraph, module);
+        if (!issuer) return [];
+        const issuerEntries = this.findModuleEntries(issuer, compilation, resourcePath2Entries, visited);
+        if (issuerEntries.length > 0) return issuerEntries;
+        const entryName = this.getEntryNameFromIssuer(issuer);
+        if (entryName) return [
+            this.createEntryFromIssuer(issuer, entryName)
+        ];
+        return [];
+    }
+    getEntryPathByName(entryName, compilation) {
+        const entryDependency = compilation.entries.get(entryName);
+        if (entryDependency && entryDependency.dependencies.length > 0) {
+            const firstDep = entryDependency.dependencies[0];
+            if ('request' in firstDep && 'string' == typeof firstDep.request) return firstDep.request;
+        }
+    }
+    apply(compiler) {
+        const { EntryPlugin, WebpackError, sources: { RawSource } } = compiler.rspack;
+        const includeModule = async (compilation, resource, resourceEntryNames, layer)=>{
+            const entries = Array.from(compilation.entries.entries());
+            if (0 === entries.length) return void compilation.errors.push(new WebpackError("Could not find an entry in the compilation."));
+            const includePromises = entries.filter(([entryName])=>resourceEntryNames?.includes(entryName)).map(([entryName])=>{
+                const dependency = EntryPlugin.createDependency(resource);
+                return new Promise((resolve, reject)=>{
+                    compilation.addInclude(compiler.context, dependency, {
+                        name: entryName,
+                        layer
+                    }, (error, module)=>{
+                        if (error) {
+                            compilation.errors.push(error);
+                            return reject(error);
+                        }
+                        if (!module) {
+                            const noModuleError = new WebpackError("Module not added");
+                            noModuleError.file = resource;
+                            compilation.errors.push(noModuleError);
+                            return reject(noModuleError);
+                        }
+                        setRscBuildInfo(module, {
+                            __entryName: entryName
+                        });
+                        compilation.moduleGraph.getExportsInfo(module).setUsedInUnknownWay(entryName);
+                        resolve();
+                    });
+                });
+            });
+            await Promise.all(includePromises);
+        };
+        let needsAdditionalPass = false;
+        compiler.hooks.finishMake.tapPromise(RscServerPlugin.name, async (compilation)=>{
+            this.buildModuleToEntriesMapping(compilation);
+            const processModules = (modules)=>{
+                let hasChangeReference = false;
+                for (const module of modules){
+                    if ('resource' in module && isCssModule(module)) this.styles.add(module.resource);
+                    const buildInfo = getRscBuildInfo(module);
+                    if (!buildInfo || !buildInfo.resourcePath) continue;
+                    if (module.layer && 'server' === buildInfo.type) sharedData.set(buildInfo?.resourcePath, buildInfo);
+                    if (!module.layer && 'client' === buildInfo.type) sharedData.set(buildInfo?.resourcePath, buildInfo);
+                    const currentReference = buildInfo?.type === 'client' ? this.clientReferencesMap.get(buildInfo.resourcePath) : this.serverReferencesMap.get(buildInfo.resourcePath);
+                    if (buildInfo?.type !== 'client' || currentReference) {
+                        if (buildInfo?.type === 'server' && !currentReference) {
+                            hasChangeReference = true;
+                            this.serverReferencesMap.set(buildInfo.resourcePath, buildInfo.exportNames);
+                        }
+                    } else {
+                        hasChangeReference = true;
+                        this.clientReferencesMap.set(buildInfo.resourcePath, buildInfo.clientReferences);
+                    }
+                    const entries = this.findModuleEntries(module, compilation, rspack_rsc_server_plugin_resourcePath2Entries);
+                    if (entries.length > 0) rspack_rsc_server_plugin_resourcePath2Entries.set(module.resource, entries);
+                }
+                return hasChangeReference;
+            };
+            this.serverManifest = {};
+            const clientReferences = [
+                ...this.clientReferencesMap.keys()
+            ];
+            const serverReferences = [
+                ...this.serverReferencesMap.keys()
+            ];
+            const referencesBefore = [
+                ...clientReferences,
+                ...serverReferences
+            ];
+            let hasChangeReference = false;
+            await Promise.all([
+                ...clientReferences.map(async (resource)=>{
+                    try {
+                        await includeModule(compilation, resource, rspack_rsc_server_plugin_resourcePath2Entries.get(resource)?.map((entry)=>entry.entryName) || []);
+                    } catch (error) {
+                        console.error(error);
+                        hasChangeReference = true;
+                        this.clientReferencesMap.delete(resource);
+                    }
+                }),
+                ...serverReferences.map(async (resource)=>{
+                    try {
+                        await includeModule(compilation, resource, rspack_rsc_server_plugin_resourcePath2Entries.get(resource)?.map((entry)=>entry.entryName) || [], rspackRscLayerName);
+                    } catch (error) {
+                        console.error(error);
+                        hasChangeReference = true;
+                        this.serverReferencesMap.delete(resource);
+                    }
+                })
+            ]);
+            hasChangeReference = processModules(compilation.modules);
+            const referencesAfter = [
+                ...this.clientReferencesMap.keys(),
+                ...this.serverReferencesMap.keys()
+            ];
+            if (referencesBefore.length !== referencesAfter.length || !referencesAfter.every((reference)=>referencesBefore.includes(reference)) && hasChangeReference) needsAdditionalPass = true;
+        });
+        compiler.hooks.done.tap(RscServerPlugin.name, ()=>{
+            sharedData.set('serverReferencesMap', this.serverReferencesMap);
+            sharedData.set('clientReferencesMap', this.clientReferencesMap);
+            sharedData.set('styles', this.styles);
+        });
+        compiler.hooks.afterCompile.tap(RscServerPlugin.name, (compilation)=>{
+            for (const module of compilation.modules){
+                const resource = module.nameForCondition();
+                if (!resource) continue;
+                const moduleId = compilation.chunkGraph.getModuleId(module);
+                if (null !== moduleId) {
+                    if (module.layer !== rspackRscLayerName && this.clientReferencesMap.has(resource)) {
+                        const clientReferences = this.clientReferencesMap.get(resource);
+                        if (clientReferences) for (const clientReference of clientReferences)clientReference.ssrId = moduleId;
+                        else compilation.errors.push(new WebpackError(`Could not find client references info in \`clientReferencesMap\` for ${resource}.`));
+                    } else if (module.layer === rspackRscLayerName && getRscBuildInfo(module)?.type === 'server') {
+                        const serverReferencesModuleInfo = getRscBuildInfo(module);
+                        if (serverReferencesModuleInfo) {
+                            serverReferencesModuleInfo.moduleId = moduleId;
+                            for (const exportName of serverReferencesModuleInfo.exportNames)this.serverManifest[`${moduleId}#${exportName}`] = {
+                                id: moduleId,
+                                chunks: [],
+                                name: exportName
+                            };
+                        } else compilation.errors.push(new WebpackError(`Could not find server references module info in \`serverReferencesMap\` for ${resource}.`));
+                    }
+                }
+            }
+        });
+        compiler.hooks.thisCompilation.tap(RscServerPlugin.name, (compilation)=>{
+            compilation.hooks.needAdditionalPass.tap(RscServerPlugin.name, ()=>!(needsAdditionalPass = !needsAdditionalPass));
+            compilation.hooks.processAssets.tap(RscServerPlugin.name, ()=>{
+                compilation.emitAsset(this.serverManifestFilename, new RawSource(JSON.stringify(this.serverManifest, null, 2), false));
+            });
+        });
+    }
+    constructor(options){
+        this.clientReferencesMap = new Map();
+        this.serverReferencesMap = new Map();
+        this.serverManifest = {};
+        this.entryPath2Name = new Map();
+        this.moduleToEntries = new Map();
+        this.styles = new Set();
+        this.serverManifestFilename = options?.serverManifestFilename || "react-server-manifest.json";
+        this.entryPath2Name = options?.entryPath2Name || new Map();
+    }
+}
+export { RscServerPlugin };

package/dist/esm/rsc/rsc-client-loader.mjs

@@ -0,0 +1,37 @@
+import { isServerModule, parseSource, sharedData } from "./common.mjs";
+async function rscClientLoader(source, sourceMap) {
+    this.cacheable(true);
+    const callback = this.async();
+    const ast = await parseSource(source);
+    const hasUseServerDirective = await isServerModule(ast);
+    if (!hasUseServerDirective) return void callback(null, source, sourceMap);
+    const { callServerImport = "@modern-js/runtime/rsc/client", registerImport = "@modern-js/runtime/rsc/client" } = this.getOptions();
+    const buildInfo = sharedData.get(this.resourcePath);
+    const moduleInfo = buildInfo ? {
+        moduleId: buildInfo?.moduleId,
+        exportNames: buildInfo?.exportNames
+    } : null;
+    if (!moduleInfo) {
+        this.emitError(new Error(`Could not find server module info in \`serverReferencesMap\` for ${this.resourcePath}.`));
+        callback(null, '');
+        return;
+    }
+    const { moduleId, exportNames } = moduleInfo;
+    if (!moduleId) {
+        this.emitError(new Error(`Could not find server module ID in \`serverReferencesMap\` for ${this.resourcePath}.`));
+        callback(null, '');
+        return;
+    }
+    if (!exportNames) return void callback(null, '');
+    const importsCode = `
+    import { createServerReference } from "${registerImport}";
+    import { callServer } from "${callServerImport}";
+  `;
+    const exportsCode = exportNames.map((item)=>{
+        const name = item;
+        if ('default' === name) return `export default createServerReference("${moduleId}", callServer);`;
+        return `export var ${name} = createServerReference("${moduleId}#${name}", callServer);`;
+    }).join('\n');
+    callback(null, `${importsCode}\n${exportsCode}`);
+}
+export { rscClientLoader as default };

package/dist/esm/rsc/rsc-css-loader.mjs

@@ -0,0 +1,8 @@
+import { setRscBuildInfo } from "./common.mjs";
+function rscCssLoader(source) {
+    this._module && setRscBuildInfo(this._module, {
+        isCssModule: true
+    });
+    return source;
+}
+export { rscCssLoader as default };

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

@@ -0,0 +1,58 @@
+import path from "path";
+import { transform } from "@swc/core";
+import { setRscBuildInfo } from "./common.mjs";
+function extractMetadata(code) {
+    const metadataRegex = /\/\* @modern-js-rsc-metadata\n([\s\S]*?)\*\//;
+    const match = code.match(metadataRegex);
+    if (!match) return null;
+    try {
+        const metadata = JSON.parse(match[1]);
+        return metadata;
+    } catch (e) {
+        console.error('Failed to parse metadata:', e);
+        return null;
+    }
+}
+async function rscServerLoader(source) {
+    this.cacheable(true);
+    const callback = this.async();
+    const { appDir, runtimePath = '@modern-js/runtime/rsc/server' } = this.getOptions();
+    const result = await transform(source, {
+        filename: this.resourcePath,
+        jsc: {
+            target: 'es2020',
+            experimental: {
+                cacheRoot: path.resolve(appDir, 'node_modules/.swc'),
+                plugins: [
+                    [
+                        require.resolve('@modern-js/flight-server-transform-plugin'),
+                        {
+                            appDir: appDir,
+                            runtimePath: runtimePath
+                        }
+                    ]
+                ]
+            }
+        },
+        isModule: true
+    });
+    const { code, map } = result;
+    const metadata = extractMetadata(code);
+    if (metadata?.directive && 'client' === metadata.directive) {
+        const { exportNames } = metadata;
+        if (exportNames.length > 0) setRscBuildInfo(this._module, {
+            type: 'client',
+            resourcePath: this.resourcePath,
+            clientReferences: exportNames
+        });
+    } else if (metadata) {
+        const { exportNames } = metadata;
+        if (exportNames.length > 0) setRscBuildInfo(this._module, {
+            type: 'server',
+            resourcePath: this.resourcePath,
+            exportNames: exportNames.map((item)=>item.exportName)
+        });
+    }
+    return callback(null, code, map);
+}
+export { rscServerLoader as default };

package/dist/esm/rsc/rsc-ssr-loader.mjs

@@ -0,0 +1,26 @@
+import { getExportNames, isServerModule, parseSource, setRscBuildInfo } from "./common.mjs";
+async function rscSsrLoader(source, sourceMap) {
+    this.cacheable(true);
+    const callback = this.async();
+    const ast = await parseSource(source);
+    const hasDeclareServerDirective = await isServerModule(ast);
+    const resourcePath = this.resourcePath;
+    if (!hasDeclareServerDirective) return void callback(null, source, sourceMap);
+    const exportedNames = await getExportNames(ast, true);
+    const importsCode = `
+    'use server';
+  `;
+    const exportsCode = exportedNames.map((name)=>{
+        if ('default' === name) return 'export default () => {throw new Error("Server actions must not be called during server-side rendering.")}';
+        return `export const ${name} = () => {
+          throw new Error("Server actions must not be called during server-side rendering.")
+        }`;
+    }).join('\n');
+    if (exportedNames.length > 0) setRscBuildInfo(this._module, {
+        type: 'server',
+        resourcePath,
+        exportNames: exportedNames
+    });
+    callback(null, `${importsCode}\n${exportsCode}`, sourceMap);
+}
+export { rscSsrLoader as default };

package/dist/esm/shared/devServer.mjs

@@ -0,0 +1,53 @@
+import { applyOptionsChain, isProd } from "@modern-js/utils";
+import { merge } from "ts-deepmerge";
+const defaultDevConfig = {
+    writeToDisk: (file)=>!file.includes('.hot-update.'),
+    hmr: true,
+    liveReload: true,
+    progressBar: true,
+    client: {
+        path: '/webpack-hmr',
+        overlay: false,
+        port: '<port>'
+    }
+};
+const transformToRsbuildServerOptions = (dev, devServer, server)=>{
+    const { host = '0.0.0.0', https, startUrl, beforeStartUrl, server: devServerConfig, ...devConfig } = dev;
+    const port = process.env.PORT ? Number(process.env.PORT) : server?.port ?? 8080;
+    const rsbuildDev = merge(defaultDevConfig, devConfig);
+    delete rsbuildDev.setupMiddlewares;
+    const legacyServerConfig = applyOptionsChain({}, devServer, {}, merge);
+    const serverCofig = {
+        compress: devServerConfig?.compress ?? legacyServerConfig.compress,
+        headers: devServerConfig?.headers ?? legacyServerConfig.headers,
+        historyApiFallback: devServerConfig?.historyApiFallback ?? legacyServerConfig.historyApiFallback,
+        proxy: devServerConfig?.proxy ?? legacyServerConfig.proxy
+    };
+    const rsbuildServer = isProd() ? {
+        publicDir: false,
+        htmlFallback: false,
+        printUrls: false
+    } : {
+        publicDir: false,
+        htmlFallback: false,
+        printUrls: false,
+        compress: serverCofig.compress,
+        headers: serverCofig.headers,
+        historyApiFallback: serverCofig.historyApiFallback,
+        proxy: serverCofig.proxy,
+        host,
+        port,
+        https: https ? https : void 0,
+        middlewareMode: true,
+        cors: server?.cors
+    };
+    if (!isProd() && startUrl) rsbuildServer.open = beforeStartUrl ? {
+        target: true === startUrl ? '//localhost:<port>' : startUrl,
+        before: beforeStartUrl
+    } : startUrl;
+    return {
+        rsbuildDev,
+        rsbuildServer
+    };
+};
+export { transformToRsbuildServerOptions };

package/dist/esm/shared/getCssSupport.mjs

@@ -0,0 +1,77 @@
+import browserslist from "browserslist";
+const CSS_FEATURES_BROWSER = {
+    customProperties: {
+        and_chr: '49',
+        and_ff: '31',
+        android: '50',
+        chrome: '49',
+        edge: '15',
+        firefox: '31',
+        ios_saf: '9.3',
+        op_mob: '36',
+        opera: '36',
+        safari: '9.1',
+        samsung: '5.0'
+    },
+    initial: {
+        and_chr: '37',
+        and_ff: '27',
+        android: '37',
+        chrome: '37',
+        edge: '79',
+        firefox: '27',
+        ios_saf: '9.3',
+        op_mob: '24',
+        opera: '24',
+        safari: '9.1',
+        samsung: '3.0'
+    },
+    pageBreak: {
+        and_chr: '51',
+        and_ff: '92',
+        android: '51',
+        chrome: '51',
+        edge: '12',
+        firefox: '92',
+        ios_saf: '10',
+        op_mob: '37',
+        opera: '11.1',
+        safari: '10',
+        samsung: '5.0'
+    },
+    fontVariant: {
+        and_chr: '18',
+        and_ff: '34',
+        android: '4.4',
+        chrome: '1',
+        edge: '12',
+        firefox: '34',
+        ios_saf: '9.3',
+        op_mob: '12',
+        opera: '10',
+        safari: '9.1',
+        samsung: '1.0'
+    },
+    mediaMinmax: {
+        and_chr: '104',
+        and_ff: '109',
+        android: '104',
+        chrome: '104',
+        edge: '104',
+        firefox: '63',
+        opera: '91'
+    }
+};
+const getCssFeatureBrowsers = (feature)=>{
+    const featureBrowsers = CSS_FEATURES_BROWSER[feature];
+    return browserslist(Object.entries(featureBrowsers).map(([key, value])=>`${key} >= ${value}`));
+};
+const isFeatureSupported = (projectBrowsers, featureBrowsers)=>projectBrowsers.every((item)=>featureBrowsers.includes(item));
+function getCssSupport(projectBrowserslist) {
+    const projectBrowsers = browserslist(projectBrowserslist);
+    return Object.keys(CSS_FEATURES_BROWSER).reduce((acc, key)=>{
+        acc[key] = isFeatureSupported(projectBrowsers, getCssFeatureBrowsers(key));
+        return acc;
+    }, {});
+}
+export { getCssSupport };

package/dist/esm/shared/manifest.mjs

@@ -0,0 +1,12 @@
+const generateManifest = (seed, files, entries)=>{
+    const manifestFiles = files.reduce((manifest, file)=>{
+        manifest[file.name] = file.path;
+        return manifest;
+    }, seed);
+    const entrypointFiles = Object.keys(entries).reduce((previous, name)=>previous.concat(entries[name].filter((fileName)=>!fileName.endsWith('.map'))), []);
+    return {
+        files: manifestFiles,
+        entrypoints: entrypointFiles
+    };
+};
+export { generateManifest };