@rsbuild/core 2.0.13 → 2.0.15

package/compiled/rspack-chain/package.json

@@ -1 +1 @@
-{"name":"rspack-chain","version":"2.0.2","license":"MIT","types":"types/index.d.ts","type":"module"}
+{"name":"rspack-chain","version":"2.1.0","license":"MIT","types":"types/index.d.ts","type":"module"}

package/compiled/rspack-chain/types/index.d.ts

@@ -1,4 +1,8 @@
-import { Configuration, RuleSetRule } from '@rspack/core';
+import type {
+  Configuration,
+  RuleSetLoaderWithOptions,
+  RuleSetRule,
+} from '@rspack/core';
 
 // The compiler type of Rspack / webpack are mismatch,
 // so we use a loose type here to allow using webpack plugins.
@@ -82,12 +86,14 @@ export declare class RspackChain extends __Config.ChainedMap<void> {
   bail(value: RspackConfig['bail']): this;
   cache(value: RspackConfig['cache']): this;
   dependencies(value: RspackConfig['dependencies']): this;
+  extends(value: RspackConfig['extends']): this;
   ignoreWarnings(value: RspackConfig['ignoreWarnings']): this;
   loader(value: RspackConfig['loader']): this;
   name(value: RspackConfig['name']): this;
   infrastructureLogging(value: RspackConfig['infrastructureLogging']): this;
   snapshot(value: RspackConfig['snapshot']): this;
   lazyCompilation(value: RspackConfig['lazyCompilation']): this;
+  incremental(value: RspackConfig['incremental']): this;
 
   entry(name: string): RspackChain.EntryPoint;
   plugin(name: string): RspackChain.Plugin<this, PluginInstance>;
@@ -166,9 +172,11 @@ export declare namespace RspackChain {
   type RspackModule = Required<NonNullable<Configuration['module']>>;
 
   class Module extends ChainedMap<RspackChain> {
+    defaultRules: TypedChainedMap<this, { [key: string]: Rule }>;
     rules: TypedChainedMap<this, { [key: string]: Rule }>;
     generator: ChainedMap<this>;
     parser: ChainedMap<this>;
+    defaultRule(name: string): Rule;
     rule(name: string): Rule;
     noParse(value: RspackModule['noParse']): this;
   }
@@ -177,6 +185,7 @@ export declare namespace RspackChain {
 
   class Output extends ChainedMap<RspackChain> {
     assetModuleFilename(value: RspackOutput['assetModuleFilename']): this;
+    asyncChunks(value: RspackOutput['asyncChunks']): this;
     bundlerInfo(value: RspackOutput['bundlerInfo']): this;
     chunkFilename(value: RspackOutput['chunkFilename']): this;
     chunkLoadTimeout(value: RspackOutput['chunkLoadTimeout']): this;
@@ -184,6 +193,8 @@ export declare namespace RspackChain {
     chunkLoading(value: RspackOutput['chunkLoading']): this;
     chunkFormat(value: RspackOutput['chunkFormat']): this;
     crossOriginLoading(value: RspackOutput['crossOriginLoading']): this;
+    cssChunkFilename(value: RspackOutput['cssChunkFilename']): this;
+    cssFilename(value: RspackOutput['cssFilename']): this;
     devtoolFallbackModuleFilenameTemplate(
       value: RspackOutput['devtoolFallbackModuleFilenameTemplate'],
     ): this;
@@ -206,6 +217,7 @@ export declare namespace RspackChain {
     hotUpdateMainFilename(value: RspackOutput['hotUpdateMainFilename']): this;
     library(value: RspackOutput['library']): this;
     importFunctionName(value: RspackOutput['importFunctionName']): this;
+    importMetaName(value: RspackOutput['importMetaName']): this;
     path(value: RspackOutput['path']): this;
     pathinfo(value: RspackOutput['pathinfo']): this;
     publicPath(value: RspackOutput['publicPath']): this;
@@ -217,7 +229,10 @@ export declare namespace RspackChain {
     strictModuleExceptionHandling(
       value: RspackOutput['strictModuleExceptionHandling'],
     ): this;
+    trustedTypes(value: RspackOutput['trustedTypes']): this;
     workerChunkLoading(value: RspackOutput['workerChunkLoading']): this;
+    workerPublicPath(value: RspackOutput['workerPublicPath']): this;
+    workerWasmLoading(value: RspackOutput['workerWasmLoading']): this;
     enabledLibraryTypes(value: RspackOutput['enabledLibraryTypes']): this;
     environment(value: RspackOutput['environment']): this;
     compareBeforeEmit(value: RspackOutput['compareBeforeEmit']): this;
@@ -243,6 +258,7 @@ export declare namespace RspackChain {
 
   class DevServer extends TypedChainedMap<RspackChain, RspackDevServer> {}
 
+  // rslint-disable-next-line @typescript-eslint/no-empty-object-type
   interface DevServer extends DevServerShorthandMethods<DevServer> {}
 
   type RspackPerformance = Exclude<
@@ -289,16 +305,15 @@ export declare namespace RspackChain {
     >;
     byDependency: TypedChainedMap<this, RspackResolve['byDependency']>;
     enforceExtension(value: RspackResolve['enforceExtension']): this;
+    fullySpecified(value: RspackResolve['fullySpecified']): this;
+    pnp(value: RspackResolve['pnp']): this;
     symlinks(value: RspackResolve['symlinks']): this;
     preferRelative(value: RspackResolve['preferRelative']): this;
     preferAbsolute(value: RspackResolve['preferAbsolute']): this;
 
     tsConfig(value: RspackResolve['tsConfig']): this;
   }
-
-  class RuleResolve<T = RspackChain> extends Resolve<T> {
-    fullySpecified(value: boolean): this;
-  }
+  class RuleResolve<T = RspackChain> extends Resolve<T> {}
 
   class ResolveLoader extends Resolve {
     modules: ChainedSet<this>;
@@ -317,16 +332,20 @@ export declare namespace RspackChain {
     resolve: RuleResolve<Rule<T>>;
 
     dependency(value: RspackRuleSet['dependency']): this;
+    descriptionData(value: RspackRuleSet['descriptionData']): this;
     enforce(value: RspackRuleSet['enforce']): this;
+    extractSourceMap(value: RspackRuleSet['extractSourceMap']): this;
     issuer(value: RspackRuleSet['issuer']): this;
     issuerLayer(value: RspackRuleSet['issuerLayer']): this;
     layer(value: RspackRuleSet['layer']): this;
     mimetype(value: RspackRuleSet['mimetype']): this;
+    phase(value: RspackRuleSet['phase']): this;
     parser(value: RspackRuleSet['parser']): this;
     generator(value: RspackRuleSet['generator']): this;
     resource(value: RspackRuleSet['resource']): this;
     resourceFragment(value: RspackRuleSet['resourceFragment']): this;
     resourceQuery(value: RspackRuleSet['resourceQuery']): this;
+    scheme(value: RspackRuleSet['scheme']): this;
     sideEffects(value: RspackRuleSet['sideEffects']): this;
     with(value: RspackRuleSet['with']): this;
     test(value: RspackRuleSet['test']): this;
@@ -386,10 +405,15 @@ export declare namespace RspackChain {
     [name: string]: any;
   }
 
+  type LoaderParallelOptions = NonNullable<
+    RuleSetLoaderWithOptions['parallel']
+  >;
+
   class Use<Parent = Rule> extends ChainedMap<Parent> implements Orderable {
+    ident(value: NonNullable<RuleSetLoaderWithOptions['ident']>): this;
     loader(value: string): this;
     options(value: LoaderOptions): this;
-    parallel(value: boolean): this;
+    parallel(value: LoaderParallelOptions): this;
 
     tap(f: (options: LoaderOptions) => LoaderOptions): this;
 

package/dist/349.js

@@ -0,0 +1,10 @@
+let CSS_MODULE_REGEX = /\.module(s)?\.\w+$/i, CSS_ICSS_REGEX = /\.icss\.\w+$/i, isCSSModules = (modules, loaderContext)=>{
+    if (!modules) return !1;
+    if (!0 === modules || 'string' == typeof modules) return !0;
+    let { auto } = modules;
+    if (void 0 === auto) return !0;
+    if (!1 === auto) return !1;
+    let resourcePath = loaderContext._module?.matchResource || loaderContext.resourcePath;
+    return auto instanceof RegExp ? auto.test(resourcePath) : 'function' == typeof auto ? auto(resourcePath, loaderContext.resourceQuery, loaderContext.resourceFragment) : CSS_MODULE_REGEX.test(resourcePath) || CSS_ICSS_REGEX.test(resourcePath);
+};
+export { isCSSModules };

package/dist/756.js

@@ -1788,6 +1788,8 @@ let ChainedMap = createMap(createChainable(Object)), ChainedValueMap = (superCla
             this[key] = new ChainedSet(this);
         }), this.extend([
             'enforceExtension',
+            'fullySpecified',
+            'pnp',
             'symlinks',
             'preferRelative',
             'preferAbsolute',
@@ -1846,6 +1848,7 @@ let ChainedMap = createMap(createChainable(Object)), ChainedValueMap = (superCla
     constructor(parent){
         super(parent), this.extend([
             'assetModuleFilename',
+            'asyncChunks',
             'bundlerInfo',
             'chunkFilename',
             'chunkLoadTimeout',
@@ -1854,6 +1857,8 @@ let ChainedMap = createMap(createChainable(Object)), ChainedValueMap = (superCla
             'chunkFormat',
             'enabledChunkLoadingTypes',
             'crossOriginLoading',
+            'cssChunkFilename',
+            'cssFilename',
             'devtoolFallbackModuleFilenameTemplate',
             'devtoolModuleFilenameTemplate',
             'devtoolNamespace',
@@ -1869,6 +1874,7 @@ let ChainedMap = createMap(createChainable(Object)), ChainedValueMap = (superCla
             'hotUpdateMainFilename',
             'library',
             'importFunctionName',
+            'importMetaName',
             'path',
             'pathinfo',
             'publicPath',
@@ -1876,7 +1882,10 @@ let ChainedMap = createMap(createChainable(Object)), ChainedValueMap = (superCla
             'sourceMapFilename',
             'strictModuleErrorHandling',
             'strictModuleExceptionHandling',
+            'trustedTypes',
             'workerChunkLoading',
+            'workerPublicPath',
+            'workerWasmLoading',
             'enabledLibraryTypes',
             'environment',
             'compareBeforeEmit',
@@ -1983,6 +1992,7 @@ let ChainedMap = createMap(createChainable(Object)), ChainedValueMap = (superCla
 }), Use = Orderable(class extends ChainedMap {
     constructor(parent, name){
         super(parent), this.name = name, this.extend([
+            'ident',
             'loader',
             'options',
             'parallel'
@@ -2023,20 +2033,22 @@ let Rule = Orderable(class extends ChainedMap {
         super(parent), this.ruleName = name, this.names = [], this.ruleType = ruleType, this.ruleTypes = [];
         let rule = this;
         for(; rule instanceof Rule;)this.names.unshift(rule.ruleName), this.ruleTypes.unshift(rule.ruleType), rule = rule.parent;
-        this.uses = new ChainedMap(this), this.include = new ChainedSet(this), this.exclude = new ChainedSet(this), this.rules = new ChainedMap(this), this.oneOfs = new ChainedMap(this), this.resolve = new Resolve(this), this.resolve.extend([
-            'fullySpecified'
-        ]), this.extend([
+        this.uses = new ChainedMap(this), this.include = new ChainedSet(this), this.exclude = new ChainedSet(this), this.rules = new ChainedMap(this), this.oneOfs = new ChainedMap(this), this.resolve = new Resolve(this), this.extend([
             'dependency',
+            "descriptionData",
             'enforce',
+            'extractSourceMap',
             'issuer',
             'issuerLayer',
             'layer',
             'mimetype',
+            'phase',
             'parser',
             'generator',
             'resource',
             'resourceFragment',
             'resourceQuery',
+            'scheme',
             'sideEffects',
             'with',
             'test',
@@ -2182,12 +2194,14 @@ class RspackChain extends ChainedMap {
             'bail',
             'cache',
             'dependencies',
+            'extends',
             'ignoreWarnings',
             'loader',
             'name',
             'infrastructureLogging',
             'snapshot',
-            'lazyCompilation'
+            'lazyCompilation',
+            'incremental'
         ]);
     }
     static toString(config, { verbose = !1, configPrefix = 'config' } = {}) {
@@ -3483,7 +3497,7 @@ function createPublicContext(context) {
 async function createContext(options, userConfig, logger) {
     let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = join(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0;
     return {
-        version: "2.0.13",
+        version: "2.0.15",
         rootPath,
         distPath: '',
         cachePath,
@@ -6680,7 +6694,7 @@ function createAssetsMiddleware(context, ready, outputFileSystem) {
 }
 async function setupOutputFileSystem(writeToDisk, compilers) {
     if (!0 !== writeToDisk) {
-        let { createFsFromVolume, Volume } = await import("./memfs.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/memfs@4.57.6/node_modules/memfs/lib/index.js", 23)), outputFileSystem = createFsFromVolume(new Volume());
+        let { createFsFromVolume, Volume } = await import("./memfs.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/memfs@4.57.7/node_modules/memfs/lib/index.js", 23)), outputFileSystem = createFsFromVolume(new Volume());
         for (let compiler of compilers)compiler.outputFileSystem = outputFileSystem;
     }
     let compiler = compilers.find((compiler)=>!!compiler.outputFileSystem);
@@ -7343,7 +7357,12 @@ async function setupCliShortcuts({ help = !0, openPage, closeServer, printUrls,
         rl.close();
     };
 }
-let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xml/i;
+let createDeferred = ()=>{
+    let deferred = {};
+    return deferred.promise = new Promise((resolve)=>{
+        deferred.resolve = resolve;
+    }), deferred;
+}, ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xml/i;
 function gzipMiddleware_gzipMiddleware({ filter, level = node_zlib.constants.Z_BEST_SPEED } = {}) {
     return function gzipMiddleware(req, res, next) {
         let gzip, writeHeadStatus, writeHeadMessage;
@@ -8065,7 +8084,8 @@ async function startWatchFiles({ paths, options, type = 'reload-page' }, buildMa
     }), watcher;
 }
 async function devServer_createDevServer(options, createCompiler, config, { getPortSilently, runCompile = !0 } = {}) {
-    let lastStats, { context } = options, { logger } = context;
+    var environmentCount;
+    let stats, waiters, { context } = options, { logger } = context;
     logger.debug('create dev server');
     let { port, portTip } = await resolvePort(config), { middlewareMode, host } = config.server, isHttps = !!config.server.https, routes = getRoutes(context), fallbackPathname = 0 === routes.length && context.environmentList.some((item)=>'web' === item.config.output.target) ? config.server.base : void 0;
     context.devServer = {
@@ -8073,24 +8093,40 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
         port,
         https: isHttps
     };
-    let waitLastCompileDoneResolve = null, waitLastCompileDone = new Promise((resolve)=>{
-        waitLastCompileDoneResolve = resolve;
-    });
-    context.hooks.onAfterDevCompile.tap(({ stats })=>{
-        lastStats = 'stats' in stats ? stats.stats : [
-            stats
-        ], waitLastCompileDoneResolve && (waitLastCompileDoneResolve(), waitLastCompileDoneResolve = null);
-    });
-    let startCompile = async ()=>{
+    let compileState = (stats = Array(environmentCount = context.environmentList.length), waiters = Array.from({
+        length: environmentCount
+    }, createDeferred), {
+        reset (index) {
+            stats[index] && (stats[index] = void 0, waiters[index] = createDeferred());
+        },
+        done (index, nextStats) {
+            stats[index] = nextStats, waiters[index].resolve(nextStats);
+        },
+        async wait (index) {
+            let currentStats = stats[index];
+            return currentStats || waiters[index].promise;
+        }
+    }), startCompile = async ()=>{
         let compiler = await createCompiler();
         if (!compiler) throw Error(`${color.dim('[rsbuild:server]')} Failed to get compiler instance.`);
         context.publicPathnames = getPublicPathnames(compiler_isMultiCompiler(compiler) ? compiler.compilers.map(getPublicPathFromCompiler) : [
             getPublicPathFromCompiler(compiler)
-        ], config.server.base), compiler?.hooks.watchRun.tap('rsbuild:watchRun', ()=>{
-            lastStats && (waitLastCompileDoneResolve && (waitLastCompileDoneResolve(), waitLastCompileDoneResolve = null), waitLastCompileDone = new Promise((resolve)=>{
-                waitLastCompileDoneResolve = resolve;
-            }));
-        });
+        ], config.server.base);
+        let hookOptions = {
+            name: 'rsbuild:environment-api',
+            stage: -10000
+        };
+        compiler_isMultiCompiler(compiler) ? compiler.compilers.forEach((compiler, index)=>{
+            compiler.hooks.watchRun.tap(hookOptions, ()=>{
+                compileState.reset(index);
+            }), compiler.hooks.done.tap(hookOptions, (stats)=>{
+                compileState.done(index, stats);
+            });
+        }) : (compiler.hooks.watchRun.tap(hookOptions, ()=>{
+            compileState.reset(0);
+        }), compiler.hooks.done.tap(hookOptions, (stats)=>{
+            compileState.done(0, stats);
+        }));
         let buildManager = new BuildManager({
             context,
             config,
@@ -8160,18 +8196,18 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
             },
             getStats: async ()=>{
                 if (!state.buildManager) throw Error(getErrorMsg('getStats'));
-                return await waitLastCompileDone, lastStats[index];
+                return compileState.wait(index);
             },
             loadBundle: async (entryName)=>{
                 if (!state.buildManager) throw Error(getErrorMsg('loadBundle'));
-                return await waitLastCompileDone, cacheableLoadBundle(lastStats[index], entryName, {
+                return cacheableLoadBundle(await compileState.wait(index), entryName, {
                     readFileSync: state.buildManager.readFileSync,
                     environment
                 });
             },
             getTransformedHtml: async (entryName)=>{
                 if (!state.buildManager) throw Error(getErrorMsg('getTransformedHtml'));
-                return await waitLastCompileDone, cacheableTransformedHtml(lastStats[index], entryName, {
+                return cacheableTransformedHtml(await compileState.wait(index), entryName, {
                     readFileSync: state.buildManager.readFileSync,
                     environment
                 });
@@ -8357,10 +8393,7 @@ function applyDefaultPlugins(pluginManager, context) {
                         level: 'error'
                     }), chain.watchOptions({
                         aggregateTimeout: 0
-                    }), chain.performance.hints(!1), chain.experiments({
-                        ...chain.get('experiments'),
-                        pureFunctions: !0
-                    }), chain.module.parser.merge({
+                    }), chain.performance.hints(!1), chain.module.parser.merge({
                         javascript: {
                             typeReexportsPresence: 'tolerant'
                         }
@@ -9040,7 +9073,9 @@ try {
                             } : {
                                 ...cssLoaderOptions,
                                 importLoaders: importLoaders.normal
-                            }, rule.use(CHAIN_ID.USE.CSS).options(finalOptions), 'url' !== type && rule.sideEffects(!0), rule.resolve.preferRelative(!0);
+                            }, emitCss || 'main' !== type || rule.use(CHAIN_ID.USE.IGNORE_CSS).options({
+                                modules: finalOptions.modules
+                            }), rule.use(CHAIN_ID.USE.CSS).options(finalOptions), 'url' !== type && rule.sideEffects(!0), rule.resolve.preferRelative(!0);
                         });
                         let cssUrlFilename = getFilename(config, 'css', isProd), cssUrlPath = config.output.distPath.css;
                         urlRule.use(CHAIN_ID.USE.CSS_URL).options({
@@ -9970,7 +10005,7 @@ let applyServerOptions = (command)=>{
 };
 function setupCommands() {
     let cli = ((name = "")=>new CAC(name))('rsbuild');
-    cli.version("2.0.13"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
+    cli.version("2.0.15"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
         default: 'auto'
     }).option('--env-dir <dir>', 'Set the directory for loading `.env` files').option('--env-mode <mode>', 'Set the env mode to load the `.env.[mode]` file').option('--environment <name>', 'Set the environment name(s) to build', {
         type: [
@@ -10041,7 +10076,7 @@ function initNodeEnv(command) {
 }
 function showGreeting() {
     let { npm_execpath, npm_lifecycle_event, NODE_RUN_SCRIPT_NAME } = process.env, isBun = npm_execpath?.includes('.bun');
-    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.0.13\n`);
+    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.0.15\n`);
 }
 function setupLogLevel() {
     if (cli_argv.length <= 3) return;
@@ -10063,5 +10098,5 @@ function runCLI() {
         src_logger.error('Failed to start Rsbuild CLI.'), src_logger.error(err), process.exit(1);
     }
 }
-let src_version = "2.0.13";
+let src_version = "2.0.15";
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, core_rspack as rspack, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, loadConfig_loadConfig as loadConfig, loadEnv, logger_createLogger as createLogger, mergeRsbuildConfig, mrmime_lookup, runCLI, src_logger as logger, src_version as version };

package/dist/cssUrlLoader.mjs

@@ -1,15 +1,11 @@
 import node_path from "node:path";
-let CSS_MODULE_REGEX = /\.module\.\w+$/i, HASH_PLACEHOLDER_REGEX = /\[(?:[^:\]]+:)?(?:chunkhash|contenthash|hash|fullhash)(?::[^\]]+)?]/i, getRelativePath = (root, resourcePath)=>{
+import { isCSSModules } from "./349.js";
+let HASH_PLACEHOLDER_REGEX = /\[(?:[^:\]]+:)?(?:chunkhash|contenthash|hash|fullhash)(?::[^\]]+)?]/i, getRelativePath = (root, resourcePath)=>{
     let relativePath = node_path.relative(root, resourcePath);
     if (relativePath && !('..' === relativePath || relativePath.startsWith(`..${node_path.sep}`)) && !node_path.isAbsolute(relativePath)) return relativePath.replace(/\\/g, '/');
 }, pitch = async function(remainingRequest) {
     let root, resourcePath, nameSource, hash, options = this.getOptions();
-    if (((modules, resourcePath, resourceQuery, resourceFragment)=>{
-        if (!modules) return !1;
-        if (!0 === modules || 'string' == typeof modules) return !0;
-        let { auto } = modules;
-        return !1 !== auto && (auto instanceof RegExp ? auto.test(resourcePath) : 'function' == typeof auto ? auto(resourcePath, resourceQuery, resourceFragment) : CSS_MODULE_REGEX.test(resourcePath));
-    })(options.modules, this.resourcePath, this.resourceQuery, this.resourceFragment)) throw Error('[rsbuild:css] CSS Modules do not support the ?url query. Use ?inline to import the compiled CSS content as a string.');
+    if (isCSSModules(options.modules, this)) throw Error('[rsbuild:css] CSS Modules do not support the ?url query. Use ?inline to import the compiled CSS content as a string.');
     let content = ((moduleExports)=>{
         let content = moduleExports && 'object' == typeof moduleExports && 'default' in moduleExports ? moduleExports.default : moduleExports;
         if ('string' != typeof content) throw Error('[rsbuild:css] Expected CSS ?url imports to export a string.');

package/dist/ignoreCssLoader.mjs

@@ -1,3 +1,9 @@
+import { isCSSModules } from "./349.js";
+let pitch = function() {
+    let { modules } = this.getOptions();
+    if (!isCSSModules(modules, this)) return '';
+};
 export default function(source) {
-    return (this?.cacheable(!0), source.includes('___CSS_LOADER_EXPORT___')) ? '' : source;
+    return source.includes('___CSS_LOADER_EXPORT___') ? '' : source;
 };
+export { pitch };