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

package/dist/cjs/plugins/postcss.js

@@ -0,0 +1,162 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+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__, {
+    pluginPostcss: ()=>pluginPostcss
+});
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("node:url");
+const utils_namespaceObject = require("@modern-js/utils");
+const core_namespaceObject = require("@rsbuild/core");
+const getCssSupport_js_namespaceObject = require("../shared/getCssSupport.js");
+const builderRequire = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+const createRootRequire = (rootPath)=>(0, external_node_module_namespaceObject.createRequire)((0, external_node_url_namespaceObject.pathToFileURL)(external_node_path_default().join(rootPath, 'package.json')).href);
+const loadByResolver = (resolveWith, name)=>{
+    try {
+        return resolveWith(name);
+    } catch (error) {
+        const resolved = resolveWith.resolve(name);
+        return resolveWith(resolved);
+    }
+};
+const loadPostcssPlugin = (name, appRootPath)=>{
+    const resolvers = [
+        builderRequire,
+        createRootRequire(appRootPath),
+        createRootRequire(process.cwd())
+    ];
+    let firstError = null;
+    for (const resolveWith of resolvers)try {
+        return loadByResolver(resolveWith, name);
+    } catch (error) {
+        firstError ??= error;
+    }
+    throw firstError;
+};
+const importPostcssPlugin = (name, appRootPath)=>Promise.resolve(loadPostcssPlugin(name, appRootPath));
+const clonePostCSSConfig = (config)=>({
+        ...config,
+        plugins: config.plugins ? [
+            ...config.plugins
+        ] : void 0
+    });
+const postcssLoadConfig = builderRequire('postcss-load-config');
+const userPostcssrcCache = new Map();
+const loadUserPostcssrc = async (root)=>{
+    const cached = userPostcssrcCache.get(root);
+    if (cached) return clonePostCSSConfig(await cached);
+    const promise = postcssLoadConfig({}, root).catch((err)=>{
+        if (err?.message?.includes('No PostCSS Config found')) return {};
+        throw err;
+    });
+    userPostcssrcCache.set(root, promise);
+    return promise.then((config)=>{
+        userPostcssrcCache.set(root, config);
+        return clonePostCSSConfig(config);
+    });
+};
+const pluginPostcss = (options = {})=>({
+        name: 'builder:postcss-plugins',
+        pre: [
+            'builder:environment-defaults-plugin'
+        ],
+        setup (api) {
+            const { autoprefixer } = options;
+            api.modifyEnvironmentConfig(async (config, { mergeEnvironmentConfig })=>{
+                if ('web' !== config.output.target) return config;
+                const cssSupport = (0, getCssSupport_js_namespaceObject.getCssSupport)(config.output.overrideBrowserslist);
+                const enableExtractCSS = !config.output?.injectStyles;
+                const enableCssMinify = !enableExtractCSS && (0, utils_namespaceObject.isProd)();
+                const cssnanoOptions = {
+                    preset: [
+                        'default',
+                        {
+                            mergeLonghand: false,
+                            normalizeUrl: false
+                        }
+                    ]
+                };
+                const plugins = await Promise.all([
+                    importPostcssPlugin('postcss-flexbugs-fixes', api.context.rootPath),
+                    !cssSupport.customProperties && importPostcssPlugin('postcss-custom-properties', api.context.rootPath),
+                    !cssSupport.initial && importPostcssPlugin('postcss-initial', api.context.rootPath),
+                    !cssSupport.pageBreak && importPostcssPlugin('postcss-page-break', api.context.rootPath),
+                    !cssSupport.fontVariant && importPostcssPlugin('postcss-font-variant', api.context.rootPath),
+                    !cssSupport.mediaMinmax && importPostcssPlugin('postcss-media-minmax', api.context.rootPath),
+                    importPostcssPlugin('postcss-nesting', api.context.rootPath),
+                    enableCssMinify && importPostcssPlugin('cssnano', api.context.rootPath).then((cssnano)=>cssnano(cssnanoOptions)),
+                    importPostcssPlugin('autoprefixer', api.context.rootPath).then((autoprefixerPlugin)=>autoprefixerPlugin((0, utils_namespaceObject.applyOptionsChain)({
+                            flexbox: 'no-2009',
+                            overrideBrowserslist: config.output.overrideBrowserslist
+                        }, autoprefixer)))
+                ]).then((results)=>results.filter(Boolean));
+                const userOptions = await loadUserPostcssrc(api.context.rootPath);
+                return mergeEnvironmentConfig({
+                    tools: {
+                        postcss: (opts)=>{
+                            if ('function' == typeof opts.postcssOptions) {
+                                core_namespaceObject.logger.warn('unexpected function type postcssOptions, the default postcss plugins will not be applied.');
+                                return opts;
+                            }
+                            const existingOptions = opts.postcssOptions ?? {};
+                            const mergedOptions = {
+                                ...userOptions,
+                                ...existingOptions
+                            };
+                            const userPlugins = userOptions.plugins ?? [];
+                            const existingPlugins = existingOptions.plugins ?? [];
+                            mergedOptions.plugins = [
+                                ...userPlugins,
+                                ...existingPlugins,
+                                ...plugins
+                            ];
+                            opts.postcssOptions = mergedOptions;
+                        }
+                    }
+                }, config);
+            });
+        }
+    });
+exports.pluginPostcss = __webpack_exports__.pluginPostcss;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "pluginPostcss"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/rscConfig.js

@@ -0,0 +1,159 @@
+"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__, {
+    getRscPlugins: ()=>getRscPlugins,
+    pluginRscConfig: ()=>pluginRscConfig
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const ASYNC_STORAGE_PATTERN = /universal[/\\]async_storage/;
+const RSC_COMMON_LAYER = 'rsc-common';
+const ENTRY_NAME_VAR = '__MODERN_JS_ENTRY_NAME';
+const createVirtualModule = (content)=>`data:text/javascript,${encodeURIComponent(content)}`;
+const isAsyncStorageExclude = (exclude)=>{
+    if ('string' == typeof exclude) return ASYNC_STORAGE_PATTERN.test(exclude);
+    if (exclude instanceof RegExp) return exclude.test('universal/async_storage') || exclude.test('universal\\async_storage');
+    return false;
+};
+function pluginRscConfig() {
+    return {
+        name: 'builder:rsc-config',
+        setup (api) {
+            let layersCache = null;
+            const getLayers = async ()=>{
+                if (!layersCache) {
+                    const { Layers } = await import("rsbuild-plugin-rsc");
+                    layersCache = Layers;
+                }
+                return layersCache;
+            };
+            api.modifyBundlerChain({
+                handler: (chain, { isServer })=>{
+                    if (isServer) {
+                        const routeFilePattern = /[/\\]routes[/\\](?:.*[/\\])?(?:layout|page|\$)\.[tj]sx?$/;
+                        const appFilePattern = /[/\\]App\.[tj]sx?$/;
+                        const combinedPattern = new RegExp(`(${routeFilePattern.source}|${appFilePattern.source})`);
+                        let loaderPath;
+                        try {
+                            loaderPath = require.resolve('../shared/rsc/rsc-server-entry-loader');
+                        } catch  {
+                            loaderPath = external_path_default().resolve(__dirname, '../shared/rsc/rsc-server-entry-loader');
+                        }
+                        chain.module.rule('rsc-server-entry').test(/\.(tsx?|jsx?)$/).resource(combinedPattern).exclude.add(/node_modules/).end().use('rsc-server-entry-loader').loader(loaderPath).end();
+                    }
+                },
+                order: 'pre'
+            });
+            api.modifyRspackConfig(async (config, utils)=>{
+                const isServer = 'node' === config.target || 'node' === utils.target || utils.environment?.name === 'server';
+                if (!isServer) return;
+                const Layers = await getLayers();
+                if (config.entry) {
+                    const entries = config.entry;
+                    const newEntries = {};
+                    for (const [entryName, entryValue] of Object.entries(entries))if ('string' == typeof entryValue) newEntries[entryName] = {
+                        import: entryValue,
+                        layer: Layers.ssr
+                    };
+                    else if (Array.isArray(entryValue)) newEntries[entryName] = {
+                        import: entryValue,
+                        layer: Layers.ssr
+                    };
+                    else if ('object' == typeof entryValue && null !== entryValue) newEntries[entryName] = {
+                        ...entryValue,
+                        layer: Layers.ssr
+                    };
+                    else newEntries[entryName] = entryValue;
+                    config.entry = newEntries;
+                }
+                if (config.module?.rules) {
+                    const rules = config.module.rules;
+                    for (const rule of rules)if (rule.layer === Layers.rsc) {
+                        if (rule.exclude) {
+                            if (!Array.isArray(rule.exclude)) rule.exclude = [
+                                rule.exclude
+                            ];
+                        } else rule.exclude = [];
+                        const hasExclude = rule.exclude.some(isAsyncStorageExclude);
+                        if (!hasExclude) rule.exclude.push(ASYNC_STORAGE_PATTERN);
+                    }
+                    if (!Array.isArray(config.module.rules)) config.module.rules = [];
+                    config.module.rules.push({
+                        resource: ASYNC_STORAGE_PATTERN,
+                        layer: RSC_COMMON_LAYER
+                    });
+                }
+            });
+            api.modifyBundlerChain((chain, { isServer, isWebWorker })=>{
+                if (!isServer && !isWebWorker) {
+                    const entries = chain.entryPoints.entries();
+                    if (entries && 'object' == typeof entries) for (const entryName of Object.keys(entries)){
+                        const entryPoint = chain.entry(entryName);
+                        const code = `window.${ENTRY_NAME_VAR}="${entryName}";`;
+                        entryPoint.add(createVirtualModule(code));
+                    }
+                }
+            });
+        }
+    };
+}
+async function getRscPlugins(enableRsc, internalDirectory) {
+    if (enableRsc) {
+        const routesFileReg = new RegExp(`${internalDirectory.replace(/[/\\]/g, '[/\\\\]')}[/\\\\][^/\\\\]*[/\\\\]routes`);
+        const { pluginRSC } = await import("rsbuild-plugin-rsc");
+        return [
+            pluginRSC({
+                layers: {
+                    rsc: [
+                        /render[/\\].*[/\\]server[/\\]rsc/,
+                        /AppProxy/,
+                        routesFileReg
+                    ]
+                }
+            }),
+            pluginRscConfig()
+        ];
+    }
+    return [];
+}
+exports.getRscPlugins = __webpack_exports__.getRscPlugins;
+exports.pluginRscConfig = __webpack_exports__.pluginRscConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getRscPlugins",
+    "pluginRscConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/rsdoctor.js

@@ -0,0 +1,64 @@
+"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__, {
+    pluginRsdoctor: ()=>pluginRsdoctor
+});
+const isRsdoctorEnabled = (config)=>{
+    if (void 0 === config) return false;
+    if ('boolean' == typeof config) return config;
+    if ('boolean' == typeof config?.enabled) return config.enabled;
+    return true;
+};
+const getRsdoctorPluginOptions = (config)=>{
+    if (config && 'object' == typeof config) return {
+        disableClientServer: config.disableClientServer ?? true
+    };
+    return {
+        disableClientServer: true
+    };
+};
+const pluginRsdoctor = (config)=>{
+    if (!isRsdoctorEnabled(config)) return null;
+    const pluginOptions = getRsdoctorPluginOptions(config);
+    return {
+        name: 'builder:rsdoctor',
+        setup (api) {
+            api.modifyBundlerChain(async (chain)=>{
+                const { RsdoctorRspackPlugin } = await import("@rsdoctor/rspack-plugin");
+                chain.plugin('rsdoctor').use(RsdoctorRspackPlugin, [
+                    pluginOptions
+                ]);
+            });
+        }
+    };
+};
+exports.pluginRsdoctor = __webpack_exports__.pluginRsdoctor;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "pluginRsdoctor"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/runtimeChunk.js

@@ -0,0 +1,55 @@
+"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__, {
+    pluginRuntimeChunk: ()=>pluginRuntimeChunk
+});
+const utils_js_namespaceObject = require("../shared/utils.js");
+const pluginRuntimeChunk = (disableInlineRuntimeChunk)=>({
+        name: 'builder:runtime-chunk',
+        setup (api) {
+            api.modifyBundlerChain(async (chain, { target, environment })=>{
+                if ('web' !== target) return;
+                const { config } = environment;
+                const { chunkSplit } = config.performance;
+                if (chunkSplit?.strategy !== 'all-in-one' && false !== config.splitChunks) chain.optimization.runtimeChunk({
+                    name: utils_js_namespaceObject.RUNTIME_CHUNK_NAME
+                });
+            });
+            api.modifyRsbuildConfig((config)=>{
+                config.output ||= {};
+                if (disableInlineRuntimeChunk) return;
+                const originalConfig = api.getRsbuildConfig('original');
+                if (originalConfig.output?.inlineScripts === void 0) config.output.inlineScripts = utils_js_namespaceObject.RUNTIME_CHUNK_REGEX;
+            });
+        }
+    });
+exports.pluginRuntimeChunk = __webpack_exports__.pluginRuntimeChunk;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "pluginRuntimeChunk"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/devServer.js

@@ -0,0 +1,87 @@
+"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__, {
+    transformToRsbuildServerOptions: ()=>transformToRsbuildServerOptions
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_ts_deepmerge_namespaceObject = require("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 = (0, external_ts_deepmerge_namespaceObject.merge)(defaultDevConfig, devConfig);
+    delete rsbuildDev.setupMiddlewares;
+    const legacyServerConfig = (0, utils_namespaceObject.applyOptionsChain)({}, devServer, {}, external_ts_deepmerge_namespaceObject.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 = (0, utils_namespaceObject.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 (!(0, utils_namespaceObject.isProd)() && startUrl) rsbuildServer.open = beforeStartUrl ? {
+        target: true === startUrl ? '//localhost:<port>' : startUrl,
+        before: beforeStartUrl
+    } : startUrl;
+    return {
+        rsbuildDev,
+        rsbuildServer
+    };
+};
+exports.transformToRsbuildServerOptions = __webpack_exports__.transformToRsbuildServerOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "transformToRsbuildServerOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/getCssSupport.js

@@ -0,0 +1,121 @@
+"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__, {
+    getCssSupport: ()=>getCssSupport
+});
+const external_browserslist_namespaceObject = require("browserslist");
+var external_browserslist_default = /*#__PURE__*/ __webpack_require__.n(external_browserslist_namespaceObject);
+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 external_browserslist_default()(Object.entries(featureBrowsers).map(([key, value])=>`${key} >= ${value}`));
+};
+const isFeatureSupported = (projectBrowsers, featureBrowsers)=>projectBrowsers.every((item)=>featureBrowsers.includes(item));
+function getCssSupport(projectBrowserslist) {
+    const projectBrowsers = external_browserslist_default()(projectBrowserslist);
+    return Object.keys(CSS_FEATURES_BROWSER).reduce((acc, key)=>{
+        acc[key] = isFeatureSupported(projectBrowsers, getCssFeatureBrowsers(key));
+        return acc;
+    }, {});
+}
+exports.getCssSupport = __webpack_exports__.getCssSupport;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getCssSupport"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});